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
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
|
/*
|
|
|
|
|
* fs/partitions/fit.c
|
|
|
|
|
* Copyright (C) 2021 Daniel Golle
|
|
|
|
|
*
|
|
|
|
|
* headers extracted from U-Boot mkimage sources
|
|
|
|
|
* (C) Copyright 2008 Semihalf
|
|
|
|
|
* (C) Copyright 2000-2005
|
|
|
|
|
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
|
|
|
|
*
|
|
|
|
|
* based on existing partition parsers
|
|
|
|
|
* Copyright (C) 1991-1998 Linus Torvalds
|
|
|
|
|
* Re-organised Feb 1998 Russell King
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) fmt
|
|
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/of.h>
|
|
|
|
|
#include <linux/of_device.h>
|
|
|
|
|
#include <linux/of_fdt.h>
|
|
|
|
|
#include <linux/libfdt.h>
|
2022-01-07 17:39:42 +00:00
|
|
|
#include <linux/version.h>
|
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
|
|
|
|
|
|
|
|
#include "check.h"
|
|
|
|
|
|
|
|
|
|
#define FIT_IMAGES_PATH "/images"
|
|
|
|
|
#define FIT_CONFS_PATH "/configurations"
|
|
|
|
|
|
|
|
|
|
/* hash/signature/key node */
|
|
|
|
|
#define FIT_HASH_NODENAME "hash"
|
|
|
|
|
#define FIT_ALGO_PROP "algo"
|
|
|
|
|
#define FIT_VALUE_PROP "value"
|
|
|
|
|
#define FIT_IGNORE_PROP "uboot-ignore"
|
|
|
|
|
#define FIT_SIG_NODENAME "signature"
|
|
|
|
|
#define FIT_KEY_REQUIRED "required"
|
|
|
|
|
#define FIT_KEY_HINT "key-name-hint"
|
|
|
|
|
|
|
|
|
|
/* cipher node */
|
|
|
|
|
#define FIT_CIPHER_NODENAME "cipher"
|
|
|
|
|
#define FIT_ALGO_PROP "algo"
|
|
|
|
|
|
|
|
|
|
/* image node */
|
|
|
|
|
#define FIT_DATA_PROP "data"
|
|
|
|
|
#define FIT_DATA_POSITION_PROP "data-position"
|
|
|
|
|
#define FIT_DATA_OFFSET_PROP "data-offset"
|
|
|
|
|
#define FIT_DATA_SIZE_PROP "data-size"
|
|
|
|
|
#define FIT_TIMESTAMP_PROP "timestamp"
|
|
|
|
|
#define FIT_DESC_PROP "description"
|
|
|
|
|
#define FIT_ARCH_PROP "arch"
|
|
|
|
|
#define FIT_TYPE_PROP "type"
|
|
|
|
|
#define FIT_OS_PROP "os"
|
|
|
|
|
#define FIT_COMP_PROP "compression"
|
|
|
|
|
#define FIT_ENTRY_PROP "entry"
|
|
|
|
|
#define FIT_LOAD_PROP "load"
|
|
|
|
|
|
|
|
|
|
/* configuration node */
|
|
|
|
|
#define FIT_KERNEL_PROP "kernel"
|
|
|
|
|
#define FIT_FILESYSTEM_PROP "filesystem"
|
|
|
|
|
#define FIT_RAMDISK_PROP "ramdisk"
|
|
|
|
|
#define FIT_FDT_PROP "fdt"
|
|
|
|
|
#define FIT_LOADABLE_PROP "loadables"
|
|
|
|
|
#define FIT_DEFAULT_PROP "default"
|
|
|
|
|
#define FIT_SETUP_PROP "setup"
|
|
|
|
|
#define FIT_FPGA_PROP "fpga"
|
|
|
|
|
#define FIT_FIRMWARE_PROP "firmware"
|
|
|
|
|
#define FIT_STANDALONE_PROP "standalone"
|
|
|
|
|
|
|
|
|
|
#define FIT_MAX_HASH_LEN HASH_MAX_DIGEST_SIZE
|
|
|
|
|
|
2021-02-27 03:18:46 +00:00
|
|
|
#define MIN_FREE_SECT 16
|
|
|
|
|
#define REMAIN_VOLNAME "rootfs_data"
|
|
|
|
|
|
|
|
|
|
int parse_fit_partitions(struct parsed_partitions *state, u64 fit_start_sector, u64 sectors, int *slot, int add_remain)
|
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
|
|
|
{
|
2022-01-07 17:39:42 +00:00
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 11, 0)
|
|
|
|
|
struct block_device *bdev = state->disk->part0;
|
|
|
|
|
#else
|
|
|
|
|
struct block_device *bdev = state->bdev;
|
|
|
|
|
#endif
|
|
|
|
|
struct address_space *mapping = bdev->bd_inode->i_mapping;
|
2021-02-27 03:18:46 +00:00
|
|
|
struct page *page;
|
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
|
|
|
void *fit, *init_fit;
|
|
|
|
|
struct partition_meta_info *info;
|
|
|
|
|
char tmp[sizeof(info->volname)];
|
2021-02-27 03:18:46 +00:00
|
|
|
u64 dsize, dsectors, imgmaxsect = 0;
|
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
|
|
|
u32 size, image_pos, image_len;
|
|
|
|
|
const u32 *image_offset_be, *image_len_be, *image_pos_be;
|
2021-02-27 03:18:46 +00:00
|
|
|
int ret = 1, node, images, 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
|
|
|
const char *image_name, *image_type, *image_description, *config_default,
|
|
|
|
|
*config_description, *config_loadables;
|
|
|
|
|
int image_name_len, image_type_len, image_description_len, config_default_len,
|
|
|
|
|
config_description_len, config_loadables_len;
|
|
|
|
|
sector_t start_sect, nr_sects;
|
|
|
|
|
size_t label_min;
|
2022-03-21 23:31:38 +00:00
|
|
|
struct device_node *np = NULL;
|
|
|
|
|
const char *bootconf;
|
2022-03-24 02:56:01 +00:00
|
|
|
const char *loadable;
|
|
|
|
|
const char *select_rootfs = NULL;
|
2022-03-23 19:29:07 +00:00
|
|
|
bool found;
|
|
|
|
|
int loadables_rem_len, loadable_len;
|
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
|
|
|
|
2021-02-27 03:18:46 +00:00
|
|
|
if (fit_start_sector % (1<<(PAGE_SHIFT - SECTOR_SHIFT)))
|
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
|
|
page = read_mapping_page(mapping, fit_start_sector >> (PAGE_SHIFT - SECTOR_SHIFT), NULL);
|
2021-08-27 20:30:32 +00:00
|
|
|
if (IS_ERR(page))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (PageError(page))
|
|
|
|
|
return -EFAULT;
|
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
|
|
|
|
|
|
|
|
init_fit = page_address(page);
|
|
|
|
|
|
|
|
|
|
if (!init_fit) {
|
|
|
|
|
put_page(page);
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fdt_check_header(init_fit)) {
|
|
|
|
|
put_page(page);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-07 17:39:42 +00:00
|
|
|
dsectors = get_capacity(bdev->bd_disk);
|
2021-02-27 03:18:46 +00:00
|
|
|
if (sectors)
|
|
|
|
|
dsectors = (dsectors>sectors)?sectors:dsectors;
|
|
|
|
|
|
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
|
|
|
dsize = dsectors << SECTOR_SHIFT;
|
|
|
|
|
size = fdt_totalsize(init_fit);
|
2021-04-02 23:41:30 +00:00
|
|
|
|
|
|
|
|
/* silently skip non-external-data legacy FIT images */
|
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 (size > PAGE_SIZE) {
|
|
|
|
|
put_page(page);
|
2021-04-02 23:41:30 +00:00
|
|
|
return 0;
|
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 (size >= dsize) {
|
2021-04-02 23:41:30 +00:00
|
|
|
state->access_beyond_eod = 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
|
|
|
put_page(page);
|
2021-04-02 23:41:30 +00:00
|
|
|
return -EFBIG;
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fit = kmemdup(init_fit, size, GFP_KERNEL);
|
|
|
|
|
put_page(page);
|
|
|
|
|
if (!fit)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2022-03-23 19:29:07 +00:00
|
|
|
np = of_find_node_by_path("/chosen");
|
|
|
|
|
if (np)
|
|
|
|
|
bootconf = of_get_property(np, "bootconf", NULL);
|
|
|
|
|
else
|
|
|
|
|
bootconf = NULL;
|
|
|
|
|
|
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
|
|
|
config = fdt_path_offset(fit, FIT_CONFS_PATH);
|
|
|
|
|
if (config < 0) {
|
|
|
|
|
printk(KERN_ERR "FIT: Cannot find %s node: %d\n", FIT_CONFS_PATH, images);
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto ret_out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
config_default = fdt_getprop(fit, config, FIT_DEFAULT_PROP, &config_default_len);
|
|
|
|
|
|
2022-03-21 23:31:38 +00:00
|
|
|
if (!config_default && !bootconf) {
|
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
|
|
|
printk(KERN_ERR "FIT: Cannot find default configuration\n");
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto ret_out;
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-21 23:31:38 +00:00
|
|
|
node = fdt_subnode_offset(fit, config, bootconf?:config_default);
|
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 (node < 0) {
|
2022-03-21 23:31:38 +00:00
|
|
|
printk(KERN_ERR "FIT: Cannot find %s node: %d\n", bootconf?:config_default, 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
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto ret_out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
config_description = fdt_getprop(fit, node, FIT_DESC_PROP, &config_description_len);
|
|
|
|
|
config_loadables = fdt_getprop(fit, node, FIT_LOADABLE_PROP, &config_loadables_len);
|
|
|
|
|
|
2022-03-21 23:31:38 +00:00
|
|
|
printk(KERN_DEBUG "FIT: %s configuration: \"%s\"%s%s%s\n",
|
|
|
|
|
bootconf?"Selected":"Default", bootconf?:config_default,
|
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
|
|
|
config_description?" (":"", config_description?:"", config_description?")":"");
|
|
|
|
|
|
2022-03-23 19:29:07 +00:00
|
|
|
if (!config_loadables || !config_loadables_len) {
|
|
|
|
|
printk(KERN_ERR "FIT: No loadables configured in \"%s\"\n", bootconf?:config_default);
|
|
|
|
|
ret = -ENOENT;
|
|
|
|
|
goto ret_out;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
images = fdt_path_offset(fit, FIT_IMAGES_PATH);
|
|
|
|
|
if (images < 0) {
|
|
|
|
|
printk(KERN_ERR "FIT: Cannot find %s node: %d\n", FIT_IMAGES_PATH, images);
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto ret_out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fdt_for_each_subnode(node, fit, images) {
|
|
|
|
|
image_name = fdt_get_name(fit, node, &image_name_len);
|
|
|
|
|
image_type = fdt_getprop(fit, node, FIT_TYPE_PROP, &image_type_len);
|
|
|
|
|
image_offset_be = fdt_getprop(fit, node, FIT_DATA_OFFSET_PROP, NULL);
|
|
|
|
|
image_pos_be = fdt_getprop(fit, node, FIT_DATA_POSITION_PROP, NULL);
|
|
|
|
|
image_len_be = fdt_getprop(fit, node, FIT_DATA_SIZE_PROP, NULL);
|
|
|
|
|
if (!image_name || !image_type || !image_len_be)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
image_len = be32_to_cpu(*image_len_be);
|
|
|
|
|
if (!image_len)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (image_offset_be)
|
|
|
|
|
image_pos = be32_to_cpu(*image_offset_be) + size;
|
|
|
|
|
else if (image_pos_be)
|
|
|
|
|
image_pos = be32_to_cpu(*image_pos_be);
|
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
image_description = fdt_getprop(fit, node, FIT_DESC_PROP, &image_description_len);
|
|
|
|
|
|
2021-07-12 15:54:45 +00:00
|
|
|
printk(KERN_DEBUG "FIT: %16s sub-image 0x%08x..0x%08x \"%s\" %s%s%s\n",
|
|
|
|
|
image_type, image_pos, image_pos + image_len - 1, image_name,
|
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
|
|
|
image_description?"(":"", image_description?:"", image_description?") ":"");
|
|
|
|
|
|
|
|
|
|
if (strcmp(image_type, FIT_FILESYSTEM_PROP))
|
|
|
|
|
continue;
|
|
|
|
|
|
2022-03-23 19:29:07 +00:00
|
|
|
/* check if sub-image is part of configured loadables */
|
|
|
|
|
found = false;
|
|
|
|
|
loadable = config_loadables;
|
|
|
|
|
loadables_rem_len = config_loadables_len;
|
|
|
|
|
while (loadables_rem_len > 1) {
|
|
|
|
|
loadable_len = strnlen(loadable, loadables_rem_len - 1) + 1;
|
|
|
|
|
loadables_rem_len -= loadable_len;
|
|
|
|
|
if (!strncmp(image_name, loadable, loadable_len)) {
|
|
|
|
|
found = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
loadable += loadable_len;
|
|
|
|
|
}
|
|
|
|
|
if (!found)
|
|
|
|
|
continue;
|
|
|
|
|
|
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 (image_pos & ((1 << PAGE_SHIFT)-1)) {
|
|
|
|
|
printk(KERN_ERR "FIT: image %s start not aligned to page boundaries, skipping\n", image_name);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (image_len & ((1 << PAGE_SHIFT)-1)) {
|
|
|
|
|
printk(KERN_ERR "FIT: sub-image %s end not aligned to page boundaries, skipping\n", image_name);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
start_sect = image_pos >> SECTOR_SHIFT;
|
|
|
|
|
nr_sects = image_len >> SECTOR_SHIFT;
|
2021-02-27 03:18:46 +00:00
|
|
|
imgmaxsect = (imgmaxsect < (start_sect + nr_sects))?(start_sect + nr_sects):imgmaxsect;
|
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 (start_sect + nr_sects > dsectors) {
|
|
|
|
|
state->access_beyond_eod = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-27 03:18:46 +00:00
|
|
|
put_partition(state, ++(*slot), fit_start_sector + start_sect, nr_sects);
|
2022-03-23 19:29:07 +00:00
|
|
|
state->parts[*slot].flags = ADDPART_FLAG_READONLY;
|
|
|
|
|
state->parts[*slot].has_info = true;
|
2021-02-27 03:18:46 +00:00
|
|
|
info = &state->parts[*slot].info;
|
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
|
|
|
|
|
|
|
|
label_min = min_t(int, sizeof(info->volname) - 1, image_name_len);
|
|
|
|
|
strncpy(info->volname, image_name, label_min);
|
|
|
|
|
info->volname[label_min] = '\0';
|
|
|
|
|
|
|
|
|
|
snprintf(tmp, sizeof(tmp), "(%s)", info->volname);
|
|
|
|
|
strlcat(state->pp_buf, tmp, PAGE_SIZE);
|
|
|
|
|
|
2022-03-23 19:29:07 +00:00
|
|
|
/* Mark first loadable listed to be mounted as rootfs */
|
|
|
|
|
if (!strcmp(image_name, config_loadables)) {
|
|
|
|
|
select_rootfs = image_name;
|
2021-02-27 03:18:46 +00:00
|
|
|
state->parts[*slot].flags |= ADDPART_FLAG_ROOTDEV;
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-23 19:29:07 +00:00
|
|
|
if (select_rootfs)
|
|
|
|
|
printk(KERN_DEBUG "FIT: selecting configured loadable \"%s\" to be root filesystem\n", select_rootfs);
|
|
|
|
|
|
2021-02-27 03:18:46 +00:00
|
|
|
if (add_remain && (imgmaxsect + MIN_FREE_SECT) < dsectors) {
|
|
|
|
|
put_partition(state, ++(*slot), fit_start_sector + imgmaxsect, dsectors - imgmaxsect);
|
|
|
|
|
state->parts[*slot].flags = 0;
|
|
|
|
|
info = &state->parts[*slot].info;
|
|
|
|
|
strcpy(info->volname, REMAIN_VOLNAME);
|
|
|
|
|
snprintf(tmp, sizeof(tmp), "(%s)", REMAIN_VOLNAME);
|
|
|
|
|
strlcat(state->pp_buf, tmp, PAGE_SIZE);
|
|
|
|
|
}
|
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
|
|
|
ret_out:
|
|
|
|
|
kfree(fit);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2021-02-27 03:18:46 +00:00
|
|
|
|
|
|
|
|
int fit_partition(struct parsed_partitions *state) {
|
|
|
|
|
int slot = 0;
|
|
|
|
|
return parse_fit_partitions(state, 0, 0, &slot, 0);
|
|
|
|
|
}
|