mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-25 06:00:43 +00:00
741d1e9d3f
EFI applications can be very large and thus used to cause boot failures
when malloc() space was exhausted.
A recent changed fixed this by using the kernel_addr_r environment var
as the address of the buffer. However, it still frees the buffer when
the bootflow is discarded.
Fix this by introducing a flag to indicate whether the buffer was
allocated, or not.
Note that kernel_addr_r is not the last word here. It might be better
to use lmb to place images. But there is a lot of refactoring to do
before we can remove the environment variables. The distro scripts rely
on them so it is safe for bootstd to do so too.
Fixes: 6a8c2f9781
bootstd: Avoid allocating memory for the EFI file
Signed-off-by: Simon Glass <sjg@chromium.org>
Reported by: Simon Glass <sjg@chromium.org>
Reported by: Shantur Rathore <i@shantur.com>
Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
Tested-by: Shantur Rathore <i@shantur.com>
946 lines
21 KiB
C
946 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright 2021 Google LLC
|
|
* Written by Simon Glass <sjg@chromium.org>
|
|
*/
|
|
|
|
#define LOG_CATEGORY UCLASS_BOOTSTD
|
|
|
|
#include <common.h>
|
|
#include <bootdev.h>
|
|
#include <bootflow.h>
|
|
#include <bootmeth.h>
|
|
#include <bootstd.h>
|
|
#include <dm.h>
|
|
#include <env_internal.h>
|
|
#include <malloc.h>
|
|
#include <serial.h>
|
|
#include <dm/device-internal.h>
|
|
#include <dm/uclass-internal.h>
|
|
|
|
/* error codes used to signal running out of things */
|
|
enum {
|
|
BF_NO_MORE_PARTS = -ESHUTDOWN,
|
|
BF_NO_MORE_DEVICES = -ENODEV,
|
|
};
|
|
|
|
/**
|
|
* bootflow_state - name for each state
|
|
*
|
|
* See enum bootflow_state_t for what each of these means
|
|
*/
|
|
static const char *const bootflow_state[BOOTFLOWST_COUNT] = {
|
|
"base",
|
|
"media",
|
|
"part",
|
|
"fs",
|
|
"file",
|
|
"ready",
|
|
};
|
|
|
|
const char *bootflow_state_get_name(enum bootflow_state_t state)
|
|
{
|
|
/* This doesn't need to be a useful name, since it will never occur */
|
|
if (state < 0 || state >= BOOTFLOWST_COUNT)
|
|
return "?";
|
|
|
|
return bootflow_state[state];
|
|
}
|
|
|
|
int bootflow_first_glob(struct bootflow **bflowp)
|
|
{
|
|
struct bootstd_priv *std;
|
|
int ret;
|
|
|
|
ret = bootstd_get_priv(&std);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (list_empty(&std->glob_head))
|
|
return -ENOENT;
|
|
|
|
*bflowp = list_first_entry(&std->glob_head, struct bootflow,
|
|
glob_node);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int bootflow_next_glob(struct bootflow **bflowp)
|
|
{
|
|
struct bootstd_priv *std;
|
|
struct bootflow *bflow = *bflowp;
|
|
int ret;
|
|
|
|
ret = bootstd_get_priv(&std);
|
|
if (ret)
|
|
return ret;
|
|
|
|
*bflowp = NULL;
|
|
|
|
if (list_is_last(&bflow->glob_node, &std->glob_head))
|
|
return -ENOENT;
|
|
|
|
*bflowp = list_entry(bflow->glob_node.next, struct bootflow, glob_node);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void bootflow_iter_init(struct bootflow_iter *iter, int flags)
|
|
{
|
|
memset(iter, '\0', sizeof(*iter));
|
|
iter->first_glob_method = -1;
|
|
iter->flags = flags;
|
|
|
|
/* remember the first bootdevs we see */
|
|
iter->max_devs = BOOTFLOW_MAX_USED_DEVS;
|
|
}
|
|
|
|
void bootflow_iter_uninit(struct bootflow_iter *iter)
|
|
{
|
|
free(iter->method_order);
|
|
}
|
|
|
|
int bootflow_iter_drop_bootmeth(struct bootflow_iter *iter,
|
|
const struct udevice *bmeth)
|
|
{
|
|
/* We only support disabling the current bootmeth */
|
|
if (bmeth != iter->method || iter->cur_method >= iter->num_methods ||
|
|
iter->method_order[iter->cur_method] != bmeth)
|
|
return -EINVAL;
|
|
|
|
memmove(&iter->method_order[iter->cur_method],
|
|
&iter->method_order[iter->cur_method + 1],
|
|
(iter->num_methods - iter->cur_method - 1) * sizeof(void *));
|
|
|
|
iter->num_methods--;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* bootflow_iter_set_dev() - switch to the next bootdev when iterating
|
|
*
|
|
* This sets iter->dev, records the device in the dev_used[] list and shows a
|
|
* message if required
|
|
*
|
|
* @iter: Iterator to update
|
|
* @dev: Bootdev to use, or NULL if there are no more
|
|
*/
|
|
static void bootflow_iter_set_dev(struct bootflow_iter *iter,
|
|
struct udevice *dev, int method_flags)
|
|
{
|
|
struct bootmeth_uc_plat *ucp = dev_get_uclass_plat(iter->method);
|
|
|
|
log_debug("iter: Setting dev to %s, flags %x\n",
|
|
dev ? dev->name : "(none)", method_flags);
|
|
iter->dev = dev;
|
|
iter->method_flags = method_flags;
|
|
|
|
if (IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
|
|
/* record the device for later */
|
|
if (dev && iter->num_devs < iter->max_devs)
|
|
iter->dev_used[iter->num_devs++] = dev;
|
|
|
|
if ((iter->flags & (BOOTFLOWIF_SHOW | BOOTFLOWIF_SINGLE_DEV)) ==
|
|
BOOTFLOWIF_SHOW) {
|
|
if (dev)
|
|
printf("Scanning bootdev '%s':\n", dev->name);
|
|
else if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) &&
|
|
ucp->flags & BOOTMETHF_GLOBAL)
|
|
printf("Scanning global bootmeth '%s':\n",
|
|
iter->method->name);
|
|
else
|
|
printf("No more bootdevs\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* scan_next_in_uclass() - Scan for the next bootdev in the same media uclass
|
|
*
|
|
* Move through the following bootdevs until we find another in this media
|
|
* uclass, or run out
|
|
*
|
|
* @devp: On entry, the device to check, on exit the new device, or NULL if
|
|
* there is none
|
|
*/
|
|
static void scan_next_in_uclass(struct udevice **devp)
|
|
{
|
|
struct udevice *dev = *devp;
|
|
enum uclass_id cur_id = device_get_uclass_id(dev->parent);
|
|
|
|
do {
|
|
uclass_find_next_device(&dev);
|
|
} while (dev && cur_id != device_get_uclass_id(dev->parent));
|
|
|
|
*devp = dev;
|
|
}
|
|
|
|
/**
|
|
* iter_incr() - Move to the next item (method, part, bootdev)
|
|
*
|
|
* Return: 0 if OK, BF_NO_MORE_DEVICES if there are no more bootdevs
|
|
*/
|
|
static int iter_incr(struct bootflow_iter *iter)
|
|
{
|
|
struct udevice *dev;
|
|
bool inc_dev = true;
|
|
bool global;
|
|
int ret;
|
|
|
|
log_debug("entry: err=%d\n", iter->err);
|
|
global = iter->doing_global;
|
|
|
|
if (iter->err == BF_NO_MORE_DEVICES)
|
|
return BF_NO_MORE_DEVICES;
|
|
|
|
if (iter->err != BF_NO_MORE_PARTS) {
|
|
/* Get the next boothmethod */
|
|
if (++iter->cur_method < iter->num_methods) {
|
|
iter->method = iter->method_order[iter->cur_method];
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* If we have finished scanning the global bootmeths, start the
|
|
* normal bootdev scan
|
|
*/
|
|
if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && global) {
|
|
iter->num_methods = iter->first_glob_method;
|
|
iter->doing_global = false;
|
|
|
|
/*
|
|
* Don't move to the next dev as we haven't tried this
|
|
* one yet!
|
|
*/
|
|
inc_dev = false;
|
|
}
|
|
}
|
|
|
|
/* No more bootmeths; start at the first one, and... */
|
|
iter->cur_method = 0;
|
|
iter->method = iter->method_order[iter->cur_method];
|
|
|
|
if (iter->err != BF_NO_MORE_PARTS) {
|
|
/* ...select next partition */
|
|
if (++iter->part <= iter->max_part)
|
|
return 0;
|
|
}
|
|
|
|
/* No more partitions; start at the first one and... */
|
|
iter->part = 0;
|
|
|
|
/*
|
|
* Note: as far as we know, there is no partition table on the next
|
|
* bootdev, so set max_part to 0 until we discover otherwise. See
|
|
* bootdev_find_in_blk() for where this is set.
|
|
*/
|
|
iter->max_part = 0;
|
|
|
|
/* ...select next bootdev */
|
|
if (iter->flags & BOOTFLOWIF_SINGLE_DEV) {
|
|
ret = -ENOENT;
|
|
} else {
|
|
int method_flags;
|
|
|
|
ret = 0;
|
|
dev = iter->dev;
|
|
log_debug("inc_dev=%d\n", inc_dev);
|
|
if (!inc_dev) {
|
|
ret = bootdev_setup_iter(iter, NULL, &dev,
|
|
&method_flags);
|
|
} else if (IS_ENABLED(CONFIG_BOOTSTD_FULL) &&
|
|
(iter->flags & BOOTFLOWIF_SINGLE_UCLASS)) {
|
|
scan_next_in_uclass(&dev);
|
|
if (!dev) {
|
|
log_debug("finished uclass %s\n",
|
|
dev_get_uclass_name(dev));
|
|
ret = -ENODEV;
|
|
}
|
|
} else if (IS_ENABLED(CONFIG_BOOTSTD_FULL) &&
|
|
iter->flags & BOOTFLOWIF_SINGLE_MEDIA) {
|
|
log_debug("next in single\n");
|
|
method_flags = 0;
|
|
do {
|
|
/*
|
|
* Move to the next bootdev child of this media
|
|
* device. This ensures that we cover all the
|
|
* available SCSI IDs and LUNs.
|
|
*/
|
|
device_find_next_child(&dev);
|
|
log_debug("- next %s\n",
|
|
dev ? dev->name : "(none)");
|
|
} while (dev && device_get_uclass_id(dev) !=
|
|
UCLASS_BOOTDEV);
|
|
if (!dev) {
|
|
log_debug("finished uclass %s\n",
|
|
dev_get_uclass_name(dev));
|
|
ret = -ENODEV;
|
|
}
|
|
} else {
|
|
log_debug("labels %p\n", iter->labels);
|
|
if (iter->labels) {
|
|
/*
|
|
* when the label is "mmc" we want to scan all
|
|
* mmc bootdevs, not just the first. See
|
|
* bootdev_find_by_label() where this flag is
|
|
* set up
|
|
*/
|
|
if (iter->method_flags &
|
|
BOOTFLOW_METHF_SINGLE_UCLASS) {
|
|
scan_next_in_uclass(&dev);
|
|
log_debug("looking for next device %s: %s\n",
|
|
iter->dev->name,
|
|
dev ? dev->name : "<none>");
|
|
} else {
|
|
dev = NULL;
|
|
}
|
|
if (!dev) {
|
|
log_debug("looking at next label\n");
|
|
ret = bootdev_next_label(iter, &dev,
|
|
&method_flags);
|
|
}
|
|
} else {
|
|
ret = bootdev_next_prio(iter, &dev);
|
|
method_flags = 0;
|
|
}
|
|
}
|
|
log_debug("ret=%d, dev=%p %s\n", ret, dev,
|
|
dev ? dev->name : "none");
|
|
if (ret) {
|
|
bootflow_iter_set_dev(iter, NULL, 0);
|
|
} else {
|
|
/*
|
|
* Probe the bootdev. This does not probe any attached
|
|
* block device, since they are siblings
|
|
*/
|
|
ret = device_probe(dev);
|
|
log_debug("probe %s %d\n", dev->name, ret);
|
|
if (!log_msg_ret("probe", ret))
|
|
bootflow_iter_set_dev(iter, dev, method_flags);
|
|
}
|
|
}
|
|
|
|
/* if there are no more bootdevs, give up */
|
|
if (ret)
|
|
return log_msg_ret("incr", BF_NO_MORE_DEVICES);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* bootflow_check() - Check if a bootflow can be obtained
|
|
*
|
|
* @iter: Provides part, bootmeth to use
|
|
* @bflow: Bootflow to update on success
|
|
* Return: 0 if OK, -ENOSYS if there is no bootflow support on this device,
|
|
* BF_NO_MORE_PARTS if there are no more partitions on bootdev
|
|
*/
|
|
static int bootflow_check(struct bootflow_iter *iter, struct bootflow *bflow)
|
|
{
|
|
struct udevice *dev;
|
|
int ret;
|
|
|
|
if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && iter->doing_global) {
|
|
bootflow_iter_set_dev(iter, NULL, 0);
|
|
ret = bootmeth_get_bootflow(iter->method, bflow);
|
|
if (ret)
|
|
return log_msg_ret("glob", ret);
|
|
|
|
return 0;
|
|
}
|
|
|
|
dev = iter->dev;
|
|
ret = bootdev_get_bootflow(dev, iter, bflow);
|
|
|
|
/* If we got a valid bootflow, return it */
|
|
if (!ret) {
|
|
log_debug("Bootdev '%s' part %d method '%s': Found bootflow\n",
|
|
dev->name, iter->part, iter->method->name);
|
|
return 0;
|
|
}
|
|
|
|
/* Unless there is nothing more to try, move to the next device */
|
|
else if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
|
|
log_debug("Bootdev '%s' part %d method '%s': Error %d\n",
|
|
dev->name, iter->part, iter->method->name, ret);
|
|
/*
|
|
* For 'all' we return all bootflows, even
|
|
* those with errors
|
|
*/
|
|
if (iter->flags & BOOTFLOWIF_ALL)
|
|
return log_msg_ret("all", ret);
|
|
}
|
|
if (ret)
|
|
return log_msg_ret("check", ret);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int bootflow_scan_first(struct udevice *dev, const char *label,
|
|
struct bootflow_iter *iter, int flags,
|
|
struct bootflow *bflow)
|
|
{
|
|
int ret;
|
|
|
|
if (dev || label)
|
|
flags |= BOOTFLOWIF_SKIP_GLOBAL;
|
|
bootflow_iter_init(iter, flags);
|
|
|
|
/*
|
|
* Set up the ordering of bootmeths. This sets iter->doing_global and
|
|
* iter->first_glob_method if we are starting with the global bootmeths
|
|
*/
|
|
ret = bootmeth_setup_iter_order(iter, !(flags & BOOTFLOWIF_SKIP_GLOBAL));
|
|
if (ret)
|
|
return log_msg_ret("obmeth", -ENODEV);
|
|
|
|
/* Find the first bootmeth (there must be at least one!) */
|
|
iter->method = iter->method_order[iter->cur_method];
|
|
|
|
if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) || !iter->doing_global) {
|
|
struct udevice *dev = NULL;
|
|
int method_flags;
|
|
|
|
ret = bootdev_setup_iter(iter, label, &dev, &method_flags);
|
|
if (ret)
|
|
return log_msg_ret("obdev", -ENODEV);
|
|
|
|
bootflow_iter_set_dev(iter, dev, method_flags);
|
|
}
|
|
|
|
ret = bootflow_check(iter, bflow);
|
|
if (ret) {
|
|
log_debug("check - ret=%d\n", ret);
|
|
if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
|
|
if (iter->flags & BOOTFLOWIF_ALL)
|
|
return log_msg_ret("all", ret);
|
|
}
|
|
iter->err = ret;
|
|
ret = bootflow_scan_next(iter, bflow);
|
|
if (ret)
|
|
return log_msg_ret("get", ret);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int bootflow_scan_next(struct bootflow_iter *iter, struct bootflow *bflow)
|
|
{
|
|
int ret;
|
|
|
|
do {
|
|
ret = iter_incr(iter);
|
|
log_debug("iter_incr: ret=%d\n", ret);
|
|
if (ret == BF_NO_MORE_DEVICES)
|
|
return log_msg_ret("done", ret);
|
|
|
|
if (!ret) {
|
|
ret = bootflow_check(iter, bflow);
|
|
log_debug("check - ret=%d\n", ret);
|
|
if (!ret)
|
|
return 0;
|
|
iter->err = ret;
|
|
if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
|
|
if (iter->flags & BOOTFLOWIF_ALL)
|
|
return log_msg_ret("all", ret);
|
|
}
|
|
} else {
|
|
log_debug("incr failed, err=%d\n", ret);
|
|
iter->err = ret;
|
|
}
|
|
|
|
} while (1);
|
|
}
|
|
|
|
void bootflow_init(struct bootflow *bflow, struct udevice *bootdev,
|
|
struct udevice *meth)
|
|
{
|
|
memset(bflow, '\0', sizeof(*bflow));
|
|
bflow->dev = bootdev;
|
|
bflow->method = meth;
|
|
bflow->state = BOOTFLOWST_BASE;
|
|
}
|
|
|
|
void bootflow_free(struct bootflow *bflow)
|
|
{
|
|
free(bflow->name);
|
|
free(bflow->subdir);
|
|
free(bflow->fname);
|
|
if (!(bflow->flags & BOOTFLOWF_STATIC_BUF))
|
|
free(bflow->buf);
|
|
free(bflow->os_name);
|
|
free(bflow->fdt_fname);
|
|
free(bflow->bootmeth_priv);
|
|
}
|
|
|
|
void bootflow_remove(struct bootflow *bflow)
|
|
{
|
|
if (bflow->dev)
|
|
list_del(&bflow->bm_node);
|
|
list_del(&bflow->glob_node);
|
|
|
|
bootflow_free(bflow);
|
|
free(bflow);
|
|
}
|
|
|
|
#if CONFIG_IS_ENABLED(BOOTSTD_FULL)
|
|
int bootflow_read_all(struct bootflow *bflow)
|
|
{
|
|
int ret;
|
|
|
|
if (bflow->state != BOOTFLOWST_READY)
|
|
return log_msg_ret("rd", -EPROTO);
|
|
|
|
ret = bootmeth_read_all(bflow->method, bflow);
|
|
if (ret)
|
|
return log_msg_ret("rd2", ret);
|
|
|
|
return 0;
|
|
}
|
|
#endif /* BOOTSTD_FULL */
|
|
|
|
int bootflow_boot(struct bootflow *bflow)
|
|
{
|
|
int ret;
|
|
|
|
if (bflow->state != BOOTFLOWST_READY)
|
|
return log_msg_ret("load", -EPROTO);
|
|
|
|
ret = bootmeth_boot(bflow->method, bflow);
|
|
if (ret)
|
|
return log_msg_ret("boot", ret);
|
|
|
|
/*
|
|
* internal error, should not get here since we should have booted
|
|
* something or returned an error
|
|
*/
|
|
|
|
return log_msg_ret("end", -EFAULT);
|
|
}
|
|
|
|
int bootflow_run_boot(struct bootflow_iter *iter, struct bootflow *bflow)
|
|
{
|
|
int ret;
|
|
|
|
printf("** Booting bootflow '%s' with %s\n", bflow->name,
|
|
bflow->method->name);
|
|
if (IS_ENABLED(CONFIG_OF_HAS_PRIOR_STAGE) &&
|
|
(bflow->flags & BOOTFLOWF_USE_PRIOR_FDT))
|
|
printf("Using prior-stage device tree\n");
|
|
ret = bootflow_boot(bflow);
|
|
if (!IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
|
|
printf("Boot failed (err=%d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
switch (ret) {
|
|
case -EPROTO:
|
|
printf("Bootflow not loaded (state '%s')\n",
|
|
bootflow_state_get_name(bflow->state));
|
|
break;
|
|
case -ENOSYS:
|
|
printf("Boot method '%s' not supported\n", bflow->method->name);
|
|
break;
|
|
case -ENOTSUPP:
|
|
/* Disable this bootflow for this iteration */
|
|
if (iter) {
|
|
int ret2;
|
|
|
|
ret2 = bootflow_iter_drop_bootmeth(iter, bflow->method);
|
|
if (!ret2) {
|
|
printf("Boot method '%s' failed and will not be retried\n",
|
|
bflow->method->name);
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
printf("Boot failed (err=%d)\n", ret);
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int bootflow_iter_check_blk(const struct bootflow_iter *iter)
|
|
{
|
|
const struct udevice *media = dev_get_parent(iter->dev);
|
|
enum uclass_id id = device_get_uclass_id(media);
|
|
|
|
log_debug("uclass %d: %s\n", id, uclass_get_name(id));
|
|
if (id != UCLASS_ETH && id != UCLASS_BOOTSTD && id != UCLASS_QFW)
|
|
return 0;
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
int bootflow_iter_check_sf(const struct bootflow_iter *iter)
|
|
{
|
|
const struct udevice *media = dev_get_parent(iter->dev);
|
|
enum uclass_id id = device_get_uclass_id(media);
|
|
|
|
log_debug("uclass %d: %s\n", id, uclass_get_name(id));
|
|
if (id == UCLASS_SPI_FLASH)
|
|
return 0;
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
int bootflow_iter_check_net(const struct bootflow_iter *iter)
|
|
{
|
|
const struct udevice *media = dev_get_parent(iter->dev);
|
|
enum uclass_id id = device_get_uclass_id(media);
|
|
|
|
log_debug("uclass %d: %s\n", id, uclass_get_name(id));
|
|
if (id == UCLASS_ETH)
|
|
return 0;
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
int bootflow_iter_check_system(const struct bootflow_iter *iter)
|
|
{
|
|
const struct udevice *media = dev_get_parent(iter->dev);
|
|
enum uclass_id id = device_get_uclass_id(media);
|
|
|
|
log_debug("uclass %d: %s\n", id, uclass_get_name(id));
|
|
if (id == UCLASS_BOOTSTD)
|
|
return 0;
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
/**
|
|
* bootflow_cmdline_set() - Set the command line for a bootflow
|
|
*
|
|
* @value: New command-line string
|
|
* Returns 0 if OK, -ENOENT if no current bootflow, -ENOMEM if out of memory
|
|
*/
|
|
int bootflow_cmdline_set(struct bootflow *bflow, const char *value)
|
|
{
|
|
char *cmdline = NULL;
|
|
|
|
if (value) {
|
|
cmdline = strdup(value);
|
|
if (!cmdline)
|
|
return -ENOMEM;
|
|
}
|
|
|
|
free(bflow->cmdline);
|
|
bflow->cmdline = cmdline;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_BOOTSTD_FULL
|
|
/**
|
|
* on_bootargs() - Update the cmdline of a bootflow
|
|
*/
|
|
static int on_bootargs(const char *name, const char *value, enum env_op op,
|
|
int flags)
|
|
{
|
|
struct bootstd_priv *std;
|
|
struct bootflow *bflow;
|
|
int ret;
|
|
|
|
ret = bootstd_get_priv(&std);
|
|
if (ret)
|
|
return 0;
|
|
bflow = std->cur_bootflow;
|
|
if (!bflow)
|
|
return 0;
|
|
|
|
switch (op) {
|
|
case env_op_create:
|
|
case env_op_overwrite:
|
|
ret = bootflow_cmdline_set(bflow, value);
|
|
if (ret && ret != ENOENT)
|
|
return 1;
|
|
return 0;
|
|
case env_op_delete:
|
|
bootflow_cmdline_set(bflow, NULL);
|
|
fallthrough;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
U_BOOT_ENV_CALLBACK(bootargs, on_bootargs);
|
|
#endif
|
|
|
|
/**
|
|
* copy_in() - Copy a string into a cmdline buffer
|
|
*
|
|
* @buf: Buffer to copy into
|
|
* @end: End of buffer (pointer to char after the end)
|
|
* @arg: String to copy from
|
|
* @len: Number of chars to copy from @arg (note that this is not usually the
|
|
* sane as strlen(arg) since the string may contain following arguments)
|
|
* @new_val: Value to put after arg, or BOOTFLOWCL_EMPTY to use an empty value
|
|
* with no '=' sign
|
|
* Returns: Number of chars written to @buf
|
|
*/
|
|
static int copy_in(char *buf, char *end, const char *arg, int len,
|
|
const char *new_val)
|
|
{
|
|
char *to = buf;
|
|
|
|
/* copy the arg name */
|
|
if (to + len >= end)
|
|
return -E2BIG;
|
|
memcpy(to, arg, len);
|
|
to += len;
|
|
|
|
if (new_val == BOOTFLOWCL_EMPTY) {
|
|
/* no value */
|
|
} else {
|
|
bool need_quote = strchr(new_val, ' ');
|
|
len = strlen(new_val);
|
|
|
|
/* need space for value, equals sign and maybe two quotes */
|
|
if (to + 1 + (need_quote ? 2 : 0) + len >= end)
|
|
return -E2BIG;
|
|
*to++ = '=';
|
|
if (need_quote)
|
|
*to++ = '"';
|
|
memcpy(to, new_val, len);
|
|
to += len;
|
|
if (need_quote)
|
|
*to++ = '"';
|
|
}
|
|
|
|
return to - buf;
|
|
}
|
|
|
|
int cmdline_set_arg(char *buf, int maxlen, const char *cmdline,
|
|
const char *set_arg, const char *new_val, int *posp)
|
|
{
|
|
bool found_arg = false;
|
|
const char *from;
|
|
char *to, *end;
|
|
int set_arg_len;
|
|
char empty = '\0';
|
|
int ret;
|
|
|
|
from = cmdline ?: ∅
|
|
|
|
/* check if the value has quotes inside */
|
|
if (new_val && new_val != BOOTFLOWCL_EMPTY && strchr(new_val, '"'))
|
|
return -EBADF;
|
|
|
|
set_arg_len = strlen(set_arg);
|
|
for (to = buf, end = buf + maxlen; *from;) {
|
|
const char *val, *arg_end, *val_end, *p;
|
|
bool in_quote;
|
|
|
|
if (to >= end)
|
|
return -E2BIG;
|
|
while (*from == ' ')
|
|
from++;
|
|
if (!*from)
|
|
break;
|
|
|
|
/* find the end of this arg */
|
|
val = NULL;
|
|
arg_end = NULL;
|
|
val_end = NULL;
|
|
in_quote = false;
|
|
for (p = from;; p++) {
|
|
if (in_quote) {
|
|
if (!*p)
|
|
return -EINVAL;
|
|
if (*p == '"')
|
|
in_quote = false;
|
|
continue;
|
|
}
|
|
if (*p == '=' && !arg_end) {
|
|
arg_end = p;
|
|
val = p + 1;
|
|
} else if (*p == '"') {
|
|
in_quote = true;
|
|
} else if (!*p || *p == ' ') {
|
|
val_end = p;
|
|
if (!arg_end)
|
|
arg_end = p;
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
* At this point val_end points to the end of the value, or the
|
|
* last char after the arg name, if there is no label.
|
|
* arg_end is the char after the arg name
|
|
* val points to the value, or NULL if there is none
|
|
* char after the value.
|
|
*
|
|
* fred=1234
|
|
* ^ ^^ ^
|
|
* from || |
|
|
* / \ \
|
|
* arg_end val val_end
|
|
*/
|
|
log_debug("from %s arg_end %ld val %ld val_end %ld\n", from,
|
|
(long)(arg_end - from), (long)(val - from),
|
|
(long)(val_end - from));
|
|
|
|
if (to != buf) {
|
|
if (to >= end)
|
|
return -E2BIG;
|
|
*to++ = ' ';
|
|
}
|
|
|
|
/* if this is the target arg, update it */
|
|
if (arg_end - from == set_arg_len &&
|
|
!strncmp(from, set_arg, set_arg_len)) {
|
|
if (!buf) {
|
|
bool has_quote = val_end[-1] == '"';
|
|
|
|
/*
|
|
* exclude any start/end quotes from
|
|
* calculations
|
|
*/
|
|
if (!val)
|
|
val = val_end;
|
|
*posp = val - cmdline + has_quote;
|
|
return val_end - val - 2 * has_quote;
|
|
}
|
|
found_arg = true;
|
|
if (!new_val) {
|
|
/* delete this arg */
|
|
from = val_end + (*val_end == ' ');
|
|
log_debug("delete from: %s\n", from);
|
|
if (to != buf)
|
|
to--; /* drop the space we added */
|
|
continue;
|
|
}
|
|
|
|
ret = copy_in(to, end, from, arg_end - from, new_val);
|
|
if (ret < 0)
|
|
return ret;
|
|
to += ret;
|
|
|
|
/* if not the target arg, copy it unchanged */
|
|
} else if (to) {
|
|
int len;
|
|
|
|
len = val_end - from;
|
|
if (to + len >= end)
|
|
return -E2BIG;
|
|
memcpy(to, from, len);
|
|
to += len;
|
|
}
|
|
from = val_end;
|
|
}
|
|
|
|
/* If we didn't find the arg, add it */
|
|
if (!found_arg) {
|
|
/* trying to delete something that is not there */
|
|
if (!new_val || !buf)
|
|
return -ENOENT;
|
|
if (to >= end)
|
|
return -E2BIG;
|
|
|
|
/* add a space to separate it from the previous arg */
|
|
if (to != buf && to[-1] != ' ')
|
|
*to++ = ' ';
|
|
ret = copy_in(to, end, set_arg, set_arg_len, new_val);
|
|
log_debug("ret=%d, to: %s buf: %s\n", ret, to, buf);
|
|
if (ret < 0)
|
|
return ret;
|
|
to += ret;
|
|
}
|
|
|
|
/* delete any trailing space */
|
|
if (to > buf && to[-1] == ' ')
|
|
to--;
|
|
|
|
if (to >= end)
|
|
return -E2BIG;
|
|
*to++ = '\0';
|
|
|
|
return to - buf;
|
|
}
|
|
|
|
int bootflow_cmdline_set_arg(struct bootflow *bflow, const char *set_arg,
|
|
const char *new_val, bool set_env)
|
|
{
|
|
char buf[2048];
|
|
char *cmd = NULL;
|
|
int ret;
|
|
|
|
ret = cmdline_set_arg(buf, sizeof(buf), bflow->cmdline, set_arg,
|
|
new_val, NULL);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = bootflow_cmdline_set(bflow, buf);
|
|
if (*buf) {
|
|
cmd = strdup(buf);
|
|
if (!cmd)
|
|
return -ENOMEM;
|
|
}
|
|
free(bflow->cmdline);
|
|
bflow->cmdline = cmd;
|
|
|
|
if (set_env) {
|
|
ret = env_set("bootargs", bflow->cmdline);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int cmdline_get_arg(const char *cmdline, const char *arg, int *posp)
|
|
{
|
|
int ret;
|
|
|
|
ret = cmdline_set_arg(NULL, 1, cmdline, arg, NULL, posp);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int bootflow_cmdline_get_arg(struct bootflow *bflow, const char *arg,
|
|
const char **val)
|
|
{
|
|
int ret;
|
|
int pos;
|
|
|
|
ret = cmdline_get_arg(bflow->cmdline, arg, &pos);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = bflow->cmdline + pos;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int bootflow_cmdline_auto(struct bootflow *bflow, const char *arg)
|
|
{
|
|
struct serial_device_info info;
|
|
char buf[50];
|
|
int ret;
|
|
|
|
ret = serial_getinfo(gd->cur_serial_dev, &info);
|
|
if (ret)
|
|
return ret;
|
|
|
|
*buf = '\0';
|
|
if (!strcmp("earlycon", arg)) {
|
|
snprintf(buf, sizeof(buf),
|
|
"uart8250,mmio32,%#lx,%dn8", info.addr,
|
|
info.baudrate);
|
|
} else if (!strcmp("console", arg)) {
|
|
snprintf(buf, sizeof(buf),
|
|
"ttyS0,%dn8", info.baudrate);
|
|
}
|
|
|
|
if (!*buf) {
|
|
printf("Unknown param '%s\n", arg);
|
|
return -ENOENT;
|
|
}
|
|
|
|
ret = bootflow_cmdline_set_arg(bflow, arg, buf, true);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|