/* SPDX-License-Identifier: GPL-2.0-only */

#ifndef __BOOTM_H

#define __BOOTM_H

#include <image.h>

#include <filetype.h>

#include <linux/list.h>

#include <loadable.h>

enum bootm_verify {

  BOOTM_VERIFY_NONE,

  BOOTM_VERIFY_HASH,

  BOOTM_VERIFY_SIGNATURE,

  BOOTM_VERIFY_AVAILABLE,

};

enum bootm_efi_mode {

  BOOTM_EFI_DISABLED,

  BOOTM_EFI_AVAILABLE,

  BOOTM_EFI_REQUIRED,

};

struct bootm_data {

  const char *os_file;

  const char *initrd_file;

  const char *oftree_file;

  const char *root_dev;

  const char *root_param;

  int verbose;

  enum bootm_verify verify;

  bool force;

  bool dryrun;

  /*

   * appendroot - if true, try to add a suitable root= Kernel option to

   * mount the rootfs from the same device as the Kernel comes from.

   * The default rootfs device can be overridden with root_dev.

   */

  bool appendroot;

  /*

   * provide_machine_id - if true, try to add systemd.machine_id= with

   * value of global.machine_id to Kernel.

   */

  bool provide_machine_id;

  /*

   * provide_hostname - if true, try to add systemd.hostname= with value

   * of global.hostname to Kernel.

   */

  bool provide_hostname;

  /*

   * provide_policy - if true, try to add barebox.security.policy= with

   * with value of currently selected policy

   */

  bool provide_policy;

  enum bootm_efi_mode efi_boot;

  unsigned long initrd_address;

  unsigned long os_address;

  unsigned long os_entry;

};

int bootm_image_name_and_part(const char *name, char **filename, char **part);

int bootm_boot(const struct bootm_data *data);

struct image_data *bootm_boot_prep(const struct bootm_data *bootm_data);

int bootm_open_os_compressed(struct image_data *data);

int bootm_boot_handler(struct image_data *data);

void bootm_boot_cleanup(struct image_data *data);

struct image_data {

  /* simplest case. barebox has already loaded the os here */

  struct resource *os_res;

  /* Generic loadable object for OS image */

  struct loadable *os;

  /* if os is an uImage this will be provided */

  struct uimage_handle *os_uimage;

  char *os_part;

  /* otherwise only the filename will be provided */

  char *os_file;

  /*

   * The address the user wants to load the os image to.

   * May be UIMAGE_INVALID_ADDRESS to indicate that the

   * user has not specified any address. In this case the

   * handler may choose a suitable address

   */

  unsigned long os_address;

  /* entry point to the os. relative to the start of the image */

  unsigned long os_entry;

  /* initial os_address/os_entry supplied at entry to bootm_boot */

  unsigned long os_address_hint;

  unsigned long os_entry_hint;

  /* if initrd is already loaded this resource will be !NULL */

  struct resource *initrd_res;

  /* Generic loadable object for initrd */

  struct loadable *initrd;

  /* if initrd is an uImage this will be provided */

  struct uimage_handle *initrd_uimage;

  char *initrd_part;

  /* otherwise only the filename will be provided */

  char *initrd_file;

  unsigned long initrd_address;

  char *oftree_file;

  char *oftree_part;

  /* if oftree is an uImage this will be provided */

  struct uimage_handle *oftree_uimage;

  struct device_node *of_root_node;

  struct resource *oftree_res;

  /* Generic loadable object for oftree */

  struct loadable *oftree;

  /*

   * The first PAGE_SIZE bytes of the OS image. Can be used by the image

   * handlers to analyze the OS image before actually loading the bulk of

   * it.

   */

  void *os_header;

  /* Type of OS image, e.g. filetype_fit or the same as kernel_type */

  enum filetype image_type;

  /* Type of kernel image that's going to be booted */

  enum filetype kernel_type;

  enum bootm_verify verify;

  int verbose;

  int force;

  int dryrun;

  struct {

    u8 os:1;

    u8 initrd:1;

    u8 oftree:1;

  } is_override;

  enum bootm_efi_mode efi_boot;

};

struct image_handler {

  const char *name;

  struct list_head list;

  int ih_os;

  enum filetype filetype;

  bool (*check_image)(struct image_handler *handler,

          struct image_data *data,

          enum filetype detected_filetype);

  int (*bootm)(struct image_data *data);

};

int register_image_handler(struct image_handler *handle);

#ifdef CONFIG_BOOTM_VERBOSE

static inline int bootm_verbose(struct image_data *data)

{

  return data->verbose;

}

#else

static inline int bootm_verbose(struct image_data *data)

{

  return 0;

}

Unexecuted instantiation: bootm.c:bootm_verbose

Unexecuted instantiation: booti.c:bootm_verbose

Unexecuted instantiation: bootm-uimage.c:bootm_verbose

Unexecuted instantiation: image-fit.c:bootm_verbose

Unexecuted instantiation: bootm-fit.c:bootm_verbose

Unexecuted instantiation: boot.c:bootm_verbose

Unexecuted instantiation: fastboot.c:bootm_verbose

Unexecuted instantiation: overlay.c:bootm_verbose

#endif

void bootm_data_init_defaults(struct bootm_data *data);

void bootm_data_restore_defaults(const struct bootm_data *data);

const struct resource *

bootm_load_os(struct image_data *data,

        ulong load_address, ulong end_address);

const struct resource *

bootm_load_initrd(struct image_data *data,

      ulong load_address, ulong end_address);

void *bootm_get_devicetree(struct image_data *data);

const struct resource *

bootm_load_devicetree(struct image_data *data, void *fdt,

          ulong load_address, ulong end_address);

loff_t bootm_get_os_size(struct image_data *data);

enum bootm_verify bootm_get_verify_mode(void);

void bootm_set_verify_mode(enum bootm_verify mode);

bool bootm_signed_images_are_forced(void);

void bootm_force_signed_images(void);

#define UIMAGE_SOME_ADDRESS (UIMAGE_INVALID_ADDRESS - 1)

#define UIMAGE_IS_ADDRESS_VALID(addr) \

  ((addr) != UIMAGE_INVALID_ADDRESS && \

   (addr) != UIMAGE_SOME_ADDRESS)

void *booti_load_image(struct image_data *data, phys_addr_t *oftree);

bool bootm_efi_check_image(struct image_handler *handler,

         struct image_data *data,

         enum filetype detected_filetype);

int file_read_and_detect_boot_image_type(const char *os_file, void **os_header);

#endif /* __BOOTM_H */