1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2013 David Chisnall 5 * All rights reserved. 6 * 7 * This software was developed by SRI International and the University of 8 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) 9 * ("CTSRD"), as part of the DARPA CRASH research programme. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD$ 33 */ 34 35 #include <sys/resource.h> 36 #include <fcntl.h> 37 #include <libgen.h> 38 #include <limits.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <time.h> 42 #include <unistd.h> 43 44 45 #include "fdt.hh" 46 #include "checking.hh" 47 #include "util.hh" 48 49 using namespace dtc; 50 using std::string; 51 52 /** 53 * The current major version of the tool. 54 */ 55 int version_major = 0; 56 int version_major_compatible = 1; 57 /** 58 * The current minor version of the tool. 59 */ 60 int version_minor = 5; 61 int version_minor_compatible = 4; 62 /** 63 * The current patch level of the tool. 64 */ 65 int version_patch = 0; 66 int version_patch_compatible = 0; 67 68 static void usage(const string &argv0) 69 { 70 fprintf(stderr, "Usage:\n" 71 "\t%s\t[-fhsv@] [-b boot_cpu_id] [-d dependency_file]" 72 "[-E [no-]checker_name]\n" 73 "\t\t[-H phandle_format] [-I input_format]" 74 "[-O output_format]\n" 75 "\t\t[-o output_file] [-R entries] [-S bytes] [-p bytes]" 76 "[-V blob_version]\n" 77 "\t\t-W [no-]checker_name] input_file\n", basename(argv0).c_str()); 78 } 79 80 /** 81 * Prints the current version of this program.. 82 */ 83 static void version(const char* progname) 84 { 85 fprintf(stdout, "Version: %s %d.%d.%d compatible with gpl dtc %d.%d.%d\n", progname, 86 version_major, version_minor, version_patch, 87 version_major_compatible, version_minor_compatible, 88 version_patch_compatible); 89 } 90 91 using fdt::device_tree; 92 93 int 94 main(int argc, char **argv) 95 { 96 int ch; 97 int outfile = fileno(stdout); 98 const char *outfile_name = "-"; 99 const char *in_file = "-"; 100 FILE *depfile = 0; 101 bool debug_mode = false; 102 auto write_fn = &device_tree::write_binary; 103 auto read_fn = &device_tree::parse_dts; 104 uint32_t boot_cpu; 105 bool boot_cpu_specified = false; 106 bool keep_going = false; 107 bool sort = false; 108 clock_t c0 = clock(); 109 class device_tree tree; 110 fdt::checking::check_manager checks; 111 const char *options = "@hqI:O:o:V:d:R:S:p:b:fi:svH:W:E:DP:"; 112 113 // Don't forget to update the man page if any more options are added. 114 while ((ch = getopt(argc, argv, options)) != -1) 115 { 116 switch (ch) 117 { 118 case 'h': 119 usage(argv[0]); 120 return EXIT_SUCCESS; 121 case 'v': 122 version(argv[0]); 123 return EXIT_SUCCESS; 124 case '@': 125 tree.write_symbols = true; 126 break; 127 case 'I': 128 { 129 string arg(optarg); 130 if (arg == "dtb") 131 { 132 read_fn = &device_tree::parse_dtb; 133 } 134 else if (arg == "dts") 135 { 136 read_fn = &device_tree::parse_dts; 137 } 138 else 139 { 140 fprintf(stderr, "Unknown input format: %s\n", optarg); 141 return EXIT_FAILURE; 142 } 143 break; 144 } 145 case 'O': 146 { 147 string arg(optarg); 148 if (arg == "dtb") 149 { 150 write_fn = &device_tree::write_binary; 151 } 152 else if (arg == "asm") 153 { 154 write_fn = &device_tree::write_asm; 155 } 156 else if (arg == "dts") 157 { 158 write_fn = &device_tree::write_dts; 159 } 160 else 161 { 162 fprintf(stderr, "Unknown output format: %s\n", optarg); 163 return EXIT_FAILURE; 164 } 165 break; 166 } 167 case 'o': 168 { 169 outfile_name = optarg; 170 outfile = open(optarg, O_CREAT | O_TRUNC | O_WRONLY, 0666); 171 if (outfile == -1) 172 { 173 perror("Unable to open output file"); 174 return EXIT_FAILURE; 175 } 176 break; 177 } 178 case 'D': 179 debug_mode = true; 180 break; 181 case 'V': 182 if (string(optarg) != "17") 183 { 184 fprintf(stderr, "Unknown output format version: %s\n", optarg); 185 return EXIT_FAILURE; 186 } 187 break; 188 case 'd': 189 { 190 if (depfile != 0) 191 { 192 fclose(depfile); 193 } 194 if (string(optarg) == "-") 195 { 196 depfile = stdout; 197 } 198 else 199 { 200 depfile = fdopen(open(optarg, O_CREAT | O_TRUNC | O_WRONLY, 0666), "w"); 201 if (depfile == 0) 202 { 203 perror("Unable to open dependency file"); 204 return EXIT_FAILURE; 205 } 206 } 207 break; 208 } 209 case 'H': 210 { 211 string arg(optarg); 212 if (arg == "both") 213 { 214 tree.set_phandle_format(device_tree::BOTH); 215 } 216 else if (arg == "epapr") 217 { 218 tree.set_phandle_format(device_tree::EPAPR); 219 } 220 else if (arg == "linux") 221 { 222 tree.set_phandle_format(device_tree::LINUX); 223 } 224 else 225 { 226 fprintf(stderr, "Unknown phandle format: %s\n", optarg); 227 return EXIT_FAILURE; 228 } 229 break; 230 } 231 case 'b': 232 // Don't bother to check if strtoll fails, just 233 // use the 0 it returns. 234 boot_cpu = (uint32_t)strtoll(optarg, 0, 10); 235 boot_cpu_specified = true; 236 break; 237 case 'f': 238 keep_going = true; 239 break; 240 case 'W': 241 case 'E': 242 { 243 string arg(optarg); 244 if ((arg.size() > 3) && (strncmp(optarg, "no-", 3) == 0)) 245 { 246 arg = string(optarg+3); 247 if (!checks.disable_checker(arg)) 248 { 249 fprintf(stderr, "Checker %s either does not exist or is already disabled\n", optarg+3); 250 } 251 break; 252 } 253 if (!checks.enable_checker(arg)) 254 { 255 fprintf(stderr, "Checker %s either does not exist or is already enabled\n", optarg); 256 } 257 break; 258 } 259 case 's': 260 { 261 sort = true; 262 break; 263 } 264 case 'i': 265 { 266 tree.add_include_path(optarg); 267 break; 268 } 269 // Should quiet warnings, but for now is silently ignored. 270 case 'q': 271 break; 272 case 'R': 273 tree.set_empty_reserve_map_entries(strtoll(optarg, 0, 10)); 274 break; 275 case 'S': 276 tree.set_blob_minimum_size(strtoll(optarg, 0, 10)); 277 break; 278 case 'p': 279 tree.set_blob_padding(strtoll(optarg, 0, 10)); 280 break; 281 case 'P': 282 if (!tree.parse_define(optarg)) 283 { 284 fprintf(stderr, "Invalid predefine value %s\n", 285 optarg); 286 } 287 break; 288 default: 289 fprintf(stderr, "Unknown option %c\n", ch); 290 return EXIT_FAILURE; 291 } 292 } 293 if (optind < argc) 294 { 295 in_file = argv[optind]; 296 } 297 if (depfile != 0) 298 { 299 fputs(outfile_name, depfile); 300 fputs(": ", depfile); 301 fputs(in_file, depfile); 302 } 303 clock_t c1 = clock(); 304 (tree.*read_fn)(in_file, depfile); 305 // Override the boot CPU found in the header, if we're loading from dtb 306 if (boot_cpu_specified) 307 { 308 tree.set_boot_cpu(boot_cpu); 309 } 310 if (sort) 311 { 312 tree.sort(); 313 } 314 if (depfile != 0) 315 { 316 putc('\n', depfile); 317 fclose(depfile); 318 } 319 if (!(tree.is_valid() || keep_going)) 320 { 321 fprintf(stderr, "Failed to parse tree.\n"); 322 return EXIT_FAILURE; 323 } 324 clock_t c2 = clock(); 325 if (!(checks.run_checks(&tree, true) || keep_going)) 326 { 327 return EXIT_FAILURE; 328 } 329 clock_t c3 = clock(); 330 (tree.*write_fn)(outfile); 331 close(outfile); 332 clock_t c4 = clock(); 333 334 if (debug_mode) 335 { 336 struct rusage r; 337 338 getrusage(RUSAGE_SELF, &r); 339 fprintf(stderr, "Peak memory usage: %ld bytes\n", r.ru_maxrss); 340 fprintf(stderr, "Setup and option parsing took %f seconds\n", 341 ((double)(c1-c0))/CLOCKS_PER_SEC); 342 fprintf(stderr, "Parsing took %f seconds\n", 343 ((double)(c2-c1))/CLOCKS_PER_SEC); 344 fprintf(stderr, "Checking took %f seconds\n", 345 ((double)(c3-c2))/CLOCKS_PER_SEC); 346 fprintf(stderr, "Generating output took %f seconds\n", 347 ((double)(c4-c3))/CLOCKS_PER_SEC); 348 fprintf(stderr, "Total time: %f seconds\n", 349 ((double)(c4-c0))/CLOCKS_PER_SEC); 350 // This is not needed, but keeps valgrind quiet. 351 fclose(stdin); 352 } 353 return EXIT_SUCCESS; 354 } 355 356