boot/bootflow.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2021 Google LLC
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_BOOTSTD
   8
   9 #include <common.h>
  10 #include <bootdev.h>
  11 #include <bootflow.h>
  12 #include <bootmeth.h>
  13 #include <bootstd.h>
  14 #include <dm.h>
  15 #include <malloc.h>
  16 #include <dm/device-internal.h>
  17 #include <dm/uclass-internal.h>
  18
  19 /* error codes used to signal running out of things */
  20 enum {
  21         BF_NO_MORE_PARTS        = -ESHUTDOWN,
  22         BF_NO_MORE_DEVICES      = -ENODEV,
  23 };
  24
  25 /**
  26  * bootflow_state - name for each state
  27  *
  28  * See enum bootflow_state_t for what each of these means
  29  */
  30 static const char *const bootflow_state[BOOTFLOWST_COUNT] = {
  31         "base",
  32         "media",
  33         "part",
  34         "fs",
  35         "file",
  36         "ready",
  37 };
  38
  39 const char *bootflow_state_get_name(enum bootflow_state_t state)
  40 {
  41         /* This doesn't need to be a useful name, since it will never occur */
  42         if (state < 0 || state >= BOOTFLOWST_COUNT)
  43                 return "?";
  44
  45         return bootflow_state[state];
  46 }
  47
  48 int bootflow_first_glob(struct bootflow **bflowp)
  49 {
  50         struct bootstd_priv *std;
  51         int ret;
  52
  53         ret = bootstd_get_priv(&std);
  54         if (ret)
  55                 return ret;
  56
  57         if (list_empty(&std->glob_head))
  58                 return -ENOENT;
  59
  60         *bflowp = list_first_entry(&std->glob_head, struct bootflow,
  61                                    glob_node);
  62
  63         return 0;
  64 }
  65
  66 int bootflow_next_glob(struct bootflow **bflowp)
  67 {
  68         struct bootstd_priv *std;
  69         struct bootflow *bflow = *bflowp;
  70         int ret;
  71
  72         ret = bootstd_get_priv(&std);
  73         if (ret)
  74                 return ret;
  75
  76         *bflowp = NULL;
  77
  78         if (list_is_last(&bflow->glob_node, &std->glob_head))
  79                 return -ENOENT;
  80
  81         *bflowp = list_entry(bflow->glob_node.next, struct bootflow, glob_node);
  82
  83         return 0;
  84 }
  85
  86 void bootflow_iter_init(struct bootflow_iter *iter, int flags)
  87 {
  88         memset(iter, '\0', sizeof(*iter));
  89         iter->first_glob_method = -1;
  90         iter->flags = flags;
  91
  92         /* remember the first bootdevs we see */
  93         iter->max_devs = BOOTFLOW_MAX_USED_DEVS;
  94 }
  95
  96 void bootflow_iter_uninit(struct bootflow_iter *iter)
  97 {
  98         free(iter->method_order);
  99 }
 100
 101 int bootflow_iter_drop_bootmeth(struct bootflow_iter *iter,
 102                                 const struct udevice *bmeth)
 103 {
 104         /* We only support disabling the current bootmeth */
 105         if (bmeth != iter->method || iter->cur_method >= iter->num_methods ||
 106             iter->method_order[iter->cur_method] != bmeth)
 107                 return -EINVAL;
 108
 109         memmove(&iter->method_order[iter->cur_method],
 110                 &iter->method_order[iter->cur_method + 1],
 111                 (iter->num_methods - iter->cur_method - 1) * sizeof(void *));
 112
 113         iter->num_methods--;
 114
 115         return 0;
 116 }
 117
 118 /**
 119  * bootflow_iter_set_dev() - switch to the next bootdev when iterating
 120  *
 121  * This sets iter->dev, records the device in the dev_used[] list and shows a
 122  * message if required
 123  *
 124  * @iter: Iterator to update
 125  * @dev: Bootdev to use, or NULL if there are no more
 126  */
 127 static void bootflow_iter_set_dev(struct bootflow_iter *iter,
 128                                   struct udevice *dev, int method_flags)
 129 {
 130         struct bootmeth_uc_plat *ucp = dev_get_uclass_plat(iter->method);
 131
 132         log_debug("iter: Setting dev to %s, flags %x\n",
 133                   dev ? dev->name : "(none)", method_flags);
 134         iter->dev = dev;
 135         iter->method_flags = method_flags;
 136
 137         if (IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
 138                 /* record the device for later */
 139                 if (dev && iter->num_devs < iter->max_devs)
 140                         iter->dev_used[iter->num_devs++] = dev;
 141
 142                 if ((iter->flags & (BOOTFLOWF_SHOW | BOOTFLOWF_SINGLE_DEV)) ==
 143                     BOOTFLOWF_SHOW) {
 144                         if (dev)
 145                                 printf("Scanning bootdev '%s':\n", dev->name);
 146                         else if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) &&
 147                                 ucp->flags & BOOTMETHF_GLOBAL)
 148                                 printf("Scanning global bootmeth '%s':\n",
 149                                 iter->method->name);
 150                         else
 151                                 printf("No more bootdevs\n");
 152                 }
 153         }
 154 }
 155
 156 /**
 157  * iter_incr() - Move to the next item (method, part, bootdev)
 158  *
 159  * Return: 0 if OK, BF_NO_MORE_DEVICES if there are no more bootdevs
 160  */
 161 static int iter_incr(struct bootflow_iter *iter)
 162 {
 163         struct udevice *dev;
 164         bool inc_dev = true;
 165         bool global;
 166         int ret;
 167
 168         log_debug("entry: err=%d\n", iter->err);
 169         global = iter->doing_global;
 170
 171         if (iter->err == BF_NO_MORE_DEVICES)
 172                 return BF_NO_MORE_DEVICES;
 173
 174         if (iter->err != BF_NO_MORE_PARTS) {
 175                 /* Get the next boothmethod */
 176                 if (++iter->cur_method < iter->num_methods) {
 177                         iter->method = iter->method_order[iter->cur_method];
 178                         return 0;
 179                 }
 180
 181                 /*
 182                  * If we have finished scanning the global bootmeths, start the
 183                  * normal bootdev scan
 184                  */
 185                 if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && global) {
 186                         iter->num_methods = iter->first_glob_method;
 187                         iter->doing_global = false;
 188
 189                         /*
 190                          * Don't move to the next dev as we haven't tried this
 191                          * one yet!
 192                          */
 193                         inc_dev = false;
 194                 }
 195         }
 196
 197         /* No more bootmeths; start at the first one, and... */
 198         iter->cur_method = 0;
 199         iter->method = iter->method_order[iter->cur_method];
 200
 201         if (iter->err != BF_NO_MORE_PARTS) {
 202                 /* ...select next partition  */
 203                 if (++iter->part <= iter->max_part)
 204                         return 0;
 205         }
 206
 207         /* No more partitions; start at the first one and... */
 208         iter->part = 0;
 209
 210         /*
 211          * Note: as far as we know, there is no partition table on the next
 212          * bootdev, so set max_part to 0 until we discover otherwise. See
 213          * bootdev_find_in_blk() for where this is set.
 214          */
 215         iter->max_part = 0;
 216
 217         /* ...select next bootdev */
 218         if (iter->flags & BOOTFLOWF_SINGLE_DEV) {
 219                 ret = -ENOENT;
 220         } else {
 221                 int method_flags;
 222
 223                 ret = 0;
 224                 dev = iter->dev;
 225                 log_debug("inc_dev=%d\n", inc_dev);
 226                 if (!inc_dev) {
 227                         ret = bootdev_setup_iter(iter, NULL, &dev,
 228                                                  &method_flags);
 229                 } else if (IS_ENABLED(CONFIG_BOOTSTD_FULL) &&
 230                            (iter->flags & BOOTFLOWF_SINGLE_UCLASS)) {
 231                         /* Move to the next bootdev in this uclass */
 232                         uclass_find_next_device(&dev);
 233                         if (!dev) {
 234                                 log_debug("finished uclass %s\n",
 235                                           dev_get_uclass_name(dev));
 236                                 ret = -ENODEV;
 237                         }
 238                 } else if (IS_ENABLED(CONFIG_BOOTSTD_FULL) &&
 239                            iter->flags & BOOTFLOWF_SINGLE_MEDIA) {
 240                         log_debug("next in single\n");
 241                         method_flags = 0;
 242                         do {
 243                                 /*
 244                                  * Move to the next bootdev child of this media
 245                                  * device. This ensures that we cover all the
 246                                  * available SCSI IDs and LUNs.
 247                                  */
 248                                 device_find_next_child(&dev);
 249                                 log_debug("- next %s\n",
 250                                         dev ? dev->name : "(none)");
 251                         } while (dev && device_get_uclass_id(dev) !=
 252                                 UCLASS_BOOTDEV);
 253                         if (!dev) {
 254                                 log_debug("finished uclass %s\n",
 255                                           dev_get_uclass_name(dev));
 256                                 ret = -ENODEV;
 257                         }
 258                 } else {
 259                         log_debug("labels %p\n", iter->labels);
 260                         if (iter->labels) {
 261                                 ret = bootdev_next_label(iter, &dev,
 262                                                          &method_flags);
 263                         } else {
 264                                 ret = bootdev_next_prio(iter, &dev);
 265                                 method_flags = 0;
 266                         }
 267                 }
 268                 log_debug("ret=%d, dev=%p %s\n", ret, dev,
 269                           dev ? dev->name : "none");
 270                 if (ret) {
 271                         bootflow_iter_set_dev(iter, NULL, 0);
 272                 } else {
 273                         ret = device_probe(dev);
 274                         log_debug("probe %s %d\n", dev->name, ret);
 275                         if (!log_msg_ret("probe", ret))
 276                                 bootflow_iter_set_dev(iter, dev, method_flags);
 277                 }
 278         }
 279
 280         /* if there are no more bootdevs, give up */
 281         if (ret)
 282                 return log_msg_ret("incr", BF_NO_MORE_DEVICES);
 283
 284         return 0;
 285 }
 286
 287 /**
 288  * bootflow_check() - Check if a bootflow can be obtained
 289  *
 290  * @iter: Provides part, bootmeth to use
 291  * @bflow: Bootflow to update on success
 292  * Return: 0 if OK, -ENOSYS if there is no bootflow support on this device,
 293  *      BF_NO_MORE_PARTS if there are no more partitions on bootdev
 294  */
 295 static int bootflow_check(struct bootflow_iter *iter, struct bootflow *bflow)
 296 {
 297         struct udevice *dev;
 298         int ret;
 299
 300         if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && iter->doing_global) {
 301                 bootflow_iter_set_dev(iter, NULL, 0);
 302                 ret = bootmeth_get_bootflow(iter->method, bflow);
 303                 if (ret)
 304                         return log_msg_ret("glob", ret);
 305
 306                 return 0;
 307         }
 308
 309         dev = iter->dev;
 310         ret = bootdev_get_bootflow(dev, iter, bflow);
 311
 312         /* If we got a valid bootflow, return it */
 313         if (!ret) {
 314                 log_debug("Bootdevice '%s' part %d method '%s': Found bootflow\n",
 315                           dev->name, iter->part, iter->method->name);
 316                 return 0;
 317         }
 318
 319         /* Unless there is nothing more to try, move to the next device */
 320         else if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
 321                 log_debug("Bootdevice '%s' part %d method '%s': Error %d\n",
 322                           dev->name, iter->part, iter->method->name, ret);
 323                 /*
 324                  * For 'all' we return all bootflows, even
 325                  * those with errors
 326                  */
 327                 if (iter->flags & BOOTFLOWF_ALL)
 328                         return log_msg_ret("all", ret);
 329         }
 330         if (ret)
 331                 return log_msg_ret("check", ret);
 332
 333         return 0;
 334 }
 335
 336 int bootflow_scan_first(struct udevice *dev, const char *label,
 337                         struct bootflow_iter *iter, int flags,
 338                         struct bootflow *bflow)
 339 {
 340         int ret;
 341
 342         if (dev || label)
 343                 flags |= BOOTFLOWF_SKIP_GLOBAL;
 344         bootflow_iter_init(iter, flags);
 345
 346         /*
 347          * Set up the ordering of bootmeths. This sets iter->doing_global and
 348          * iter->first_glob_method if we are starting with the global bootmeths
 349          */
 350         ret = bootmeth_setup_iter_order(iter, !(flags & BOOTFLOWF_SKIP_GLOBAL));
 351         if (ret)
 352                 return log_msg_ret("obmeth", -ENODEV);
 353
 354         /* Find the first bootmeth (there must be at least one!) */
 355         iter->method = iter->method_order[iter->cur_method];
 356
 357         if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) || !iter->doing_global) {
 358                 struct udevice *dev = NULL;
 359                 int method_flags;
 360
 361                 ret = bootdev_setup_iter(iter, label, &dev, &method_flags);
 362                 if (ret)
 363                         return log_msg_ret("obdev", -ENODEV);
 364
 365                 bootflow_iter_set_dev(iter, dev, method_flags);
 366         }
 367
 368         ret = bootflow_check(iter, bflow);
 369         if (ret) {
 370                 log_debug("check - ret=%d\n", ret);
 371                 if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
 372                         if (iter->flags & BOOTFLOWF_ALL)
 373                                 return log_msg_ret("all", ret);
 374                 }
 375                 iter->err = ret;
 376                 ret = bootflow_scan_next(iter, bflow);
 377                 if (ret)
 378                         return log_msg_ret("get", ret);
 379         }
 380
 381         return 0;
 382 }
 383
 384 int bootflow_scan_next(struct bootflow_iter *iter, struct bootflow *bflow)
 385 {
 386         int ret;
 387
 388         do {
 389                 ret = iter_incr(iter);
 390                 log_debug("iter_incr: ret=%d\n", ret);
 391                 if (ret == BF_NO_MORE_DEVICES)
 392                         return log_msg_ret("done", ret);
 393
 394                 if (!ret) {
 395                         ret = bootflow_check(iter, bflow);
 396                         log_debug("check - ret=%d\n", ret);
 397                         if (!ret)
 398                                 return 0;
 399                         iter->err = ret;
 400                         if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) {
 401                                 if (iter->flags & BOOTFLOWF_ALL)
 402                                         return log_msg_ret("all", ret);
 403                         }
 404                 } else {
 405                         log_debug("incr failed, err=%d\n", ret);
 406                         iter->err = ret;
 407                 }
 408
 409         } while (1);
 410 }
 411
 412 void bootflow_init(struct bootflow *bflow, struct udevice *bootdev,
 413                    struct udevice *meth)
 414 {
 415         memset(bflow, '\0', sizeof(*bflow));
 416         bflow->dev = bootdev;
 417         bflow->method = meth;
 418         bflow->state = BOOTFLOWST_BASE;
 419 }
 420
 421 void bootflow_free(struct bootflow *bflow)
 422 {
 423         free(bflow->name);
 424         free(bflow->subdir);
 425         free(bflow->fname);
 426         free(bflow->buf);
 427         free(bflow->os_name);
 428         free(bflow->fdt_fname);
 429 }
 430
 431 void bootflow_remove(struct bootflow *bflow)
 432 {
 433         if (bflow->dev)
 434                 list_del(&bflow->bm_node);
 435         list_del(&bflow->glob_node);
 436
 437         bootflow_free(bflow);
 438         free(bflow);
 439 }
 440
 441 int bootflow_boot(struct bootflow *bflow)
 442 {
 443         int ret;
 444
 445         if (bflow->state != BOOTFLOWST_READY)
 446                 return log_msg_ret("load", -EPROTO);
 447
 448         ret = bootmeth_boot(bflow->method, bflow);
 449         if (ret)
 450                 return log_msg_ret("boot", ret);
 451
 452         /*
 453          * internal error, should not get here since we should have booted
 454          * something or returned an error
 455          */
 456
 457         return log_msg_ret("end", -EFAULT);
 458 }
 459
 460 int bootflow_run_boot(struct bootflow_iter *iter, struct bootflow *bflow)
 461 {
 462         int ret;
 463
 464         printf("** Booting bootflow '%s' with %s\n", bflow->name,
 465                bflow->method->name);
 466         ret = bootflow_boot(bflow);
 467         if (!IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
 468                 printf("Boot failed (err=%d)\n", ret);
 469                 return ret;
 470         }
 471
 472         switch (ret) {
 473         case -EPROTO:
 474                 printf("Bootflow not loaded (state '%s')\n",
 475                        bootflow_state_get_name(bflow->state));
 476                 break;
 477         case -ENOSYS:
 478                 printf("Boot method '%s' not supported\n", bflow->method->name);
 479                 break;
 480         case -ENOTSUPP:
 481                 /* Disable this bootflow for this iteration */
 482                 if (iter) {
 483                         int ret2;
 484
 485                         ret2 = bootflow_iter_drop_bootmeth(iter, bflow->method);
 486                         if (!ret2) {
 487                                 printf("Boot method '%s' failed and will not be retried\n",
 488                                        bflow->method->name);
 489                         }
 490                 }
 491
 492                 break;
 493         default:
 494                 printf("Boot failed (err=%d)\n", ret);
 495                 break;
 496         }
 497
 498         return ret;
 499 }
 500
 501 int bootflow_iter_check_blk(const struct bootflow_iter *iter)
 502 {
 503         const struct udevice *media = dev_get_parent(iter->dev);
 504         enum uclass_id id = device_get_uclass_id(media);
 505
 506         log_debug("uclass %d: %s\n", id, uclass_get_name(id));
 507         if (id != UCLASS_ETH && id != UCLASS_BOOTSTD)
 508                 return 0;
 509
 510         return -ENOTSUPP;
 511 }
 512
 513 int bootflow_iter_check_sf(const struct bootflow_iter *iter)
 514 {
 515         const struct udevice *media = dev_get_parent(iter->dev);
 516         enum uclass_id id = device_get_uclass_id(media);
 517
 518         log_debug("uclass %d: %s\n", id, uclass_get_name(id));
 519         if (id == UCLASS_SPI_FLASH)
 520                 return 0;
 521
 522         return -ENOTSUPP;
 523 }
 524
 525 int bootflow_iter_check_net(const struct bootflow_iter *iter)
 526 {
 527         const struct udevice *media = dev_get_parent(iter->dev);
 528         enum uclass_id id = device_get_uclass_id(media);
 529
 530         log_debug("uclass %d: %s\n", id, uclass_get_name(id));
 531         if (id == UCLASS_ETH)
 532                 return 0;
 533
 534         return -ENOTSUPP;
 535 }
 536
 537 int bootflow_iter_check_system(const struct bootflow_iter *iter)
 538 {
 539         const struct udevice *media = dev_get_parent(iter->dev);
 540         enum uclass_id id = device_get_uclass_id(media);
 541
 542         log_debug("uclass %d: %s\n", id, uclass_get_name(id));
 543         if (id == UCLASS_BOOTSTD)
 544                 return 0;
 545
 546         return -ENOTSUPP;
 547 }