// SPDX-License-Identifier: GPL-2.0+ /* * Copyright 2021 Google LLC * Written by Simon Glass */ #define LOG_CATEGORY UCLASS_BOOTSTD #include #include #include #include #include #include #include #include #include #include #include /* 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 : ""); } 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); 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 = 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 (!strncmp(from, set_arg, arg_end - from)) { 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; }