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