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