1 /* 2 * (C) Copyright 2008 Semihalf 3 * 4 * (C) Copyright 2000-2009 5 * DENX Software Engineering 6 * Wolfgang Denk, wd@denx.de 7 * 8 * SPDX-License-Identifier: GPL-2.0+ 9 */ 10 11 #include "mkimage.h" 12 #include <image.h> 13 #include <version.h> 14 15 static void copy_file(int, const char *, int); 16 static void usage(void); 17 18 /* parameters initialized by core will be used by the image type code */ 19 struct image_tool_params params = { 20 .os = IH_OS_LINUX, 21 .arch = IH_ARCH_PPC, 22 .type = IH_TYPE_KERNEL, 23 .comp = IH_COMP_GZIP, 24 .dtc = MKIMAGE_DEFAULT_DTC_OPTIONS, 25 .imagename = "", 26 .imagename2 = "", 27 }; 28 29 static int h_compare_image_name(const void *vtype1, const void *vtype2) 30 { 31 const int *type1 = vtype1; 32 const int *type2 = vtype2; 33 const char *name1 = genimg_get_type_short_name(*type1); 34 const char *name2 = genimg_get_type_short_name(*type2); 35 36 return strcmp(name1, name2); 37 } 38 39 /* Show all image types supported by mkimage */ 40 static void show_image_types(void) 41 { 42 struct image_type_params *tparams; 43 int order[IH_TYPE_COUNT]; 44 int count; 45 int type; 46 int i; 47 48 /* Sort the names in order of short name for easier reading */ 49 memset(order, '\0', sizeof(order)); 50 for (count = 0, type = 0; type < IH_TYPE_COUNT; type++) { 51 tparams = imagetool_get_type(type); 52 if (tparams) 53 order[count++] = type; 54 } 55 qsort(order, count, sizeof(int), h_compare_image_name); 56 57 fprintf(stderr, "\nInvalid image type. Supported image types:\n"); 58 for (i = 0; i < count; i++) { 59 type = order[i]; 60 tparams = imagetool_get_type(type); 61 if (tparams) { 62 fprintf(stderr, "\t%-15s %s\n", 63 genimg_get_type_short_name(type), 64 genimg_get_type_name(type)); 65 } 66 } 67 fprintf(stderr, "\n"); 68 } 69 70 int main(int argc, char **argv) 71 { 72 int ifd = -1; 73 struct stat sbuf; 74 char *ptr; 75 int retval = 0; 76 struct image_type_params *tparams = NULL; 77 int pad_len = 0; 78 int dfd; 79 80 params.cmdname = *argv; 81 params.addr = params.ep = 0; 82 83 while (--argc > 0 && **++argv == '-') { 84 while (*++*argv) { 85 switch (**argv) { 86 case 'l': 87 params.lflag = 1; 88 break; 89 case 'A': 90 if ((--argc <= 0) || 91 (params.arch = 92 genimg_get_arch_id (*++argv)) < 0) 93 usage (); 94 goto NXTARG; 95 case 'c': 96 if (--argc <= 0) 97 usage(); 98 params.comment = *++argv; 99 goto NXTARG; 100 case 'C': 101 if ((--argc <= 0) || 102 (params.comp = 103 genimg_get_comp_id (*++argv)) < 0) 104 usage (); 105 goto NXTARG; 106 case 'D': 107 if (--argc <= 0) 108 usage (); 109 params.dtc = *++argv; 110 goto NXTARG; 111 112 case 'O': 113 if ((--argc <= 0) || 114 (params.os = 115 genimg_get_os_id (*++argv)) < 0) 116 usage (); 117 goto NXTARG; 118 case 'T': 119 params.type = -1; 120 if (--argc >= 0 && argv[1]) { 121 params.type = 122 genimg_get_type_id(*++argv); 123 } 124 if (params.type < 0) { 125 show_image_types(); 126 usage(); 127 } 128 goto NXTARG; 129 case 'a': 130 if (--argc <= 0) 131 usage (); 132 params.addr = strtoul (*++argv, &ptr, 16); 133 if (*ptr) { 134 fprintf (stderr, 135 "%s: invalid load address %s\n", 136 params.cmdname, *argv); 137 exit (EXIT_FAILURE); 138 } 139 goto NXTARG; 140 case 'd': 141 if (--argc <= 0) 142 usage (); 143 params.datafile = *++argv; 144 params.dflag = 1; 145 goto NXTARG; 146 case 'e': 147 if (--argc <= 0) 148 usage (); 149 params.ep = strtoul (*++argv, &ptr, 16); 150 if (*ptr) { 151 fprintf (stderr, 152 "%s: invalid entry point %s\n", 153 params.cmdname, *argv); 154 exit (EXIT_FAILURE); 155 } 156 params.eflag = 1; 157 goto NXTARG; 158 case 'f': 159 if (--argc <= 0) 160 usage (); 161 params.datafile = *++argv; 162 /* no break */ 163 case 'F': 164 /* 165 * The flattened image tree (FIT) format 166 * requires a flattened device tree image type 167 */ 168 params.type = IH_TYPE_FLATDT; 169 params.fflag = 1; 170 goto NXTARG; 171 case 'k': 172 if (--argc <= 0) 173 usage(); 174 params.keydir = *++argv; 175 goto NXTARG; 176 case 'K': 177 if (--argc <= 0) 178 usage(); 179 params.keydest = *++argv; 180 goto NXTARG; 181 case 'n': 182 if (--argc <= 0) 183 usage (); 184 params.imagename = *++argv; 185 goto NXTARG; 186 case 'r': 187 params.require_keys = 1; 188 break; 189 case 'R': 190 if (--argc <= 0) 191 usage(); 192 /* 193 * This entry is for the second configuration 194 * file, if only one is not enough. 195 */ 196 params.imagename2 = *++argv; 197 goto NXTARG; 198 case 's': 199 params.skipcpy = 1; 200 break; 201 case 'v': 202 params.vflag++; 203 break; 204 case 'V': 205 printf("mkimage version %s\n", PLAIN_VERSION); 206 exit(EXIT_SUCCESS); 207 case 'x': 208 params.xflag++; 209 break; 210 default: 211 usage (); 212 } 213 } 214 NXTARG: ; 215 } 216 217 if (argc != 1) 218 usage (); 219 220 /* set tparams as per input type_id */ 221 tparams = imagetool_get_type(params.type); 222 if (tparams == NULL) { 223 fprintf (stderr, "%s: unsupported type %s\n", 224 params.cmdname, genimg_get_type_name(params.type)); 225 exit (EXIT_FAILURE); 226 } 227 228 /* 229 * check the passed arguments parameters meets the requirements 230 * as per image type to be generated/listed 231 */ 232 if (tparams->check_params) 233 if (tparams->check_params (¶ms)) 234 usage (); 235 236 if (!params.eflag) { 237 params.ep = params.addr; 238 /* If XIP, entry point must be after the U-Boot header */ 239 if (params.xflag) 240 params.ep += tparams->header_size; 241 } 242 243 params.imagefile = *argv; 244 245 if (params.fflag){ 246 if (tparams->fflag_handle) 247 /* 248 * in some cases, some additional processing needs 249 * to be done if fflag is defined 250 * 251 * For ex. fit_handle_file for Fit file support 252 */ 253 retval = tparams->fflag_handle(¶ms); 254 255 if (retval != EXIT_SUCCESS) 256 exit (retval); 257 } 258 259 if (params.lflag || params.fflag) { 260 ifd = open (params.imagefile, O_RDONLY|O_BINARY); 261 } else { 262 ifd = open (params.imagefile, 263 O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666); 264 } 265 266 if (ifd < 0) { 267 fprintf (stderr, "%s: Can't open %s: %s\n", 268 params.cmdname, params.imagefile, 269 strerror(errno)); 270 exit (EXIT_FAILURE); 271 } 272 273 if (params.lflag || params.fflag) { 274 /* 275 * list header information of existing image 276 */ 277 if (fstat(ifd, &sbuf) < 0) { 278 fprintf (stderr, "%s: Can't stat %s: %s\n", 279 params.cmdname, params.imagefile, 280 strerror(errno)); 281 exit (EXIT_FAILURE); 282 } 283 284 if ((unsigned)sbuf.st_size < tparams->header_size) { 285 fprintf (stderr, 286 "%s: Bad size: \"%s\" is not valid image\n", 287 params.cmdname, params.imagefile); 288 exit (EXIT_FAILURE); 289 } 290 291 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0); 292 if (ptr == MAP_FAILED) { 293 fprintf (stderr, "%s: Can't read %s: %s\n", 294 params.cmdname, params.imagefile, 295 strerror(errno)); 296 exit (EXIT_FAILURE); 297 } 298 299 /* 300 * scan through mkimage registry for all supported image types 301 * and verify the input image file header for match 302 * Print the image information for matched image type 303 * Returns the error code if not matched 304 */ 305 retval = imagetool_verify_print_header(ptr, &sbuf, 306 tparams, ¶ms); 307 308 (void) munmap((void *)ptr, sbuf.st_size); 309 (void) close (ifd); 310 311 exit (retval); 312 } 313 314 if (!params.type == IH_TYPE_MULTI || 315 !params.type == IH_TYPE_SCRIPT) { 316 dfd = open(params.datafile, O_RDONLY | O_BINARY); 317 if (dfd < 0) { 318 fprintf(stderr, "%s: Can't open %s: %s\n", 319 params.cmdname, params.datafile, 320 strerror(errno)); 321 exit(EXIT_FAILURE); 322 } 323 324 if (fstat(dfd, &sbuf) < 0) { 325 fprintf(stderr, "%s: Can't stat %s: %s\n", 326 params.cmdname, params.datafile, 327 strerror(errno)); 328 exit(EXIT_FAILURE); 329 } 330 331 params.file_size = sbuf.st_size + tparams->header_size; 332 close(dfd); 333 } 334 335 /* 336 * In case there an header with a variable 337 * length will be added, the corresponding 338 * function is called. This is responsible to 339 * allocate memory for the header itself. 340 */ 341 if (tparams->vrec_header) 342 pad_len = tparams->vrec_header(¶ms, tparams); 343 else 344 memset(tparams->hdr, 0, tparams->header_size); 345 346 if (write(ifd, tparams->hdr, tparams->header_size) 347 != tparams->header_size) { 348 fprintf (stderr, "%s: Write error on %s: %s\n", 349 params.cmdname, params.imagefile, strerror(errno)); 350 exit (EXIT_FAILURE); 351 } 352 353 if (!params.skipcpy) { 354 if (params.type == IH_TYPE_MULTI || 355 params.type == IH_TYPE_SCRIPT) { 356 char *file = params.datafile; 357 uint32_t size; 358 359 for (;;) { 360 char *sep = NULL; 361 362 if (file) { 363 if ((sep = strchr(file, ':')) != NULL) { 364 *sep = '\0'; 365 } 366 367 if (stat (file, &sbuf) < 0) { 368 fprintf (stderr, "%s: Can't stat %s: %s\n", 369 params.cmdname, file, strerror(errno)); 370 exit (EXIT_FAILURE); 371 } 372 size = cpu_to_uimage (sbuf.st_size); 373 } else { 374 size = 0; 375 } 376 377 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) { 378 fprintf (stderr, "%s: Write error on %s: %s\n", 379 params.cmdname, params.imagefile, 380 strerror(errno)); 381 exit (EXIT_FAILURE); 382 } 383 384 if (!file) { 385 break; 386 } 387 388 if (sep) { 389 *sep = ':'; 390 file = sep + 1; 391 } else { 392 file = NULL; 393 } 394 } 395 396 file = params.datafile; 397 398 for (;;) { 399 char *sep = strchr(file, ':'); 400 if (sep) { 401 *sep = '\0'; 402 copy_file (ifd, file, 1); 403 *sep++ = ':'; 404 file = sep; 405 } else { 406 copy_file (ifd, file, 0); 407 break; 408 } 409 } 410 } else if (params.type == IH_TYPE_PBLIMAGE) { 411 /* PBL has special Image format, implements its' own */ 412 pbl_load_uboot(ifd, ¶ms); 413 } else { 414 copy_file(ifd, params.datafile, pad_len); 415 } 416 } 417 418 /* We're a bit of paranoid */ 419 #if defined(_POSIX_SYNCHRONIZED_IO) && \ 420 !defined(__sun__) && \ 421 !defined(__FreeBSD__) && \ 422 !defined(__OpenBSD__) && \ 423 !defined(__APPLE__) 424 (void) fdatasync (ifd); 425 #else 426 (void) fsync (ifd); 427 #endif 428 429 if (fstat(ifd, &sbuf) < 0) { 430 fprintf (stderr, "%s: Can't stat %s: %s\n", 431 params.cmdname, params.imagefile, strerror(errno)); 432 exit (EXIT_FAILURE); 433 } 434 params.file_size = sbuf.st_size; 435 436 ptr = mmap(0, sbuf.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0); 437 if (ptr == MAP_FAILED) { 438 fprintf (stderr, "%s: Can't map %s: %s\n", 439 params.cmdname, params.imagefile, strerror(errno)); 440 exit (EXIT_FAILURE); 441 } 442 443 /* Setup the image header as per input image type*/ 444 if (tparams->set_header) 445 tparams->set_header (ptr, &sbuf, ifd, ¶ms); 446 else { 447 fprintf (stderr, "%s: Can't set header for %s: %s\n", 448 params.cmdname, tparams->name, strerror(errno)); 449 exit (EXIT_FAILURE); 450 } 451 452 /* Print the image information by processing image header */ 453 if (tparams->print_header) 454 tparams->print_header (ptr); 455 else { 456 fprintf (stderr, "%s: Can't print header for %s: %s\n", 457 params.cmdname, tparams->name, strerror(errno)); 458 exit (EXIT_FAILURE); 459 } 460 461 (void) munmap((void *)ptr, sbuf.st_size); 462 463 /* We're a bit of paranoid */ 464 #if defined(_POSIX_SYNCHRONIZED_IO) && \ 465 !defined(__sun__) && \ 466 !defined(__FreeBSD__) && \ 467 !defined(__OpenBSD__) && \ 468 !defined(__APPLE__) 469 (void) fdatasync (ifd); 470 #else 471 (void) fsync (ifd); 472 #endif 473 474 if (close(ifd)) { 475 fprintf (stderr, "%s: Write error on %s: %s\n", 476 params.cmdname, params.imagefile, strerror(errno)); 477 exit (EXIT_FAILURE); 478 } 479 480 exit (EXIT_SUCCESS); 481 } 482 483 static void 484 copy_file (int ifd, const char *datafile, int pad) 485 { 486 int dfd; 487 struct stat sbuf; 488 unsigned char *ptr; 489 int tail; 490 int zero = 0; 491 uint8_t zeros[4096]; 492 int offset = 0; 493 int size; 494 struct image_type_params *tparams = imagetool_get_type(params.type); 495 496 memset(zeros, 0, sizeof(zeros)); 497 498 if (params.vflag) { 499 fprintf (stderr, "Adding Image %s\n", datafile); 500 } 501 502 if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) { 503 fprintf (stderr, "%s: Can't open %s: %s\n", 504 params.cmdname, datafile, strerror(errno)); 505 exit (EXIT_FAILURE); 506 } 507 508 if (fstat(dfd, &sbuf) < 0) { 509 fprintf (stderr, "%s: Can't stat %s: %s\n", 510 params.cmdname, datafile, strerror(errno)); 511 exit (EXIT_FAILURE); 512 } 513 514 ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, dfd, 0); 515 if (ptr == MAP_FAILED) { 516 fprintf (stderr, "%s: Can't read %s: %s\n", 517 params.cmdname, datafile, strerror(errno)); 518 exit (EXIT_FAILURE); 519 } 520 521 if (params.xflag) { 522 unsigned char *p = NULL; 523 /* 524 * XIP: do not append the image_header_t at the 525 * beginning of the file, but consume the space 526 * reserved for it. 527 */ 528 529 if ((unsigned)sbuf.st_size < tparams->header_size) { 530 fprintf (stderr, 531 "%s: Bad size: \"%s\" is too small for XIP\n", 532 params.cmdname, datafile); 533 exit (EXIT_FAILURE); 534 } 535 536 for (p = ptr; p < ptr + tparams->header_size; p++) { 537 if ( *p != 0xff ) { 538 fprintf (stderr, 539 "%s: Bad file: \"%s\" has invalid buffer for XIP\n", 540 params.cmdname, datafile); 541 exit (EXIT_FAILURE); 542 } 543 } 544 545 offset = tparams->header_size; 546 } 547 548 size = sbuf.st_size - offset; 549 if (write(ifd, ptr + offset, size) != size) { 550 fprintf (stderr, "%s: Write error on %s: %s\n", 551 params.cmdname, params.imagefile, strerror(errno)); 552 exit (EXIT_FAILURE); 553 } 554 555 tail = size % 4; 556 if ((pad == 1) && (tail != 0)) { 557 558 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) { 559 fprintf (stderr, "%s: Write error on %s: %s\n", 560 params.cmdname, params.imagefile, 561 strerror(errno)); 562 exit (EXIT_FAILURE); 563 } 564 } else if (pad > 1) { 565 while (pad > 0) { 566 int todo = sizeof(zeros); 567 568 if (todo > pad) 569 todo = pad; 570 if (write(ifd, (char *)&zeros, todo) != todo) { 571 fprintf(stderr, "%s: Write error on %s: %s\n", 572 params.cmdname, params.imagefile, 573 strerror(errno)); 574 exit(EXIT_FAILURE); 575 } 576 pad -= todo; 577 } 578 } 579 580 (void) munmap((void *)ptr, sbuf.st_size); 581 (void) close (dfd); 582 } 583 584 static void usage(void) 585 { 586 fprintf (stderr, "Usage: %s -l image\n" 587 " -l ==> list image header information\n", 588 params.cmdname); 589 fprintf (stderr, " %s [-x] -A arch -O os -T type -C comp " 590 "-a addr -e ep -n name -d data_file[:data_file...] image\n" 591 " -A ==> set architecture to 'arch'\n" 592 " -O ==> set operating system to 'os'\n" 593 " -T ==> set image type to 'type'\n" 594 " -C ==> set compression type 'comp'\n" 595 " -a ==> set load address to 'addr' (hex)\n" 596 " -e ==> set entry point to 'ep' (hex)\n" 597 " -n ==> set image name to 'name'\n" 598 " -d ==> use image data from 'datafile'\n" 599 " -x ==> set XIP (execute in place)\n", 600 params.cmdname); 601 fprintf(stderr, " %s [-D dtc_options] [-f fit-image.its|-F] fit-image\n", 602 params.cmdname); 603 fprintf(stderr, " -D => set all options for device tree compiler\n" 604 " -f => input filename for FIT source\n"); 605 #ifdef CONFIG_FIT_SIGNATURE 606 fprintf(stderr, "Signing / verified boot options: [-k keydir] [-K dtb] [ -c <comment>] [-r]\n" 607 " -k => set directory containing private keys\n" 608 " -K => write public keys to this .dtb file\n" 609 " -c => add comment in signature node\n" 610 " -F => re-sign existing FIT image\n" 611 " -r => mark keys used as 'required' in dtb\n"); 612 #else 613 fprintf(stderr, "Signing / verified boot not supported (CONFIG_FIT_SIGNATURE undefined)\n"); 614 #endif 615 fprintf (stderr, " %s -V ==> print version information and exit\n", 616 params.cmdname); 617 fprintf(stderr, "Use -T to see a list of available image types\n"); 618 619 exit (EXIT_FAILURE); 620 } 621