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
|
|
|
--- a/block/blk.h
|
|
|
|
|
+++ b/block/blk.h
|
2021-09-15 09:31:37 +00:00
|
|
|
@@ -355,6 +355,7 @@ char *disk_name(struct gendisk *hd, int
|
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
|
|
|
#define ADDPART_FLAG_NONE 0
|
|
|
|
|
#define ADDPART_FLAG_RAID 1
|
|
|
|
|
#define ADDPART_FLAG_WHOLEDISK 2
|
|
|
|
|
+#define ADDPART_FLAG_ROOTDEV 4
|
|
|
|
|
void delete_partition(struct hd_struct *part);
|
|
|
|
|
int bdev_add_partition(struct block_device *bdev, int partno,
|
|
|
|
|
sector_t start, sector_t length);
|
|
|
|
|
--- a/block/partitions/Kconfig
|
|
|
|
|
+++ b/block/partitions/Kconfig
|
|
|
|
|
@@ -101,6 +101,13 @@ config ATARI_PARTITION
|
|
|
|
|
Say Y here if you would like to use hard disks under Linux which
|
|
|
|
|
were partitioned under the Atari OS.
|
|
|
|
|
|
|
|
|
|
+config FIT_PARTITION
|
|
|
|
|
+ bool "Flattened-Image-Tree (FIT) partition support" if PARTITION_ADVANCED
|
|
|
|
|
+ default n
|
|
|
|
|
+ help
|
|
|
|
|
+ Say Y here if your system needs to mount the filesystem part of
|
|
|
|
|
+ a Flattened-Image-Tree (FIT) image commonly used with Das U-Boot.
|
|
|
|
|
+
|
|
|
|
|
config IBM_PARTITION
|
|
|
|
|
bool "IBM disk label and partition support"
|
|
|
|
|
depends on PARTITION_ADVANCED && S390
|
|
|
|
|
--- a/block/partitions/Makefile
|
|
|
|
|
+++ b/block/partitions/Makefile
|
|
|
|
|
@@ -8,6 +8,7 @@ obj-$(CONFIG_ACORN_PARTITION) += acorn.o
|
|
|
|
|
obj-$(CONFIG_AMIGA_PARTITION) += amiga.o
|
|
|
|
|
obj-$(CONFIG_ATARI_PARTITION) += atari.o
|
|
|
|
|
obj-$(CONFIG_AIX_PARTITION) += aix.o
|
|
|
|
|
+obj-$(CONFIG_FIT_PARTITION) += fit.o
|
|
|
|
|
obj-$(CONFIG_CMDLINE_PARTITION) += cmdline.o
|
|
|
|
|
obj-$(CONFIG_MAC_PARTITION) += mac.o
|
|
|
|
|
obj-$(CONFIG_LDM_PARTITION) += ldm.o
|
|
|
|
|
--- a/block/partitions/check.h
|
|
|
|
|
+++ b/block/partitions/check.h
|
|
|
|
|
@@ -58,6 +58,7 @@ int amiga_partition(struct parsed_partit
|
|
|
|
|
int atari_partition(struct parsed_partitions *state);
|
|
|
|
|
int cmdline_partition(struct parsed_partitions *state);
|
|
|
|
|
int efi_partition(struct parsed_partitions *state);
|
|
|
|
|
+int fit_partition(struct parsed_partitions *state);
|
|
|
|
|
int ibm_partition(struct parsed_partitions *);
|
|
|
|
|
int karma_partition(struct parsed_partitions *state);
|
|
|
|
|
int ldm_partition(struct parsed_partitions *state);
|
2021-02-27 03:18:46 +00:00
|
|
|
@@ -68,3 +69,5 @@ int sgi_partition(struct parsed_partitio
|
|
|
|
|
int sun_partition(struct parsed_partitions *state);
|
|
|
|
|
int sysv68_partition(struct parsed_partitions *state);
|
|
|
|
|
int ultrix_partition(struct parsed_partitions *state);
|
|
|
|
|
+
|
|
|
|
|
+int parse_fit_partitions(struct parsed_partitions *state, u64 start_sector, u64 nr_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
|
|
|
--- a/block/partitions/core.c
|
|
|
|
|
+++ b/block/partitions/core.c
|
2021-02-27 03:18:46 +00:00
|
|
|
@@ -10,6 +10,10 @@
|
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 <linux/vmalloc.h>
|
|
|
|
|
#include <linux/blktrace_api.h>
|
|
|
|
|
#include <linux/raid/detect.h>
|
2021-02-27 03:18:46 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
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 <linux/root_dev.h>
|
2021-02-27 03:18:46 +00:00
|
|
|
+#endif
|
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"
|
|
|
|
|
|
|
|
|
|
static int (*check_part[])(struct parsed_partitions *) = {
|
2021-02-27 03:18:46 +00:00
|
|
|
@@ -46,6 +50,9 @@ static int (*check_part[])(struct parsed
|
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
|
|
|
#ifdef CONFIG_EFI_PARTITION
|
|
|
|
|
efi_partition, /* this must come before msdos */
|
|
|
|
|
#endif
|
|
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
|
|
|
|
+ fit_partition,
|
|
|
|
|
+#endif
|
|
|
|
|
#ifdef CONFIG_SGI_PARTITION
|
|
|
|
|
sgi_partition,
|
|
|
|
|
#endif
|
2021-11-01 16:17:45 +00:00
|
|
|
@@ -694,6 +701,11 @@ static bool blk_add_partition(struct gen
|
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
|
|
|
(state->parts[p].flags & ADDPART_FLAG_RAID))
|
|
|
|
|
md_autodetect_dev(part_to_dev(part)->devt);
|
|
|
|
|
|
2021-02-27 03:18:46 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
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 ((state->parts[p].flags & ADDPART_FLAG_ROOTDEV) && ROOT_DEV == 0)
|
|
|
|
|
+ ROOT_DEV = part_to_dev(part)->devt;
|
2021-02-27 03:18:46 +00:00
|
|
|
+#endif
|
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
|
|
|
+
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
--- a/drivers/mtd/ubi/block.c
|
|
|
|
|
+++ b/drivers/mtd/ubi/block.c
|
2021-04-02 23:41:30 +00:00
|
|
|
@@ -396,7 +396,11 @@ int ubiblock_create(struct ubi_volume_in
|
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
|
|
|
dev->leb_size = vi->usable_leb_size;
|
|
|
|
|
|
|
|
|
|
/* Initialize the gendisk of this ubiblock device */
|
2021-04-02 23:41:30 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
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
|
|
|
+ gd = alloc_disk(0);
|
2021-04-02 23:41:30 +00:00
|
|
|
+#else
|
|
|
|
|
gd = alloc_disk(1);
|
|
|
|
|
+#endif
|
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 (!gd) {
|
|
|
|
|
pr_err("UBI: block: alloc_disk failed\n");
|
|
|
|
|
ret = -ENODEV;
|
2021-04-02 23:41:30 +00:00
|
|
|
@@ -413,6 +417,9 @@ int ubiblock_create(struct ubi_volume_in
|
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
|
|
|
goto out_put_disk;
|
|
|
|
|
}
|
|
|
|
|
gd->private_data = dev;
|
2021-04-02 23:41:30 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
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
|
|
|
+ gd->flags |= GENHD_FL_EXT_DEVT;
|
2021-04-02 23:41:30 +00:00
|
|
|
+#endif
|
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
|
|
|
sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
|
|
|
|
|
set_capacity(gd, disk_capacity);
|
|
|
|
|
dev->gd = gd;
|
2021-02-27 03:18:46 +00:00
|
|
|
--- a/block/partitions/efi.c
|
|
|
|
|
+++ b/block/partitions/efi.c
|
2021-03-31 20:29:26 +00:00
|
|
|
@@ -706,6 +706,9 @@ int efi_partition(struct parsed_partitio
|
2021-02-27 03:18:46 +00:00
|
|
|
gpt_entry *ptes = NULL;
|
2021-03-31 20:29:26 +00:00
|
|
|
u32 i;
|
2021-02-27 03:18:46 +00:00
|
|
|
unsigned ssz = bdev_logical_block_size(state->bdev) / 512;
|
2021-03-31 20:29:26 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
|
|
|
|
+ u32 extra_slot = 64;
|
|
|
|
|
+#endif
|
2021-02-27 03:18:46 +00:00
|
|
|
|
|
|
|
|
if (!find_valid_gpt(state, &gpt, &ptes) || !gpt || !ptes) {
|
2021-03-31 20:29:26 +00:00
|
|
|
kfree(gpt);
|
|
|
|
|
@@ -739,6 +742,11 @@ int efi_partition(struct parsed_partitio
|
2021-02-27 03:18:46 +00:00
|
|
|
ARRAY_SIZE(ptes[i].partition_name));
|
|
|
|
|
utf16_le_to_7bit(ptes[i].partition_name, label_max, info->volname);
|
2021-03-31 20:29:26 +00:00
|
|
|
state->parts[i + 1].has_info = true;
|
2021-02-27 03:18:46 +00:00
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
|
|
|
|
+ /* If this is a U-Boot FIT volume it may have subpartitions */
|
|
|
|
|
+ if (!efi_guidcmp(ptes[i].partition_type_guid, PARTITION_LINUX_FIT_GUID))
|
2021-03-31 20:29:26 +00:00
|
|
|
+ (void) parse_fit_partitions(state, start * ssz, size * ssz, &extra_slot, 1);
|
2021-02-27 03:18:46 +00:00
|
|
|
+#endif
|
|
|
|
|
}
|
|
|
|
|
kfree(ptes);
|
|
|
|
|
kfree(gpt);
|
|
|
|
|
--- a/block/partitions/efi.h
|
|
|
|
|
+++ b/block/partitions/efi.h
|
|
|
|
|
@@ -52,6 +52,9 @@
|
|
|
|
|
#define PARTITION_LINUX_LVM_GUID \
|
|
|
|
|
EFI_GUID( 0xe6d6d379, 0xf507, 0x44c2, \
|
|
|
|
|
0xa2, 0x3c, 0x23, 0x8f, 0x2a, 0x3d, 0xf9, 0x28)
|
|
|
|
|
+#define PARTITION_LINUX_FIT_GUID \
|
|
|
|
|
+ EFI_GUID( 0xcae9be83, 0xb15f, 0x49cc, \
|
|
|
|
|
+ 0x86, 0x3f, 0x08, 0x1b, 0x74, 0x4a, 0x2d, 0x93)
|
|
|
|
|
|
|
|
|
|
typedef struct _gpt_header {
|
|
|
|
|
__le64 signature;
|
2021-04-02 23:41:30 +00:00
|
|
|
--- a/drivers/mtd/mtdblock.c
|
|
|
|
|
+++ b/drivers/mtd/mtdblock.c
|
|
|
|
|
@@ -334,7 +334,11 @@ static void mtdblock_remove_dev(struct m
|
|
|
|
|
static struct mtd_blktrans_ops mtdblock_tr = {
|
|
|
|
|
.name = "mtdblock",
|
|
|
|
|
.major = MTD_BLOCK_MAJOR,
|
|
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
|
|
|
|
+ .part_bits = 1,
|
|
|
|
|
+#else
|
|
|
|
|
.part_bits = 0,
|
|
|
|
|
+#endif
|
|
|
|
|
.blksize = 512,
|
|
|
|
|
.open = mtdblock_open,
|
|
|
|
|
.flush = mtdblock_flush,
|
|
|
|
|
--- a/drivers/mtd/mtd_blkdevs.c
|
|
|
|
|
+++ b/drivers/mtd/mtd_blkdevs.c
|
|
|
|
|
@@ -407,18 +407,8 @@ int add_mtd_blktrans_dev(struct mtd_blkt
|
|
|
|
|
gd->first_minor = (new->devnum) << tr->part_bits;
|
|
|
|
|
gd->fops = &mtd_block_ops;
|
|
|
|
|
|
|
|
|
|
- if (tr->part_bits)
|
|
|
|
|
- if (new->devnum < 26)
|
|
|
|
|
- snprintf(gd->disk_name, sizeof(gd->disk_name),
|
|
|
|
|
- "%s%c", tr->name, 'a' + new->devnum);
|
|
|
|
|
- else
|
|
|
|
|
- snprintf(gd->disk_name, sizeof(gd->disk_name),
|
|
|
|
|
- "%s%c%c", tr->name,
|
|
|
|
|
- 'a' - 1 + new->devnum / 26,
|
|
|
|
|
- 'a' + new->devnum % 26);
|
|
|
|
|
- else
|
|
|
|
|
- snprintf(gd->disk_name, sizeof(gd->disk_name),
|
|
|
|
|
- "%s%d", tr->name, new->devnum);
|
|
|
|
|
+ snprintf(gd->disk_name, sizeof(gd->disk_name),
|
|
|
|
|
+ "%s%d", tr->name, new->devnum);
|
|
|
|
|
|
|
|
|
|
set_capacity(gd, ((u64)new->size * tr->blksize) >> 9);
|
|
|
|
|
|
2021-07-12 15:54:45 +00:00
|
|
|
--- a/block/partitions/msdos.c
|
|
|
|
|
+++ b/block/partitions/msdos.c
|
2021-07-21 15:49:05 +00:00
|
|
|
@@ -563,6 +563,15 @@ static void parse_minix(struct parsed_pa
|
2021-07-12 15:54:45 +00:00
|
|
|
#endif /* CONFIG_MINIX_SUBPARTITION */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
+static void parse_fit_mbr(struct parsed_partitions *state,
|
|
|
|
|
+ sector_t offset, sector_t size, int origin)
|
|
|
|
|
+{
|
|
|
|
|
+#ifdef CONFIG_FIT_PARTITION
|
|
|
|
|
+ u32 extra_slot = 64;
|
|
|
|
|
+ (void) parse_fit_partitions(state, offset, size, &extra_slot, 1);
|
|
|
|
|
+#endif /* CONFIG_FIT_PARTITION */
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
static struct {
|
|
|
|
|
unsigned char id;
|
|
|
|
|
void (*parse)(struct parsed_partitions *, sector_t, sector_t, int);
|
2021-07-21 15:49:05 +00:00
|
|
|
@@ -574,6 +583,7 @@ static struct {
|
2021-07-12 15:54:45 +00:00
|
|
|
{UNIXWARE_PARTITION, parse_unixware},
|
|
|
|
|
{SOLARIS_X86_PARTITION, parse_solaris_x86},
|
|
|
|
|
{NEW_SOLARIS_X86_PARTITION, parse_solaris_x86},
|
|
|
|
|
+ {FIT_PARTITION, parse_fit_mbr},
|
|
|
|
|
{0, NULL},
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
--- a/include/linux/msdos_partition.h
|
|
|
|
|
+++ b/include/linux/msdos_partition.h
|
|
|
|
|
@@ -31,6 +31,7 @@ enum msdos_sys_ind {
|
|
|
|
|
LINUX_LVM_PARTITION = 0x8e,
|
|
|
|
|
LINUX_RAID_PARTITION = 0xfd, /* autodetect RAID partition */
|
|
|
|
|
|
|
|
|
|
+ FIT_PARTITION = 0x2e, /* U-Boot uImage.FIT */
|
|
|
|
|
SOLARIS_X86_PARTITION = 0x82, /* also Linux swap partitions */
|
|
|
|
|
NEW_SOLARIS_X86_PARTITION = 0xbf,
|
|
|
|
|
|
