2020-01-06 02:31:20 +00:00
|
|
|
#!/bin/sh
|
2013-05-29 01:27:29 +00:00
|
|
|
#
|
|
|
|
# Licensed under the terms of the GNU GPL License version 2 or later.
|
|
|
|
#
|
|
|
|
# Author: Peter Tyser <ptyser@xes-inc.com>
|
|
|
|
#
|
|
|
|
# U-Boot firmware supports the booting of images in the Flattened Image
|
|
|
|
# Tree (FIT) format. The FIT format uses a device tree structure to
|
|
|
|
# describe a kernel image, device tree blob, ramdisk, etc. This script
|
|
|
|
# creates an Image Tree Source (.its file) which can be passed to the
|
|
|
|
# 'mkimage' utility to generate an Image Tree Blob (.itb file). The .itb
|
|
|
|
# file can then be booted by U-Boot (or other bootloaders which support
|
|
|
|
# FIT images). See doc/uImage.FIT/howto.txt in U-Boot source code for
|
|
|
|
# additional information on FIT images.
|
|
|
|
#
|
|
|
|
|
|
|
|
usage() {
|
2020-07-11 16:46:53 +00:00
|
|
|
printf "Usage: %s -A arch -C comp -a addr -e entry" "$(basename "$0")"
|
2020-08-29 20:48:49 +00:00
|
|
|
printf " -v version -k kernel [-D name -n address -d dtb] -o its_file"
|
2020-07-11 16:46:53 +00:00
|
|
|
|
2020-01-06 02:31:17 +00:00
|
|
|
printf "\n\t-A ==> set architecture to 'arch'"
|
|
|
|
printf "\n\t-C ==> set compression type 'comp'"
|
|
|
|
printf "\n\t-c ==> set config name 'config'"
|
|
|
|
printf "\n\t-a ==> set load address to 'addr' (hex)"
|
|
|
|
printf "\n\t-e ==> set entry point to 'entry' (hex)"
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
printf "\n\t-f ==> set device tree compatible string"
|
2021-02-21 14:19:26 +00:00
|
|
|
printf "\n\t-i ==> include initrd Blob 'initrd'"
|
2020-01-06 02:31:17 +00:00
|
|
|
printf "\n\t-v ==> set kernel version to 'version'"
|
|
|
|
printf "\n\t-k ==> include kernel image 'kernel'"
|
|
|
|
printf "\n\t-D ==> human friendly Device Tree Blob 'name'"
|
2020-08-29 20:48:49 +00:00
|
|
|
printf "\n\t-n ==> fdt unit-address 'address'"
|
2020-01-06 02:31:17 +00:00
|
|
|
printf "\n\t-d ==> include Device Tree Blob 'dtb'"
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
printf "\n\t-r ==> include RootFS blob 'rootfs'"
|
|
|
|
printf "\n\t-H ==> specify hash algo instead of SHA1"
|
2021-07-19 04:21:44 +00:00
|
|
|
printf "\n\t-l ==> legacy mode character (@ etc otherwise -)"
|
2021-03-17 17:27:55 +00:00
|
|
|
printf "\n\t-o ==> create output file 'its_file'"
|
|
|
|
printf "\n\t-O ==> create config with dt overlay 'name:dtb'"
|
|
|
|
printf "\n\t\t(can be specified more than once)\n"
|
2013-05-29 01:27:29 +00:00
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
|
2021-07-19 04:21:44 +00:00
|
|
|
REFERENCE_CHAR='-'
|
2020-08-29 20:48:49 +00:00
|
|
|
FDTNUM=1
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
ROOTFSNUM=1
|
2021-02-21 14:19:26 +00:00
|
|
|
INITRDNUM=1
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
HASH=sha1
|
|
|
|
LOADABLES=
|
2021-03-17 17:27:55 +00:00
|
|
|
DTOVERLAY=
|
|
|
|
DTADDR=
|
2020-08-29 20:48:49 +00:00
|
|
|
|
2021-07-19 04:21:44 +00:00
|
|
|
while getopts ":A:a:c:C:D:d:e:f:i:k:l:n:o:O:v:r:H:" OPTION
|
2013-05-29 01:27:29 +00:00
|
|
|
do
|
|
|
|
case $OPTION in
|
|
|
|
A ) ARCH=$OPTARG;;
|
|
|
|
a ) LOAD_ADDR=$OPTARG;;
|
2018-03-05 08:51:47 +00:00
|
|
|
c ) CONFIG=$OPTARG;;
|
2013-10-16 10:29:50 +00:00
|
|
|
C ) COMPRESS=$OPTARG;;
|
|
|
|
D ) DEVICE=$OPTARG;;
|
2013-05-29 01:27:29 +00:00
|
|
|
d ) DTB=$OPTARG;;
|
|
|
|
e ) ENTRY_ADDR=$OPTARG;;
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
f ) COMPATIBLE=$OPTARG;;
|
2021-02-21 14:19:26 +00:00
|
|
|
i ) INITRD=$OPTARG;;
|
2013-05-29 01:27:29 +00:00
|
|
|
k ) KERNEL=$OPTARG;;
|
2021-07-19 04:21:44 +00:00
|
|
|
l ) REFERENCE_CHAR=$OPTARG;;
|
2020-08-29 20:48:49 +00:00
|
|
|
n ) FDTNUM=$OPTARG;;
|
2013-05-29 01:27:29 +00:00
|
|
|
o ) OUTPUT=$OPTARG;;
|
2021-03-17 17:27:55 +00:00
|
|
|
O ) DTOVERLAY="$DTOVERLAY ${OPTARG}";;
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
r ) ROOTFS=$OPTARG;;
|
2021-07-06 07:13:59 +00:00
|
|
|
H ) HASH=$OPTARG;;
|
2013-05-29 01:27:29 +00:00
|
|
|
v ) VERSION=$OPTARG;;
|
2020-01-06 02:31:19 +00:00
|
|
|
* ) echo "Invalid option passed to '$0' (options:$*)"
|
2013-05-29 01:27:29 +00:00
|
|
|
usage;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
|
|
|
# Make sure user entered all required parameters
|
|
|
|
if [ -z "${ARCH}" ] || [ -z "${COMPRESS}" ] || [ -z "${LOAD_ADDR}" ] || \
|
|
|
|
[ -z "${ENTRY_ADDR}" ] || [ -z "${VERSION}" ] || [ -z "${KERNEL}" ] || \
|
2018-03-05 08:51:47 +00:00
|
|
|
[ -z "${OUTPUT}" ] || [ -z "${CONFIG}" ]; then
|
2013-05-29 01:27:29 +00:00
|
|
|
usage
|
|
|
|
fi
|
|
|
|
|
2020-01-06 02:31:18 +00:00
|
|
|
ARCH_UPPER=$(echo "$ARCH" | tr '[:lower:]' '[:upper:]')
|
2013-10-16 10:29:50 +00:00
|
|
|
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
if [ -n "${COMPATIBLE}" ]; then
|
|
|
|
COMPATIBLE_PROP="compatible = \"${COMPATIBLE}\";"
|
|
|
|
fi
|
|
|
|
|
2021-03-17 17:27:55 +00:00
|
|
|
[ "$DTOVERLAY" ] && {
|
|
|
|
dtbsize=$(wc -c "$DTB" | cut -d' ' -f1)
|
|
|
|
DTADDR=$(printf "0x%08x" $(($LOAD_ADDR - $dtbsize)) )
|
|
|
|
}
|
|
|
|
|
2015-05-10 11:46:45 +00:00
|
|
|
# Conditionally create fdt information
|
|
|
|
if [ -n "${DTB}" ]; then
|
2019-09-16 09:42:49 +00:00
|
|
|
FDT_NODE="
|
2021-07-19 04:21:44 +00:00
|
|
|
fdt${REFERENCE_CHAR}$FDTNUM {
|
2015-05-10 11:46:45 +00:00
|
|
|
description = \"${ARCH_UPPER} OpenWrt ${DEVICE} device tree blob\";
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
${COMPATIBLE_PROP}
|
2015-05-10 11:46:45 +00:00
|
|
|
data = /incbin/(\"${DTB}\");
|
|
|
|
type = \"flat_dt\";
|
2021-03-17 17:27:55 +00:00
|
|
|
${DTADDR:+load = <${DTADDR}>;}
|
2015-05-10 11:46:45 +00:00
|
|
|
arch = \"${ARCH}\";
|
|
|
|
compression = \"none\";
|
|
|
|
hash@1 {
|
|
|
|
algo = \"crc32\";
|
|
|
|
};
|
|
|
|
hash@2 {
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
algo = \"${HASH}\";
|
2015-05-10 11:46:45 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
"
|
2021-07-19 04:21:44 +00:00
|
|
|
FDT_PROP="fdt = \"fdt${REFERENCE_CHAR}$FDTNUM\";"
|
2015-05-10 11:46:45 +00:00
|
|
|
fi
|
|
|
|
|
2021-02-21 14:19:26 +00:00
|
|
|
if [ -n "${INITRD}" ]; then
|
|
|
|
INITRD_NODE="
|
2021-07-19 04:21:44 +00:00
|
|
|
initrd${REFERENCE_CHAR}$INITRDNUM {
|
2021-02-21 14:19:26 +00:00
|
|
|
description = \"${ARCH_UPPER} OpenWrt ${DEVICE} initrd\";
|
|
|
|
${COMPATIBLE_PROP}
|
|
|
|
data = /incbin/(\"${INITRD}\");
|
|
|
|
type = \"ramdisk\";
|
|
|
|
arch = \"${ARCH}\";
|
|
|
|
os = \"linux\";
|
|
|
|
hash@1 {
|
|
|
|
algo = \"crc32\";
|
|
|
|
};
|
|
|
|
hash@2 {
|
|
|
|
algo = \"${HASH}\";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
"
|
2021-07-19 04:21:44 +00:00
|
|
|
INITRD_PROP="ramdisk=\"initrd${REFERENCE_CHAR}${INITRDNUM}\";"
|
2021-02-21 14:19:26 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
if [ -n "${ROOTFS}" ]; then
|
|
|
|
dd if="${ROOTFS}" of="${ROOTFS}.pagesync" bs=4096 conv=sync
|
|
|
|
ROOTFS_NODE="
|
2021-03-04 11:37:21 +00:00
|
|
|
rootfs-$ROOTFSNUM {
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
description = \"${ARCH_UPPER} OpenWrt ${DEVICE} rootfs\";
|
|
|
|
${COMPATIBLE_PROP}
|
|
|
|
data = /incbin/(\"${ROOTFS}.pagesync\");
|
|
|
|
type = \"filesystem\";
|
|
|
|
arch = \"${ARCH}\";
|
|
|
|
compression = \"none\";
|
|
|
|
hash@1 {
|
|
|
|
algo = \"crc32\";
|
|
|
|
};
|
|
|
|
hash@2 {
|
|
|
|
algo = \"${HASH}\";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
"
|
2021-07-19 04:21:44 +00:00
|
|
|
LOADABLES="${LOADABLES:+$LOADABLES, }\"rootfs${REFERENCE_CHAR}${ROOTFSNUM}\""
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
fi
|
|
|
|
|
2021-03-17 17:27:55 +00:00
|
|
|
# add DT overlay blobs
|
|
|
|
FDTOVERLAY_NODE=""
|
|
|
|
OVCONFIGS=""
|
|
|
|
[ "$DTOVERLAY" ] && for overlay in $DTOVERLAY ; do
|
|
|
|
overlay_blob=${overlay##*:}
|
|
|
|
ovname=${overlay%%:*}
|
|
|
|
ovnode="fdt-$ovname"
|
|
|
|
ovsize=$(wc -c "$overlay_blob" | cut -d' ' -f1)
|
|
|
|
echo "$ovname ($overlay_blob) : $ovsize" >&2
|
|
|
|
DTADDR=$(printf "0x%08x" $(($DTADDR - $ovsize)))
|
|
|
|
FDTOVERLAY_NODE="$FDTOVERLAY_NODE
|
|
|
|
|
|
|
|
$ovnode {
|
|
|
|
description = \"${ARCH_UPPER} OpenWrt ${DEVICE} device tree overlay $ovname\";
|
|
|
|
${COMPATIBLE_PROP}
|
|
|
|
data = /incbin/(\"${overlay_blob}\");
|
|
|
|
type = \"flat_dt\";
|
|
|
|
arch = \"${ARCH}\";
|
|
|
|
load = <${DTADDR}>;
|
|
|
|
compression = \"none\";
|
|
|
|
hash@1 {
|
|
|
|
algo = \"crc32\";
|
|
|
|
};
|
|
|
|
hash@2 {
|
|
|
|
algo = \"${HASH}\";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
"
|
|
|
|
OVCONFIGS="$OVCONFIGS
|
|
|
|
|
|
|
|
config-$ovname {
|
|
|
|
description = \"OpenWrt ${DEVICE} with $ovname\";
|
2021-07-19 04:21:44 +00:00
|
|
|
kernel = \"kernel${REFERENCE_CHAR}1\";
|
|
|
|
fdt = \"fdt${REFERENCE_CHAR}$FDTNUM\", \"$ovnode\";
|
2021-03-17 17:27:55 +00:00
|
|
|
${LOADABLES:+loadables = ${LOADABLES};}
|
|
|
|
${COMPATIBLE_PROP}
|
|
|
|
${INITRD_PROP}
|
|
|
|
};
|
|
|
|
"
|
|
|
|
done
|
|
|
|
|
2013-05-29 01:27:29 +00:00
|
|
|
# Create a default, fully populated DTS file
|
|
|
|
DATA="/dts-v1/;
|
|
|
|
|
|
|
|
/ {
|
2013-10-16 10:29:50 +00:00
|
|
|
description = \"${ARCH_UPPER} OpenWrt FIT (Flattened Image Tree)\";
|
2013-05-29 01:27:29 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
|
|
|
|
images {
|
2021-07-19 04:21:44 +00:00
|
|
|
kernel${REFERENCE_CHAR}1 {
|
2013-10-16 10:29:50 +00:00
|
|
|
description = \"${ARCH_UPPER} OpenWrt Linux-${VERSION}\";
|
2013-05-29 01:27:29 +00:00
|
|
|
data = /incbin/(\"${KERNEL}\");
|
|
|
|
type = \"kernel\";
|
|
|
|
arch = \"${ARCH}\";
|
|
|
|
os = \"linux\";
|
|
|
|
compression = \"${COMPRESS}\";
|
|
|
|
load = <${LOAD_ADDR}>;
|
|
|
|
entry = <${ENTRY_ADDR}>;
|
|
|
|
hash@1 {
|
|
|
|
algo = \"crc32\";
|
|
|
|
};
|
|
|
|
hash@2 {
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
algo = \"$HASH\";
|
2013-05-29 01:27:29 +00:00
|
|
|
};
|
|
|
|
};
|
2021-02-21 14:19:26 +00:00
|
|
|
${INITRD_NODE}
|
2019-09-16 09:42:49 +00:00
|
|
|
${FDT_NODE}
|
2021-03-17 17:27:55 +00:00
|
|
|
${FDTOVERLAY_NODE}
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
${ROOTFS_NODE}
|
2013-05-29 01:27:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
configurations {
|
2018-03-05 08:51:47 +00:00
|
|
|
default = \"${CONFIG}\";
|
|
|
|
${CONFIG} {
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
description = \"OpenWrt ${DEVICE}\";
|
2021-07-19 04:21:44 +00:00
|
|
|
kernel = \"kernel${REFERENCE_CHAR}1\";
|
2019-09-16 09:42:49 +00:00
|
|
|
${FDT_PROP}
|
image: add support for building FIT image with filesystem
Allow for single (external-data) FIT image to hold kernel, dtb and
squashfs. In that way, the bootloader verifies the system integrity
including the rootfs, because what's the point of checking that the
hash of the kernel is correct if it won't boot in case of squashfs
being corrupted? Better allow bootloader to check everything needed
to make it at least up to failsafe mode. As a positive side effect
this change also makes the sysupgrade process on nand potentially
much easier as it is now.
In short: mkimage has a parameter '-E' which allows generating FIT
images with 'external' data rather than embedding the data into the
device-tree blob itself. In this way, the FIT structure itself remains
small and can be parsed easily (rather than having to page around
megabytes of image content). This patch makes use of that and adds
support for adding sub-images of type 'filesystem' which are used to
store the squashfs. Now U-Boot can verify the whole OS and the new
partition parsers added in the Linux kernel can detect the filesystem
sub-images, create partitions for them, and select the active rootfs
volume based on the configuration in FIT (passing configuration via
device tree could be implemented easily at a later stage).
This new FIT partition parser works for NOR flash (on top of mtdblock),
NAND flash (on top of ubiblock) as well as classic block devices
(ie. eMMC, SDcard, SATA, NVME, ...).
It could even be used to mount such FIT images via `losetup -P` on a
user PC if this patch gets included in Linux upstream one day ;)
Signed-off-by: John Crispin <john@phrozen.org>
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
2021-02-15 14:37:17 +00:00
|
|
|
${LOADABLES:+loadables = ${LOADABLES};}
|
|
|
|
${COMPATIBLE_PROP}
|
2021-02-21 14:19:26 +00:00
|
|
|
${INITRD_PROP}
|
2013-05-29 01:27:29 +00:00
|
|
|
};
|
2021-03-17 17:27:55 +00:00
|
|
|
${OVCONFIGS}
|
2013-05-29 01:27:29 +00:00
|
|
|
};
|
|
|
|
};"
|
|
|
|
|
|
|
|
# Write .its file to disk
|
2020-01-06 02:31:18 +00:00
|
|
|
echo "$DATA" > "${OUTPUT}"
|