Makefiles: Docker USB passthrough in Linux only

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.
4 years ago · 089565762a
parent 3a794448ad
commit 089565762a
20 changed files with 524 additions and 458 deletions
--- a/01_wait_forever/Makefile
+++ b/01_wait_forever/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/02_runtime_init/Makefile
+++ b/02_runtime_init/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/03_hacky_hello_world/Makefile
+++ b/03_hacky_hello_world/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/04_zero_overhead_abstraction/Makefile
+++ b/04_zero_overhead_abstraction/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/05_safe_globals/Makefile
+++ b/05_safe_globals/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/06_drivers_gpio_uart/Makefile
+++ b/06_drivers_gpio_uart/Makefile
@ -35,30 +35,31 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+
+DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
+
+EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)

 .PHONY: all doc qemu clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -70,9 +71,7 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 clippy:
--- a/07_uart_chainloader/Makefile
+++ b/07_uart_chainloader/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -42,33 +45,41 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
-DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
+
+DOCKER_QEMU = $(DOCKER_CMD) $(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)
+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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -83,20 +94,14 @@ qemuasm:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)

 qemuasm: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT) -d in_asm
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
 endif

 chainboot:
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(CHAINBOOT_DEMO_PAYLOAD)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)

 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
--- a/07_uart_chainloader/README.md
+++ b/07_uart_chainloader/README.md
@ -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
 --- 06_drivers_gpio_uart/Makefile
 +++ 07_uart_chainloader/Makefile
-@@ -7,6 +7,11 @@
+@@ -7,6 +7,14 @@
 	BSP = rpi3
 endif

-+# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 +ifndef DEV_SERIAL
 +	DEV_SERIAL = /dev/ttyUSB0
 +endif
+
+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
 +
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
-@@ -15,7 +20,8 @@
+@@ -15,7 +23,8 @@
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	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)
 	TARGET            = aarch64-unknown-none-softfloat
 	OUTPUT            = kernel8.img
-@@ -23,7 +29,8 @@
+@@ -23,7 +32,8 @@
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	LINKER_FILE       = src/bsp/raspberrypi/link.ld
@ -120,21 +123,31 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
 endif

 SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
-@@ -49,9 +56,12 @@
+@@ -47,12 +57,22 @@
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
- DOCKER_CMD           = docker run -it --rm
- DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-+DOCKER_ARG_TTY       = --privileged -v /dev:/dev
- DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
-+DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+ DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
+
+ DOCKER_QEMU = $(DOCKER_CMD) $(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)
+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 qemuasm chainboot clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-@@ -68,13 +78,26 @@
+@@ -69,11 +89,20 @@
 ifeq ($(QEMU_MACHINE_TYPE),)
 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."
 else
 qemu: all
- 	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
- 		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
- 		-kernel $(OUTPUT)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 +
 +qemuasm: all
-+	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-+		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-+		-kernel $(OUTPUT) -d in_asm
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
 endif

 +chainboot:
-+	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-+		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-+		$(CHAINBOOT_DEMO_PAYLOAD)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
 +
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
--- a/08_timestamps/Makefile
+++ b/08_timestamps/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -40,33 +43,41 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
-DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
+
+DOCKER_QEMU = $(DOCKER_CMD) $(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)
+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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -78,15 +89,11 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)

 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
--- a/08_timestamps/README.md
+++ b/08_timestamps/README.md
@ -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
 --- 07_uart_chainloader/Makefile
 +++ 08_timestamps/Makefile
-@@ -20,8 +20,7 @@
+@@ -23,8 +23,7 @@
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	LINKER_FILE       = src/bsp/raspberrypi/link.ld
@ -56,7 +56,7 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
 else ifeq ($(BSP),rpi4)
 	TARGET            = aarch64-unknown-none-softfloat
 	OUTPUT            = kernel8.img
-@@ -29,8 +28,7 @@
+@@ -32,8 +31,7 @@
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	LINKER_FILE       = src/bsp/raspberrypi/link.ld
@ -66,16 +66,16 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
 endif

 SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
-@@ -61,7 +59,7 @@
- DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
- DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+@@ -72,7 +70,7 @@
+ 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 chainboot clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-@@ -78,25 +76,17 @@
+@@ -89,19 +87,13 @@
 ifeq ($(QEMU_MACHINE_TYPE),)
 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."
 else
 qemu: all
- 	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
- 		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
- 		-kernel $(OUTPUT)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 -
 -qemuasm: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT) -d in_asm
+-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
 endif

 -chainboot:
+-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
 +chainboot: all
- 	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
- 		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(CHAINBOOT_DEMO_PAYLOAD)
-+		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)

 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
--- a/09_hw_debug_JTAG/Makefile
+++ b/09_hw_debug_JTAG/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -44,35 +47,48 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -84,30 +100,22 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(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)                   \
-		/jtag/$(JTAG_BOOT_IMAGE)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) 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) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/09_hw_debug_JTAG/README.md
+++ b/09_hw_debug_JTAG/README.md
@ -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
 --- 08_timestamps/Makefile
 +++ 09_hw_debug_JTAG/Makefile
-@@ -19,6 +19,8 @@
+@@ -22,6 +22,8 @@
 	QEMU_BINARY       = qemu-system-aarch64
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 +	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
-@@ -27,6 +29,8 @@
+@@ -30,6 +32,8 @@
 	# QEMU_BINARY       = qemu-system-aarch64
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 +	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
-@@ -55,11 +59,13 @@
- DOCKER_CMD           = docker run -it --rm
- DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
- DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
- DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+@@ -56,21 +60,28 @@
+ DOCKER_IMAGE         = rustembedded/osdev-utils
+ DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+ DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+ DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 +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 jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm

 all: clean $(OUTPUT)

-@@ -88,6 +94,28 @@
- 		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
- 		$(OUTPUT)
+@@ -95,6 +106,24 @@
+ chainboot: all
+ 	@$(DOCKER_CHAINBOOT) $(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)                   \
-+		/jtag/$(JTAG_BOOT_IMAGE)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
 +
 +openocd:
-+	@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-+		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) 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) \
-+		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 +endef
 +
 +gdb: clean $(SOURCES)
--- a/10_privilege_level/Makefile
+++ b/10_privilege_level/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -44,35 +47,48 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -84,30 +100,22 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(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)                   \
-		/jtag/$(JTAG_BOOT_IMAGE)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) 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) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/11_virtual_memory/Makefile
+++ b/11_virtual_memory/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -44,35 +47,48 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -84,30 +100,22 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(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)                   \
-		/jtag/$(JTAG_BOOT_IMAGE)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) 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) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/12_exceptions_part1_groundwork/Makefile
+++ b/12_exceptions_part1_groundwork/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -20,7 +23,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -30,7 +33,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -44,35 +47,48 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -84,30 +100,22 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(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)                   \
-		/jtag/$(JTAG_BOOT_IMAGE)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) 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) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/13_integrated_testing/Makefile
+++ b/13_integrated_testing/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -21,7 +24,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -32,7 +35,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	# QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -57,37 +60,51 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-TEST_CMD   = cargo test $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
+TEST_CMD    = cargo test $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 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_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -102,17 +119,14 @@ test:
 	@echo $(QEMU_MISSING_STRING)
 else
 qemu: all
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)          \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)

 define KERNEL_TEST_RUNNER
 	#!/usr/bin/env bash

 	$(OBJCOPY_CMD) $$1 $$1.img
 	TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
-	$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+	$(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
 endef

 export KERNEL_TEST_RUNNER
@ -124,24 +138,18 @@ test: $(SOURCES)
 endif

 chainboot: all
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                       \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)

 jtagboot:
-	@$(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)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)

 define gen_gdb
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-	cp $(CARGO_OUTPUT) kernel_for_jtag
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/13_integrated_testing/README.md
+++ b/13_integrated_testing/README.md
@ -350,8 +350,7 @@ define KERNEL_TEST_RUNNER

 	$(OBJCOPY_CMD) $$1 $$1.img
 	TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
-	$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+	$(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
 endef

 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`:

 ```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
@ -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
 --- 12_exceptions_part1_groundwork/Makefile
 +++ 13_integrated_testing/Makefile
-@@ -19,6 +19,7 @@
+@@ -22,6 +22,7 @@
 	QEMU_BINARY       = qemu-system-aarch64
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 +	QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
-@@ -29,12 +30,24 @@
+@@ -32,12 +33,24 @@
 	# QEMU_BINARY       = qemu-system-aarch64
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 +	# QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -853,34 +852,49 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)

 RUSTFLAGS          = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
-@@ -47,6 +60,7 @@
- RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+@@ -50,6 +63,7 @@
+ RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
- CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-+TEST_CMD   = cargo test $(COMPILER_ARGS)
-
- CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
-@@ -56,7 +70,8 @@
- 	-O binary
+ CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
+TEST_CMD    = cargo test $(COMPILER_ARGS)
+ OBJCOPY_CMD = cargo objcopy \
+ 	--                  \
+ 	--strip-all         \
+@@ -58,18 +72,20 @@
+ KERNEL_ELF = target/$(TARGET)/release/kernel

 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-+DOCKER_CMD_TEST      = docker run -i --rm
+-DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_CMD_TEST      = docker run -i --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
 +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:/utils
- DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-@@ -65,7 +80,7 @@
- DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
- DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+ DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+ DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+ DOCKER_ARG_DEV       = --privileged -v /dev:/dev
+ DOCKER_ARG_NET       = --network host
+
+-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 test

 all: clean $(OUTPUT)

-@@ -81,32 +96,51 @@
+@@ -97,10 +113,28 @@

 ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
@ -891,19 +905,14 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 +	@echo $(QEMU_MISSING_STRING)
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-+	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-+		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)          \
- 		-kernel $(OUTPUT)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 +
 +define KERNEL_TEST_RUNNER
 +	#!/usr/bin/env bash
 +
 +	$(OBJCOPY_CMD) $$1 $$1.img
 +	TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
-+	$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-+		ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+	$(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
 +endef
 +
 +export KERNEL_TEST_RUNNER
@ -915,32 +924,6 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 endif

 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
 --- 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs
--- a/14_exceptions_part2_peripheral_IRQs/Makefile
+++ b/14_exceptions_part2_peripheral_IRQs/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -21,7 +24,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_RELEASE_ARGS = -serial stdio -display none
 	QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
@ -32,7 +35,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
 	# QEMU_TEST_ARGS    = $(QEMU_RELEASE_ARGS) -semihosting
 	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
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
@ -52,43 +55,57 @@ SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)

 RUSTFLAGS          = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
 RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs
-FEATURES           = bsp_$(BSP)

+FEATURES      = bsp_$(BSP)
 COMPILER_ARGS = --target=$(TARGET) \
 	--features $(FEATURES)     \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-TEST_CMD   = cargo test $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
+TEST_CMD    = cargo test $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 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_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/jtag
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DIR_JTAG  = -v $(shell pwd)/../X1_JTAG_boot:/work/X1_JTAG_boot
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
 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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -104,17 +121,14 @@ test:
 	@echo $(QEMU_MISSING_STRING)
 else
 qemu: all
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)          \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)

 define KERNEL_TEST_RUNNER
 	#!/usr/bin/env bash

 	$(OBJCOPY_CMD) $$1 $$1.img
 	TEST_BINARY=$$(echo $$1.img | sed -e 's/.*target/target/g')
-	$(DOCKER_CMD_TEST) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		ruby tests/runner.rb $(DOCKER_EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
+	$(DOCKER_TEST) ruby tests/runner.rb $(EXEC_QEMU) $(QEMU_TEST_ARGS) -kernel $$TEST_BINARY
 endef

 export KERNEL_TEST_RUNNER
@ -127,24 +141,18 @@ test: $(SOURCES)
 endif

 chainboot: all
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                       \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)

 jtagboot:
-	@$(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)
+	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)

 openocd:
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_TTY) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		openocd $(OPENOCD_ARG)
+	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)

 define gen_gdb
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-	cp $(CARGO_OUTPUT) kernel_for_jtag
-	@$(DOCKER_CMD_USER) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_NET) $(DOCKER_IMAGE) \
-		gdb-multiarch -q kernel_for_jtag
+	cp $(KERNEL_ELF) kernel_for_jtag
+	@$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
 endef

 gdb: clean $(SOURCES)
--- a/14_exceptions_part2_peripheral_IRQs/README.md
+++ b/14_exceptions_part2_peripheral_IRQs/README.md
@ -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
 --- 13_integrated_testing/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_PEDANTIC = $(RUSTFLAGS) -D warnings -D missing_docs
-+FEATURES           = bsp_$(BSP)

+FEATURES      = bsp_$(BSP)
 COMPILER_ARGS = --target=$(TARGET) \
 -	--features bsp_$(BSP)      \
 +	--features $(FEATURES)     \
 	--release

- RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
-@@ -94,6 +95,7 @@
+ RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
+@@ -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_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),)
 qemu:
 	@echo $(QEMU_MISSING_STRING)
-@@ -116,6 +118,7 @@
+@@ -130,6 +132,7 @@
 endef

 export KERNEL_TEST_RUNNER
--- a/X1_JTAG_boot/Makefile
+++ b/X1_JTAG_boot/Makefile
@ -7,11 +7,14 @@ ifndef BSP
 	BSP = rpi3
 endif

-# Default to /dev/ttyUSB0
+# Default to a serial device name that is common in Linux.
 ifndef DEV_SERIAL
 	DEV_SERIAL = /dev/ttyUSB0
 endif

+# Query the host system's kernel name
+UNAME_S := $(shell uname -s)
+
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
 	TARGET            = aarch64-unknown-none-softfloat
@ -40,33 +43,41 @@ COMPILER_ARGS = --target=$(TARGET) \
 	--features bsp_$(BSP)      \
 	--release

-RUSTC_CMD  = cargo rustc $(COMPILER_ARGS)
+RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
 DOC_CMD     = cargo doc $(COMPILER_ARGS)
-CLIPPY_CMD = cargo clippy $(COMPILER_ARGS)
-
-CARGO_OUTPUT = target/$(TARGET)/release/kernel
-
+CLIPPY_CMD  = cargo clippy $(COMPILER_ARGS)
 OBJCOPY_CMD = cargo objcopy \
 	--                  \
 	--strip-all         \
 	-O binary

+KERNEL_ELF = target/$(TARGET)/release/kernel
+
 DOCKER_IMAGE         = rustembedded/osdev-utils
-DOCKER_CMD           = docker run -it --rm
-DOCKER_ARG_DIR_TUT   = -v $(shell pwd):/work -w /work
-DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/utils
-DOCKER_ARG_TTY       = --privileged -v /dev:/dev
-DOCKER_EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
-DOCKER_EXEC_MINIPUSH = ruby /utils/minipush.rb
+DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
+DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
+DOCKER_ARG_DEV       = --privileged -v /dev:/dev
+
+DOCKER_QEMU = $(DOCKER_CMD) $(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)
+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

 all: clean $(OUTPUT)

-$(CARGO_OUTPUT): $(SOURCES)
+$(KERNEL_ELF): $(SOURCES)
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)

-$(OUTPUT): $(CARGO_OUTPUT)
+$(OUTPUT): $(KERNEL_ELF)
 	cp $< .
 	$(OBJCOPY_CMD) $< $(OUTPUT)

@ -78,15 +89,11 @@ qemu:
 	@echo "This board is not yet supported for QEMU."
 else
 qemu: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_IMAGE) \
-		$(DOCKER_EXEC_QEMU) $(QEMU_RELEASE_ARGS)     \
-		-kernel $(OUTPUT)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
 endif

 chainboot: all
-	@$(DOCKER_CMD) $(DOCKER_ARG_DIR_TUT) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_TTY) \
-		$(DOCKER_IMAGE) $(DOCKER_EXEC_MINIPUSH) $(DEV_SERIAL)                  \
-		$(OUTPUT)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)

 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)