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