From 4e36b1739b03e81ff395959b58fe33e67c4d2233 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 5 Mar 2025 17:25:00 -0700 Subject: x86: Move the bootm state for zimage into cmd/ Rather than holding the state in the implementation code, move it to the command code. The state is now passed to the implementation functions and can there (with future work) be pass in from bootstd, without going through the commands. Signed-off-by: Simon Glass --- cmd/bootflow.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'cmd/bootflow.c') diff --git a/cmd/bootflow.c b/cmd/bootflow.c index f88995a478f..72b06a42e4d 100644 --- a/cmd/bootflow.c +++ b/cmd/bootflow.c @@ -380,7 +380,10 @@ static int do_bootflow_info(struct cmd_tbl *cmdtp, int flag, int argc, bflow = std->cur_bootflow; if (IS_ENABLED(CONFIG_X86) && x86_setup) { - zimage_dump(bflow->x86_setup, false); + struct bootm_info bmi; + + bootm_init(&bmi); + zimage_dump(&bmi, bflow->x86_setup, false); return 0; } -- cgit v1.3.1 From 1592ff27d502efdc79992f57c07ff0cf81bc9305 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 5 Mar 2025 17:25:01 -0700 Subject: bootstd: Correct display of kernel version The address of the bzImage is not recorded in the bootflow, so we cannot actually locate the version at present. Handle this case, to avoid showing invalid data. Signed-off-by: Simon Glass --- arch/x86/lib/zimage.c | 13 ++++++++----- cmd/bootflow.c | 2 ++ 2 files changed, 10 insertions(+), 5 deletions(-) (limited to 'cmd/bootflow.c') diff --git a/arch/x86/lib/zimage.c b/arch/x86/lib/zimage.c index 7f4b117b403..d71285e71d9 100644 --- a/arch/x86/lib/zimage.c +++ b/arch/x86/lib/zimage.c @@ -558,7 +558,6 @@ void zimage_dump(struct bootm_info *bmi, struct boot_params *base_ptr, bool show_cmdline) { struct setup_header *hdr; - const char *version; int i; printf("Setup located at %p:\n\n", base_ptr); @@ -595,10 +594,14 @@ void zimage_dump(struct bootm_info *bmi, struct boot_params *base_ptr, print_num("Real mode switch", hdr->realmode_swtch); print_num("Start sys seg", hdr->start_sys_seg); print_num("Kernel version", hdr->kernel_version); - version = zimage_get_kernel_version(base_ptr, - (void *)bmi->bzimage_addr); - if (version) - printf(" @%p: %s\n", version, version); + if (bmi->bzimage_addr) { + const char *version; + + version = zimage_get_kernel_version(base_ptr, + (void *)bmi->bzimage_addr); + if (version) + printf(" @%p: %s\n", version, version); + } print_num("Type of loader", hdr->type_of_loader); show_loader(hdr); print_num("Load flags", hdr->loadflags); diff --git a/cmd/bootflow.c b/cmd/bootflow.c index 72b06a42e4d..da17fd93b8b 100644 --- a/cmd/bootflow.c +++ b/cmd/bootflow.c @@ -383,6 +383,8 @@ static int do_bootflow_info(struct cmd_tbl *cmdtp, int flag, int argc, struct bootm_info bmi; bootm_init(&bmi); + /* we don't know this at present */ + bootm_x86_set(&bmi, bzimage_addr, 0); zimage_dump(&bmi, bflow->x86_setup, false); return 0; -- cgit v1.3.1 From c73da92304280b229e3d8dfd565fae5a24fe3ce8 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Wed, 5 Mar 2025 17:25:02 -0700 Subject: x86: Drop the unnecessary base_ptr argument to zboot_dump() This value is include the bootm_info, so drop the unnecessary parameter. Signed-off-by: Simon Glass --- arch/x86/lib/zimage.c | 5 +++-- cmd/bootflow.c | 3 ++- cmd/x86/zboot.c | 8 +++----- include/bootm.h | 7 ++----- 4 files changed, 10 insertions(+), 13 deletions(-) (limited to 'cmd/bootflow.c') diff --git a/arch/x86/lib/zimage.c b/arch/x86/lib/zimage.c index d71285e71d9..145ba0b8ea0 100644 --- a/arch/x86/lib/zimage.c +++ b/arch/x86/lib/zimage.c @@ -554,12 +554,13 @@ static void show_loader(struct setup_header *hdr) printf("\n"); } -void zimage_dump(struct bootm_info *bmi, struct boot_params *base_ptr, - bool show_cmdline) +void zimage_dump(struct bootm_info *bmi, bool show_cmdline) { + struct boot_params *base_ptr; struct setup_header *hdr; int i; + base_ptr = bmi->base_ptr; printf("Setup located at %p:\n\n", base_ptr); print_num64("ACPI RSDP addr", base_ptr->acpi_rsdp_addr); diff --git a/cmd/bootflow.c b/cmd/bootflow.c index da17fd93b8b..6d0be320bdb 100644 --- a/cmd/bootflow.c +++ b/cmd/bootflow.c @@ -385,7 +385,8 @@ static int do_bootflow_info(struct cmd_tbl *cmdtp, int flag, int argc, bootm_init(&bmi); /* we don't know this at present */ bootm_x86_set(&bmi, bzimage_addr, 0); - zimage_dump(&bmi, bflow->x86_setup, false); + bootm_x86_set(&bmi, base_ptr, bflow->x86_setup); + zimage_dump(&bmi, false); return 0; } diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index 029ff4eb9fd..ee099ca041b 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -103,15 +103,13 @@ static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { - struct boot_params *base_ptr = bmi.base_ptr; - if (argc > 1) - base_ptr = (void *)hextoul(argv[1], NULL); - if (!base_ptr) { + bmi.base_ptr = (void *)hextoul(argv[1], NULL); + if (!bmi.base_ptr) { printf("No zboot setup_base\n"); return CMD_RET_FAILURE; } - zimage_dump(&bmi, base_ptr, true); + zimage_dump(&bmi, true); return 0; } diff --git a/include/bootm.h b/include/bootm.h index fe7f80b88a5..c471615b08c 100644 --- a/include/bootm.h +++ b/include/bootm.h @@ -342,13 +342,10 @@ const char *zimage_get_kernel_version(struct boot_params *params, * * This shows all available information in a zimage that has been loaded. * - * @bmi: Bootm information - * @base_ptr: Pointer to the boot parameters, typically at address - * DEFAULT_SETUP_BASE + * @bmi: Bootm information, with valid base_ptr * @show_cmdline: true to show the full command line */ -void zimage_dump(struct bootm_info *bmi, struct boot_params *base_ptr, - bool show_cmdline); +void zimage_dump(struct bootm_info *bmi, bool show_cmdline); /* * bootm_boot_start() - Boot an image at the given address -- cgit v1.3.1 From 6acb0d28b06c408740e8b80e4015e1e656c7faf4 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sat, 15 Mar 2025 14:25:58 +0000 Subject: boot: Consider non-bootable partitions Any 'bootable' flag in a DOS partition causes boostd to only scan bootable partitions for that media. This can mean that extlinux.conf files on the root disk are missed. Put this logic behind a flag and update the documentation. For now, the flag is enabled, to preserve the existing behaviour of bootstd which is to ignore non-bootable partitions so long as there is at least one bootable partition on the disk. Future work may provide a command (or some other mechanism) to control this. Signed-off-by: Simon Glass --- boot/bootdev-uclass.c | 4 +++- cmd/bootflow.c | 2 +- doc/develop/bootstd/overview.rst | 5 +++-- include/bootflow.h | 2 ++ test/boot/bootdev.c | 1 + test/boot/bootflow.c | 5 +++-- 6 files changed, 13 insertions(+), 6 deletions(-) (limited to 'cmd/bootflow.c') diff --git a/boot/bootdev-uclass.c b/boot/bootdev-uclass.c index c39147940b6..9e4c3db2dc1 100644 --- a/boot/bootdev-uclass.c +++ b/boot/bootdev-uclass.c @@ -168,8 +168,10 @@ int bootdev_find_in_blk(struct udevice *dev, struct udevice *blk, */ /* if there are bootable partitions, scan only those */ - } else if (iter->first_bootable >= 0 && + } else if ((iter->flags & BOOTFLOWIF_ONLY_BOOTABLE) && + iter->first_bootable >= 0 && (iter->first_bootable ? !info.bootable : iter->part != 1)) { + log_debug("Skipping non-bootable partition %d\n", iter->part); return log_msg_ret("boot", -EINVAL); } else { ret = fs_set_blk_dev_with_part(desc, bflow->part); diff --git a/cmd/bootflow.c b/cmd/bootflow.c index 6d0be320bdb..5349abe49b5 100644 --- a/cmd/bootflow.c +++ b/cmd/bootflow.c @@ -173,7 +173,7 @@ static int do_bootflow_scan(struct cmd_tbl *cmdtp, int flag, int argc, std->cur_bootflow = NULL; - flags = 0; + flags = BOOTFLOWIF_ONLY_BOOTABLE; if (list) flags |= BOOTFLOWIF_SHOW; if (all) diff --git a/doc/develop/bootstd/overview.rst b/doc/develop/bootstd/overview.rst index e3ce97cc4f5..9fe5630ab16 100644 --- a/doc/develop/bootstd/overview.rst +++ b/doc/develop/bootstd/overview.rst @@ -235,8 +235,9 @@ means that `default_get_bootflow()` is used. This simply obtains the block device and calls a bootdev helper function to do the rest. The implementation of `bootdev_find_in_blk()` checks the partition table, and attempts to read a file from a filesystem on the partition number given by the -`@iter->part` parameter. If there are any bootable partitions in the table, -then only bootable partitions are considered. +`@iter->part` parameter. If there are any bootable partitions in the table and +the BOOTFLOWIF_ONLY_BOOTABLE flag is set in `@iter->flags`, then only bootable +partitions are considered. Each bootdev has a priority, which indicates the order in which it is used, if `boot_targets` is not used. Faster bootdevs are used first, since they are diff --git a/include/bootflow.h b/include/bootflow.h index 480cf8a5af1..d408b8c85bd 100644 --- a/include/bootflow.h +++ b/include/bootflow.h @@ -160,6 +160,7 @@ struct bootflow_img { * before using it * @BOOTFLOWIF_ALL: Return bootflows with errors as well * @BOOTFLOWIF_HUNT: Hunt for new bootdevs using the bootdrv hunters + * @BOOTFLOWIF_ONLY_BOOTABLE: Only consider partitions marked 'bootable' * * Internal flags: * @BOOTFLOWIF_SINGLE_DEV: (internal) Just scan one bootdev @@ -176,6 +177,7 @@ enum bootflow_iter_flags_t { BOOTFLOWIF_SHOW = 1 << 1, BOOTFLOWIF_ALL = 1 << 2, BOOTFLOWIF_HUNT = 1 << 3, + BOOTFLOWIF_ONLY_BOOTABLE = BIT(4), /* * flags used internally by standard boot - do not set these when diff --git a/test/boot/bootdev.c b/test/boot/bootdev.c index 5f07430714e..d5499918249 100644 --- a/test/boot/bootdev.c +++ b/test/boot/bootdev.c @@ -509,6 +509,7 @@ static int bootdev_test_bootable(struct unit_test_state *uts) iter.part = 0; ut_assertok(uclass_get_device_by_name(UCLASS_BLK, "mmc1.blk", &blk)); iter.dev = blk; + iter.flags = BOOTFLOWIF_ONLY_BOOTABLE; ut_assertok(device_find_next_child(&iter.dev)); uclass_first_device(UCLASS_BOOTMETH, &bflow.method); diff --git a/test/boot/bootflow.c b/test/boot/bootflow.c index eb7f00af39a..5f9c037ff53 100644 --- a/test/boot/bootflow.c +++ b/test/boot/bootflow.c @@ -297,8 +297,9 @@ static int bootflow_iter(struct unit_test_state *uts) /* The first device is mmc2.bootdev which has no media */ ut_asserteq(-EPROTONOSUPPORT, - bootflow_scan_first(NULL, NULL, &iter, - BOOTFLOWIF_ALL | BOOTFLOWIF_SKIP_GLOBAL, &bflow)); + bootflow_scan_first(NULL, NULL, &iter, BOOTFLOWIF_ALL | + BOOTFLOWIF_SKIP_GLOBAL | + BOOTFLOWIF_ONLY_BOOTABLE, &bflow)); ut_asserteq(2, iter.num_methods); ut_asserteq(0, iter.cur_method); ut_asserteq(0, iter.part); -- cgit v1.3.1 From f892a7f397a66d8d09f418d1e0e06dfb48bac27d Mon Sep 17 00:00:00 2001 From: Tom Rini Date: Mon, 7 Apr 2025 12:35:13 -0600 Subject: Revert "Merge patch series "pxe: Precursor series for supporting read_all() in extlinux / PXE"" This reverts commit 8bc3542384e3a1219e5ffb62b79d16dddc1b1fb9, reversing changes made to 698edd63eca090a2e299cd3facf90a0b97bed677. There are still problems with this series to work out. Link: https://lore.kernel.org/u-boot/CAFLszTjw_MJbK9tpzVYi3XKGazcv55auBAdgVzcAVUta7dRqcg@mail.gmail.com/ Signed-off-by: Tom Rini --- arch/arm/lib/image.c | 9 +- arch/riscv/lib/image.c | 9 +- arch/sandbox/lib/bootm.c | 5 - arch/x86/include/asm/zimage.h | 57 ++++-- arch/x86/lib/zimage.c | 102 +++++------ boot/Makefile | 2 +- boot/bootm.c | 77 +------- boot/bootmeth_cros.c | 6 +- boot/image-board.c | 36 ++-- boot/pxe_utils.c | 417 +++++++++++++++++++----------------------- cmd/bootflow.c | 8 +- cmd/net.c | 92 +++++----- cmd/x86/zboot.c | 33 ++-- include/bootm.h | 63 +------ include/image.h | 48 +---- include/net-common.h | 30 --- net/net.c | 44 ----- 17 files changed, 377 insertions(+), 661 deletions(-) (limited to 'cmd/bootflow.c') diff --git a/arch/arm/lib/image.c b/arch/arm/lib/image.c index d78d704cb58..1f672eee2c8 100644 --- a/arch/arm/lib/image.c +++ b/arch/arm/lib/image.c @@ -28,13 +28,6 @@ struct Image_header { uint32_t res5; }; -bool booti_is_valid(const void *img) -{ - const struct Image_header *ih = img; - - return ih->magic == le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC); -} - int booti_setup(ulong image, ulong *relocated_addr, ulong *size, bool force_reloc) { @@ -46,7 +39,7 @@ int booti_setup(ulong image, ulong *relocated_addr, ulong *size, ih = (struct Image_header *)map_sysmem(image, 0); - if (!booti_is_valid(ih)) { + if (ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)) { puts("Bad Linux ARM64 Image magic!\n"); return 1; } diff --git a/arch/riscv/lib/image.c b/arch/riscv/lib/image.c index 859326cbac8..a82f48e9a50 100644 --- a/arch/riscv/lib/image.c +++ b/arch/riscv/lib/image.c @@ -32,13 +32,6 @@ struct linux_image_h { uint32_t res4; /* reserved */ }; -bool booti_is_valid(const void *img) -{ - const struct linux_image_h *lhdr = img; - - return lhdr->magic == LINUX_RISCV_IMAGE_MAGIC; -} - int booti_setup(ulong image, ulong *relocated_addr, ulong *size, bool force_reloc) { @@ -46,7 +39,7 @@ int booti_setup(ulong image, ulong *relocated_addr, ulong *size, lhdr = (struct linux_image_h *)map_sysmem(image, 0); - if (!booti_is_valid(lhdr)) { + if (lhdr->magic != LINUX_RISCV_IMAGE_MAGIC) { puts("Bad Linux RISCV Image magic!\n"); return -EINVAL; } diff --git a/arch/sandbox/lib/bootm.c b/arch/sandbox/lib/bootm.c index 8ed923750f4..44ba8b52e13 100644 --- a/arch/sandbox/lib/bootm.c +++ b/arch/sandbox/lib/bootm.c @@ -89,8 +89,3 @@ int booti_setup(ulong image, ulong *relocated_addr, ulong *size, return 1; } - -bool booti_is_valid(const void *img) -{ - return false; -} diff --git a/arch/x86/include/asm/zimage.h b/arch/x86/include/asm/zimage.h index 4ed6d8d5cc2..8b542605170 100644 --- a/arch/x86/include/asm/zimage.h +++ b/arch/x86/include/asm/zimage.h @@ -10,8 +10,6 @@ #include #include -struct bootm_info; - /* linux i386 zImage/bzImage header. Offsets relative to * the start of the image */ @@ -44,6 +42,43 @@ enum { ZBOOT_STATE_COUNT = 5, }; +/** + * struct zboot_state - Current state of the boot + * + * @bzimage_addr: Address of the bzImage to boot, or 0 if the image has already + * been loaded and does not exist (as a cohesive whole) in memory + * @bzimage_size: Size of the bzImage, or 0 to detect this + * @initrd_addr: Address of the initial ramdisk, or 0 if none + * @initrd_size: Size of the initial ramdisk, or 0 if none + * @load_address: Address where the bzImage is moved before booting, either + * BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR + * This is set up when loading the zimage + * @base_ptr: Pointer to the boot parameters, typically at address + * DEFAULT_SETUP_BASE + * This is set up when loading the zimage + * @cmdline: Environment variable containing the 'override' command line, or + * NULL to use the one in the setup block + */ +struct zboot_state { + ulong bzimage_addr; + ulong bzimage_size; + ulong initrd_addr; + ulong initrd_size; + ulong load_address; + struct boot_params *base_ptr; + const char *cmdline; +}; + +extern struct zboot_state state; + +/** + * zimage_dump() - Dump information about a zimage + * + * @base_ptr: Pointer to the boot parameters + * @show_cmdline: true to show the kernel command line + */ +void zimage_dump(struct boot_params *base_ptr, bool show_cmdline); + /** * zboot_load() - Load a zimage * @@ -51,21 +86,21 @@ enum { * * Return: 0 if OK, -ve on error */ -int zboot_load(struct bootm_info *bmi); +int zboot_load(void); /** * zboot_setup() - Set up the zboot image reeady for booting * * Return: 0 if OK, -ve on error */ -int zboot_setup(struct bootm_info *bmi); +int zboot_setup(void); /** * zboot_go() - Start the image * * Return: 0 if OK, -ve on error */ -int zboot_go(struct bootm_info *bmi); +int zboot_go(void); /** * load_zimage() - Load a zImage or bzImage @@ -104,7 +139,6 @@ int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, * * Record information about a zimage so it can be booted * - * @bmi: Bootm information * @bzimage_addr: Address of the bzImage to boot * @bzimage_size: Size of the bzImage, or 0 to detect this * @initrd_addr: Address of the initial ramdisk, or 0 if none @@ -115,17 +149,14 @@ int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, * @cmdline: Environment variable containing the 'override' command line, or * NULL to use the one in the setup block */ -void zboot_start(struct bootm_info *bmi, ulong bzimage_addr, ulong bzimage_size, - ulong initrd_addr, ulong initrd_size, ulong base_addr, - const char *cmdline); +void zboot_start(ulong bzimage_addr, ulong bzimage_size, ulong initrd_addr, + ulong initrd_size, ulong base_addr, const char *cmdline); /** * zboot_info() - Show simple info about a zimage * - * Shows where the kernel was loaded and also the setup base - * - * @bmi: Bootm information + * Shows wherer the kernel was loaded and also the setup base */ -void zboot_info(struct bootm_info *bmi); +void zboot_info(void); #endif diff --git a/arch/x86/lib/zimage.c b/arch/x86/lib/zimage.c index 8f1c18eaadc..2ea9bcf59c2 100644 --- a/arch/x86/lib/zimage.c +++ b/arch/x86/lib/zimage.c @@ -55,6 +55,9 @@ DECLARE_GLOBAL_DATA_PTR; #define COMMAND_LINE_SIZE 2048 +/* Current state of the boot */ +struct zboot_state state; + static void build_command_line(char *command_line, int auto_boot) { char *env_command_line; @@ -366,54 +369,54 @@ int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, return 0; } -int zboot_load(struct bootm_info *bmi) +int zboot_load(void) { struct boot_params *base_ptr; int ret; - if (bmi->base_ptr) { - struct boot_params *from = (struct boot_params *)bmi->base_ptr; + if (state.base_ptr) { + struct boot_params *from = (struct boot_params *)state.base_ptr; base_ptr = (struct boot_params *)DEFAULT_SETUP_BASE; log_debug("Building boot_params at %lx\n", (ulong)base_ptr); memset(base_ptr, '\0', sizeof(*base_ptr)); base_ptr->hdr = from->hdr; } else { - base_ptr = load_zimage((void *)bmi->bzimage_addr, - bmi->bzimage_size, &bmi->load_address); + base_ptr = load_zimage((void *)state.bzimage_addr, state.bzimage_size, + &state.load_address); if (!base_ptr) { puts("## Kernel loading failed ...\n"); return -EINVAL; } } - bmi->base_ptr = base_ptr; + state.base_ptr = base_ptr; - ret = env_set_hex("zbootbase", map_to_sysmem(bmi->base_ptr)); + ret = env_set_hex("zbootbase", map_to_sysmem(state.base_ptr)); if (!ret) - ret = env_set_hex("zbootaddr", bmi->load_address); + ret = env_set_hex("zbootaddr", state.load_address); if (ret) return ret; return 0; } -int zboot_setup(struct bootm_info *bmi) +int zboot_setup(void) { - struct boot_params *base_ptr = bmi->base_ptr; + struct boot_params *base_ptr = state.base_ptr; int ret; ret = setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET, - 0, bmi->initrd_addr, bmi->initrd_size, - (ulong)bmi->cmdline); + 0, state.initrd_addr, state.initrd_size, + (ulong)state.cmdline); if (ret) return -EINVAL; return 0; } -int zboot_go(struct bootm_info *bmi) +int zboot_go(void) { - struct boot_params *params = bmi->base_ptr; + struct boot_params *params = state.base_ptr; struct setup_header *hdr = ¶ms->hdr; bool image_64bit; ulong entry; @@ -421,7 +424,7 @@ int zboot_go(struct bootm_info *bmi) disable_interrupts(); - entry = bmi->load_address; + entry = state.load_address; image_64bit = false; if (IS_ENABLED(CONFIG_X86_64) && (hdr->xloadflags & XLF_KERNEL_64)) { @@ -429,43 +432,30 @@ int zboot_go(struct bootm_info *bmi) } /* we assume that the kernel is in place */ - ret = boot_linux_kernel((ulong)bmi->base_ptr, entry, image_64bit); + ret = boot_linux_kernel((ulong)state.base_ptr, entry, image_64bit); return ret; } -int zboot_run(struct bootm_info *bmi) +int zboot_run(ulong addr, ulong size, ulong initrd, ulong initrd_size, + ulong base, char *cmdline) { int ret; - ret = zboot_load(bmi); + zboot_start(addr, size, initrd, initrd_size, base, cmdline); + ret = zboot_load(); if (ret) return log_msg_ret("ld", ret); - ret = zboot_setup(bmi); + ret = zboot_setup(); if (ret) return log_msg_ret("set", ret); - ret = zboot_go(bmi); + ret = zboot_go(); if (ret) return log_msg_ret("go", ret); return -EFAULT; } -int zboot_run_args(ulong addr, ulong size, ulong initrd, ulong initrd_size, - ulong base, char *cmdline) -{ - struct bootm_info bmi; - int ret; - - bootm_init(&bmi); - zboot_start(&bmi, addr, size, initrd, initrd_size, base, cmdline); - ret = zboot_run(&bmi); - if (ret) - return log_msg_ret("zra", ret); - - return 0; -} - static void print_num(const char *name, ulong value) { printf("%-20s: %lx\n", name, value); @@ -559,12 +549,11 @@ static void show_loader(struct setup_header *hdr) printf("\n"); } -void zimage_dump(struct bootm_info *bmi, bool show_cmdline) +void zimage_dump(struct boot_params *base_ptr, bool show_cmdline) { - struct boot_params *base_ptr; struct setup_header *hdr; + const char *version; - base_ptr = bmi->base_ptr; printf("Setup located at %p:\n\n", base_ptr); print_num64("ACPI RSDP addr", base_ptr->acpi_rsdp_addr); @@ -590,14 +579,10 @@ void zimage_dump(struct bootm_info *bmi, bool show_cmdline) print_num("Real mode switch", hdr->realmode_swtch); print_num("Start sys seg", hdr->start_sys_seg); print_num("Kernel version", hdr->kernel_version); - if (bmi->bzimage_addr) { - const char *version; - - version = zimage_get_kernel_version(base_ptr, - (void *)bmi->bzimage_addr); - if (version) - printf(" @%p: %s\n", version, version); - } + version = zimage_get_kernel_version(base_ptr, + (void *)state.bzimage_addr); + if (version) + printf(" @%p: %s\n", version, version); print_num("Type of loader", hdr->type_of_loader); show_loader(hdr); print_num("Load flags", hdr->loadflags); @@ -638,24 +623,25 @@ void zimage_dump(struct bootm_info *bmi, bool show_cmdline) print_num("Kernel info offset", hdr->kernel_info_offset); } -void zboot_start(struct bootm_info *bmi, ulong bzimage_addr, ulong bzimage_size, - ulong initrd_addr, ulong initrd_size, ulong base_addr, - const char *cmdline) +void zboot_start(ulong bzimage_addr, ulong bzimage_size, ulong initrd_addr, + ulong initrd_size, ulong base_addr, const char *cmdline) { - bmi->bzimage_size = bzimage_size; - bmi->initrd_addr = initrd_addr; - bmi->initrd_size = initrd_size; + memset(&state, '\0', sizeof(state)); + + state.bzimage_size = bzimage_size; + state.initrd_addr = initrd_addr; + state.initrd_size = initrd_size; if (base_addr) { - bmi->base_ptr = map_sysmem(base_addr, 0); - bmi->load_address = bzimage_addr; + state.base_ptr = map_sysmem(base_addr, 0); + state.load_address = bzimage_addr; } else { - bmi->bzimage_addr = bzimage_addr; + state.bzimage_addr = bzimage_addr; } - bmi->cmdline = cmdline; + state.cmdline = cmdline; } -void zboot_info(struct bootm_info *bmi) +void zboot_info(void) { printf("Kernel loaded at %08lx, setup_base=%p\n", - bmi->load_address, bmi->base_ptr); + state.load_address, state.base_ptr); } diff --git a/boot/Makefile b/boot/Makefile index f1e4444aa0a..34bac26c4e2 100644 --- a/boot/Makefile +++ b/boot/Makefile @@ -10,7 +10,7 @@ obj-$(CONFIG_CMD_BOOTM) += bootm.o bootm_os.o obj-$(CONFIG_CMD_BOOTZ) += bootm.o bootm_os.o obj-$(CONFIG_CMD_BOOTI) += bootm.o bootm_os.o -obj-$(CONFIG_PXE_UTILS) += bootm.o pxe_utils.o +obj-$(CONFIG_PXE_UTILS) += pxe_utils.o endif diff --git a/boot/bootm.c b/boot/bootm.c index 8a1aac7515f..854ac7ec738 100644 --- a/boot/bootm.c +++ b/boot/bootm.c @@ -146,7 +146,7 @@ static int boot_get_kernel(const char *addr_fit, struct bootm_headers *images, /* check image type, for FIT images get FIT kernel node */ *os_data = *os_len = 0; buf = map_sysmem(img_addr, 0); - switch (genimg_get_format_comp(buf)) { + switch (genimg_get_format(buf)) { #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT) case IMAGE_FORMAT_LEGACY: printf("## Booting kernel from Legacy Image at %08lx ...\n", @@ -227,9 +227,6 @@ static int boot_get_kernel(const char *addr_fit, struct bootm_headers *images, break; } #endif - case IMAGE_FORMAT_BOOTI: - *os_data = img_addr; - break; default: bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE); return -EPROTOTYPE; @@ -289,35 +286,6 @@ static int bootm_pre_load(const char *addr_str) return ret; } -static int found_booti_os(enum image_comp_t comp) -{ - images.os.load = images.os.image_start; - images.os.type = IH_TYPE_KERNEL; - images.os.os = IH_OS_LINUX; - images.os.comp = comp; - if (IS_ENABLED(CONFIG_RISCV_SMODE)) - images.os.arch = IH_ARCH_RISCV; - else if (IS_ENABLED(CONFIG_ARM64)) - images.os.arch = IH_ARCH_ARM64; - - log_debug("load %lx start %lx len %lx ep %lx os %x comp %x\n", - images.os.load, images.os.image_start, images.os.image_len, - images.ep, images.os.os, images.os.comp); - if (comp != IH_COMP_NONE) { - images.os.load = env_get_hex("kernel_comp_addr_r", 0); - images.os.image_len = env_get_ulong("kernel_comp_size", 16, 0); - if (!images.os.load || !images.os.image_len) { - puts("kernel_comp_addr_r or kernel_comp_size is not provided!\n"); - return -ENOTSUPP; - } - if (lmb_reserve(images.os.load, images.os.image_len, LMB_NONE) - < 0) - return -EXDEV; - } - - return 0; -} - /** * bootm_find_os(): Find the OS to boot * @@ -422,28 +390,7 @@ static int bootm_find_os(const char *cmd_name, const char *addr_fit) } break; #endif - case IMAGE_FORMAT_BOOTI: - if (IS_ENABLED(CONFIG_CMD_BOOTI)) { - if (found_booti_os(IH_COMP_NONE)) - return 1; - ep_found = true; - break; - } - fallthrough; default: - /* any compressed image is probably a booti image */ - if (IS_ENABLED(CONFIG_CMD_BOOTI)) { - int comp; - - comp = image_decomp_type(os_hdr, 2); - if (comp != IH_COMP_NONE) { - if (found_booti_os(comp)) - return 1; - ep_found = true; - } - break; - } - puts("ERROR: unknown image format type!\n"); return 1; } @@ -594,7 +541,6 @@ int bootm_find_images(ulong img_addr, const char *conf_ramdisk, static int bootm_find_other(ulong img_addr, const char *conf_ramdisk, const char *conf_fdt) { - log_debug("find_other type %x os %x\n", images.os.type, images.os.os); if ((images.os.type == IH_TYPE_KERNEL || images.os.type == IH_TYPE_KERNEL_NOLOAD || images.os.type == IH_TYPE_MULTI) && @@ -683,17 +629,15 @@ static int bootm_load_os(struct bootm_headers *images, int boot_progress) debug("Allocated %lx bytes at %lx for kernel (size %lx) decompression\n", req_size, load, image_len); } - log_debug("load_os load %lx image_start %lx image_len %lx\n", load, - image_start, image_len); load_buf = map_sysmem(load, 0); image_buf = map_sysmem(os.image_start, image_len); err = image_decomp(os.comp, load, os.image_start, os.type, - load_buf, image_buf, image_len, bootm_len(), - &load_end); + load_buf, image_buf, image_len, + CONFIG_SYS_BOOTM_LEN, &load_end); if (err) { - err = handle_decomp_error(os.comp, load_end - load, bootm_len(), - err); + err = handle_decomp_error(os.comp, load_end - load, + CONFIG_SYS_BOOTM_LEN, err); bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE); return err; } @@ -1166,10 +1110,6 @@ int boot_run(struct bootm_info *bmi, const char *cmd, int extra_states) states |= BOOTM_STATE_RAMDISK; states |= extra_states; - log_debug("cmd '%s' states %x addr_img '%s' conf_ramdisk '%s' conf_fdt '%s' images %p\n", - cmd, states, bmi->addr_img, bmi->conf_ramdisk, bmi->conf_fdt, - bmi->images); - return bootm_run_states(bmi, states); } @@ -1187,9 +1127,7 @@ int bootz_run(struct bootm_info *bmi) int booti_run(struct bootm_info *bmi) { - return boot_run(bmi, "booti", BOOTM_STATE_START | BOOTM_STATE_FINDOS | - BOOTM_STATE_PRE_LOAD | BOOTM_STATE_FINDOTHER | - BOOTM_STATE_LOADOS); + return boot_run(bmi, "booti", 0); } int bootm_boot_start(ulong addr, const char *cmdline) @@ -1228,8 +1166,7 @@ void bootm_init(struct bootm_info *bmi) { memset(bmi, '\0', sizeof(struct bootm_info)); bmi->boot_progress = true; - if (IS_ENABLED(CONFIG_CMD_BOOTM) || IS_ENABLED(CONFIG_CMD_BOOTZ) || - IS_ENABLED(CONFIG_CMD_BOOTI) || IS_ENABLED(CONFIG_PXE_UTILS)) + if (IS_ENABLED(CONFIG_CMD_BOOTM)) bmi->images = &images; } diff --git a/boot/bootmeth_cros.c b/boot/bootmeth_cros.c index ea4c9ed830f..c7b862e512a 100644 --- a/boot/bootmeth_cros.c +++ b/boot/bootmeth_cros.c @@ -446,9 +446,9 @@ static int cros_boot(struct udevice *dev, struct bootflow *bflow) } if (IS_ENABLED(CONFIG_X86)) { - ret = zboot_run_args(map_to_sysmem(bflow->buf), bflow->size, 0, - 0, map_to_sysmem(bflow->x86_setup), - bflow->cmdline); + ret = zboot_run(map_to_sysmem(bflow->buf), bflow->size, 0, 0, + map_to_sysmem(bflow->x86_setup), + bflow->cmdline); } else { ret = bootm_boot_start(map_to_sysmem(bflow->buf), bflow->cmdline); diff --git a/boot/image-board.c b/boot/image-board.c index a2bafba7ae1..514f8e63f9c 100644 --- a/boot/image-board.c +++ b/boot/image-board.c @@ -234,7 +234,21 @@ ulong genimg_get_kernel_addr(char * const img_addr) &fit_uname_kernel); } -enum image_fmt_t genimg_get_format(const void *img_addr) +/** + * genimg_get_format - get image format type + * @img_addr: image start address + * + * genimg_get_format() checks whether provided address points to a valid + * legacy or FIT image. + * + * New uImage format and FDT blob are based on a libfdt. FDT blob + * may be passed directly or embedded in a FIT image. In both situations + * genimg_get_format() must be able to dectect libfdt header. + * + * returns: + * image format type or IMAGE_FORMAT_INVALID if no image is present + */ +int genimg_get_format(const void *img_addr) { if (CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)) { const struct legacy_img_hdr *hdr; @@ -250,24 +264,10 @@ enum image_fmt_t genimg_get_format(const void *img_addr) if (IS_ENABLED(CONFIG_ANDROID_BOOT_IMAGE) && is_android_boot_image_header(img_addr)) return IMAGE_FORMAT_ANDROID; - if (IS_ENABLED(CONFIG_CMD_BOOTI) && - booti_is_valid(img_addr)) - return IMAGE_FORMAT_BOOTI; return IMAGE_FORMAT_INVALID; } -enum image_fmt_t genimg_get_format_comp(const void *img_addr) -{ - enum image_fmt_t fmt = genimg_get_format(img_addr); - - if (IS_ENABLED(CONFIG_CMD_BOOTI) && fmt == IMAGE_FORMAT_INVALID && - image_decomp_type(img_addr, 2) != IH_COMP_NONE) - fmt = IMAGE_FORMAT_BOOTI; - - return fmt; -} - /** * fit_has_config - check if there is a valid FIT configuration * @images: pointer to the bootm command headers structure @@ -364,7 +364,7 @@ static int select_ramdisk(struct bootm_headers *images, const char *select, u8 a * check image type, for FIT images get FIT node. */ buf = map_sysmem(rd_addr, 0); - switch (genimg_get_format_comp(buf)) { + switch (genimg_get_format(buf)) { case IMAGE_FORMAT_LEGACY: if (CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)) { const struct legacy_img_hdr *rd_hdr; @@ -434,10 +434,6 @@ static int select_ramdisk(struct bootm_headers *images, const char *select, u8 a done = true; } break; - case IMAGE_FORMAT_BOOTI: - break; - case IMAGE_FORMAT_INVALID: - break; } if (!done) { diff --git a/boot/pxe_utils.c b/boot/pxe_utils.c index c606da9e96b..82f217aaf86 100644 --- a/boot/pxe_utils.c +++ b/boot/pxe_utils.c @@ -7,7 +7,6 @@ #define LOG_CATEGORY LOGC_BOOT #include -#include #include #include #include @@ -433,42 +432,169 @@ skip_overlay: } #endif -/* - * label_process_fdt() - Process FDT for the label - * - * @ctx: PXE context - * @label: Label to process - * @kernel_addr: String containing kernel address - * @fdt_argp: bootm argument to fill in, for FDT - * Return: 0 if OK, -ENOMEM if out of memory, -ENOENT if FDT file could not be - * loaded - * - * fdt usage is optional: - * It handles the following scenarios. +/** + * label_boot() - Boot according to the contents of a pxe_label * - * Scenario 1: If fdt_addr_r specified and "fdt" or "fdtdir" label is - * defined in pxe file, retrieve fdt blob from server. Pass fdt_addr_r to - * bootm, and adjust argc appropriately. + * If we can't boot for any reason, we return. A successful boot never + * returns. * - * If retrieve fails and no exact fdt blob is specified in pxe file with - * "fdt" label, try Scenario 2. + * The kernel will be stored in the location given by the 'kernel_addr_r' + * environment variable. * - * Scenario 2: If there is an fdt_addr specified, pass it along to - * bootm, and adjust argc appropriately. + * If the label specifies an initrd file, it will be stored in the location + * given by the 'ramdisk_addr_r' environment variable. * - * Scenario 3: If there is an fdtcontroladdr specified, pass it along to - * bootm, and adjust argc appropriately, unless the image type is fitImage. + * If the label specifies an 'append' line, its contents will overwrite that + * of the 'bootargs' environment variable. * - * Scenario 4: fdt blob is not available. + * @ctx: PXE context + * @label: Label to process + * Returns does not return on success, otherwise returns 0 if a localboot + * label was processed, or 1 on error */ -static int label_process_fdt(struct pxe_context *ctx, struct pxe_label *label, - char *kernel_addr, const char **fdt_argp) +static int label_boot(struct pxe_context *ctx, struct pxe_label *label) { + char *bootm_argv[] = { "bootm", NULL, NULL, NULL, NULL }; + char *zboot_argv[] = { "zboot", NULL, "0", NULL, NULL }; + char *kernel_addr = NULL; + char *initrd_addr_str = NULL; + char initrd_filesize[10]; + char initrd_str[28]; + char mac_str[29] = ""; + char ip_str[68] = ""; + char *fit_addr = NULL; + int bootm_argc = 2; + int zboot_argc = 3; + int len = 0; + ulong kernel_addr_r; + void *buf; + + label_print(label); + + label->attempted = 1; + + if (label->localboot) { + if (label->localboot_val >= 0) + label_localboot(label); + return 0; + } + + if (!label->kernel) { + printf("No kernel given, skipping %s\n", + label->name); + return 1; + } + + if (get_relfile_envaddr(ctx, label->kernel, "kernel_addr_r", + (enum bootflow_img_t)IH_TYPE_KERNEL, NULL) + < 0) { + printf("Skipping %s for failure retrieving kernel\n", + label->name); + return 1; + } + + kernel_addr = env_get("kernel_addr_r"); + /* for FIT, append the configuration identifier */ + if (label->config) { + int len = strlen(kernel_addr) + strlen(label->config) + 1; + + fit_addr = malloc(len); + if (!fit_addr) { + printf("malloc fail (FIT address)\n"); + return 1; + } + snprintf(fit_addr, len, "%s%s", kernel_addr, label->config); + kernel_addr = fit_addr; + } + + /* For FIT, the label can be identical to kernel one */ + if (label->initrd && !strcmp(label->kernel_label, label->initrd)) { + initrd_addr_str = kernel_addr; + } else if (label->initrd) { + ulong size; + if (get_relfile_envaddr(ctx, label->initrd, "ramdisk_addr_r", + (enum bootflow_img_t)IH_TYPE_RAMDISK, + &size) < 0) { + printf("Skipping %s for failure retrieving initrd\n", + label->name); + goto cleanup; + } + strcpy(initrd_filesize, simple_xtoa(size)); + initrd_addr_str = env_get("ramdisk_addr_r"); + size = snprintf(initrd_str, sizeof(initrd_str), "%s:%lx", + initrd_addr_str, size); + if (size >= sizeof(initrd_str)) + goto cleanup; + } + + if (label->ipappend & 0x1) { + sprintf(ip_str, " ip=%s:%s:%s:%s", + env_get("ipaddr"), env_get("serverip"), + env_get("gatewayip"), env_get("netmask")); + } + + if (IS_ENABLED(CONFIG_CMD_NET)) { + if (label->ipappend & 0x2) { + int err; + + strcpy(mac_str, " BOOTIF="); + err = format_mac_pxe(mac_str + 8, sizeof(mac_str) - 8); + if (err < 0) + mac_str[0] = '\0'; + } + } + + if ((label->ipappend & 0x3) || label->append) { + char bootargs[CONFIG_SYS_CBSIZE] = ""; + char finalbootargs[CONFIG_SYS_CBSIZE]; + + if (strlen(label->append ?: "") + + strlen(ip_str) + strlen(mac_str) + 1 > sizeof(bootargs)) { + printf("bootarg overflow %zd+%zd+%zd+1 > %zd\n", + strlen(label->append ?: ""), + strlen(ip_str), strlen(mac_str), + sizeof(bootargs)); + goto cleanup; + } + + if (label->append) + strncpy(bootargs, label->append, sizeof(bootargs)); + + strcat(bootargs, ip_str); + strcat(bootargs, mac_str); + + cli_simple_process_macros(bootargs, finalbootargs, + sizeof(finalbootargs)); + env_set("bootargs", finalbootargs); + printf("append: %s\n", finalbootargs); + } + + /* + * fdt usage is optional: + * It handles the following scenarios. + * + * Scenario 1: If fdt_addr_r specified and "fdt" or "fdtdir" label is + * defined in pxe file, retrieve fdt blob from server. Pass fdt_addr_r to + * bootm, and adjust argc appropriately. + * + * If retrieve fails and no exact fdt blob is specified in pxe file with + * "fdt" label, try Scenario 2. + * + * Scenario 2: If there is an fdt_addr specified, pass it along to + * bootm, and adjust argc appropriately. + * + * Scenario 3: If there is an fdtcontroladdr specified, pass it along to + * bootm, and adjust argc appropriately, unless the image type is fitImage. + * + * Scenario 4: fdt blob is not available. + */ + bootm_argv[3] = env_get("fdt_addr_r"); + /* For FIT, the label can be identical to kernel one */ if (label->fdt && !strcmp(label->kernel_label, label->fdt)) { - *fdt_argp = kernel_addr; + bootm_argv[3] = kernel_addr; /* if fdt label is defined then get fdt from server */ - } else if (*fdt_argp) { + } else if (bootm_argv[3]) { char *fdtfile = NULL; char *fdtfilefree = NULL; @@ -481,7 +607,6 @@ static int label_process_fdt(struct pxe_context *ctx, struct pxe_label *label, } } else if (label->fdtdir) { char *f1, *f2, *f3, *f4, *slash; - int len; f1 = env_get("fdtfile"); if (f1) { @@ -524,7 +649,7 @@ static int label_process_fdt(struct pxe_context *ctx, struct pxe_label *label, fdtfilefree = malloc(len); if (!fdtfilefree) { printf("malloc fail (FDT filename)\n"); - return -ENOMEM; + goto cleanup; } snprintf(fdtfilefree, len, "%s%s%s%s%s%s", @@ -539,12 +664,12 @@ static int label_process_fdt(struct pxe_context *ctx, struct pxe_label *label, free(fdtfilefree); if (err < 0) { - *fdt_argp = NULL; + bootm_argv[3] = NULL; if (label->fdt) { printf("Skipping %s for failure retrieving FDT\n", label->name); - return -ENOENT; + goto cleanup; } if (label->fdtdir) { @@ -561,236 +686,74 @@ static int label_process_fdt(struct pxe_context *ctx, struct pxe_label *label, label_boot_fdtoverlay(ctx, label); #endif } else { - *fdt_argp = NULL; + bootm_argv[3] = NULL; } } - return 0; -} - -/** - * label_run_boot() - Set up the FDT and call the appropriate bootm/z/i command - * - * @ctx: PXE context - * @label: Label to process - * @kernel_addr: String containing kernel address (cannot be NULL) - * @initrd_addr_str: String containing initrd address (NULL if none) - * @initrd_filesize: String containing initrd size (only used if - * @initrd_addr_str) - * @initrd_str: initrd string to process (only used if @initrd_addr_str) - * Return: does not return on success, or returns 0 if the boot command - * returned, or -ve error value on error - */ -static int label_run_boot(struct pxe_context *ctx, struct pxe_label *label, - char *kernel_addr, char *initrd_addr_str, - char *initrd_filesize, char *initrd_str) -{ - struct bootm_info bmi; - ulong kernel_addr_r; - void *buf; - int ret; - - bootm_init(&bmi); - - bmi.conf_fdt = env_get("fdt_addr_r"); - - ret = label_process_fdt(ctx, label, kernel_addr, &bmi.conf_fdt); - if (ret) - return ret; - - bmi.addr_img = kernel_addr; - bootm_x86_set(&bmi, bzimage_addr, hextoul(kernel_addr, NULL)); + bootm_argv[1] = kernel_addr; + zboot_argv[1] = kernel_addr; if (initrd_addr_str) { - bmi.conf_ramdisk = initrd_str; - bootm_x86_set(&bmi, initrd_addr, - hextoul(initrd_addr_str, NULL)); - bootm_x86_set(&bmi, initrd_size, - hextoul(initrd_filesize, NULL)); + bootm_argv[2] = initrd_str; + bootm_argc = 3; + + zboot_argv[3] = initrd_addr_str; + zboot_argv[4] = initrd_filesize; + zboot_argc = 5; } - if (!bmi.conf_fdt) { - if (!IS_ENABLED(CONFIG_SUPPORT_PASSING_ATAGS) || - strcmp("-", label->fdt)) - bmi.conf_fdt = env_get("fdt_addr"); + if (!bootm_argv[3]) { + if (IS_ENABLED(CONFIG_SUPPORT_PASSING_ATAGS)) { + if (strcmp("-", label->fdt)) + bootm_argv[3] = env_get("fdt_addr"); + } else { + bootm_argv[3] = env_get("fdt_addr"); + } } kernel_addr_r = genimg_get_kernel_addr(kernel_addr); buf = map_sysmem(kernel_addr_r, 0); - if (!bmi.conf_fdt && genimg_get_format(buf) != IMAGE_FORMAT_FIT) { - if (!IS_ENABLED(CONFIG_SUPPORT_PASSING_ATAGS) || - strcmp("-", label->fdt)) - bmi.conf_fdt = env_get("fdtcontroladdr"); + if (!bootm_argv[3] && genimg_get_format(buf) != IMAGE_FORMAT_FIT) { + if (IS_ENABLED(CONFIG_SUPPORT_PASSING_ATAGS)) { + if (strcmp("-", label->fdt)) + bootm_argv[3] = env_get("fdtcontroladdr"); + } else { + bootm_argv[3] = env_get("fdtcontroladdr"); + } + } + + if (bootm_argv[3]) { + if (!bootm_argv[2]) + bootm_argv[2] = "-"; + bootm_argc = 4; } /* Try bootm for legacy and FIT format image */ if (genimg_get_format(buf) != IMAGE_FORMAT_INVALID && IS_ENABLED(CONFIG_CMD_BOOTM)) { log_debug("using bootm\n"); - ret = bootm_run(&bmi); + do_bootm(ctx->cmdtp, 0, bootm_argc, bootm_argv); /* Try booting an AArch64 Linux kernel image */ } else if (IS_ENABLED(CONFIG_CMD_BOOTI)) { log_debug("using booti\n"); - ret = booti_run(&bmi); + do_booti(ctx->cmdtp, 0, bootm_argc, bootm_argv); /* Try booting a Image */ } else if (IS_ENABLED(CONFIG_CMD_BOOTZ)) { log_debug("using bootz\n"); - ret = bootz_run(&bmi); + do_bootz(ctx->cmdtp, 0, bootm_argc, bootm_argv); /* Try booting an x86_64 Linux kernel image */ } else if (IS_ENABLED(CONFIG_CMD_ZBOOT)) { log_debug("using zboot\n"); - ret = zboot_run(&bmi); + do_zboot_parent(ctx->cmdtp, 0, zboot_argc, zboot_argv, NULL); } unmap_sysmem(buf); - if (ret) - return ret; - - return 0; -} - -/** - * label_boot() - Boot according to the contents of a pxe_label - * - * If we can't boot for any reason, we return. A successful boot never - * returns. - * - * The kernel will be stored in the location given by the 'kernel_addr_r' - * environment variable. - * - * If the label specifies an initrd file, it will be stored in the location - * given by the 'ramdisk_addr_r' environment variable. - * - * If the label specifies an 'append' line, its contents will overwrite that - * of the 'bootargs' environment variable. - * - * @ctx: PXE context - * @label: Label to process - * Returns does not return on success, otherwise returns 0 if a localboot - * label was processed, or 1 on error - */ -static int label_boot(struct pxe_context *ctx, struct pxe_label *label) -{ - char *kernel_addr = NULL; - char *initrd_addr_str = NULL; - char initrd_filesize[10]; - char initrd_str[28]; - char mac_str[29] = ""; - char ip_str[68] = ""; - char *fit_addr = NULL; - - label_print(label); - - label->attempted = 1; - - if (label->localboot) { - if (label->localboot_val >= 0) - label_localboot(label); - return 0; - } - - if (!label->kernel) { - printf("No kernel given, skipping %s\n", - label->name); - return 1; - } - - if (get_relfile_envaddr(ctx, label->kernel, "kernel_addr_r", - (enum bootflow_img_t)IH_TYPE_KERNEL, NULL) - < 0) { - printf("Skipping %s for failure retrieving kernel\n", - label->name); - return 1; - } - - kernel_addr = env_get("kernel_addr_r"); - /* for FIT, append the configuration identifier */ - if (label->config) { - int len = strlen(kernel_addr) + strlen(label->config) + 1; - - fit_addr = malloc(len); - if (!fit_addr) { - printf("malloc fail (FIT address)\n"); - return 1; - } - snprintf(fit_addr, len, "%s%s", kernel_addr, label->config); - kernel_addr = fit_addr; - } - - /* For FIT, the label can be identical to kernel one */ - if (label->initrd && !strcmp(label->kernel_label, label->initrd)) { - initrd_addr_str = kernel_addr; - } else if (label->initrd) { - ulong size; - int ret; - - ret = get_relfile_envaddr(ctx, label->initrd, "ramdisk_addr_r", - (enum bootflow_img_t)IH_TYPE_RAMDISK, - &size); - if (ret < 0) { - printf("Skipping %s for failure retrieving initrd\n", - label->name); - goto cleanup; - } - strcpy(initrd_filesize, simple_xtoa(size)); - initrd_addr_str = env_get("ramdisk_addr_r"); - size = snprintf(initrd_str, sizeof(initrd_str), "%s:%lx", - initrd_addr_str, size); - if (size >= sizeof(initrd_str)) - goto cleanup; - } - - if (label->ipappend & 0x1) { - sprintf(ip_str, " ip=%s:%s:%s:%s", - env_get("ipaddr"), env_get("serverip"), - env_get("gatewayip"), env_get("netmask")); - } - - if (IS_ENABLED(CONFIG_CMD_NET)) { - if (label->ipappend & 0x2) { - int err; - - strcpy(mac_str, " BOOTIF="); - err = format_mac_pxe(mac_str + 8, sizeof(mac_str) - 8); - if (err < 0) - mac_str[0] = '\0'; - } - } - - if ((label->ipappend & 0x3) || label->append) { - char bootargs[CONFIG_SYS_CBSIZE] = ""; - char finalbootargs[CONFIG_SYS_CBSIZE]; - - if (strlen(label->append ?: "") + - strlen(ip_str) + strlen(mac_str) + 1 > sizeof(bootargs)) { - printf("bootarg overflow %zd+%zd+%zd+1 > %zd\n", - strlen(label->append ?: ""), - strlen(ip_str), strlen(mac_str), - sizeof(bootargs)); - goto cleanup; - } - - if (label->append) - strlcpy(bootargs, label->append, sizeof(bootargs)); - - strcat(bootargs, ip_str); - strcat(bootargs, mac_str); - - cli_simple_process_macros(bootargs, finalbootargs, - sizeof(finalbootargs)); - env_set("bootargs", finalbootargs); - printf("append: %s\n", finalbootargs); - } - - label_run_boot(ctx, label, kernel_addr, initrd_addr_str, - initrd_filesize, initrd_str); - /* ignore the error value since we are going to fail anyway */ cleanup: free(fit_addr); - return 1; /* returning is always failure */ + return 1; } /** enum token_type - Tokens for the pxe file parser */ diff --git a/cmd/bootflow.c b/cmd/bootflow.c index 5349abe49b5..a1fd59a69f4 100644 --- a/cmd/bootflow.c +++ b/cmd/bootflow.c @@ -380,13 +380,7 @@ static int do_bootflow_info(struct cmd_tbl *cmdtp, int flag, int argc, bflow = std->cur_bootflow; if (IS_ENABLED(CONFIG_X86) && x86_setup) { - struct bootm_info bmi; - - bootm_init(&bmi); - /* we don't know this at present */ - bootm_x86_set(&bmi, bzimage_addr, 0); - bootm_x86_set(&bmi, base_ptr, bflow->x86_setup); - zimage_dump(&bmi, false); + zimage_dump(bflow->x86_setup, false); return 0; } diff --git a/cmd/net.c b/cmd/net.c index 8f33c9f55d5..79525f73a51 100644 --- a/cmd/net.c +++ b/cmd/net.c @@ -297,15 +297,13 @@ static void netboot_update_env(void) /** * parse_addr_size() - parse address and size arguments for tftpput * - * @argv: command line arguments (argv[1] and argv[2] must be valid) - * @addrp: returns the address, on success - * @sizep: returns the size, on success + * @argv: command line arguments * Return: 0 on success */ -static int parse_addr_size(char * const argv[], ulong *addrp, ulong *sizep) +static int parse_addr_size(char * const argv[]) { - if (strict_strtoul(argv[1], 16, addrp) < 0 || - strict_strtoul(argv[2], 16, sizep) < 0) { + if (strict_strtoul(argv[1], 16, &image_save_addr) < 0 || + strict_strtoul(argv[2], 16, &image_save_size) < 0) { printf("Invalid address/size\n"); return CMD_RET_USAGE; } @@ -315,31 +313,24 @@ static int parse_addr_size(char * const argv[], ulong *addrp, ulong *sizep) /** * parse_args() - parse command line arguments * - * Sets: - * - image_save_addr and image_save_size, if proto == TFTPPUT - * * @proto: command prototype - * @argc: number of arguments, include the command, which has already been - * parsed - * @argv: command line arguments, with argv[0] being the command - * @fnamep: set to the filename, if provided, else NULL - * @addrp: returns the load/save address, if any is provided, else it is - * left unchanged - * @sizep: returns the save size, if any is provided, else it is left - * unchanged + * @argc: number of arguments + * @argv: command line arguments * Return: 0 on success */ -static int parse_args(enum proto_t proto, int argc, char *const argv[], - const char **fnamep, ulong *addrp, ulong *sizep) +static int parse_args(enum proto_t proto, int argc, char *const argv[]) { ulong addr; char *end; - *fnamep = NULL; switch (argc) { case 1: if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) return 1; + + /* refresh bootfile name from env */ + copy_filename(net_boot_file_name, env_get("bootfile"), + sizeof(net_boot_file_name)); break; case 2: @@ -352,42 +343,48 @@ static int parse_args(enum proto_t proto, int argc, char *const argv[], * mis-interpreted as a valid number. */ addr = hextoul(argv[1], &end); - if (end == (argv[1] + strlen(argv[1]))) - *addrp = addr; - else - *fnamep = argv[1]; + if (end == (argv[1] + strlen(argv[1]))) { + image_load_addr = addr; + /* refresh bootfile name from env */ + copy_filename(net_boot_file_name, env_get("bootfile"), + sizeof(net_boot_file_name)); + } else { + net_boot_file_name_explicit = true; + copy_filename(net_boot_file_name, argv[1], + sizeof(net_boot_file_name)); + } break; case 3: if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) { - if (parse_addr_size(argv, addrp, sizep)) + if (parse_addr_size(argv)) return 1; } else { - *addrp = hextoul(argv[1], NULL); - *fnamep = argv[2]; + image_load_addr = hextoul(argv[1], NULL); + net_boot_file_name_explicit = true; + copy_filename(net_boot_file_name, argv[2], + sizeof(net_boot_file_name)); } break; +#ifdef CONFIG_CMD_TFTPPUT case 4: - if (IS_ENABLED(CONFIG_CMD_TFTPPUT)) { - if (parse_addr_size(argv, addrp, sizep)) - return 1; - *fnamep = argv[3]; - break; - } + if (parse_addr_size(argv)) + return 1; + net_boot_file_name_explicit = true; + copy_filename(net_boot_file_name, argv[3], + sizeof(net_boot_file_name)); + break; +#endif default: return 1; } - return 0; } static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc, char *const argv[]) { - ulong addr, save_size; - bool fname_explicit; - const char *fname; char *s; int rcode = 0; int size; @@ -395,10 +392,10 @@ static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc, net_boot_file_name_explicit = false; *net_boot_file_name = '\0'; - /* pre-set addr */ + /* pre-set image_load_addr */ s = env_get("loadaddr"); if (s != NULL) - addr = hextoul(s, NULL); + image_load_addr = hextoul(s, NULL); if (IS_ENABLED(CONFIG_IPV6)) { use_ip6 = false; @@ -411,17 +408,12 @@ static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc, } } - if (parse_args(proto, argc, argv, &fname, &addr, &save_size)) { + if (parse_args(proto, argc, argv)) { bootstage_error(BOOTSTAGE_ID_NET_START); return CMD_RET_USAGE; } - if (fname) { - fname_explicit = true; - } else { - fname_explicit = false; - fname = env_get("bootfile"); - } + bootstage_mark(BOOTSTAGE_ID_NET_START); if (IS_ENABLED(CONFIG_IPV6) && !use_ip6) { char *s, *e; @@ -436,10 +428,12 @@ static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc, } } - size = netboot_run_(proto, addr, fname, save_size, fname_explicit, - IS_ENABLED(CONFIG_IPV6) && use_ip6); - if (size < 0) + size = net_loop(proto); + if (size < 0) { + bootstage_error(BOOTSTAGE_ID_NET_NETLOOP_OK); return CMD_RET_FAILURE; + } + bootstage_mark(BOOTSTAGE_ID_NET_NETLOOP_OK); /* net_loop ok, update environment */ netboot_update_env(); diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index ee099ca041b..94e602b8a5b 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -7,15 +7,11 @@ #define LOG_CATEGORY LOGC_BOOT -#include #include #include #include #include -/* Current state of the boot */ -static struct bootm_info bmi; - static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { @@ -24,8 +20,6 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, ulong base_addr; int i; - bootm_init(&bmi); - log_debug("argc %d:", argc); for (i = 0; i < argc; i++) log_debug(" %s", argv[i]); @@ -41,7 +35,7 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, base_addr = argc > 5 ? hextoul(argv[5], NULL) : 0; cmdline = argc > 6 ? env_get(argv[6]) : NULL; - zboot_start(&bmi, bzimage_addr, bzimage_size, initrd_addr, initrd_size, + zboot_start(bzimage_addr, bzimage_size, initrd_addr, initrd_size, base_addr, cmdline); return 0; @@ -52,7 +46,7 @@ static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, { int ret; - ret = zboot_load(&bmi); + ret = zboot_load(); if (ret) return ret; @@ -62,17 +56,16 @@ static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { - if (!bmi.base_ptr) { + if (!state.base_ptr) { printf("base is not set: use 'zboot load' first\n"); return CMD_RET_FAILURE; } - - if (zboot_setup(&bmi)) { + if (zboot_setup()) { puts("Setting up boot parameters failed ...\n"); return CMD_RET_FAILURE; } - if (zboot_setup(&bmi)) + if (zboot_setup()) return CMD_RET_FAILURE; return 0; @@ -81,7 +74,7 @@ static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { - zboot_info(&bmi); + zboot_info(); return 0; } @@ -91,7 +84,7 @@ static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, { int ret; - ret = zboot_go(&bmi); + ret = zboot_go(); if (ret) { printf("Kernel returned! (err=%d)\n", ret); return CMD_RET_FAILURE; @@ -103,13 +96,15 @@ static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { + struct boot_params *base_ptr = state.base_ptr; + if (argc > 1) - bmi.base_ptr = (void *)hextoul(argv[1], NULL); - if (!bmi.base_ptr) { + base_ptr = (void *)hextoul(argv[1], NULL); + if (!base_ptr) { printf("No zboot setup_base\n"); return CMD_RET_FAILURE; } - zimage_dump(&bmi, true); + zimage_dump(base_ptr, true); return 0; } @@ -124,8 +119,8 @@ U_BOOT_SUBCMDS(zboot, U_BOOT_CMD_MKENT(dump, 2, 1, do_zboot_dump, "", ""), ) -static int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[], int state_mask) +int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[], int state_mask) { int ret = 0; diff --git a/include/bootm.h b/include/bootm.h index 465577a66f5..61160705215 100644 --- a/include/bootm.h +++ b/include/bootm.h @@ -44,21 +44,6 @@ struct cmd_tbl; * @argc: Number of arguments to the command (excluding the actual command). * This is 0 if there are no arguments * @argv: NULL-terminated list of arguments, or NULL if there are no arguments - * - * For zboot: - * @bzimage_addr: Address of the bzImage to boot, or 0 if the image has already - * been loaded and does not exist (as a cohesive whole) in memory - * @bzimage_size: Size of the bzImage, or 0 to detect this - * @initrd_addr: Address of the initial ramdisk, or 0 if none - * @initrd_size: Size of the initial ramdisk, or 0 if none - * @load_address: Address where the bzImage is moved before booting, either - * BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR - * This is set up when loading the zimage - * @base_ptr: Pointer to the boot parameters, typically at address - * DEFAULT_SETUP_BASE - * This is set up when loading the zimage - * @cmdline: Environment variable containing the 'override' command line, or - * NULL to use the one in the setup block */ struct bootm_info { const char *addr_img; @@ -69,39 +54,11 @@ struct bootm_info { const char *cmd_name; int argc; char *const *argv; - - /* zboot items */ -#ifdef CONFIG_X86 - ulong bzimage_addr; - ulong bzimage_size; - ulong initrd_addr; - ulong initrd_size; - ulong load_address; - struct boot_params *base_ptr; - const char *cmdline; -#endif }; -/* macro to allow setting fields in generic code */ -#ifdef CONFIG_X86 -#define bootm_x86_set(_bmi, _field, _val) (_bmi)->_field = (_val) -#else -#define bootm_x86_set(_bmi, _field, _val) -#endif - -static inline ulong bootm_len(void) -{ -#ifdef CONFIG_SYS_BOOTM_LEN - return CONFIG_SYS_BOOTM_LEN; -#endif - return 0; -} - /** * bootm_init() - Set up a bootm_info struct with useful defaults * - * @bmi: Bootm information - * * Set up the struct with default values for all members: * @boot_progress is set to true and @images is set to the global images * variable. Everything else is set to NULL except @argc which is 0 @@ -117,7 +74,7 @@ void bootm_init(struct bootm_info *bmi); * - disabled interrupts. * * @flag: Flags indicating what to do (BOOTM_STATE_...) - * @bmi: Bootm information + * bmi: Bootm information * Return: 1 on error. On success the OS boots so this function does * not return. */ @@ -318,15 +275,6 @@ int bootm_process_cmdline_env(int flags); /** * zboot_run() - Run through the various steps to boot a zimage * - * @bmi: Bootm information, with bzimage_size, initrd_addr, initrd_size and - * cmdline set up. If base_ptr is 0, then bzimage_addr must be set to the start - * of the bzImage. Otherwise base_ptr and load_address must be provided. - */ -int zboot_run(struct bootm_info *bmi); - -/** - * zboot_run_args() - Run through the various steps to boot a zimage - * * Boot a zimage, given the component parts * * @addr: Address where the bzImage is moved before booting, either @@ -341,8 +289,8 @@ int zboot_run(struct bootm_info *bmi); * to use for booting * Return: -EFAULT on error (normally it does not return) */ -int zboot_run_args(ulong addr, ulong size, ulong initrd, ulong initrd_size, - ulong base, char *cmdline); +int zboot_run(ulong addr, ulong size, ulong initrd, ulong initrd_size, + ulong base, char *cmdline); /* * zimage_get_kernel_version() - Get the version string from a kernel @@ -359,10 +307,11 @@ const char *zimage_get_kernel_version(struct boot_params *params, * * This shows all available information in a zimage that has been loaded. * - * @bmi: Bootm information, with valid base_ptr + * @base_ptr: Pointer to the boot parameters, typically at address + * DEFAULT_SETUP_BASE * @show_cmdline: true to show the full command line */ -void zimage_dump(struct bootm_info *bmi, bool show_cmdline); +void zimage_dump(struct boot_params *base_ptr, bool show_cmdline); /* * bootm_boot_start() - Boot an image at the given address diff --git a/include/image.h b/include/image.h index 2455baa6667..c1db8383459 100644 --- a/include/image.h +++ b/include/image.h @@ -244,7 +244,7 @@ enum image_type_t { * New IDs *MUST* be appended at the end of the list and *NEVER* * inserted for backward compatibility. */ -enum image_comp_t { +enum { IH_COMP_NONE = 0, /* No Compression Used */ IH_COMP_GZIP, /* gzip Compression Used */ IH_COMP_BZIP2, /* bzip2 Compression Used */ @@ -598,13 +598,10 @@ int boot_get_setup(struct bootm_headers *images, uint8_t arch, ulong *setup_star ulong *setup_len); /* Image format types, returned by _get_format() routine */ -enum image_fmt_t { - IMAGE_FORMAT_INVALID, - IMAGE_FORMAT_LEGACY, /* legacy image_header based format */ - IMAGE_FORMAT_FIT, /* new, libfdt based format */ - IMAGE_FORMAT_ANDROID, /* Android boot image */ - IMAGE_FORMAT_BOOTI, /* Arm64/RISC-V boot image */ -}; +#define IMAGE_FORMAT_INVALID 0x00 +#define IMAGE_FORMAT_LEGACY 0x01 /* legacy image_header based format */ +#define IMAGE_FORMAT_FIT 0x02 /* new, libfdt based format */ +#define IMAGE_FORMAT_ANDROID 0x03 /* Android boot image */ /** * genimg_get_kernel_addr_fit() - Parse FIT specifier @@ -633,42 +630,9 @@ ulong genimg_get_kernel_addr_fit(const char *const img_addr, const char **fit_uname_kernel); ulong genimg_get_kernel_addr(char * const img_addr); - -/** - * genimg_get_format - get image format type - * @img_addr: image start address - * Return: image format type or IMAGE_FORMAT_INVALID if no image is present - * - * genimg_get_format() checks whether provided address points to a valid - * legacy or FIT image. - * - * New uImage format and FDT blob are based on a libfdt. FDT blob - * may be passed directly or embedded in a FIT image. In both situations - * genimg_get_format() must be able to dectect libfdt header. - */ -enum image_fmt_t genimg_get_format(const void *img_addr); - -/** - * genimg_get_format_comp() - Like genimg_get_format() but adds compressed booti - * - * If a compressed file is detected (with image_decomp_type()) and - * CONFIG_CMD_BOOTI is enabled, then this returns IMAGE_FORMAT_BOOTI - * - * @img_addr: image start address - * Return: image format type or IMAGE_FORMAT_INVALID if no image is present - */ -enum image_fmt_t genimg_get_format_comp(const void *img_addr); - +int genimg_get_format(const void *img_addr); int genimg_has_config(struct bootm_headers *images); -/** - * booti_is_valid() - Check if an image appears to be an Arm64 image - * - * @img: Pointer to image - * Return: true if the image has the Arm64 magic - */ -bool booti_is_valid(const void *img); - /** * boot_get_fpga() - Locate the FPGA image * diff --git a/include/net-common.h b/include/net-common.h index 6a39091a5d4..1d507b13b06 100644 --- a/include/net-common.h +++ b/include/net-common.h @@ -475,36 +475,6 @@ int net_init(void); enum proto_t; int net_loop(enum proto_t protocol); -/* internal function: do not use! */ -int netboot_run_(enum proto_t proto, ulong addr, const char *fname, ulong size, - bool fname_explicit, bool ipv6); - -/** - * netboot_run() - Run a network operation - * - * The following proto values are NOT supported: - * PING, since net_ping_ip cannot be set - * NETCONS, since its parameters cannot bet set - * RS, since first_call cannot be set, along with perhaps other things - * UDP, since udp_ops cannot be set - * DNS, since net_dns_resolve and net_dns_env_var cannot be set - * WGET, since DNS must be done first and that is not supported - * DHCP6, since the required parameters cannot be passed in - * - * To support one of these, either add the required arguments or perhaps a - * separate function and a struct to hold the information. - * - * @proto: Operation to run: TFTPGET, FASTBOOT_UDP, FASTBOOT_TCP, BOOTP, - * TFTPPUT, RARP, NFS, DHCP - * @addr: Load/save address - * @fname: Filename - * @size: Save size (not used for TFTPGET) - * @ipv6: true to use IPv6, false to use IPv4 - * Return 0 on success, else -ve error code - */ -int netboot_run(enum proto_t proto, ulong addr, const char *fname, ulong size, - bool ipv6); - /** * dhcp_run() - Run DHCP on the current ethernet device * diff --git a/net/net.c b/net/net.c index ef97377cdec..1828f1cca36 100644 --- a/net/net.c +++ b/net/net.c @@ -775,50 +775,6 @@ done: return ret; } -int netboot_run_(enum proto_t proto, ulong addr, const char *fname, ulong size, - bool fname_explicit, bool ipv6) -{ - int ret; - - bootstage_mark(BOOTSTAGE_ID_NET_START); - - /* - * For now we use the global variables as that is the only way to - * control the network stack. At some point, perhaps, the state could be - * in a struct - */ - if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) - image_save_addr = addr; - else - image_load_addr = addr; - - net_boot_file_name_explicit = fname_explicit; - copy_filename(net_boot_file_name, fname, sizeof(net_boot_file_name)); - if (IS_ENABLED(CONFIG_IPV6)) - use_ip6 = ipv6; - if (IS_ENABLED(CONFIG_CMD_TFTPPUT) && proto == TFTPPUT) { - image_save_addr = addr; - image_save_size = size; - } else { - image_load_addr = addr; - } - - ret = net_loop(proto); - if (ret < 0) { - bootstage_error(BOOTSTAGE_ID_NET_NETLOOP_OK); - return ret; - } - bootstage_mark(BOOTSTAGE_ID_NET_NETLOOP_OK); - - return 0; -} - -int netboot_run(enum proto_t proto, ulong addr, const char *fname, ulong size, - bool ipv6) -{ - return netboot_run_(proto, addr, fname, size, true, ipv6); -} - /**********************************************************************/ static void start_again_timeout_handler(void) -- cgit v1.3.1