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: stable/12/usr.bin/dtc/dtc.cc 358205 2020-02-21 04:34:54Z kevans $
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 <string.h>
42 #include <time.h>
43 #include <unistd.h>
44
45
46 #include "fdt.hh"
47 #include "checking.hh"
48 #include "util.hh"
49
50 using namespace dtc;
51 using std::string;
52
53 namespace {
54
55 /**
56 * The current major version of the tool.
57 */
58 int version_major = 0;
59 int version_major_compatible = 1;
60 /**
61 * The current minor version of the tool.
62 */
63 int version_minor = 5;
64 int version_minor_compatible = 4;
65 /**
66 * The current patch level of the tool.
67 */
68 int version_patch = 0;
69 int version_patch_compatible = 7;
70
usage(const string & argv0)71 void usage(const string &argv0)
72 {
73 fprintf(stderr, "Usage:\n"
74 "\t%s\t[-fhsv@] [-b boot_cpu_id] [-d dependency_file]"
75 "[-E [no-]checker_name]\n"
76 "\t\t[-H phandle_format] [-I input_format]"
77 "[-O output_format]\n"
78 "\t\t[-o output_file] [-R entries] [-S bytes] [-p bytes]"
79 "[-V blob_version]\n"
80 "\t\t-W [no-]checker_name] input_file\n", basename(argv0).c_str());
81 }
82
83 /**
84 * Prints the current version of this program..
85 */
version(const char * progname)86 void version(const char* progname)
87 {
88 fprintf(stdout, "Version: %s %d.%d.%d compatible with gpl dtc %d.%d.%d\n", progname,
89 version_major, version_minor, version_patch,
90 version_major_compatible, version_minor_compatible,
91 version_patch_compatible);
92 }
93
94 } // Anonymous namespace
95
96 using fdt::device_tree;
97 using fdt::tree_write_fn_ptr;
98 using fdt::tree_read_fn_ptr;
99
100 int
main(int argc,char ** argv)101 main(int argc, char **argv)
102 {
103 int ch;
104 int outfile = fileno(stdout);
105 const char *outfile_name = "-";
106 const char *in_file = "-";
107 FILE *depfile = 0;
108 bool debug_mode = false;
109 tree_write_fn_ptr write_fn = nullptr;
110 tree_read_fn_ptr read_fn = nullptr;
111 uint32_t boot_cpu = 0;
112 bool boot_cpu_specified = false;
113 bool keep_going = false;
114 bool sort = false;
115 clock_t c0 = clock();
116 class device_tree tree;
117 fdt::checking::check_manager checks;
118 const char *options = "@hqI:O:o:V:d:R:S:p:b:fi:svH:W:E:DP:";
119
120 // Don't forget to update the man page if any more options are added.
121 while ((ch = getopt(argc, argv, options)) != -1)
122 {
123 switch (ch)
124 {
125 case 'h':
126 usage(argv[0]);
127 return EXIT_SUCCESS;
128 case 'v':
129 version(argv[0]);
130 return EXIT_SUCCESS;
131 case '@':
132 tree.write_symbols = true;
133 break;
134 case 'I':
135 {
136 string arg(optarg);
137 if (arg == "dtb")
138 {
139 read_fn = &device_tree::parse_dtb;
140 if (write_fn == nullptr)
141 {
142 write_fn = &device_tree::write_dts;
143 }
144 }
145 else if (arg == "dts")
146 {
147 read_fn = &device_tree::parse_dts;
148 }
149 else
150 {
151 fprintf(stderr, "Unknown input format: %s\n", optarg);
152 return EXIT_FAILURE;
153 }
154 break;
155 }
156 case 'O':
157 {
158 string arg(optarg);
159 if (arg == "dtb")
160 {
161 write_fn = &device_tree::write_binary;
162 }
163 else if (arg == "asm")
164 {
165 write_fn = &device_tree::write_asm;
166 }
167 else if (arg == "dts")
168 {
169 write_fn = &device_tree::write_dts;
170 if (read_fn == nullptr)
171 {
172 read_fn = &device_tree::parse_dtb;
173 }
174 }
175 else
176 {
177 fprintf(stderr, "Unknown output format: %s\n", optarg);
178 return EXIT_FAILURE;
179 }
180 break;
181 }
182 case 'o':
183 {
184 outfile_name = optarg;
185 if (strcmp(outfile_name, "-") != 0)
186 {
187 outfile = open(optarg, O_CREAT | O_TRUNC | O_WRONLY, 0666);
188 if (outfile == -1)
189 {
190 perror("Unable to open output file");
191 return EXIT_FAILURE;
192 }
193 }
194 break;
195 }
196 case 'D':
197 debug_mode = true;
198 break;
199 case 'V':
200 if (string(optarg) != "17")
201 {
202 fprintf(stderr, "Unknown output format version: %s\n", optarg);
203 return EXIT_FAILURE;
204 }
205 break;
206 case 'd':
207 {
208 if (depfile != 0)
209 {
210 fclose(depfile);
211 }
212 if (string(optarg) == "-")
213 {
214 depfile = stdout;
215 }
216 else
217 {
218 depfile = fdopen(open(optarg, O_CREAT | O_TRUNC | O_WRONLY, 0666), "w");
219 if (depfile == 0)
220 {
221 perror("Unable to open dependency file");
222 return EXIT_FAILURE;
223 }
224 }
225 break;
226 }
227 case 'H':
228 {
229 string arg(optarg);
230 if (arg == "both")
231 {
232 tree.set_phandle_format(device_tree::BOTH);
233 }
234 else if (arg == "epapr")
235 {
236 tree.set_phandle_format(device_tree::EPAPR);
237 }
238 else if (arg == "linux")
239 {
240 tree.set_phandle_format(device_tree::LINUX);
241 }
242 else
243 {
244 fprintf(stderr, "Unknown phandle format: %s\n", optarg);
245 return EXIT_FAILURE;
246 }
247 break;
248 }
249 case 'b':
250 // Don't bother to check if strtoll fails, just
251 // use the 0 it returns.
252 boot_cpu = (uint32_t)strtoll(optarg, 0, 10);
253 boot_cpu_specified = true;
254 break;
255 case 'f':
256 keep_going = true;
257 break;
258 case 'W':
259 case 'E':
260 {
261 string arg(optarg);
262 if ((arg.size() > 3) && (strncmp(optarg, "no-", 3) == 0))
263 {
264 arg = string(optarg+3);
265 if (!checks.disable_checker(arg))
266 {
267 fprintf(stderr, "Checker %s either does not exist or is already disabled\n", optarg+3);
268 }
269 break;
270 }
271 if (!checks.enable_checker(arg))
272 {
273 fprintf(stderr, "Checker %s either does not exist or is already enabled\n", optarg);
274 }
275 break;
276 }
277 case 's':
278 {
279 sort = true;
280 break;
281 }
282 case 'i':
283 {
284 tree.add_include_path(optarg);
285 break;
286 }
287 // Should quiet warnings, but for now is silently ignored.
288 case 'q':
289 break;
290 case 'R':
291 tree.set_empty_reserve_map_entries(strtoll(optarg, 0, 10));
292 break;
293 case 'S':
294 tree.set_blob_minimum_size(strtoll(optarg, 0, 10));
295 break;
296 case 'p':
297 tree.set_blob_padding(strtoll(optarg, 0, 10));
298 break;
299 case 'P':
300 if (!tree.parse_define(optarg))
301 {
302 fprintf(stderr, "Invalid predefine value %s\n",
303 optarg);
304 }
305 break;
306 default:
307 fprintf(stderr, "Unknown option %c\n", ch);
308 return EXIT_FAILURE;
309 }
310 }
311 if (read_fn == nullptr)
312 {
313 read_fn = &device_tree::parse_dts;
314 }
315 if (write_fn == nullptr)
316 {
317 write_fn = &device_tree::write_binary;
318 }
319 if (optind < argc)
320 {
321 in_file = argv[optind];
322 }
323 if (depfile != 0)
324 {
325 fputs(outfile_name, depfile);
326 fputs(": ", depfile);
327 fputs(in_file, depfile);
328 }
329 clock_t c1 = clock();
330 (tree.*read_fn)(in_file, depfile);
331 // Override the boot CPU found in the header, if we're loading from dtb
332 if (boot_cpu_specified)
333 {
334 tree.set_boot_cpu(boot_cpu);
335 }
336 if (sort)
337 {
338 tree.sort();
339 }
340 if (depfile != 0)
341 {
342 putc('\n', depfile);
343 fclose(depfile);
344 }
345 if (!(tree.is_valid() || keep_going))
346 {
347 fprintf(stderr, "Failed to parse tree.\n");
348 return EXIT_FAILURE;
349 }
350 clock_t c2 = clock();
351 if (!(checks.run_checks(&tree, true) || keep_going))
352 {
353 return EXIT_FAILURE;
354 }
355 clock_t c3 = clock();
356 (tree.*write_fn)(outfile);
357 close(outfile);
358 clock_t c4 = clock();
359
360 if (debug_mode)
361 {
362 struct rusage r;
363
364 getrusage(RUSAGE_SELF, &r);
365 fprintf(stderr, "Peak memory usage: %ld bytes\n", r.ru_maxrss);
366 fprintf(stderr, "Setup and option parsing took %f seconds\n",
367 ((double)(c1-c0))/CLOCKS_PER_SEC);
368 fprintf(stderr, "Parsing took %f seconds\n",
369 ((double)(c2-c1))/CLOCKS_PER_SEC);
370 fprintf(stderr, "Checking took %f seconds\n",
371 ((double)(c3-c2))/CLOCKS_PER_SEC);
372 fprintf(stderr, "Generating output took %f seconds\n",
373 ((double)(c4-c3))/CLOCKS_PER_SEC);
374 fprintf(stderr, "Total time: %f seconds\n",
375 ((double)(c4-c0))/CLOCKS_PER_SEC);
376 // This is not needed, but keeps valgrind quiet.
377 fclose(stdin);
378 }
379 return EXIT_SUCCESS;
380 }
381
382