1 /* 2 * (C) Copyright 2008 Semihalf 3 * 4 * (C) Copyright 2000-2004 5 * DENX Software Engineering 6 * Wolfgang Denk, wd@denx.de 7 * All rights reserved. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 * MA 02111-1307 USA 23 */ 24 25 #include "mkimage.h" 26 #include <image.h> 27 28 extern int errno; 29 30 #ifndef MAP_FAILED 31 #define MAP_FAILED (-1) 32 #endif 33 34 extern unsigned long crc32 (unsigned long crc, const char *buf, unsigned int len); 35 static void copy_file (int, const char *, int); 36 static void usage (void); 37 static void image_verify_header (char *, int); 38 static void fit_handle_file (void); 39 40 char *datafile; 41 char *imagefile; 42 char *cmdname; 43 44 int dflag = 0; 45 int eflag = 0; 46 int fflag = 0; 47 int lflag = 0; 48 int vflag = 0; 49 int xflag = 0; 50 int opt_os = IH_OS_LINUX; 51 int opt_arch = IH_ARCH_PPC; 52 int opt_type = IH_TYPE_KERNEL; 53 int opt_comp = IH_COMP_GZIP; 54 char *opt_dtc = MKIMAGE_DEFAULT_DTC_OPTIONS; 55 56 image_header_t header; 57 image_header_t *hdr = &header; 58 59 int 60 main (int argc, char **argv) 61 { 62 int ifd = -1; 63 uint32_t checksum; 64 uint32_t addr; 65 uint32_t ep; 66 struct stat sbuf; 67 unsigned char *ptr; 68 char *name = ""; 69 70 cmdname = *argv; 71 72 addr = ep = 0; 73 74 while (--argc > 0 && **++argv == '-') { 75 while (*++*argv) { 76 switch (**argv) { 77 case 'l': 78 lflag = 1; 79 break; 80 case 'A': 81 if ((--argc <= 0) || 82 (opt_arch = genimg_get_arch_id (*++argv)) < 0) 83 usage (); 84 goto NXTARG; 85 case 'C': 86 if ((--argc <= 0) || 87 (opt_comp = genimg_get_comp_id (*++argv)) < 0) 88 usage (); 89 goto NXTARG; 90 case 'D': 91 if (--argc <= 0) 92 usage (); 93 opt_dtc = *++argv; 94 goto NXTARG; 95 96 case 'O': 97 if ((--argc <= 0) || 98 (opt_os = genimg_get_os_id (*++argv)) < 0) 99 usage (); 100 goto NXTARG; 101 case 'T': 102 if ((--argc <= 0) || 103 (opt_type = genimg_get_type_id (*++argv)) < 0) 104 usage (); 105 goto NXTARG; 106 107 case 'a': 108 if (--argc <= 0) 109 usage (); 110 addr = strtoul (*++argv, (char **)&ptr, 16); 111 if (*ptr) { 112 fprintf (stderr, 113 "%s: invalid load address %s\n", 114 cmdname, *argv); 115 exit (EXIT_FAILURE); 116 } 117 goto NXTARG; 118 case 'd': 119 if (--argc <= 0) 120 usage (); 121 datafile = *++argv; 122 dflag = 1; 123 goto NXTARG; 124 case 'e': 125 if (--argc <= 0) 126 usage (); 127 ep = strtoul (*++argv, (char **)&ptr, 16); 128 if (*ptr) { 129 fprintf (stderr, 130 "%s: invalid entry point %s\n", 131 cmdname, *argv); 132 exit (EXIT_FAILURE); 133 } 134 eflag = 1; 135 goto NXTARG; 136 case 'f': 137 if (--argc <= 0) 138 usage (); 139 datafile = *++argv; 140 fflag = 1; 141 goto NXTARG; 142 case 'n': 143 if (--argc <= 0) 144 usage (); 145 name = *++argv; 146 goto NXTARG; 147 case 'v': 148 vflag++; 149 break; 150 case 'x': 151 xflag++; 152 break; 153 default: 154 usage (); 155 } 156 } 157 NXTARG: ; 158 } 159 160 if ((argc != 1) || 161 (dflag && (fflag || lflag)) || 162 (fflag && (dflag || lflag)) || 163 (lflag && (dflag || fflag))) 164 usage(); 165 166 if (!eflag) { 167 ep = addr; 168 /* If XIP, entry point must be after the U-Boot header */ 169 if (xflag) 170 ep += image_get_header_size (); 171 } 172 173 /* 174 * If XIP, ensure the entry point is equal to the load address plus 175 * the size of the U-Boot header. 176 */ 177 if (xflag) { 178 if (ep != addr + image_get_header_size ()) { 179 fprintf (stderr, 180 "%s: For XIP, the entry point must be the load addr + %lu\n", 181 cmdname, 182 (unsigned long)image_get_header_size ()); 183 exit (EXIT_FAILURE); 184 } 185 } 186 187 imagefile = *argv; 188 189 if (!fflag){ 190 if (lflag) { 191 ifd = open (imagefile, O_RDONLY|O_BINARY); 192 } else { 193 ifd = open (imagefile, 194 O_RDWR|O_CREAT|O_TRUNC|O_BINARY, 0666); 195 } 196 197 if (ifd < 0) { 198 fprintf (stderr, "%s: Can't open %s: %s\n", 199 cmdname, imagefile, strerror(errno)); 200 exit (EXIT_FAILURE); 201 } 202 } 203 204 if (lflag) { 205 /* 206 * list header information of existing image 207 */ 208 if (fstat(ifd, &sbuf) < 0) { 209 fprintf (stderr, "%s: Can't stat %s: %s\n", 210 cmdname, imagefile, strerror(errno)); 211 exit (EXIT_FAILURE); 212 } 213 214 if ((unsigned)sbuf.st_size < image_get_header_size ()) { 215 fprintf (stderr, 216 "%s: Bad size: \"%s\" is no valid image\n", 217 cmdname, imagefile); 218 exit (EXIT_FAILURE); 219 } 220 221 ptr = (unsigned char *)mmap(0, sbuf.st_size, 222 PROT_READ, MAP_SHARED, ifd, 0); 223 if ((caddr_t)ptr == (caddr_t)-1) { 224 fprintf (stderr, "%s: Can't read %s: %s\n", 225 cmdname, imagefile, strerror(errno)); 226 exit (EXIT_FAILURE); 227 } 228 229 if (fdt_check_header (ptr)) { 230 /* old-style image */ 231 image_verify_header ((char *)ptr, sbuf.st_size); 232 image_print_contents_noindent ((image_header_t *)ptr); 233 } else { 234 /* FIT image */ 235 fit_print_contents_noindent (ptr); 236 } 237 238 (void) munmap((void *)ptr, sbuf.st_size); 239 (void) close (ifd); 240 241 exit (EXIT_SUCCESS); 242 } else if (fflag) { 243 /* Flattened Image Tree (FIT) format handling */ 244 debug ("FIT format handling\n"); 245 fit_handle_file (); 246 exit (EXIT_SUCCESS); 247 } 248 249 /* 250 * Must be -w then: 251 * 252 * write dummy header, to be fixed later 253 */ 254 memset (hdr, 0, image_get_header_size ()); 255 256 if (write(ifd, hdr, image_get_header_size ()) != image_get_header_size ()) { 257 fprintf (stderr, "%s: Write error on %s: %s\n", 258 cmdname, imagefile, strerror(errno)); 259 exit (EXIT_FAILURE); 260 } 261 262 if (opt_type == IH_TYPE_MULTI || opt_type == IH_TYPE_SCRIPT) { 263 char *file = datafile; 264 uint32_t size; 265 266 for (;;) { 267 char *sep = NULL; 268 269 if (file) { 270 if ((sep = strchr(file, ':')) != NULL) { 271 *sep = '\0'; 272 } 273 274 if (stat (file, &sbuf) < 0) { 275 fprintf (stderr, "%s: Can't stat %s: %s\n", 276 cmdname, file, strerror(errno)); 277 exit (EXIT_FAILURE); 278 } 279 size = cpu_to_uimage (sbuf.st_size); 280 } else { 281 size = 0; 282 } 283 284 if (write(ifd, (char *)&size, sizeof(size)) != sizeof(size)) { 285 fprintf (stderr, "%s: Write error on %s: %s\n", 286 cmdname, imagefile, strerror(errno)); 287 exit (EXIT_FAILURE); 288 } 289 290 if (!file) { 291 break; 292 } 293 294 if (sep) { 295 *sep = ':'; 296 file = sep + 1; 297 } else { 298 file = NULL; 299 } 300 } 301 302 file = datafile; 303 304 for (;;) { 305 char *sep = strchr(file, ':'); 306 if (sep) { 307 *sep = '\0'; 308 copy_file (ifd, file, 1); 309 *sep++ = ':'; 310 file = sep; 311 } else { 312 copy_file (ifd, file, 0); 313 break; 314 } 315 } 316 } else { 317 copy_file (ifd, datafile, 0); 318 } 319 320 /* We're a bit of paranoid */ 321 #if defined(_POSIX_SYNCHRONIZED_IO) && !defined(__sun__) && !defined(__FreeBSD__) && !defined(__APPLE__) 322 (void) fdatasync (ifd); 323 #else 324 (void) fsync (ifd); 325 #endif 326 327 if (fstat(ifd, &sbuf) < 0) { 328 fprintf (stderr, "%s: Can't stat %s: %s\n", 329 cmdname, imagefile, strerror(errno)); 330 exit (EXIT_FAILURE); 331 } 332 333 ptr = (unsigned char *)mmap(0, sbuf.st_size, 334 PROT_READ|PROT_WRITE, MAP_SHARED, ifd, 0); 335 if (ptr == (unsigned char *)MAP_FAILED) { 336 fprintf (stderr, "%s: Can't map %s: %s\n", 337 cmdname, imagefile, strerror(errno)); 338 exit (EXIT_FAILURE); 339 } 340 341 hdr = (image_header_t *)ptr; 342 343 checksum = crc32 (0, 344 (const char *)(ptr + image_get_header_size ()), 345 sbuf.st_size - image_get_header_size () 346 ); 347 348 /* Build new header */ 349 image_set_magic (hdr, IH_MAGIC); 350 image_set_time (hdr, sbuf.st_mtime); 351 image_set_size (hdr, sbuf.st_size - image_get_header_size ()); 352 image_set_load (hdr, addr); 353 image_set_ep (hdr, ep); 354 image_set_dcrc (hdr, checksum); 355 image_set_os (hdr, opt_os); 356 image_set_arch (hdr, opt_arch); 357 image_set_type (hdr, opt_type); 358 image_set_comp (hdr, opt_comp); 359 360 image_set_name (hdr, name); 361 362 checksum = crc32 (0, (const char *)hdr, image_get_header_size ()); 363 364 image_set_hcrc (hdr, checksum); 365 366 image_print_contents_noindent (hdr); 367 368 (void) munmap((void *)ptr, sbuf.st_size); 369 370 /* We're a bit of paranoid */ 371 #if defined(_POSIX_SYNCHRONIZED_IO) && !defined(__sun__) && !defined(__FreeBSD__) && !defined(__APPLE__) 372 (void) fdatasync (ifd); 373 #else 374 (void) fsync (ifd); 375 #endif 376 377 if (close(ifd)) { 378 fprintf (stderr, "%s: Write error on %s: %s\n", 379 cmdname, imagefile, strerror(errno)); 380 exit (EXIT_FAILURE); 381 } 382 383 exit (EXIT_SUCCESS); 384 } 385 386 static void 387 copy_file (int ifd, const char *datafile, int pad) 388 { 389 int dfd; 390 struct stat sbuf; 391 unsigned char *ptr; 392 int tail; 393 int zero = 0; 394 int offset = 0; 395 int size; 396 397 if (vflag) { 398 fprintf (stderr, "Adding Image %s\n", datafile); 399 } 400 401 if ((dfd = open(datafile, O_RDONLY|O_BINARY)) < 0) { 402 fprintf (stderr, "%s: Can't open %s: %s\n", 403 cmdname, datafile, strerror(errno)); 404 exit (EXIT_FAILURE); 405 } 406 407 if (fstat(dfd, &sbuf) < 0) { 408 fprintf (stderr, "%s: Can't stat %s: %s\n", 409 cmdname, datafile, strerror(errno)); 410 exit (EXIT_FAILURE); 411 } 412 413 ptr = (unsigned char *)mmap(0, sbuf.st_size, 414 PROT_READ, MAP_SHARED, dfd, 0); 415 if (ptr == (unsigned char *)MAP_FAILED) { 416 fprintf (stderr, "%s: Can't read %s: %s\n", 417 cmdname, datafile, strerror(errno)); 418 exit (EXIT_FAILURE); 419 } 420 421 if (xflag) { 422 unsigned char *p = NULL; 423 /* 424 * XIP: do not append the image_header_t at the 425 * beginning of the file, but consume the space 426 * reserved for it. 427 */ 428 429 if ((unsigned)sbuf.st_size < image_get_header_size ()) { 430 fprintf (stderr, 431 "%s: Bad size: \"%s\" is too small for XIP\n", 432 cmdname, datafile); 433 exit (EXIT_FAILURE); 434 } 435 436 for (p = ptr; p < ptr + image_get_header_size (); p++) { 437 if ( *p != 0xff ) { 438 fprintf (stderr, 439 "%s: Bad file: \"%s\" has invalid buffer for XIP\n", 440 cmdname, datafile); 441 exit (EXIT_FAILURE); 442 } 443 } 444 445 offset = image_get_header_size (); 446 } 447 448 size = sbuf.st_size - offset; 449 if (write(ifd, ptr + offset, size) != size) { 450 fprintf (stderr, "%s: Write error on %s: %s\n", 451 cmdname, imagefile, strerror(errno)); 452 exit (EXIT_FAILURE); 453 } 454 455 if (pad && ((tail = size % 4) != 0)) { 456 457 if (write(ifd, (char *)&zero, 4-tail) != 4-tail) { 458 fprintf (stderr, "%s: Write error on %s: %s\n", 459 cmdname, imagefile, strerror(errno)); 460 exit (EXIT_FAILURE); 461 } 462 } 463 464 (void) munmap((void *)ptr, sbuf.st_size); 465 (void) close (dfd); 466 } 467 468 void 469 usage () 470 { 471 fprintf (stderr, "Usage: %s -l image\n" 472 " -l ==> list image header information\n", 473 cmdname); 474 fprintf (stderr, " %s [-x] -A arch -O os -T type -C comp " 475 "-a addr -e ep -n name -d data_file[:data_file...] image\n" 476 " -A ==> set architecture to 'arch'\n" 477 " -O ==> set operating system to 'os'\n" 478 " -T ==> set image type to 'type'\n" 479 " -C ==> set compression type 'comp'\n" 480 " -a ==> set load address to 'addr' (hex)\n" 481 " -e ==> set entry point to 'ep' (hex)\n" 482 " -n ==> set image name to 'name'\n" 483 " -d ==> use image data from 'datafile'\n" 484 " -x ==> set XIP (execute in place)\n", 485 cmdname); 486 fprintf (stderr, " %s [-D dtc_options] -f fit-image.its fit-image\n", 487 cmdname); 488 489 exit (EXIT_FAILURE); 490 } 491 492 static void 493 image_verify_header (char *ptr, int image_size) 494 { 495 int len; 496 char *data; 497 uint32_t checksum; 498 image_header_t header; 499 image_header_t *hdr = &header; 500 501 /* 502 * create copy of header so that we can blank out the 503 * checksum field for checking - this can't be done 504 * on the PROT_READ mapped data. 505 */ 506 memcpy (hdr, ptr, sizeof(image_header_t)); 507 508 if (ntohl(hdr->ih_magic) != IH_MAGIC) { 509 fprintf (stderr, 510 "%s: Bad Magic Number: \"%s\" is no valid image\n", 511 cmdname, imagefile); 512 exit (EXIT_FAILURE); 513 } 514 515 data = (char *)hdr; 516 len = sizeof(image_header_t); 517 518 checksum = ntohl(hdr->ih_hcrc); 519 hdr->ih_hcrc = htonl(0); /* clear for re-calculation */ 520 521 if (crc32 (0, data, len) != checksum) { 522 fprintf (stderr, 523 "%s: ERROR: \"%s\" has bad header checksum!\n", 524 cmdname, imagefile); 525 exit (EXIT_FAILURE); 526 } 527 528 data = ptr + sizeof(image_header_t); 529 len = image_size - sizeof(image_header_t) ; 530 531 if (crc32 (0, data, len) != ntohl(hdr->ih_dcrc)) { 532 fprintf (stderr, 533 "%s: ERROR: \"%s\" has corrupted data!\n", 534 cmdname, imagefile); 535 exit (EXIT_FAILURE); 536 } 537 } 538 539 /** 540 * fit_handle_file - main FIT file processing function 541 * 542 * fit_handle_file() runs dtc to convert .its to .itb, includes 543 * binary data, updates timestamp property and calculates hashes. 544 * 545 * datafile - .its file 546 * imagefile - .itb file 547 * 548 * returns: 549 * only on success, otherwise calls exit (EXIT_FAILURE); 550 */ 551 static void fit_handle_file (void) 552 { 553 char tmpfile[MKIMAGE_MAX_TMPFILE_LEN]; 554 char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN]; 555 int tfd; 556 struct stat sbuf; 557 unsigned char *ptr; 558 559 /* call dtc to include binary properties into the tmp file */ 560 if (strlen (imagefile) + strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > 561 sizeof (tmpfile)) { 562 fprintf (stderr, "%s: Image file name (%s) too long, " 563 "can't create tmpfile", 564 imagefile, cmdname); 565 exit (EXIT_FAILURE); 566 } 567 sprintf (tmpfile, "%s%s", imagefile, MKIMAGE_TMPFILE_SUFFIX); 568 569 /* dtc -I dts -O -p 200 datafile > tmpfile */ 570 sprintf (cmd, "%s %s %s > %s", 571 MKIMAGE_DTC, opt_dtc, datafile, tmpfile); 572 debug ("Trying to execute \"%s\"\n", cmd); 573 if (system (cmd) == -1) { 574 fprintf (stderr, "%s: system(%s) failed: %s\n", 575 cmdname, cmd, strerror(errno)); 576 unlink (tmpfile); 577 exit (EXIT_FAILURE); 578 } 579 580 /* load FIT blob into memory */ 581 tfd = open (tmpfile, O_RDWR|O_BINARY); 582 583 if (tfd < 0) { 584 fprintf (stderr, "%s: Can't open %s: %s\n", 585 cmdname, tmpfile, strerror(errno)); 586 unlink (tmpfile); 587 exit (EXIT_FAILURE); 588 } 589 590 if (fstat (tfd, &sbuf) < 0) { 591 fprintf (stderr, "%s: Can't stat %s: %s\n", 592 cmdname, tmpfile, strerror(errno)); 593 unlink (tmpfile); 594 exit (EXIT_FAILURE); 595 } 596 597 ptr = (unsigned char *)mmap (0, sbuf.st_size, 598 PROT_READ|PROT_WRITE, MAP_SHARED, tfd, 0); 599 if ((caddr_t)ptr == (caddr_t)-1) { 600 fprintf (stderr, "%s: Can't read %s: %s\n", 601 cmdname, tmpfile, strerror(errno)); 602 unlink (tmpfile); 603 exit (EXIT_FAILURE); 604 } 605 606 /* check if ptr has a valid blob */ 607 if (fdt_check_header (ptr)) { 608 fprintf (stderr, "%s: Invalid FIT blob\n", cmdname); 609 unlink (tmpfile); 610 exit (EXIT_FAILURE); 611 } 612 613 /* set hashes for images in the blob */ 614 if (fit_set_hashes (ptr)) { 615 fprintf (stderr, "%s Can't add hashes to FIT blob", cmdname); 616 unlink (tmpfile); 617 exit (EXIT_FAILURE); 618 } 619 620 /* add a timestamp at offset 0 i.e., root */ 621 if (fit_set_timestamp (ptr, 0, sbuf.st_mtime)) { 622 fprintf (stderr, "%s: Can't add image timestamp\n", cmdname); 623 unlink (tmpfile); 624 exit (EXIT_FAILURE); 625 } 626 debug ("Added timestamp successfully\n"); 627 628 munmap ((void *)ptr, sbuf.st_size); 629 close (tfd); 630 631 if (rename (tmpfile, imagefile) == -1) { 632 fprintf (stderr, "%s: Can't rename %s to %s: %s\n", 633 cmdname, tmpfile, imagefile, strerror (errno)); 634 unlink (tmpfile); 635 unlink (imagefile); 636 exit (EXIT_FAILURE); 637 } 638 } 639