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