util/cbfstool/fmaptool.c

   1 /* fmaptool, CLI utility for converting plaintext fmd files into fmap blobs */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include "common.h"
   5 #include "cbfs_sections.h"
   6 #include "fmap_from_fmd.h"
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11
  12 #define STDIN_FILENAME_SENTINEL "-"
  13
  14 #define HEADER_FMAP_OFFSET "FMAP_OFFSET"
  15 #define HEADER_FMAP_SIZE "FMAP_SIZE"
  16
  17 /*
  18  * Macro name used in the generated C header file to provide list of section names that do not
  19  * have any sub-sections.
  20  */
  21 #define HEADER_FMAP_TERMINAL_SECTIONS "FMAP_TERMINAL_SECTIONS"
  22
  23 enum fmaptool_return {
  24         FMAPTOOL_EXIT_SUCCESS = 0,
  25         FMAPTOOL_EXIT_BAD_ARGS,
  26         FMAPTOOL_EXIT_BAD_INPUT_PATH,
  27         FMAPTOOL_EXIT_BAD_OUTPUT_PATH,
  28         FMAPTOOL_EXIT_FAILED_DESCRIPTOR,
  29         FMAPTOOL_EXIT_MISSING_FMAP_SECTION,
  30         FMAPTOOL_EXIT_MISSING_PRIMARY_CBFS,
  31         FMAPTOOL_EXIT_FAILED_FMAP_CONVERSION,
  32         FMAPTOOL_EXIT_UNKNOWN_FMAP_SIZE,
  33         FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT,
  34         FMAPTOOL_EXIT_FAILED_WRITING_HEADER,
  35 };
  36
  37 static void usage(const char *invoked_as)
  38 {
  39         fputs("fmaptool: Compiler for fmd (flashmap descriptor) files\n",
  40                                                                         stderr);
  41         fputs("\nUSAGE:\n", stderr);
  42         fprintf(stderr,
  43                 "\t%s [-h <header output file>] [-R <region output file>] <fmd input file> <binary output file>\n",
  44                                                                 invoked_as);
  45         fputs("\nMANDATORY ARGUMENTS:\n", stderr);
  46         fprintf(stderr,
  47                 "<fmd input file> may be '%s' to read from standard input\n",
  48                                                 STDIN_FILENAME_SENTINEL);
  49         fputs("<binary output file> must be a regular file\n", stderr);
  50         fputs("\nOPTIONAL SWITCHES:\n", stderr);
  51         fprintf(stderr,
  52                 "-h\tAlso produce a C header defining %s to the FMAP section's flash offset.\n",
  53                                                         HEADER_FMAP_OFFSET);
  54         fprintf(stderr,
  55                 "-R\tAlso produce a text file listing the CBFS regions, comma separated.\n");
  56         fputs("\nOUTPUT:\n", stderr);
  57         fputs("A successful invocation prints a summary of work done to standard error, and a comma-separated list\n",
  58                                                                         stderr);
  59         fputs("of those sections that contain CBFSes, starting with the primary such section, to standard output.\n",
  60                                                                         stderr);
  61 }
  62
  63 static void list_cbfs_section_names(FILE *out)
  64 {
  65         cbfs_section_iterator_t cbfs_it = cbfs_sections_iterator();
  66         assert(cbfs_it);
  67
  68         bool subsequent = false;
  69         while (cbfs_it) {
  70                 const char *cur_name =
  71                                 cbfs_sections_iterator_deref(cbfs_it)->name;
  72                 if (cbfs_sections_iterator_advance(&cbfs_it) && subsequent)
  73                         fputc(',', out);
  74                 fputs(cur_name, out);
  75                 subsequent = true;
  76         }
  77         fputc('\n', out);
  78 }
  79
  80 static void write_header_fmap_terminal_section_names(FILE *header,
  81                                                      const struct flashmap_descriptor *root)
  82 {
  83         assert(root);
  84
  85         if (root->list_len == 0) {
  86                 fprintf(header, "%s ", root->name);
  87                 return;
  88         }
  89
  90         fmd_foreach_child(child, root)
  91                 write_header_fmap_terminal_section_names(header, child);
  92 }
  93
  94 static void write_header_fmap_sections(FILE *header, const struct flashmap_descriptor *root,
  95                                        unsigned int offset)
  96 {
  97         assert(root);
  98         /*
  99          * The offset may only be unknown for the root node in a system where the flash isn't
 100          * memory-mapped.
 101          */
 102         if (!root->offset_known && offset != 0)
 103                 return;
 104
 105         const unsigned int current_offset = offset + (root->offset_known ? root->offset : 0);
 106         fprintf(header, "#define FMAP_SECTION_%s_START %#x\n", root->name, current_offset);
 107
 108         if (!root->size_known)
 109                 return;
 110
 111         fprintf(header, "#define FMAP_SECTION_%s_SIZE %#x\n", root->name, root->size);
 112
 113         fmd_foreach_child(child, root)
 114                 write_header_fmap_sections(header, child, current_offset);
 115 }
 116
 117 static bool write_header(const char *out_fname,
 118                          const struct flashmap_descriptor *root,
 119                          const int fmap_size)
 120 {
 121         assert(out_fname);
 122
 123         FILE *header = fopen(out_fname, "w");
 124         if (!header) {
 125                 fprintf(stderr, "FATAL: Unable to open file '%s' for writing\n",
 126                                 out_fname);
 127                 return false;
 128         }
 129
 130         unsigned fmap_offset =
 131                         fmd_calc_absolute_offset(root, SECTION_NAME_FMAP);
 132         assert(fmap_offset != FMD_NOTFOUND);
 133
 134         fputs("#ifndef FMAPTOOL_GENERATED_HEADER_H_\n", header);
 135         fputs("#define FMAPTOOL_GENERATED_HEADER_H_\n\n", header);
 136         fprintf(header, "#define %s %#x\n", HEADER_FMAP_OFFSET, fmap_offset);
 137         fprintf(header, "#define %s %#x\n\n", HEADER_FMAP_SIZE, fmap_size);
 138
 139         fprintf(header, "#define %s \"", HEADER_FMAP_TERMINAL_SECTIONS);
 140         write_header_fmap_terminal_section_names(header, root);
 141         fprintf(header, "\"\n\n");
 142
 143         write_header_fmap_sections(header, root, 0);
 144         fputs("\n", header);
 145
 146         fputs("#endif\n", header);
 147
 148         fclose(header);
 149         return true;
 150 }
 151
 152 static void full_fmd_cleanup(struct flashmap_descriptor **victim)
 153 {
 154         assert(victim);
 155
 156         cbfs_sections_cleanup();
 157         fmd_cleanup(*victim);
 158         *victim = NULL;
 159 }
 160
 161 int main(int argc, char **argv)
 162 {
 163         struct {
 164                 // Mandatory
 165                 const char *fmd_filename;
 166                 const char *fmap_filename;
 167
 168                 // Optional
 169                 const char *header_filename;
 170                 const char *region_filename;
 171         } args = {NULL, NULL, NULL, NULL};
 172
 173         bool show_usage = false;
 174         int each_arg;
 175         while (!show_usage && (each_arg = getopt(argc, argv, ":h:R:")) != -1) {
 176                 switch (each_arg) {
 177                 case 'h':
 178                         args.header_filename = optarg;
 179                         break;
 180                 case 'R':
 181                         args.region_filename = optarg;
 182                         break;
 183                 case ':':
 184                         fprintf(stderr, "-%c: Expected an accompanying value\n",
 185                                                                         optopt);
 186                         show_usage = true;
 187                         break;
 188                 default:
 189                         fprintf(stderr, "-%c: Unexpected command-line switch\n",
 190                                                                         optopt);
 191                         show_usage = true;
 192                 }
 193         }
 194
 195         if (show_usage || argc - optind != 2) {
 196                 usage(argv[0]);
 197                 return FMAPTOOL_EXIT_BAD_ARGS;
 198         }
 199         args.fmd_filename = argv[optind];
 200         args.fmap_filename = argv[optind + 1];
 201
 202         FILE *fmd_file = stdin;
 203         if (strcmp(args.fmd_filename, STDIN_FILENAME_SENTINEL) != 0) {
 204                 fmd_file = fopen(args.fmd_filename, "r");
 205                 if (!fmd_file) {
 206                         fprintf(stderr, "FATAL: Unable to open file '%s'\n",
 207                                                         args.fmd_filename);
 208                         return FMAPTOOL_EXIT_BAD_INPUT_PATH;
 209                 }
 210         }
 211
 212         struct flashmap_descriptor *descriptor = fmd_create(fmd_file);
 213         fclose(fmd_file);
 214         if (!descriptor) {
 215                 fputs("FATAL: Failed while processing provided descriptor\n",
 216                                                                         stderr);
 217                 full_fmd_cleanup(&descriptor);
 218                 return FMAPTOOL_EXIT_FAILED_DESCRIPTOR;
 219         }
 220
 221         if (!fmd_find_node(descriptor, SECTION_NAME_FMAP)) {
 222                 fprintf(stderr,
 223                         "FATAL: Flashmap descriptor must have an '%s' section\n",
 224                                                         SECTION_NAME_FMAP);
 225                 full_fmd_cleanup(&descriptor);
 226                 return FMAPTOOL_EXIT_MISSING_FMAP_SECTION;
 227         }
 228
 229         if (!cbfs_sections_primary_cbfs_accounted_for()) {
 230                 fprintf(stderr,
 231                         "FATAL: Flashmap descriptor must have a '%s' section that is annotated with '(%s)'\n",
 232                                                 SECTION_NAME_PRIMARY_CBFS,
 233                                                 SECTION_ANNOTATION_CBFS);
 234                 full_fmd_cleanup(&descriptor);
 235                 return FMAPTOOL_EXIT_MISSING_PRIMARY_CBFS;
 236         }
 237
 238         struct fmap *flashmap = fmap_from_fmd(descriptor);
 239         if (!flashmap) {
 240                 fputs("FATAL: Failed while constructing FMAP section\n",
 241                                                                         stderr);
 242                 full_fmd_cleanup(&descriptor);
 243                 return FMAPTOOL_EXIT_FAILED_FMAP_CONVERSION;
 244         }
 245
 246         int size = fmap_size(flashmap);
 247         if (size < 0) {
 248                 fputs("FATAL: Failed to determine FMAP section size\n",
 249                                                                         stderr);
 250                 fmap_destroy(flashmap);
 251                 full_fmd_cleanup(&descriptor);
 252                 return FMAPTOOL_EXIT_UNKNOWN_FMAP_SIZE;
 253         }
 254
 255         FILE *fmap_file = fopen(args.fmap_filename, "wb");
 256         if (!fmap_file) {
 257                 fprintf(stderr, "FATAL: Unable to open file '%s' for writing\n",
 258                                                         args.fmap_filename);
 259                 fmap_destroy(flashmap);
 260                 full_fmd_cleanup(&descriptor);
 261                 return FMAPTOOL_EXIT_BAD_OUTPUT_PATH;
 262         }
 263
 264         if (!fwrite(flashmap, size, 1, fmap_file)) {
 265                 fputs("FATAL: Failed to write final FMAP to file\n", stderr);
 266                 fclose(fmap_file);
 267                 fmap_destroy(flashmap);
 268                 full_fmd_cleanup(&descriptor);
 269                 return FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT;
 270         }
 271         fclose(fmap_file);
 272         fmap_destroy(flashmap);
 273
 274         if (args.header_filename &&
 275                         !write_header(args.header_filename, descriptor, size)) {
 276                 full_fmd_cleanup(&descriptor);
 277                 return FMAPTOOL_EXIT_FAILED_WRITING_HEADER;
 278         }
 279
 280         fprintf(stderr, "SUCCESS: Wrote %d bytes to file '%s'%s\n", size,
 281                                                         args.fmap_filename,
 282                         args.header_filename ? " (and generated header)" : "");
 283         fputs("The sections containing CBFSes are: ", stderr);
 284         list_cbfs_section_names(stdout);
 285         if (args.region_filename) {
 286                 FILE *region_file = fopen(args.region_filename, "w");
 287                 if (region_file == NULL)
 288                         return FMAPTOOL_EXIT_FAILED_WRITING_OUTPUT;
 289
 290                 list_cbfs_section_names(region_file);
 291                 fclose(region_file);
 292         }
 293
 294         full_fmd_cleanup(&descriptor);
 295         return FMAPTOOL_EXIT_SUCCESS;
 296 }