[people/ms/u-boot.git] / tools / fit_image.c

/*
 * (C) Copyright 2008 Semihalf
 *
 * (C) Copyright 2000-2004
 * DENX Software Engineering
 * Wolfgang Denk, wd@denx.de
 *
 * Updated-by: Prafulla Wadaskar <prafulla@marvell.com>
 *		FIT image specific code abstracted from mkimage.c
 *		some functions added to address abstraction
 *
 * All rights reserved.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include "imagetool.h"
#include "fit_common.h"
#include "mkimage.h"
#include <image.h>
#include <u-boot/crc.h>

static image_header_t header;

static int fit_add_file_data(struct image_tool_params *params, size_t size_inc,
			     const char *tmpfile)
{
	int tfd, destfd = 0;
	void *dest_blob = NULL;
	off_t destfd_size = 0;
	struct stat sbuf;
	void *ptr;
	int ret = 0;

	tfd = mmap_fdt(params->cmdname, tmpfile, size_inc, &ptr, &sbuf, true);
	if (tfd < 0)
		return -EIO;

	if (params->keydest) {
		struct stat dest_sbuf;

		destfd = mmap_fdt(params->cmdname, params->keydest, size_inc,
				  &dest_blob, &dest_sbuf, false);
		if (destfd < 0) {
			ret = -EIO;
			goto err_keydest;
		}
		destfd_size = dest_sbuf.st_size;
	}

	/* for first image creation, add a timestamp at offset 0 i.e., root  */
	if (params->datafile)
		ret = fit_set_timestamp(ptr, 0, sbuf.st_mtime);

	if (!ret) {
		ret = fit_add_verification_data(params->keydir, dest_blob, ptr,
						params->comment,
						params->require_keys);
	}

	if (dest_blob) {
		munmap(dest_blob, destfd_size);
		close(destfd);
	}

err_keydest:
	munmap(ptr, sbuf.st_size);
	close(tfd);

	return ret;
}

/**
 * fit_handle_file - main FIT file processing function
 *
 * fit_handle_file() runs dtc to convert .its to .itb, includes
 * binary data, updates timestamp property and calculates hashes.
 *
 * datafile  - .its file
 * imagefile - .itb file
 *
 * returns:
 *     only on success, otherwise calls exit (EXIT_FAILURE);
 */
static int fit_handle_file(struct image_tool_params *params)
{
	char tmpfile[MKIMAGE_MAX_TMPFILE_LEN];
	char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN];
	size_t size_inc;
	int ret;

	/* Flattened Image Tree (FIT) format  handling */
	debug ("FIT format handling\n");

	/* call dtc to include binary properties into the tmp file */
	if (strlen (params->imagefile) +
		strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > sizeof (tmpfile)) {
		fprintf (stderr, "%s: Image file name (%s) too long, "
				"can't create tmpfile",
				params->imagefile, params->cmdname);
		return (EXIT_FAILURE);
	}
	sprintf (tmpfile, "%s%s", params->imagefile, MKIMAGE_TMPFILE_SUFFIX);

	/* We either compile the source file, or use the existing FIT image */
	if (params->datafile) {
		/* dtc -I dts -O dtb -p 500 datafile > tmpfile */
		snprintf(cmd, sizeof(cmd), "%s %s %s > %s",
			 MKIMAGE_DTC, params->dtc, params->datafile, tmpfile);
		debug("Trying to execute \"%s\"\n", cmd);
	} else {
		snprintf(cmd, sizeof(cmd), "cp %s %s",
			 params->imagefile, tmpfile);
	}
	if (system (cmd) == -1) {
		fprintf (stderr, "%s: system(%s) failed: %s\n",
				params->cmdname, cmd, strerror(errno));
		goto err_system;
	}

	/*
	 * Set hashes for images in the blob. Unfortunately we may need more
	 * space in either FDT, so keep trying until we succeed.
	 *
	 * Note: this is pretty inefficient for signing, since we must
	 * calculate the signature every time. It would be better to calculate
	 * all the data and then store it in a separate step. However, this
	 * would be considerably more complex to implement. Generally a few
	 * steps of this loop is enough to sign with several keys.
	 */
	for (size_inc = 0; size_inc < 64 * 1024; size_inc += 1024) {
		ret = fit_add_file_data(params, size_inc, tmpfile);
		if (!ret || ret != -ENOSPC)
			break;
	}

	if (ret) {
		fprintf(stderr, "%s Can't add hashes to FIT blob\n",
			params->cmdname);
		goto err_system;
	}

	if (rename (tmpfile, params->imagefile) == -1) {
		fprintf (stderr, "%s: Can't rename %s to %s: %s\n",
				params->cmdname, tmpfile, params->imagefile,
				strerror (errno));
		unlink (tmpfile);
		unlink (params->imagefile);
		return EXIT_FAILURE;
	}
	return EXIT_SUCCESS;

err_system:
	unlink(tmpfile);
	return -1;
}

/**
 * fit_image_extract - extract a FIT component image
 * @fit: pointer to the FIT format image header
 * @image_noffset: offset of the component image node
 * @file_name: name of the file to store the FIT sub-image
 *
 * returns:
 *     zero in case of success or a negative value if fail.
 */
static int fit_image_extract(
	const void *fit,
	int image_noffset,
	const char *file_name)
{
	const void *file_data;
	size_t file_size = 0;

	/* get the "data" property of component at offset "image_noffset" */
	fit_image_get_data(fit, image_noffset, &file_data, &file_size);

	/* save the "file_data" into the file specified by "file_name" */
	return imagetool_save_subimage(file_name, (ulong) file_data, file_size);
}

/**
 * fit_extract_contents - retrieve a sub-image component from the FIT image
 * @ptr: pointer to the FIT format image header
 * @params: command line parameters
 *
 * returns:
 *     zero in case of success or a negative value if fail.
 */
static int fit_extract_contents(void *ptr, struct image_tool_params *params)
{
	int images_noffset;
	int noffset;
	int ndepth;
	const void *fit = ptr;
	int count = 0;
	const char *p;

	/* Indent string is defined in header image.h */
	p = IMAGE_INDENT_STRING;

	if (!fit_check_format(fit)) {
		printf("Bad FIT image format\n");
		return -1;
	}

	/* Find images parent node offset */
	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
	if (images_noffset < 0) {
		printf("Can't find images parent node '%s' (%s)\n",
		       FIT_IMAGES_PATH, fdt_strerror(images_noffset));
		return -1;
	}

	/* Avoid any overrun */
	count = fit_get_subimage_count(fit, images_noffset);
	if ((params->pflag < 0) || (count <= params->pflag)) {
		printf("No such component at '%d'\n", params->pflag);
		return -1;
	}

	/* Process its subnodes, extract the desired component from image */
	for (ndepth = 0, count = 0,
		noffset = fdt_next_node(fit, images_noffset, &ndepth);
		(noffset >= 0) && (ndepth > 0);
		noffset = fdt_next_node(fit, noffset, &ndepth)) {
		if (ndepth == 1) {
			/*
			 * Direct child node of the images parent node,
			 * i.e. component image node.
			 */
			if (params->pflag == count) {
				printf("Extracted:\n%s Image %u (%s)\n", p,
				       count, fit_get_name(fit, noffset, NULL));

				fit_image_print(fit, noffset, p);

				return fit_image_extract(fit, noffset,
						params->outfile);
			}

			count++;
		}
	}

	return 0;
}

static int fit_check_params(struct image_tool_params *params)
{
	return	((params->dflag && (params->fflag || params->lflag)) ||
		(params->fflag && (params->dflag || params->lflag)) ||
		(params->lflag && (params->dflag || params->fflag)));
}

U_BOOT_IMAGE_TYPE(
	fitimage,
	"FIT Image support",
	sizeof(image_header_t),
	(void *)&header,
	fit_check_params,
	fit_verify_header,
	fit_print_contents,
	NULL,
	fit_extract_contents,
	fit_check_image_types,
	fit_handle_file,
	NULL /* FIT images use DTB header */
);
Commit	Line	Data
89a4d6b1 PW	1	/*
	2	* (C) Copyright 2008 Semihalf
	3	*
	4	* (C) Copyright 2000-2004
	5	* DENX Software Engineering
	6	* Wolfgang Denk, wd@denx.de
	7	*
	8	* Updated-by: Prafulla Wadaskar <prafulla@marvell.com>
	9	* FIT image specific code abstracted from mkimage.c
	10	* some functions added to address abstraction
	11	*
	12	* All rights reserved.
	13	*
1a459660	14	* SPDX-License-Identifier: GPL-2.0+
89a4d6b1 PW	15	*/
89a4d6b1 PW	16
f86ed6a8	17	#include "imagetool.h"
6bf4ca07	18	#include "fit_common.h"
89a4d6b1 PW	19	#include "mkimage.h"
	20	#include <image.h>
	21	#include <u-boot/crc.h>
	22
	23	static image_header_t header;
	24
a9468115 SG	25	static int fit_add_file_data(struct image_tool_params *params, size_t size_inc,
	26	const char *tmpfile)
	27	{
	28	int tfd, destfd = 0;
	29	void *dest_blob = NULL;
	30	off_t destfd_size = 0;
	31	struct stat sbuf;
	32	void *ptr;
	33	int ret = 0;
	34
	35	tfd = mmap_fdt(params->cmdname, tmpfile, size_inc, &ptr, &sbuf, true);
	36	if (tfd < 0)
	37	return -EIO;
	38
	39	if (params->keydest) {
	40	struct stat dest_sbuf;
	41
	42	destfd = mmap_fdt(params->cmdname, params->keydest, size_inc,
	43	&dest_blob, &dest_sbuf, false);
	44	if (destfd < 0) {
	45	ret = -EIO;
	46	goto err_keydest;
	47	}
	48	destfd_size = dest_sbuf.st_size;
	49	}
	50
	51	/* for first image creation, add a timestamp at offset 0 i.e., root */
	52	if (params->datafile)
	53	ret = fit_set_timestamp(ptr, 0, sbuf.st_mtime);
	54
	55	if (!ret) {
	56	ret = fit_add_verification_data(params->keydir, dest_blob, ptr,
	57	params->comment,
	58	params->require_keys);
	59	}
	60
	61	if (dest_blob) {
	62	munmap(dest_blob, destfd_size);
	63	close(destfd);
	64	}
	65
	66	err_keydest:
	67	munmap(ptr, sbuf.st_size);
	68	close(tfd);
	69
	70	return ret;
	71	}
	72
89a4d6b1 PW	73	/**
	74	* fit_handle_file - main FIT file processing function
	75	*
	76	* fit_handle_file() runs dtc to convert .its to .itb, includes
	77	* binary data, updates timestamp property and calculates hashes.
	78	*
	79	* datafile - .its file
	80	* imagefile - .itb file
	81	*
	82	* returns:
	83	* only on success, otherwise calls exit (EXIT_FAILURE);
	84	*/
f86ed6a8	85	static int fit_handle_file(struct image_tool_params *params)
89a4d6b1 PW	86	{
	87	char tmpfile[MKIMAGE_MAX_TMPFILE_LEN];
	88	char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN];
a9468115 SG	89	size_t size_inc;
a9468115 SG	90	int ret;
89a4d6b1 PW	91
	92	/* Flattened Image Tree (FIT) format handling */
	93	debug ("FIT format handling\n");
	94
	95	/* call dtc to include binary properties into the tmp file */
	96	if (strlen (params->imagefile) +
	97	strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > sizeof (tmpfile)) {
	98	fprintf (stderr, "%s: Image file name (%s) too long, "
	99	"can't create tmpfile",
	100	params->imagefile, params->cmdname);
	101	return (EXIT_FAILURE);
	102	}
	103	sprintf (tmpfile, "%s%s", params->imagefile, MKIMAGE_TMPFILE_SUFFIX);
	104
95d77b44 SG	105	/* We either compile the source file, or use the existing FIT image */
	106	if (params->datafile) {
	107	/* dtc -I dts -O dtb -p 500 datafile > tmpfile */
	108	snprintf(cmd, sizeof(cmd), "%s %s %s > %s",
	109	MKIMAGE_DTC, params->dtc, params->datafile, tmpfile);
	110	debug("Trying to execute \"%s\"\n", cmd);
	111	} else {
	112	snprintf(cmd, sizeof(cmd), "cp %s %s",
	113	params->imagefile, tmpfile);
	114	}
89a4d6b1 PW	115	if (system (cmd) == -1) {
	116	fprintf (stderr, "%s: system(%s) failed: %s\n",
	117	params->cmdname, cmd, strerror(errno));
aa6d6db4	118	goto err_system;
89a4d6b1 PW	119	}
89a4d6b1 PW	120
a9468115 SG	121	/*
	122	* Set hashes for images in the blob. Unfortunately we may need more
	123	* space in either FDT, so keep trying until we succeed.
	124	*
	125	* Note: this is pretty inefficient for signing, since we must
	126	* calculate the signature every time. It would be better to calculate
	127	* all the data and then store it in a separate step. However, this
	128	* would be considerably more complex to implement. Generally a few
	129	* steps of this loop is enough to sign with several keys.
	130	*/
	131	for (size_inc = 0; size_inc < 64 * 1024; size_inc += 1024) {
	132	ret = fit_add_file_data(params, size_inc, tmpfile);
	133	if (!ret \|\| ret != -ENOSPC)
	134	break;
e29495d3 SG	135	}
e29495d3 SG	136
a9468115	137	if (ret) {
399c744b SG	138	fprintf(stderr, "%s Can't add hashes to FIT blob\n",
399c744b SG	139	params->cmdname);
a9468115	140	goto err_system;
e29495d3	141	}
89a4d6b1 PW	142
	143	if (rename (tmpfile, params->imagefile) == -1) {
	144	fprintf (stderr, "%s: Can't rename %s to %s: %s\n",
	145	params->cmdname, tmpfile, params->imagefile,
	146	strerror (errno));
	147	unlink (tmpfile);
	148	unlink (params->imagefile);
a9468115	149	return EXIT_FAILURE;
89a4d6b1	150	}
a9468115	151	return EXIT_SUCCESS;
aa6d6db4	152
aa6d6db4 SG	153	err_system:
	154	unlink(tmpfile);
	155	return -1;
89a4d6b1 PW	156	}
89a4d6b1 PW	157
39931f96 GMF	158	/**
	159	* fit_image_extract - extract a FIT component image
	160	* @fit: pointer to the FIT format image header
	161	* @image_noffset: offset of the component image node
	162	* @file_name: name of the file to store the FIT sub-image
	163	*
	164	* returns:
	165	* zero in case of success or a negative value if fail.
	166	*/
	167	static int fit_image_extract(
	168	const void *fit,
	169	int image_noffset,
	170	const char *file_name)
	171	{
	172	const void *file_data;
	173	size_t file_size = 0;
	174
	175	/* get the "data" property of component at offset "image_noffset" */
	176	fit_image_get_data(fit, image_noffset, &file_data, &file_size);
	177
	178	/* save the "file_data" into the file specified by "file_name" */
	179	return imagetool_save_subimage(file_name, (ulong) file_data, file_size);
	180	}
	181
	182	/**
	183	* fit_extract_contents - retrieve a sub-image component from the FIT image
	184	* @ptr: pointer to the FIT format image header
	185	* @params: command line parameters
	186	*
	187	* returns:
	188	* zero in case of success or a negative value if fail.
	189	*/
	190	static int fit_extract_contents(void ptr, struct image_tool_params params)
	191	{
	192	int images_noffset;
	193	int noffset;
	194	int ndepth;
	195	const void *fit = ptr;
	196	int count = 0;
	197	const char *p;
	198
	199	/* Indent string is defined in header image.h */
	200	p = IMAGE_INDENT_STRING;
	201
	202	if (!fit_check_format(fit)) {
	203	printf("Bad FIT image format\n");
	204	return -1;
	205	}
	206
	207	/* Find images parent node offset */
	208	images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
	209	if (images_noffset < 0) {
	210	printf("Can't find images parent node '%s' (%s)\n",
	211	FIT_IMAGES_PATH, fdt_strerror(images_noffset));
	212	return -1;
	213	}
	214
	215	/* Avoid any overrun */
	216	count = fit_get_subimage_count(fit, images_noffset);
	217	if ((params->pflag < 0) \|\| (count <= params->pflag)) {
	218	printf("No such component at '%d'\n", params->pflag);
	219	return -1;
	220	}
	221
222	/* Process its subnodes, extract the desired component from image */
223	for (ndepth = 0, count = 0,
224	noffset = fdt_next_node(fit, images_noffset, &ndepth);
225	(noffset >= 0) && (ndepth > 0);
226	noffset = fdt_next_node(fit, noffset, &ndepth)) {
227	if (ndepth == 1) {
228	/*
229	* Direct child node of the images parent node,
230	* i.e. component image node.
231	*/
232	if (params->pflag == count) {
233	printf("Extracted:\n%s Image %u (%s)\n", p,
234	count, fit_get_name(fit, noffset, NULL));
235
236	fit_image_print(fit, noffset, p);
237
238	return fit_image_extract(fit, noffset,
239	params->outfile);
240	}
241
242	count++;
243	}
244	}
245
246	return 0;
247	}
248
f86ed6a8	249	static int fit_check_params(struct image_tool_params *params)
89a4d6b1 PW	250	{
	251	return ((params->dflag && (params->fflag \|\| params->lflag)) \|\|
	252	(params->fflag && (params->dflag \|\| params->lflag)) \|\|
	253	(params->lflag && (params->dflag \|\| params->fflag)));
	254	}
	255
a93648d1 GMF	256	U_BOOT_IMAGE_TYPE(
	257	fitimage,
	258	"FIT Image support",
	259	sizeof(image_header_t),
	260	(void *)&header,
	261	fit_check_params,
	262	fit_verify_header,
	263	fit_print_contents,
	264	NULL,
39931f96	265	fit_extract_contents,
a93648d1 GMF	266	fit_check_image_types,
	267	fit_handle_file,
	268	NULL /* FIT images use DTB header */
	269	);