[bootlin/training-materials updates] master: Embedded Linux: new qemu labs (9a8178e5)
Michael Opdenacker
michael.opdenacker at bootlin.com
Wed Jun 24 13:26:24 CEST 2020
Repository : https://github.com/bootlin/training-materials
On branch : master
Link : https://github.com/bootlin/training-materials/commit/9a8178e51e3c88b129a114930e40350c45f9ed1e
>---------------------------------------------------------------
commit 9a8178e51e3c88b129a114930e40350c45f9ed1e
Author: Michael Opdenacker <michael.opdenacker at bootlin.com>
Date: Wed Jun 24 13:25:19 2020 +0200
Embedded Linux: new qemu labs
- Implemented until the kernel cross-compiling labs
- The agenda still needs updating
Signed-off-by: Michael Opdenacker <michael.opdenacker at bootlin.com>
>---------------------------------------------------------------
9a8178e51e3c88b129a114930e40350c45f9ed1e
common/embedded-linux-qemu-labs-vars.tex | 3 +
lab-data/embedded-linux-qemu/appdev | 1 +
.../embedded-linux-qemu/bootloader/data/u-boot | Bin 0 -> 4928244 bytes
lab-data/embedded-linux-qemu/debugging | 1 +
lab-data/embedded-linux-qemu/realtime | 1 +
lab-data/embedded-linux-qemu/thirdparty | 1 +
lab-data/embedded-linux-qemu/tinysystem | 1 +
lab-data/embedded-linux-qemu/toolchain | 1 +
.../sysdev-kernel-cross-compiling.tex | 60 +++--
labs/sysdev-toolchain/sysdev-toolchain.tex | 9 +-
labs/sysdev-u-boot-qemu/sysdev-u-boot-qemu.tex | 291 +++++++++++++++++++++
labs/ubuntu-vm/ubuntu-vm.tex | 31 +++
mk/embedded-linux-qemu.mk | 62 +++++
.../online-challenges/005-boot-linux-from-sd | 2 +-
.../online-challenges/006-rootfs.txt | 2 +-
15 files changed, 434 insertions(+), 32 deletions(-)
diff --git a/common/embedded-linux-qemu-labs-vars.tex b/common/embedded-linux-qemu-labs-vars.tex
new file mode 100644
index 00000000..15715485
--- /dev/null
+++ b/common/embedded-linux-qemu-labs-vars.tex
@@ -0,0 +1,3 @@
+\def\labbooktitle{Embedded Linux System Development}
+\def\labbooksubtitle{QEMU ARM variant}
+\def\labboard{qemu}
diff --git a/lab-data/embedded-linux-qemu/appdev b/lab-data/embedded-linux-qemu/appdev
new file mode 120000
index 00000000..2b2bb16b
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/appdev
@@ -0,0 +1 @@
+../embedded-linux/appdev
\ No newline at end of file
diff --git a/lab-data/embedded-linux-qemu/bootloader/data/u-boot b/lab-data/embedded-linux-qemu/bootloader/data/u-boot
new file mode 100644
index 00000000..7e2eadf3
Binary files /dev/null and b/lab-data/embedded-linux-qemu/bootloader/data/u-boot differ
diff --git a/lab-data/embedded-linux-qemu/debugging b/lab-data/embedded-linux-qemu/debugging
new file mode 120000
index 00000000..f482ac6d
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/debugging
@@ -0,0 +1 @@
+../embedded-linux/debugging
\ No newline at end of file
diff --git a/lab-data/embedded-linux-qemu/realtime b/lab-data/embedded-linux-qemu/realtime
new file mode 120000
index 00000000..c346d105
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/realtime
@@ -0,0 +1 @@
+../embedded-linux/realtime
\ No newline at end of file
diff --git a/lab-data/embedded-linux-qemu/thirdparty b/lab-data/embedded-linux-qemu/thirdparty
new file mode 120000
index 00000000..02952df4
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/thirdparty
@@ -0,0 +1 @@
+../embedded-linux/thirdparty
\ No newline at end of file
diff --git a/lab-data/embedded-linux-qemu/tinysystem b/lab-data/embedded-linux-qemu/tinysystem
new file mode 120000
index 00000000..6d9b860c
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/tinysystem
@@ -0,0 +1 @@
+../embedded-linux/tinysystem
\ No newline at end of file
diff --git a/lab-data/embedded-linux-qemu/toolchain b/lab-data/embedded-linux-qemu/toolchain
new file mode 120000
index 00000000..de5fa6fe
--- /dev/null
+++ b/lab-data/embedded-linux-qemu/toolchain
@@ -0,0 +1 @@
+../embedded-linux/toolchain
\ No newline at end of file
diff --git a/labs/sysdev-kernel-cross-compiling/sysdev-kernel-cross-compiling.tex b/labs/sysdev-kernel-cross-compiling/sysdev-kernel-cross-compiling.tex
index 845960e7..72e6b7bf 100644
--- a/labs/sysdev-kernel-cross-compiling/sysdev-kernel-cross-compiling.tex
+++ b/labs/sysdev-kernel-cross-compiling/sysdev-kernel-cross-compiling.tex
@@ -5,7 +5,7 @@ After this lab, you will be able to:
\begin{itemize}
\item Set up a cross-compiling environment
\item Configure the kernel Makefile accordingly
-\item Cross compile the kernel for the Microchip SAMA5D3 Xplained ARM board
+\item Cross compile the kernel for your board
\item Use U-Boot to download the kernel
\item Check that the kernel you compiled starts the system
\end{itemize}
@@ -14,11 +14,6 @@ After this lab, you will be able to:
Go to the \code{$HOME/__SESSION_NAME__-labs/kernel} directory.
-\section{Target system}
-
-We are going to cross-compile and boot a Linux kernel for the Microchip
-SAMA5D3 Xplained board.
-
\section{Kernel sources}
We will re-use the kernel sources downloaded and patched in the
@@ -46,10 +41,14 @@ Also, don't forget to either:
\section{Linux kernel configuration}
By running \code{make help}, find the proper Makefile target to
-configure the kernel for the Xplained board (hint: the default
+configure the kernel
+
+\ifdefstring{\labboard}{qemu}
+{for the ARM Vexpress boards (\code{vexpress_defconfig})}
+{for the Xplained board (hint: the default
configuration is not named after the board, but after the SoC
name). Once found, use this target to configure the kernel with the
-ready-made configuration.
+ready-made configuration.}
Don't hesitate to visualize the new settings by running
\code{make xconfig} afterwards!
@@ -83,22 +82,29 @@ home directory.
\section{Load and boot the kernel using U-Boot}
-We will use TFTP to load the kernel image on the Xplained board:
+We will use TFTP to load the kernel image on the ARM board:
\begin{itemize}
-\item On your workstation, copy the \code{zImage} and DTB files to the
- directory exposed by the TFTP server.
+\item On your workstation, copy the \code{zImage} and DTB to the
+\ifdefstring{\labboard}{qemu}{(\code{vexpress-v2p-ca9.dtb})}
+files to the directory exposed by the TFTP server.
\item On the target (in the U-Boot prompt), load \code{zImage} from
- TFTP into RAM at address 0x21000000:\\
- \code{tftp 0x21000000 zImage}
+TFTP into RAM:
+\ifdefstring{\labboard}{qemu}
+{\code{tftp 0x61000000 zImage}}
+{\code{tftp 0x21000000 zImage}}
-\item Now, also load the DTB file into RAM at address 0x22000000:\\
- \code{tftp 0x22000000 at91-sama5d3_xplained.dtb}
+\item Now, also load the DTB file into RAM:\\
+\ifdefstring{\labboard}{qemu}
+{\code{tftp 0x62000000 vexpress-v2p-ca9.dtb}}
+{\code{tftp 0x22000000 at91-sama5d3_xplained.dtb}}
\item Boot the kernel with its device tree:\\
- \code{bootz 0x21000000 - 0x22000000}
+\ifdefstring{\labboard}{qemu}
+{\code{bootz 0x61000000 - 0x62000000}}
+{\code{bootz 0x21000000 - 0x22000000}}
\end{itemize}
@@ -106,15 +112,22 @@ You should see Linux boot and finally panicking. This is expected: we
haven't provided a working root filesystem for our device yet.
You can now automate all this every time the board is booted or
-reset. Reset the board, and specify a different \code{bootcmd}:
+reset. Reset the board, and customize \code{bootcmd}:
+\ifdefstring{\labboard}{qemu}{\scriptsize
+\code{setenv bootcmd 'tftp 0x61000000 zImage; tftp 0x62000000
+vexpress-v2p-ca9.dtb; bootz 0x61000000 - 0x62000000'}\\
+\code{saveenv}
+}
{\scriptsize
-\begin{verbatim}
-setenv bootcmd 'tftp 0x21000000 zImage; tftp 0x22000000 at91-sama5d3_xplained.dtb; bootz 0x21000000 - 0x22000000'
-saveenv
-\end{verbatim}
+\code{setenv bootcmd 'tftp 0x21000000 zImage; tftp 0x22000000 at91-sama5d3_xplained.dtb; bootz 0x21000000 - 0x22000000'}\\
+\code{saveenv}
}
+Restart the board to make sure that booting the kernel is now automated.
+
+\ifdefstring{\labboard}{xplained}
+{
\section{Flashing the kernel and DTB in NAND flash}
In order to let the kernel boot on the board autonomously, we can
@@ -131,14 +144,12 @@ and Linux kernel images:
So, let's start by erasing the corresponding 128 KiB of NAND flash
for the DTB:
-
\begin{verbatim}
nand erase 0x180000 0x20000
(NAND offset) (size)
\end{verbatim}
Then, let's erase the 5 MiB of NAND flash for the kernel image:
-
\begin{verbatim}
nand erase 0x1a0000 0x500000
\end{verbatim}
@@ -147,7 +158,6 @@ Then, copy the DTB and kernel binaries from TFTP into memory, using the
same addresses as before.
Then, flash the DTB and kernel binaries:
-
\begin{verbatim}
nand write 0x22000000 0x180000 0x20000
(RAM addr) (NAND offset) (size)
@@ -187,3 +197,5 @@ the kernel that's running\footnote{Look at the kernel log. You will find
the kernel version number as well as the date when it was compiled.
That's very useful to check that you're not loading an older version
of the kernel instead of the one that you've just compiled.}
+}
+{}
diff --git a/labs/sysdev-toolchain/sysdev-toolchain.tex b/labs/sysdev-toolchain/sysdev-toolchain.tex
index fa14733e..c80d60eb 100644
--- a/labs/sysdev-toolchain/sysdev-toolchain.tex
+++ b/labs/sysdev-toolchain/sysdev-toolchain.tex
@@ -62,12 +62,9 @@ Crosstool-ng comes with a set of ready-made configuration files for
various typical setups: Crosstool-ng calls them {\em samples}. They can be
listed by using \code{./ct-ng list-samples}.
-We will start with the \code{arm-cortexa5-linux-uclibcgnueabihf} sample. It
-can be loaded by issuing:
-
-\begin{verbatim}
-./ct-ng arm-cortexa5-linux-uclibcgnueabihf
-\end{verbatim}
+We will load the
+\ifdefstring{\labboard}{qemu}{Cortex A9}{Cortex A5}
+sample. Load it with the \code{./ct-ng} command.
Then, to refine the configuration, let's run the \code{menuconfig} interface:
diff --git a/labs/sysdev-u-boot-qemu/sysdev-u-boot-qemu.tex b/labs/sysdev-u-boot-qemu/sysdev-u-boot-qemu.tex
new file mode 100644
index 00000000..133f9f75
--- /dev/null
+++ b/labs/sysdev-u-boot-qemu/sysdev-u-boot-qemu.tex
@@ -0,0 +1,291 @@
+\subchapter{Bootloader - U-Boot}{Objectives: Compile and install the U-Boot bootloader,
+ use basic U-Boot commands, set up TFTP communication with the development
+ workstation.}
+
+\section{Setup}
+
+Go to the \code{$HOME/__SESSION_NAME__-labs/bootloader} directory.
+
+Install the \code{qemu-system-arm} package. In this lab and in the
+following ones, we will use a QEMU emulated ARM Vexpress Cortex A9 board.
+
+\section{Configuring U-Boot}
+
+Download U-Boot v2020.04 and configure it
+to support the ARM Vexpress Cortex A9 board
+(\code{vexpress_ca9x4_defconfig})
+
+Get an understanding of U-Boot's configuration and compilation steps
+by reading the \code{README} file, and specifically the {\em Building
+the Software} section.
+
+Basically, you need to specify the cross-compiler prefix
+(the part before \code{gcc} in the cross-compiler executable name):
+\begin{verbatim}
+export CROSS_COMPILE=arm-linux-
+\end{verbatim}
+
+Now that you have a valid initial configuration, run \code{make menuconfig}
+to further edit your bootloader features:
+
+\begin{itemize}
+\item In the \code{Environment} submenu, we will configure U-Boot so
+ that it stores its environment inside a file called {\em
+ uboot.env} in a FAT filesystem on an MMC/SD card, as our emulated
+ machine won't have flash storage:
+ \begin{itemize}
+ \item Unset \code{Environment in flash memory} (\code{CONFIG_ENV_IS_IN_FLASH})
+ \item Set \code{Environment is in a FAT filesystem} (\code{CONFIG_ENV_IS_IN_FAT}
+ \item Set \code{Name of the block device for the environment} (\code{CONFIG_ENV_FAT_INTERFACE}): \code{mmc}
+ \item \code{Device and partition for where to store the environment in
+ FAT} (\code{CONFIG_ENV_FAT_DEVICE_AND_PART}): \code{0:1}\newline
+ The above two settings correspond to the arguments of the
+ \code{fatload} command.
+ \end{itemize}
+ \item Also add support for the \code{editenv} command (\code{CONFIG_CMD_EDITENV})
+ that is not present in the default configuration for our board
+ Unfortunately, this command is currently broken.
+\end{itemize}
+
+In recent versions of U-Boot and for some boards, you will
+need to have the Device Tree compiler:
+
+\begin{verbatim}
+sudo apt install device-tree-compiler
+\end{verbatim}
+
+Finally, run \code{make}\footnote{You can speed up the
+compiling by using the \code{-jX} option with \code{make}, where X
+is the number of parallel jobs used for compiling. Twice the
+number of CPU cores is a good value.}, which will build U-Boot.
+
+
+This generates several binaries, including \code{u-boot} and
+\code{u-boot.bin}.
+
+\section{Testing U-Boot}
+
+Still in U-Boot sources, test that U-Boot works:
+
+\begin{verbatim}
+qemu-system-arm -M vexpress-a9 -m 128M -nographic -kernel u-boot
+\end{verbatim}
+
+\begin{itemize}
+\item \code{-M}: emulated machine
+\item \code{-m}: amount of memory in the emulated machine
+\item \code{-kernel}: allows to load the binary directly in the emulated
+ machine and run the machine with it. This way, you don't
+ need a first stage bootloader. Of course, you don't
+ have this with real hardware.
+\end{itemize}
+
+Press a key before the end of the timeout, to access the U-Boot prompt.
+
+You can then type the \code{help} command, and explore the few commands
+available.
+
+Note: to exit QEMU, run the below command in another terminal:
+
+\begin{verbatim}
+killall qemu-system-arm
+\end{verbatim}
+
+\section{SD card setup}
+
+We now need to add an SD card image to the QEMU virtual machine,
+in particular to get a way to store U-Boot's environment.
+
+In later labs, we will also use such storage for other purposes
+(to store the kernel and device tree, root filesystem and other
+filesystems).
+
+The commands that we are going to use will be further explained
+during the {\em Block filesystems} lectures.
+
+First, using the \code{dd} command, create a 1 GB file
+filled with zeros, called code{sd.img}:
+
+\begin{verbatim}
+dd if=/dev/zero of=sd.img bs=1M count=1024
+\end{verbatim}
+
+This will be used by QEMU as an SD card disk image
+
+Now, let's use the \code{cfdisk} command to create the partitions that
+we are going to use:
+
+\begin{verbatim}
+$ cfdisk sd.img
+\end{verbatim}
+
+If \code{cfdisk} asks you to \code{Select a label type}, choose
+\code{dos}. This corresponds to traditional partitions tables that DOS/Windows
+would understand. \code{gpt} partition tables are needed for disks bigger
+than 2 TB.
+
+In the \code{cfdisk} interface, create three primary partitions,
+starting from the beginning, with the following properties:
+
+\begin{itemize}
+\item One partition, 64MB big, with the \code{FAT16} partition type.
+ Mark this partition as bootable.
+
+\item One partition, 8 MB big\footnote{For the needs of our system,
+ the partition could even be much smaller, and 1 MB would be enough.
+ However, with the 8 GB SD cards that we use in our labs, 8 MB will
+ be the smallest partition that \code{cfdisk} will allow you to
+ create.}, that will be used for the root filesystem. Due to the
+ geometry of the device, the partition might be larger than 8 MB,
+ but it does not matter. Keep the \code{Linux} type for the
+ partition.
+
+\item One partition, that fills the rest of the SD card image, that will be
+ used for the data filesystem. Here also, keep the \code{Linux} type
+ for the partition.
+\end{itemize}
+
+Press \code{Write} when you are done.
+
+We will now use the {\em loop} driver\footnote{Once again, this will
+be properly be explained during our {\em Block filesystems} lectures.}
+to emulate block devices from this image and its partitions:
+
+\begin{verbatim}
+sudo losetup -f --show --partscan sd.img
+\end{verbatim}
+
+\begin{itemize}
+\item \code{-f}: finds a free loop device
+\item \code{--show}: shows the loop device that it used
+\item \code{--partscan}: scans the loop device for partitions
+ and creates additional \code{/dev/loop<x>p<y>} block devices.
+\end{itemize}
+
+Last but not least, format the first partition as FAT16 with
+a \code{boot} label:
+
+\begin{verbatim}
+sudo mkfs.vfat -F 16 -n boot /dev/loop<x>p1
+\end{verbatim}
+
+The other partitions will be formated later.
+
+\section{Testing U-Boot's environment}
+
+Start QEMU again, but this time with the emulated SD card
+(you can type the command in a single line):
+
+\begin{verbatim}
+qemu-system-arm -M vexpress-a9 -m 128M -nographic \
+ -kernel u-boot-2020.04/u-boot \
+ -sd sd.img
+\end{verbatim}
+
+Now, in the U-Boot prompt, make sure that you can set and store an environment variable:
+
+\begin{verbatim}
+setenv foo bar
+saveenv
+\end{verbatim}
+
+Type \code{reset} which reboots the board, and then check that the
+\code{foo} variable is still set:
+
+\begin{verbatim}
+printenv foo
+\end{verbatim}
+
+\section{Setup networking between QEMU and the host}
+
+To load a kernel in the next lab, we will setup networking between the QEMU emulated
+machine and the host.
+
+The first thing to do is to create a \code{/etc/qemu-myifup} (for example)
+script that will bring up a network interface between QEMU and the host. Here are its contents:
+
+\begin{verbatim}
+#!/bin/bash
+exec /sbin/ifconfig $1 192.168.100.1
+\end{verbatim}
+
+Of course, make this script executable:
+\begin{verbatim}
+sudo chmod +x /etc/qemu-myifup
+\end{verbatim}
+
+As you can see, the host side will have the \code{192.168.100.1} IP
+address. We will use \code{192.168.100.2} for the target side.
+
+Then, you will need root privileges to run QEMU this time,
+because of the need to bring up the network interface:
+
+\begin{verbatim}
+qemu-system-arm -M vexpress-a9 -m 128M -nographic \
+ -kernel u-boot-2020.04/u-boot \
+ -sd sd.img \
+ -net tap,script=/etc/qemu-myifup -net nic
+\end{verbatim}
+
+Note the new net options:
+\begin{itemize}
+\item \code{-net tap}: creates a software network interface on the host side
+\item \code{-net nic}: adds a network device to the emulated machine
+\end{itemize}
+
+On the host machine, using the \code{ifconfig} command, check that
+there is now a \code{tap0} network interface with the expected IP
+address.
+
+On the U-Boot command line, you will have to configure the environment
+variables for networking:
+
+\begin{verbatim}
+setenv ipaddr 192.168.100.2
+setenv serverip 192.168.100.1
+saveenv
+\end{verbatim}
+
+You can now test the connection to the host:
+\begin{verbatim}
+ping 192.168.100.1
+\end{verbatim}
+
+It should finish by:
+\begin{verbatim}
+host 192.168.100.1 is alive
+\end{verbatim}
+
+\section{tftp setup}
+
+Install a {\em tftp} server on your host as explained in the slides.
+
+Back in U-Boot, run \code{bdinfo}, which will allow you to find out that
+RAM starts at \code{0x60000000}. Therefore, we will use the \code{0x61000000}
+address to test {\em tftp}.
+
+To test the TFTP connection, put a small text file in
+the directory exported through TFTP on your development
+workstation. Then, from U-Boot, do:
+
+\begin{verbatim}
+tftp 0x61000000 textfile.txt
+\end{verbatim}
+
+The \code{tftp} command should have downloaded the
+\code{textfile.txt} file from your development workstation into
+the board's memory at location \code{0x61000000}.
+
+You can verify that the download was successful by dumping the
+contents of the memory:
+
+\begin{verbatim}
+md 0x61000000
+\end{verbatim}
+
+\section{Rescue binary}
+
+If you have trouble generating binaries that work properly, or later
+make a mistake that causes you to loose your bootloader binary, you
+will find a working version under \code{data/} in the current lab
+directory.
diff --git a/labs/ubuntu-vm/ubuntu-vm.tex b/labs/ubuntu-vm/ubuntu-vm.tex
new file mode 100644
index 00000000..16684a1a
--- /dev/null
+++ b/labs/ubuntu-vm/ubuntu-vm.tex
@@ -0,0 +1,31 @@
+\subchapter{Ubuntu installation}{Set up the Linux distribution: Ubuntu 20.04}
+
+\section{Option 1: native installation}
+
+Go to \url{https://ubuntu.com/#download}, download the Desktop edition
+and then follow the instructions.
+
+You don't have to replace your existing operating system completely.
+Just make some free space (at least 30 GB for Ubuntu and the labs
+we will run) and install Ubuntu alongside your existing system.
+
+\section{Option 2: using a VirtualBox virtual machine}
+
+In case you have to keep your existing operating system and
+dual-booting is not an option, another option is to download VirtualBox
+(\url{https://www.virtualbox.org/}) and download and use our virtual
+machine image from
+\url{https://f000.backblazeb2.com/file/bootlin-big-files/training/ubuntu-20.04-20200617.ova}
+
+You will still need something like 30 GB of free space to run all the
+labs comfortably.
+
+In Virtualbox, you just have to use {\code File -> Import Appliance}
+to create a new virtual machine from this image.
+
+In this VM, here are the credentials:
+\begin{itemize}
+\item User: \code{tux}
+\item Password: \code{tux}
+\end{itemize}
+
diff --git a/mk/embedded-linux-qemu.mk b/mk/embedded-linux-qemu.mk
new file mode 100644
index 00000000..c9444f6a
--- /dev/null
+++ b/mk/embedded-linux-qemu.mk
@@ -0,0 +1,62 @@
+EMBEDDED_LINUX_QEMU_SLIDES = \
+ first-slides \
+ about-us \
+ course-information-title \
+ xplained-board \
+ sysdev-shopping-list \
+ course-information \
+ sysdev-intro \
+ sysdev-dev-environment \
+ setup-lab \
+ sysdev-toolchains-title \
+ sysdev-toolchains-definition \
+ sysdev-toolchains-c-libraries-title \
+ c-libraries \
+ sysdev-toolchains-options \
+ sysdev-toolchains-obtaining \
+ sysdev-toolchains-lab \
+ sysdev-bootloaders-title \
+ sysdev-bootloaders-sequence \
+ sysdev-bootloaders-u-boot \
+ sysdev-bootloaders-lab \
+ sysdev-linux-intro-title \
+ sysdev-linux-intro-features \
+ sysdev-linux-intro-versioning \
+ sysdev-linux-intro-sources \
+ sysdev-linux-tarballs-and-patches \
+ sysdev-linux-intro-lab-sources \
+ sysdev-kernel-building \
+ sysdev-linux-intro-lab-cross-compilation \
+ sysdev-linux-intro-modules \
+ sysdev-root-filesystem-title \
+ sysdev-root-filesystem-principles \
+ initramfs \
+ sysdev-root-filesystem-contents \
+ sysdev-root-filesystem-device-files \
+ sysdev-device-files \
+ sysdev-root-filesystem-virtual-fs \
+ sysdev-root-filesystem-minimal \
+ boot-sequence-initramfs \
+ sysdev-busybox \
+ sysdev-block-filesystems \
+ sysdev-flash-filesystems \
+ sysdev-embedded-linux \
+ sysdev-application-development \
+ sysdev-realtime \
+ sysdev-references \
+ last-slides
+
+EMBEDDED_LINUX_QEMU_LABS = ubuntu-vm \
+ setup \
+ sysdev-toolchain \
+ sysdev-u-boot-qemu \
+ sysdev-kernel-fetch-and-patch \
+ sysdev-kernel-cross-compiling \
+ sysdev-tinysystem \
+ sysdev-block-filesystems \
+ sysdev-flash-filesystems \
+ sysdev-thirdparty \
+ sysdev-buildroot \
+ sysdev-application-development \
+ sysdev-application-debugging \
+ sysdev-real-time
diff --git a/resources/embedded-linux/online-challenges/005-boot-linux-from-sd b/resources/embedded-linux/online-challenges/005-boot-linux-from-sd
index d26a04d8..34a35df4 100644
--- a/resources/embedded-linux/online-challenges/005-boot-linux-from-sd
+++ b/resources/embedded-linux/online-challenges/005-boot-linux-from-sd
@@ -34,7 +34,7 @@ environment variable to do this.
- Type "reset" and check that "foo" is still set:
printenv foo
-- Now, run "bdinfo" and fine that RAM starts at 0x60000000.
+- Now, run "bdinfo" and find that RAM starts at 0x60000000.
We will load the kernel image from the SD's FAT partition to
address 0x61000000, and the DTB at address 0x62000000
diff --git a/resources/embedded-linux/online-challenges/006-rootfs.txt b/resources/embedded-linux/online-challenges/006-rootfs.txt
index 972e3385..e575160a 100644
--- a/resources/embedded-linux/online-challenges/006-rootfs.txt
+++ b/resources/embedded-linux/online-challenges/006-rootfs.txt
@@ -30,7 +30,7 @@ sudo qemu-system-arm -M vexpress-a9 -m 128M -nographic -kernel u-boot -sd sd.img
Also note the new net options:
-net tap: creates a software network interface on the host side
- -net nice: adds a network device to the emulated machine
+ -net nic: adds a network device to the emulated machine
- In QEMU, interrupt the countdown in U-Boot modify bootargs to
setup the target IP address to 192.168.100.2
More information about the training-materials-updates
mailing list