blob: 2689a4004a7ac7667948f33f61e4aa071ee19831 [file] [log] [blame]
/* SPDX-License-Identifier: GPL-2.0+ */
* (C) Copyright 2013
* Written by Guilherme Maciel Ferreira <>
#ifndef _IMAGETOOL_H_
#define _IMAGETOOL_H_
#include "os_support.h"
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <u-boot/sha1.h>
#include "fdt_host.h"
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
/* Information about a file that needs to be placed into the FIT */
struct content_info {
struct content_info *next;
int type; /* File type (IH_TYPE_...) */
const char *fname;
* This structure defines all such variables those are initialized by
* mkimage and dumpimage main core and need to be referred by image
* type specific functions
struct image_tool_params {
int dflag;
int eflag;
int fflag;
int iflag;
int lflag;
int pflag;
int vflag;
int xflag;
int skipcpy;
int os;
int arch;
int type;
int comp;
char *dtc;
unsigned int addr;
unsigned int ep;
char *imagename;
char *imagename2;
char *datafile;
char *imagefile;
char *cmdname;
const char *outfile; /* Output filename */
const char *keydir; /* Directory holding private keys */
const char *keydest; /* Destination .dtb for public key */
const char *comment; /* Comment to add to signature node */
int require_keys; /* 1 to mark signing keys as 'required' */
int file_size; /* Total size of output file */
int orig_file_size; /* Original size for file before padding */
bool auto_its; /* Automatically create the .its file */
int fit_image_type; /* Image type to put into the FIT */
char *fit_ramdisk; /* Ramdisk file to include */
struct content_info *content_head; /* List of files to include */
struct content_info *content_tail;
bool external_data; /* Store data outside the FIT */
bool quiet; /* Don't output text in normal operation */
unsigned int external_offset; /* Add padding to external data */
const char *engine_id; /* Engine to use for signing */
* image type specific variables and callback functions
struct image_type_params {
/* name is an identification tag string for added support */
char *name;
* header size is local to the specific image type to be supported,
* mkimage core treats this as number of bytes
uint32_t header_size;
/* Image type header pointer */
void *hdr;
* There are several arguments that are passed on the command line
* and are registered as flags in image_tool_params structure.
* This callback function can be used to check the passed arguments
* are in-lined with the image type to be supported
* Returns 1 if parameter check is successful
int (*check_params) (struct image_tool_params *);
* This function is used by list command (i.e. mkimage -l <filename>)
* image type verification code must be put here
* Returns 0 if image header verification is successful
* otherwise, returns respective negative error codes
int (*verify_header) (unsigned char *, int, struct image_tool_params *);
/* Prints image information abstracting from image header */
void (*print_header) (const void *);
* The header or image contents need to be set as per image type to
* be generated using this callback function.
* further output file post processing (for ex. checksum calculation,
* padding bytes etc..) can also be done in this callback function.
void (*set_header) (void *, struct stat *, int,
struct image_tool_params *);
* This function is used by the command to retrieve a component
* (sub-image) from the image (i.e. dumpimage -i <image> -p <position>
* <sub-image-name>).
* Thus the code to extract a file from an image must be put here.
* Returns 0 if the file was successfully retrieved from the image,
* or a negative value on error.
int (*extract_subimage)(void *, struct image_tool_params *);
* Some image generation support for ex (default image type) supports
* more than one type_ids, this callback function is used to check
* whether input (-T <image_type>) is supported by registered image
* generation/list low level code
int (*check_image_type) (uint8_t);
/* This callback function will be executed if fflag is defined */
int (*fflag_handle) (struct image_tool_params *);
* This callback function will be executed for variable size record
* It is expected to build this header in memory and return its length
* and a pointer to it by using image_type_params.header_size and
* image_type_params.hdr. The return value shall indicate if an
* additional padding should be used when copying the data image
* by returning the padding length.
int (*vrec_header) (struct image_tool_params *,
struct image_type_params *);
* imagetool_get_type() - find the image type params for a given image type
* It scans all registers image type supports
* checks the input type for each supported image type
* if successful,
* returns respective image_type_params pointer if success
* if input type_id is not supported by any of image_type_support
* returns NULL
struct image_type_params *imagetool_get_type(int type);
* imagetool_verify_print_header() - verifies the image header
* Scan registered image types and verify the image_header for each
* supported image type. If verification is successful, this prints
* the respective header.
* @return 0 on success, negative if input image format does not match with
* any of supported image types
int imagetool_verify_print_header(
void *ptr,
struct stat *sbuf,
struct image_type_params *tparams,
struct image_tool_params *params);
* imagetool_verify_print_header_by_type() - verifies the image header
* Verify the image_header for the image type given by tparams.
* If verification is successful, this prints the respective header.
* @ptr: pointer the the image header
* @sbuf: stat information about the file pointed to by ptr
* @tparams: image type parameters
* @params: mkimage parameters
* @return 0 on success, negative if input image format does not match with
* the given image type
int imagetool_verify_print_header_by_type(
void *ptr,
struct stat *sbuf,
struct image_type_params *tparams,
struct image_tool_params *params);
* imagetool_save_subimage - store data into a file
* @file_name: name of the destination file
* @file_data: data to be written
* @file_len: the amount of data to store
* imagetool_save_subimage() store file_len bytes of data pointed by file_data
* into the file name by file_name.
* returns:
* zero in case of success or a negative value if fail.
int imagetool_save_subimage(
const char *file_name,
ulong file_data,
ulong file_len);
* imagetool_get_filesize() - Utility function to obtain the size of a file
* This function prints a message if an error occurs, showing the error that
* was obtained.
* @params: mkimage parameters
* @fname: filename to check
* @return size of file, or -ve value on error
int imagetool_get_filesize(struct image_tool_params *params, const char *fname);
* imagetool_get_source_date() - Get timestamp for build output.
* Gets a timestamp for embedding it in a build output. If set
* SOURCE_DATE_EPOCH is used. Else the given fallback value is returned. Prints
* an error message if SOURCE_DATE_EPOCH contains an invalid value and returns
* 0.
* @cmdname: command name
* @fallback: timestamp to use if SOURCE_DATE_EPOCH isn't set
* @return timestamp based on SOURCE_DATE_EPOCH
time_t imagetool_get_source_date(
const char *cmdname,
time_t fallback);
* There is a c file associated with supported image type low level code
* for ex. default_image.c, fit_image.c
void pbl_load_uboot(int fd, struct image_tool_params *mparams);
int zynqmpbif_copy_image(int fd, struct image_tool_params *mparams);
int imx8image_copy_image(int fd, struct image_tool_params *mparams);
int imx8mimage_copy_image(int fd, struct image_tool_params *mparams);
#define ___cat(a, b) a ## b
#define __cat(a, b) ___cat(a, b)
/* we need some special handling for this host tool running eventually on
* Darwin. The Mach-O section handling is a bit different than ELF section
* handling. The differnces in detail are:
* a) we have segments which have sections
* b) we need a API call to get the respective section symbols */
#if defined(__MACH__)
#include <mach-o/getsect.h>
#define INIT_SECTION(name) do { \
unsigned long name ## _len; \
char *__cat(pstart_, name) = getsectdata("__TEXT", \
#name, &__cat(name, _len)); \
char *__cat(pstop_, name) = __cat(pstart_, name) + \
__cat(name, _len); \
__cat(__start_, name) = (void *)__cat(pstart_, name); \
__cat(__stop_, name) = (void *)__cat(pstop_, name); \
} while (0)
#define SECTION(name) __attribute__((section("__TEXT, " #name)))
struct image_type_params **__start_image_type, **__stop_image_type;
#define INIT_SECTION(name) /* no-op for ELF */
#define SECTION(name) __attribute__((section(#name)))
/* We construct a table of pointers in an ELF section (pointers generally
* go unpadded by gcc). ld creates boundary syms for us. */
extern struct image_type_params *__start_image_type[], *__stop_image_type[];
#endif /* __MACH__ */
#if !defined(__used)
# if __GNUC__ == 3 && __GNUC_MINOR__ < 3
# define __used __attribute__((__unused__))
# else
# define __used __attribute__((__used__))
# endif
#define U_BOOT_IMAGE_TYPE( \
_id, \
_name, \
_header_size, \
_header, \
_check_params, \
_verify_header, \
_print_header, \
_set_header, \
_extract_subimage, \
_check_image_type, \
_fflag_handle, \
_vrec_header \
) \
static struct image_type_params __cat(image_type_, _id) = \
{ \
.name = _name, \
.header_size = _header_size, \
.hdr = _header, \
.check_params = _check_params, \
.verify_header = _verify_header, \
.print_header = _print_header, \
.set_header = _set_header, \
.extract_subimage = _extract_subimage, \
.check_image_type = _check_image_type, \
.fflag_handle = _fflag_handle, \
.vrec_header = _vrec_header \
}; \
static struct image_type_params *SECTION(image_type) __used \
__cat(image_type_ptr_, _id) = &__cat(image_type_, _id)
#endif /* _IMAGETOOL_H_ */