include/bootflow.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright 2021 Google LLC
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #ifndef __bootflow_h
   8 #define __bootflow_h
   9
  10 #include <linux/list.h>
  11
  12 /**
  13  * enum bootflow_state_t - states that a particular bootflow can be in
  14  *
  15  * Only bootflows in state BOOTFLOWST_READY can be used to boot.
  16  *
  17  * See bootflow_state[] for the names for each of these
  18  */
  19 enum bootflow_state_t {
  20         BOOTFLOWST_BASE,        /**< Nothing known yet */
  21         BOOTFLOWST_MEDIA,       /**< Media exists */
  22         BOOTFLOWST_PART,        /**< Partition exists */
  23         BOOTFLOWST_FS,          /**< Filesystem exists */
  24         BOOTFLOWST_FILE,        /**< Bootflow file exists */
  25         BOOTFLOWST_READY,       /**< Bootflow file loaded */
  26
  27         BOOTFLOWST_COUNT
  28 };
  29
  30 /**
  31  * struct bootflow - information about a bootflow
  32  *
  33  * This is connected into two separate linked lists:
  34  *
  35  *   bm_sibling - links all bootflows in the same bootdev
  36  *   glob_sibling - links all bootflows in all bootdevs
  37  *
  38  * @bm_node: Points to siblings in the same bootdev
  39  * @glob_node: Points to siblings in the global list (all bootdev)
  40  * @dev: Bootdevice device which produced this bootflow
  41  * @blk: Block device which contains this bootflow, NULL if this is a network
  42  *      device
  43  * @part: Partition number (0 for whole device)
  44  * @fs_type: Filesystem type (FS_TYPE...) if this is fixed by the media, else 0.
  45  *      For example, the sandbox host-filesystem bootdev sets this to
  46  *      FS_TYPE_SANDBOX
  47  * @method: Bootmethod device used to perform the boot and read files
  48  * @name: Name of bootflow (allocated)
  49  * @state: Current state (enum bootflow_state_t)
  50  * @subdir: Subdirectory to fetch files from (with trailing /), or NULL if none
  51  * @fname: Filename of bootflow file (allocated)
  52  * @buf: Bootflow file contents (allocated)
  53  * @size: Size of bootflow file in bytes
  54  * @err: Error number received (0 if OK)
  55  */
  56 struct bootflow {
  57         struct list_head bm_node;
  58         struct list_head glob_node;
  59         struct udevice *dev;
  60         struct udevice *blk;
  61         int part;
  62         int fs_type;
  63         struct udevice *method;
  64         char *name;
  65         enum bootflow_state_t state;
  66         char *subdir;
  67         char *fname;
  68         char *buf;
  69         int size;
  70         int err;
  71 };
  72
  73 /**
  74  * enum bootflow_flags_t - flags for the bootflow iterator
  75  *
  76  * @BOOTFLOWF_FIXED: Only used fixed/internal media
  77  * @BOOTFLOWF_SHOW: Show each bootdev before scanning it
  78  * @BOOTFLOWF_ALL: Return bootflows with errors as well
  79  * @BOOTFLOWF_SINGLE_DEV: Just scan one bootmeth
  80  */
  81 enum bootflow_flags_t {
  82         BOOTFLOWF_FIXED         = 1 << 0,
  83         BOOTFLOWF_SHOW          = 1 << 1,
  84         BOOTFLOWF_ALL           = 1 << 2,
  85         BOOTFLOWF_SINGLE_DEV    = 1 << 3,
  86 };
  87
  88 /**
  89  * struct bootflow_iter - state for iterating through bootflows
  90  *
  91  * This starts at with the first bootdev/partition/bootmeth and can be used to
  92  * iterate through all of them.
  93  *
  94  * Iteration starts with the bootdev. The first partition (0, i.e. whole device)
  95  * is scanned first. For partition 0, it iterates through all the available
  96  * bootmeths to see which one(s) can provide a bootflow. Then it moves to
  97  * parition 1 (if there is one) and the process continues. Once all partitions
  98  * are examined, it moves to the next bootdev.
  99  *
 100  * Initially @max_part is 0, meaning that only the whole device (@part=0) can be
 101  * used. During scanning, if a partition table is found, then @max_part is
 102  * updated to a larger value, no less than the number of available partitions.
 103  * This ensures that iteration works through all partitions on the bootdev.
 104  *
 105  * @flags: Flags to use (see enum bootflow_flags_t)
 106  * @dev: Current bootdev
 107  * @part: Current partition number (0 for whole device)
 108  * @method: Current bootmeth
 109  * @max_part: Maximum hardware partition number in @dev, 0 if there is no
 110  *      partition table
 111  * @err: Error obtained from checking the last iteration. This is used to skip
 112  *      forward (e.g. to skip the current partition because it is not valid)
 113  *      -ESHUTDOWN: try next bootdev
 114  * @num_devs: Number of bootdevs in @dev_order
 115  * @cur_dev: Current bootdev number, an index into @dev_order[]
 116  * @dev_order: List of bootdevs to scan, in order of priority. The scan starts
 117  *      with the first one on the list
 118  * @num_methods: Number of bootmeth devices in @method_order
 119  * @cur_method: Current method number, an index into @method_order
 120  * @method_order: List of bootmeth devices to use, in order
 121  */
 122 struct bootflow_iter {
 123         int flags;
 124         struct udevice *dev;
 125         int part;
 126         struct udevice *method;
 127         int max_part;
 128         int err;
 129         int num_devs;
 130         int cur_dev;
 131         struct udevice **dev_order;
 132         int num_methods;
 133         int cur_method;
 134         struct udevice **method_order;
 135 };
 136
 137 /**
 138  * bootflow_iter_init() - Reset a bootflow iterator
 139  *
 140  * This sets everything to the starting point, ready for use.
 141  *
 142  * @iter: Place to store private info (inited by this call)
 143  * @flags: Flags to use (see enum bootflow_flags_t)
 144  */
 145 void bootflow_iter_init(struct bootflow_iter *iter, int flags);
 146
 147 /**
 148  * bootflow_iter_uninit() - Free memory used by an interator
 149  *
 150  * @iter:       Iterator to free
 151  */
 152 void bootflow_iter_uninit(struct bootflow_iter *iter);
 153
 154 /**
 155  * bootflow_iter_drop_bootmeth() - Remove a bootmeth from an iterator
 156  *
 157  * Update the iterator so that the bootmeth will not be used again while this
 158  * iterator is in use
 159  *
 160  * @iter: Iterator to update
 161  * @bmeth: Boot method to remove
 162  */
 163 int bootflow_iter_drop_bootmeth(struct bootflow_iter *iter,
 164                                 const struct udevice *bmeth);
 165
 166 /**
 167  * bootflow_scan_bootdev() - find the first bootflow in a bootdev
 168  *
 169  * If @flags includes BOOTFLOWF_ALL then bootflows with errors are returned too
 170  *
 171  * @dev:        Boot device to scan, NULL to work through all of them until it
 172  *      finds one that * can supply a bootflow
 173  * @iter:       Place to store private info (inited by this call)
 174  * @flags:      Flags for bootdev (enum bootflow_flags_t)
 175  * @bflow:      Place to put the bootflow if found
 176  * Return: 0 if found,  -ENODEV if no device, other -ve on other error
 177  *      (iteration can continue)
 178  */
 179 int bootflow_scan_bootdev(struct udevice *dev, struct bootflow_iter *iter,
 180                           int flags, struct bootflow *bflow);
 181
 182 /**
 183  * bootflow_scan_first() - find the first bootflow
 184  *
 185  * This works through the available bootdev devices until it finds one that
 186  * can supply a bootflow. It then returns that
 187  *
 188  * If @flags includes BOOTFLOWF_ALL then bootflows with errors are returned too
 189  *
 190  * @iter:       Place to store private info (inited by this call), with
 191  * @flags:      Flags for bootdev (enum bootflow_flags_t)
 192  * @bflow:      Place to put the bootflow if found
 193  * Return: 0 if found, -ENODEV if no device, other -ve on other error (iteration
 194  *      can continue)
 195  */
 196 int bootflow_scan_first(struct bootflow_iter *iter, int flags,
 197                         struct bootflow *bflow);
 198
 199 /**
 200  * bootflow_scan_next() - find the next bootflow
 201  *
 202  * This works through the available bootdev devices until it finds one that
 203  * can supply a bootflow. It then returns that bootflow
 204  *
 205  * @iter:       Private info (as set up by bootflow_scan_first())
 206  * @bflow:      Place to put the bootflow if found
 207  * Return: 0 if found, -ENODEV if no device, -ESHUTDOWN if no more bootflows,
 208  *      other -ve on other error (iteration can continue)
 209  */
 210 int bootflow_scan_next(struct bootflow_iter *iter, struct bootflow *bflow);
 211
 212 /**
 213  * bootflow_first_glob() - Get the first bootflow from the global list
 214  *
 215  * Returns the first bootflow in the global list, no matter what bootflow it is
 216  * attached to
 217  *
 218  * @bflowp: Returns a pointer to the bootflow
 219  * Return: 0 if found, -ENOENT if there are no bootflows
 220  */
 221 int bootflow_first_glob(struct bootflow **bflowp);
 222
 223 /**
 224  * bootflow_next_glob() - Get the next bootflow from the global list
 225  *
 226  * Returns the next bootflow in the global list, no matter what bootflow it is
 227  * attached to
 228  *
 229  * @bflowp: On entry, the last bootflow returned , e.g. from
 230  *      bootflow_first_glob()
 231  * Return: 0 if found, -ENOENT if there are no more bootflows
 232  */
 233 int bootflow_next_glob(struct bootflow **bflowp);
 234
 235 /**
 236  * bootflow_free() - Free memory used by a bootflow
 237  *
 238  * This frees fields within @bflow, but not the @bflow pointer itself
 239  */
 240 void bootflow_free(struct bootflow *bflow);
 241
 242 /**
 243  * bootflow_boot() - boot a bootflow
 244  *
 245  * @bflow: Bootflow to boot
 246  * Return: -EPROTO if bootflow has not been loaded, -ENOSYS if the bootflow
 247  *      type is not supported, -EFAULT if the boot returned without an error
 248  *      when we are expecting it to boot, -ENOTSUPP if trying method resulted in
 249  *      finding out that is not actually supported for this boot and should not
 250  *      be tried again unless something changes
 251  */
 252 int bootflow_boot(struct bootflow *bflow);
 253
 254 /**
 255  * bootflow_run_boot() - Try to boot a bootflow
 256  *
 257  * @iter: Current iteration (or NULL if none). Used to disable a bootmeth if the
 258  *      boot returns -ENOTSUPP
 259  * @bflow: Bootflow to boot
 260  * Return: result of trying to boot
 261  */
 262 int bootflow_run_boot(struct bootflow_iter *iter, struct bootflow *bflow);
 263
 264 /**
 265  * bootflow_state_get_name() - Get the name of a bootflow state
 266  *
 267  * @state: State to check
 268  * Return: name, or "?" if invalid
 269  */
 270 const char *bootflow_state_get_name(enum bootflow_state_t state);
 271
 272 /**
 273  * bootflow_remove() - Remove a bootflow and free its memory
 274  *
 275  * This updates the linked lists containing the bootflow then frees it.
 276  *
 277  * @bflow: Bootflow to remove
 278  */
 279 void bootflow_remove(struct bootflow *bflow);
 280
 281 /**
 282  * bootflow_iter_uses_blk_dev() - Check that a bootflow uses a block device
 283  *
 284  * This checks the bootdev in the bootflow to make sure it uses a block device
 285  *
 286  * Return: 0 if OK, -ENOTSUPP if some other device is used (e.g. ethernet)
 287  */
 288 int bootflow_iter_uses_blk_dev(const struct bootflow_iter *iter);
 289
 290 /**
 291  * bootflow_iter_uses_network() - Check that a bootflow uses a network device
 292  *
 293  * This checks the bootdev in the bootflow to make sure it uses a network
 294  * device
 295  *
 296  * Return: 0 if OK, -ENOTSUPP if some other device is used (e.g. MMC)
 297  */
 298 int bootflow_iter_uses_network(const struct bootflow_iter *iter);
 299
 300 /**
 301  * bootflow_iter_uses_system() - Check that a bootflow uses the bootstd device
 302  *
 303  * This checks the bootdev in the bootflow to make sure it uses the bootstd
 304  * device
 305  *
 306  * Return: 0 if OK, -ENOTSUPP if some other device is used (e.g. MMC)
 307  */
 308 int bootflow_iter_uses_system(const struct bootflow_iter *iter);
 309
 310 #endif