xref: /openbmc/u-boot/tools/fdtgrep.c (revision a7f480d9)
1 /*
2  * Copyright (c) 2013, Google Inc.
3  * Written by Simon Glass <sjg@chromium.org>
4  *
5  * SPDX-License-Identifier:	GPL-2.0+
6  *
7  * Perform a grep of an FDT either displaying the source subset or producing
8  * a new .dtb subset which can be used as required.
9  */
10 
11 #include <assert.h>
12 #include <ctype.h>
13 #include <getopt.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <unistd.h>
18 
19 #include <../include/libfdt.h>
20 #include <libfdt_internal.h>
21 
22 /* Define DEBUG to get some debugging output on stderr */
23 #ifdef DEBUG
24 #define debug(a, b...) fprintf(stderr, a, ## b)
25 #else
26 #define debug(a, b...)
27 #endif
28 
29 /* A linked list of values we are grepping for */
30 struct value_node {
31 	int type;		/* Types this value matches (FDT_IS... mask) */
32 	int include;		/* 1 to include matches, 0 to exclude */
33 	const char *string;	/* String to match */
34 	struct value_node *next;	/* Pointer to next node, or NULL */
35 };
36 
37 /* Output formats we support */
38 enum output_t {
39 	OUT_DTS,		/* Device tree source */
40 	OUT_DTB,		/* Valid device tree binary */
41 	OUT_BIN,		/* Fragment of .dtb, for hashing */
42 };
43 
44 /* Holds information which controls our output and options */
45 struct display_info {
46 	enum output_t output;	/* Output format */
47 	int add_aliases;	/* Add aliases node to output */
48 	int all;		/* Display all properties/nodes */
49 	int colour;		/* Display output in ANSI colour */
50 	int region_list;	/* Output a region list */
51 	int flags;		/* Flags (FDT_REG_...) */
52 	int list_strings;	/* List strings in string table */
53 	int show_offset;	/* Show offset */
54 	int show_addr;		/* Show address */
55 	int header;		/* Output an FDT header */
56 	int diff;		/* Show +/- diff markers */
57 	int include_root;	/* Include the root node and all properties */
58 	int remove_strings;	/* Remove unused strings */
59 	int show_dts_version;	/* Put '/dts-v1/;' on the first line */
60 	int types_inc;		/* Mask of types that we include (FDT_IS...) */
61 	int types_exc;		/* Mask of types that we exclude (FDT_IS...) */
62 	int invert;		/* Invert polarity of match */
63 	struct value_node *value_head;	/* List of values to match */
64 	const char *output_fname;	/* Output filename */
65 	FILE *fout;		/* File to write dts/dtb output */
66 };
67 
68 static void report_error(const char *where, int err)
69 {
70 	fprintf(stderr, "Error at '%s': %s\n", where, fdt_strerror(err));
71 }
72 
73 /* Supported ANSI colours */
74 enum {
75 	COL_BLACK,
76 	COL_RED,
77 	COL_GREEN,
78 	COL_YELLOW,
79 	COL_BLUE,
80 	COL_MAGENTA,
81 	COL_CYAN,
82 	COL_WHITE,
83 
84 	COL_NONE = -1,
85 };
86 
87 /**
88  * print_ansi_colour() - Print out the ANSI sequence for a colour
89  *
90  * @fout:	Output file
91  * @col:	Colour to output (COL_...), or COL_NONE to reset colour
92  */
93 static void print_ansi_colour(FILE *fout, int col)
94 {
95 	if (col == COL_NONE)
96 		fprintf(fout, "\033[0m");
97 	else
98 		fprintf(fout, "\033[1;%dm", col + 30);
99 }
100 
101 
102 /**
103  * value_add() - Add a new value to our list of things to grep for
104  *
105  * @disp:	Display structure, holding info about our options
106  * @headp:	Pointer to header pointer of list
107  * @type:	Type of this value (FDT_IS_...)
108  * @include:	1 if we want to include matches, 0 to exclude
109  * @str:	String value to match
110  */
111 static int value_add(struct display_info *disp, struct value_node **headp,
112 		     int type, int include, const char *str)
113 {
114 	struct value_node *node;
115 
116 	/*
117 	 * Keep track of which types we are excluding/including. We don't
118 	 * allow both including and excluding things, because it doesn't make
119 	 * sense. 'Including' means that everything not mentioned is
120 	 * excluded. 'Excluding' means that everything not mentioned is
121 	 * included. So using the two together would be meaningless.
122 	 */
123 	if (include)
124 		disp->types_inc |= type;
125 	else
126 		disp->types_exc |= type;
127 	if (disp->types_inc & disp->types_exc & type) {
128 		fprintf(stderr,
129 			"Cannot use both include and exclude for '%s'\n", str);
130 		return -1;
131 	}
132 
133 	str = strdup(str);
134 	node = malloc(sizeof(*node));
135 	if (!str || !node) {
136 		fprintf(stderr, "Out of memory\n");
137 		return -1;
138 	}
139 	node->next = *headp;
140 	node->type = type;
141 	node->include = include;
142 	node->string = str;
143 	*headp = node;
144 
145 	return 0;
146 }
147 
148 static bool util_is_printable_string(const void *data, int len)
149 {
150 	const char *s = data;
151 	const char *ss, *se;
152 
153 	/* zero length is not */
154 	if (len == 0)
155 		return 0;
156 
157 	/* must terminate with zero */
158 	if (s[len - 1] != '\0')
159 		return 0;
160 
161 	se = s + len;
162 
163 	while (s < se) {
164 		ss = s;
165 		while (s < se && *s && isprint((unsigned char)*s))
166 			s++;
167 
168 		/* not zero, or not done yet */
169 		if (*s != '\0' || s == ss)
170 			return 0;
171 
172 		s++;
173 	}
174 
175 	return 1;
176 }
177 
178 static void utilfdt_print_data(const char *data, int len)
179 {
180 	int i;
181 	const char *p = data;
182 	const char *s;
183 
184 	/* no data, don't print */
185 	if (len == 0)
186 		return;
187 
188 	if (util_is_printable_string(data, len)) {
189 		printf(" = ");
190 
191 		s = data;
192 		do {
193 			printf("\"%s\"", s);
194 			s += strlen(s) + 1;
195 			if (s < data + len)
196 				printf(", ");
197 		} while (s < data + len);
198 
199 	} else if ((len % 4) == 0) {
200 		const uint32_t *cell = (const uint32_t *)data;
201 
202 		printf(" = <");
203 		for (i = 0, len /= 4; i < len; i++)
204 			printf("0x%08x%s", fdt32_to_cpu(cell[i]),
205 			       i < (len - 1) ? " " : "");
206 		printf(">");
207 	} else {
208 		printf(" = [");
209 		for (i = 0; i < len; i++)
210 			printf("%02x%s", *p++, i < len - 1 ? " " : "");
211 		printf("]");
212 	}
213 }
214 
215 /**
216  * display_fdt_by_regions() - Display regions of an FDT source
217  *
218  * This dumps an FDT as source, but only certain regions of it. This is the
219  * final stage of the grep - we have a list of regions we want to display,
220  * and this function displays them.
221  *
222  * @disp:	Display structure, holding info about our options
223  * @blob:	FDT blob to display
224  * @region:	List of regions to display
225  * @count:	Number of regions
226  */
227 static int display_fdt_by_regions(struct display_info *disp, const void *blob,
228 		struct fdt_region region[], int count)
229 {
230 	struct fdt_region *reg = region, *reg_end = region + count;
231 	uint32_t off_mem_rsvmap = fdt_off_mem_rsvmap(blob);
232 	int base = fdt_off_dt_struct(blob);
233 	int version = fdt_version(blob);
234 	int offset, nextoffset;
235 	int tag, depth, shift;
236 	FILE *f = disp->fout;
237 	uint64_t addr, size;
238 	int in_region;
239 	int file_ofs;
240 	int i;
241 
242 	if (disp->show_dts_version)
243 		fprintf(f, "/dts-v1/;\n");
244 
245 	if (disp->header) {
246 		fprintf(f, "// magic:\t\t0x%x\n", fdt_magic(blob));
247 		fprintf(f, "// totalsize:\t\t0x%x (%d)\n", fdt_totalsize(blob),
248 			fdt_totalsize(blob));
249 		fprintf(f, "// off_dt_struct:\t0x%x\n",
250 			fdt_off_dt_struct(blob));
251 		fprintf(f, "// off_dt_strings:\t0x%x\n",
252 			fdt_off_dt_strings(blob));
253 		fprintf(f, "// off_mem_rsvmap:\t0x%x\n", off_mem_rsvmap);
254 		fprintf(f, "// version:\t\t%d\n", version);
255 		fprintf(f, "// last_comp_version:\t%d\n",
256 			fdt_last_comp_version(blob));
257 		if (version >= 2) {
258 			fprintf(f, "// boot_cpuid_phys:\t0x%x\n",
259 				fdt_boot_cpuid_phys(blob));
260 		}
261 		if (version >= 3) {
262 			fprintf(f, "// size_dt_strings:\t0x%x\n",
263 				fdt_size_dt_strings(blob));
264 		}
265 		if (version >= 17) {
266 			fprintf(f, "// size_dt_struct:\t0x%x\n",
267 				fdt_size_dt_struct(blob));
268 		}
269 		fprintf(f, "\n");
270 	}
271 
272 	if (disp->flags & FDT_REG_ADD_MEM_RSVMAP) {
273 		const struct fdt_reserve_entry *p_rsvmap;
274 
275 		p_rsvmap = (const struct fdt_reserve_entry *)
276 				((const char *)blob + off_mem_rsvmap);
277 		for (i = 0; ; i++) {
278 			addr = fdt64_to_cpu(p_rsvmap[i].address);
279 			size = fdt64_to_cpu(p_rsvmap[i].size);
280 			if (addr == 0 && size == 0)
281 				break;
282 
283 			fprintf(f, "/memreserve/ %llx %llx;\n",
284 				(unsigned long long)addr,
285 				(unsigned long long)size);
286 		}
287 	}
288 
289 	depth = 0;
290 	nextoffset = 0;
291 	shift = 4;	/* 4 spaces per indent */
292 	do {
293 		const struct fdt_property *prop;
294 		const char *name;
295 		int show;
296 		int len;
297 
298 		offset = nextoffset;
299 
300 		/*
301 		 * Work out the file offset of this offset, and decide
302 		 * whether it is in the region list or not
303 		 */
304 		file_ofs = base + offset;
305 		if (reg < reg_end && file_ofs >= reg->offset + reg->size)
306 			reg++;
307 		in_region = reg < reg_end && file_ofs >= reg->offset &&
308 				file_ofs < reg->offset + reg->size;
309 		tag = fdt_next_tag(blob, offset, &nextoffset);
310 
311 		if (tag == FDT_END)
312 			break;
313 		show = in_region || disp->all;
314 		if (show && disp->diff)
315 			fprintf(f, "%c", in_region ? '+' : '-');
316 
317 		if (!show) {
318 			/* Do this here to avoid 'if (show)' in every 'case' */
319 			if (tag == FDT_BEGIN_NODE)
320 				depth++;
321 			else if (tag == FDT_END_NODE)
322 				depth--;
323 			continue;
324 		}
325 		if (tag != FDT_END) {
326 			if (disp->show_addr)
327 				fprintf(f, "%4x: ", file_ofs);
328 			if (disp->show_offset)
329 				fprintf(f, "%4x: ", file_ofs - base);
330 		}
331 
332 		/* Green means included, red means excluded */
333 		if (disp->colour)
334 			print_ansi_colour(f, in_region ? COL_GREEN : COL_RED);
335 
336 		switch (tag) {
337 		case FDT_PROP:
338 			prop = fdt_get_property_by_offset(blob, offset, NULL);
339 			name = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
340 			fprintf(f, "%*s%s", depth * shift, "", name);
341 			utilfdt_print_data(prop->data,
342 					   fdt32_to_cpu(prop->len));
343 			fprintf(f, ";");
344 			break;
345 
346 		case FDT_NOP:
347 			fprintf(f, "%*s// [NOP]", depth * shift, "");
348 			break;
349 
350 		case FDT_BEGIN_NODE:
351 			name = fdt_get_name(blob, offset, &len);
352 			fprintf(f, "%*s%s {", depth++ * shift, "",
353 				*name ? name : "/");
354 			break;
355 
356 		case FDT_END_NODE:
357 			fprintf(f, "%*s};", --depth * shift, "");
358 			break;
359 		}
360 
361 		/* Reset colour back to normal before end of line */
362 		if (disp->colour)
363 			print_ansi_colour(f, COL_NONE);
364 		fprintf(f, "\n");
365 	} while (1);
366 
367 	/* Print a list of strings if requested */
368 	if (disp->list_strings) {
369 		const char *str;
370 		int str_base = fdt_off_dt_strings(blob);
371 
372 		for (offset = 0; offset < fdt_size_dt_strings(blob);
373 				offset += strlen(str) + 1) {
374 			str = fdt_string(blob, offset);
375 			int len = strlen(str) + 1;
376 			int show;
377 
378 			/* Only print strings that are in the region */
379 			file_ofs = str_base + offset;
380 			in_region = reg < reg_end &&
381 					file_ofs >= reg->offset &&
382 					file_ofs + len < reg->offset +
383 						reg->size;
384 			show = in_region || disp->all;
385 			if (show && disp->diff)
386 				printf("%c", in_region ? '+' : '-');
387 			if (disp->show_addr)
388 				printf("%4x: ", file_ofs);
389 			if (disp->show_offset)
390 				printf("%4x: ", offset);
391 			printf("%s\n", str);
392 		}
393 	}
394 
395 	return 0;
396 }
397 
398 /**
399  * dump_fdt_regions() - Dump regions of an FDT as binary data
400  *
401  * This dumps an FDT as binary, but only certain regions of it. This is the
402  * final stage of the grep - we have a list of regions we want to dump,
403  * and this function dumps them.
404  *
405  * The output of this function may or may not be a valid FDT. To ensure it
406  * is, these disp->flags must be set:
407  *
408  *   FDT_REG_SUPERNODES: ensures that subnodes are preceeded by their
409  *		parents. Without this option, fragments of subnode data may be
410  *		output without the supernodes above them. This is useful for
411  *		hashing but cannot produce a valid FDT.
412  *   FDT_REG_ADD_STRING_TAB: Adds a string table to the end of the FDT.
413  *		Without this none of the properties will have names
414  *   FDT_REG_ADD_MEM_RSVMAP: Adds a mem_rsvmap table - an FDT is invalid
415  *		without this.
416  *
417  * @disp:	Display structure, holding info about our options
418  * @blob:	FDT blob to display
419  * @region:	List of regions to display
420  * @count:	Number of regions
421  * @out:	Output destination
422  */
423 static int dump_fdt_regions(struct display_info *disp, const void *blob,
424 		struct fdt_region region[], int count, char *out)
425 {
426 	struct fdt_header *fdt;
427 	int size, struct_start;
428 	int ptr;
429 	int i;
430 
431 	/* Set up a basic header (even if we don't actually write it) */
432 	fdt = (struct fdt_header *)out;
433 	memset(fdt, '\0', sizeof(*fdt));
434 	fdt_set_magic(fdt, FDT_MAGIC);
435 	struct_start = FDT_ALIGN(sizeof(struct fdt_header),
436 					sizeof(struct fdt_reserve_entry));
437 	fdt_set_off_mem_rsvmap(fdt, struct_start);
438 	fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
439 	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
440 
441 	/*
442 	 * Calculate the total size of the regions we are writing out. The
443 	 * first will be the mem_rsvmap if the FDT_REG_ADD_MEM_RSVMAP flag
444 	 * is set. The last will be the string table if FDT_REG_ADD_STRING_TAB
445 	 * is set.
446 	 */
447 	for (i = size = 0; i < count; i++)
448 		size += region[i].size;
449 
450 	/* Bring in the mem_rsvmap section from the old file if requested */
451 	if (count > 0 && (disp->flags & FDT_REG_ADD_MEM_RSVMAP)) {
452 		struct_start += region[0].size;
453 		size -= region[0].size;
454 	}
455 	fdt_set_off_dt_struct(fdt, struct_start);
456 
457 	/* Update the header to have the correct offsets/sizes */
458 	if (count >= 2 && (disp->flags & FDT_REG_ADD_STRING_TAB)) {
459 		int str_size;
460 
461 		str_size = region[count - 1].size;
462 		fdt_set_size_dt_struct(fdt, size - str_size);
463 		fdt_set_off_dt_strings(fdt, struct_start + size - str_size);
464 		fdt_set_size_dt_strings(fdt, str_size);
465 		fdt_set_totalsize(fdt, struct_start + size);
466 	}
467 
468 	/* Write the header if required */
469 	ptr = 0;
470 	if (disp->header) {
471 		ptr = sizeof(*fdt);
472 		while (ptr < fdt_off_mem_rsvmap(fdt))
473 			out[ptr++] = '\0';
474 	}
475 
476 	/* Output all the nodes including any mem_rsvmap/string table */
477 	for (i = 0; i < count; i++) {
478 		struct fdt_region *reg = &region[i];
479 
480 		memcpy(out + ptr, (const char *)blob + reg->offset, reg->size);
481 		ptr += reg->size;
482 	}
483 
484 	return ptr;
485 }
486 
487 /**
488  * show_region_list() - Print out a list of regions
489  *
490  * The list includes the region offset (absolute offset from start of FDT
491  * blob in bytes) and size
492  *
493  * @reg:	List of regions to print
494  * @count:	Number of regions
495  */
496 static void show_region_list(struct fdt_region *reg, int count)
497 {
498 	int i;
499 
500 	printf("Regions: %d\n", count);
501 	for (i = 0; i < count; i++, reg++) {
502 		printf("%d:  %-10x  %-10x\n", i, reg->offset,
503 		       reg->offset + reg->size);
504 	}
505 }
506 
507 static int check_type_include(void *priv, int type, const char *data, int size)
508 {
509 	struct display_info *disp = priv;
510 	struct value_node *val;
511 	int match, none_match = FDT_IS_ANY;
512 
513 	/* If none of our conditions mention this type, we know nothing */
514 	debug("type=%x, data=%s\n", type, data ? data : "(null)");
515 	if (!((disp->types_inc | disp->types_exc) & type)) {
516 		debug("   - not in any condition\n");
517 		return -1;
518 	}
519 
520 	/*
521 	 * Go through the list of conditions. For inclusive conditions, we
522 	 * return 1 at the first match. For exclusive conditions, we must
523 	 * check that there are no matches.
524 	 */
525 	for (val = disp->value_head; val; val = val->next) {
526 		if (!(type & val->type))
527 			continue;
528 		match = fdt_stringlist_contains(data, size, val->string);
529 		debug("      - val->type=%x, str='%s', match=%d\n",
530 		      val->type, val->string, match);
531 		if (match && val->include) {
532 			debug("   - match inc %s\n", val->string);
533 			return 1;
534 		}
535 		if (match)
536 			none_match &= ~val->type;
537 	}
538 
539 	/*
540 	 * If this is an exclusive condition, and nothing matches, then we
541 	 * should return 1.
542 	 */
543 	if ((type & disp->types_exc) && (none_match & type)) {
544 		debug("   - match exc\n");
545 		/*
546 		 * Allow FDT_IS_COMPAT to make the final decision in the
547 		 * case where there is no specific type
548 		 */
549 		if (type == FDT_IS_NODE && disp->types_exc == FDT_ANY_GLOBAL) {
550 			debug("   - supressed exc node\n");
551 			return -1;
552 		}
553 		return 1;
554 	}
555 
556 	/*
557 	 * Allow FDT_IS_COMPAT to make the final decision in the
558 	 * case where there is no specific type (inclusive)
559 	 */
560 	if (type == FDT_IS_NODE && disp->types_inc == FDT_ANY_GLOBAL)
561 		return -1;
562 
563 	debug("   - no match, types_inc=%x, types_exc=%x, none_match=%x\n",
564 	      disp->types_inc, disp->types_exc, none_match);
565 
566 	return 0;
567 }
568 
569 /**
570  * h_include() - Include handler function for fdt_find_regions()
571  *
572  * This function decides whether to include or exclude a node, property or
573  * compatible string. The function is defined by fdt_find_regions().
574  *
575  * The algorithm is documented in the code - disp->invert is 0 for normal
576  * operation, and 1 to invert the sense of all matches.
577  *
578  * See
579  */
580 static int h_include(void *priv, const void *fdt, int offset, int type,
581 		     const char *data, int size)
582 {
583 	struct display_info *disp = priv;
584 	int inc, len;
585 
586 	inc = check_type_include(priv, type, data, size);
587 	if (disp->include_root && type == FDT_IS_PROP && offset == 0 && inc)
588 		return 1;
589 
590 	/*
591 	 * If the node name does not tell us anything, check the
592 	 * compatible string
593 	 */
594 	if (inc == -1 && type == FDT_IS_NODE) {
595 		debug("   - checking compatible2\n");
596 		data = fdt_getprop(fdt, offset, "compatible", &len);
597 		inc = check_type_include(priv, FDT_IS_COMPAT, data, len);
598 	}
599 
600 	/* If we still have no idea, check for properties in the node */
601 	if (inc != 1 && type == FDT_IS_NODE &&
602 	    (disp->types_inc & FDT_NODE_HAS_PROP)) {
603 		debug("   - checking node '%s'\n",
604 		      fdt_get_name(fdt, offset, NULL));
605 		for (offset = fdt_first_property_offset(fdt, offset);
606 		     offset > 0 && inc != 1;
607 		     offset = fdt_next_property_offset(fdt, offset)) {
608 			const struct fdt_property *prop;
609 			const char *str;
610 
611 			prop = fdt_get_property_by_offset(fdt, offset, NULL);
612 			if (!prop)
613 				continue;
614 			str = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
615 			inc = check_type_include(priv, FDT_NODE_HAS_PROP, str,
616 						 strlen(str));
617 		}
618 		if (inc == -1)
619 			inc = 0;
620 	}
621 
622 	switch (inc) {
623 	case 1:
624 		inc = !disp->invert;
625 		break;
626 	case 0:
627 		inc = disp->invert;
628 		break;
629 	}
630 	debug("   - returning %d\n", inc);
631 
632 	return inc;
633 }
634 
635 static int h_cmp_region(const void *v1, const void *v2)
636 {
637 	const struct fdt_region *region1 = v1, *region2 = v2;
638 
639 	return region1->offset - region2->offset;
640 }
641 
642 static int fdtgrep_find_regions(const void *fdt,
643 		int (*include_func)(void *priv, const void *fdt, int offset,
644 				 int type, const char *data, int size),
645 		struct display_info *disp, struct fdt_region *region,
646 		int max_regions, char *path, int path_len, int flags)
647 {
648 	struct fdt_region_state state;
649 	int count;
650 	int ret;
651 
652 	count = 0;
653 	ret = fdt_first_region(fdt, include_func, disp,
654 			&region[count++], path, path_len,
655 			disp->flags, &state);
656 	while (ret == 0) {
657 		ret = fdt_next_region(fdt, include_func, disp,
658 				count < max_regions ? &region[count] : NULL,
659 				path, path_len, disp->flags, &state);
660 		if (!ret)
661 			count++;
662 	}
663 	if (ret && ret != -FDT_ERR_NOTFOUND)
664 		return ret;
665 
666 	/* Find all the aliases and add those regions back in */
667 	if (disp->add_aliases && count < max_regions) {
668 		int new_count;
669 
670 		new_count = fdt_add_alias_regions(fdt, region, count,
671 						  max_regions, &state);
672 		if (new_count == -FDT_ERR_NOTFOUND) {
673 			/* No alias node found */
674 		} else if (new_count < 0) {
675 			return new_count;
676 		} else if (new_count <= max_regions) {
677 			/*
678 			* The alias regions will now be at the end of the list.
679 			* Sort the regions by offset to get things into the
680 			* right order
681 			*/
682 			count = new_count;
683 			qsort(region, count, sizeof(struct fdt_region),
684 			      h_cmp_region);
685 		}
686 	}
687 
688 	return count;
689 }
690 
691 int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len)
692 {
693 	int fd = 0;	/* assume stdin */
694 	char *buf = NULL;
695 	off_t bufsize = 1024, offset = 0;
696 	int ret = 0;
697 
698 	*buffp = NULL;
699 	if (strcmp(filename, "-") != 0) {
700 		fd = open(filename, O_RDONLY);
701 		if (fd < 0)
702 			return errno;
703 	}
704 
705 	/* Loop until we have read everything */
706 	buf = malloc(bufsize);
707 	if (!buf)
708 		return -ENOMEM;
709 	do {
710 		/* Expand the buffer to hold the next chunk */
711 		if (offset == bufsize) {
712 			bufsize *= 2;
713 			buf = realloc(buf, bufsize);
714 			if (!buf)
715 				return -ENOMEM;
716 		}
717 
718 		ret = read(fd, &buf[offset], bufsize - offset);
719 		if (ret < 0) {
720 			ret = errno;
721 			break;
722 		}
723 		offset += ret;
724 	} while (ret != 0);
725 
726 	/* Clean up, including closing stdin; return errno on error */
727 	close(fd);
728 	if (ret)
729 		free(buf);
730 	else
731 		*buffp = buf;
732 	*len = bufsize;
733 	return ret;
734 }
735 
736 int utilfdt_read_err(const char *filename, char **buffp)
737 {
738 	off_t len;
739 	return utilfdt_read_err_len(filename, buffp, &len);
740 }
741 
742 char *utilfdt_read_len(const char *filename, off_t *len)
743 {
744 	char *buff;
745 	int ret = utilfdt_read_err_len(filename, &buff, len);
746 
747 	if (ret) {
748 		fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename,
749 			strerror(ret));
750 		return NULL;
751 	}
752 	/* Successful read */
753 	return buff;
754 }
755 
756 char *utilfdt_read(const char *filename)
757 {
758 	off_t len;
759 	return utilfdt_read_len(filename, &len);
760 }
761 
762 /**
763  * Run the main fdtgrep operation, given a filename and valid arguments
764  *
765  * @param disp		Display information / options
766  * @param filename	Filename of blob file
767  * @param return 0 if ok, -ve on error
768  */
769 static int do_fdtgrep(struct display_info *disp, const char *filename)
770 {
771 	struct fdt_region *region;
772 	int max_regions;
773 	int count = 100;
774 	char path[1024];
775 	char *blob;
776 	int i, ret;
777 
778 	blob = utilfdt_read(filename);
779 	if (!blob)
780 		return -1;
781 	ret = fdt_check_header(blob);
782 	if (ret) {
783 		fprintf(stderr, "Error: %s\n", fdt_strerror(ret));
784 		return ret;
785 	}
786 
787 	/* Allow old files, but they are untested */
788 	if (fdt_version(blob) < 17 && disp->value_head) {
789 		fprintf(stderr,
790 			"Warning: fdtgrep does not fully support version %d files\n",
791 			fdt_version(blob));
792 	}
793 
794 	/*
795 	 * We do two passes, since we don't know how many regions we need.
796 	 * The first pass will count the regions, but if it is too many,
797 	 * we do another pass to actually record them.
798 	 */
799 	for (i = 0; i < 3; i++) {
800 		region = malloc(count * sizeof(struct fdt_region));
801 		if (!region) {
802 			fprintf(stderr, "Out of memory for %d regions\n",
803 				count);
804 			return -1;
805 		}
806 		max_regions = count;
807 		count = fdtgrep_find_regions(blob,
808 				h_include, disp,
809 				region, max_regions, path, sizeof(path),
810 				disp->flags);
811 		if (count < 0) {
812 			report_error("fdt_find_regions", count);
813 			if (count == -FDT_ERR_BADLAYOUT)
814 				fprintf(stderr,
815 					"/aliases node must come before all other nodes\n");
816 			return -1;
817 		}
818 		if (count <= max_regions)
819 			break;
820 		free(region);
821 	}
822 
823 	/* Optionally print a list of regions */
824 	if (disp->region_list)
825 		show_region_list(region, count);
826 
827 	/* Output either source .dts or binary .dtb */
828 	if (disp->output == OUT_DTS) {
829 		ret = display_fdt_by_regions(disp, blob, region, count);
830 	} else {
831 		void *fdt;
832 		/* Allow reserved memory section to expand slightly */
833 		int size = fdt_totalsize(blob) + 16;
834 
835 		fdt = malloc(size);
836 		if (!fdt) {
837 			fprintf(stderr, "Out_of_memory\n");
838 			ret = -1;
839 			goto err;
840 		}
841 		size = dump_fdt_regions(disp, blob, region, count, fdt);
842 		if (disp->remove_strings) {
843 			void *out;
844 
845 			out = malloc(size);
846 			if (!out) {
847 				fprintf(stderr, "Out_of_memory\n");
848 				ret = -1;
849 				goto err;
850 			}
851 			ret = fdt_remove_unused_strings(fdt, out);
852 			if (ret < 0) {
853 				fprintf(stderr,
854 					"Failed to remove unused strings: err=%d\n",
855 					ret);
856 				goto err;
857 			}
858 			free(fdt);
859 			fdt = out;
860 			ret = fdt_pack(fdt);
861 			if (ret < 0) {
862 				fprintf(stderr, "Failed to pack: err=%d\n",
863 					ret);
864 				goto err;
865 			}
866 			size = fdt_totalsize(fdt);
867 		}
868 
869 		if (size != fwrite(fdt, 1, size, disp->fout)) {
870 			fprintf(stderr, "Write failure, %d bytes\n", size);
871 			free(fdt);
872 			ret = 1;
873 			goto err;
874 		}
875 		free(fdt);
876 	}
877 err:
878 	free(blob);
879 	free(region);
880 
881 	return ret;
882 }
883 
884 static const char usage_synopsis[] =
885 	"fdtgrep - extract portions from device tree\n"
886 	"\n"
887 	"Usage:\n"
888 	"	fdtgrep <options> <dt file>|-\n\n"
889 	"Output formats are:\n"
890 	"\tdts - device tree soure text\n"
891 	"\tdtb - device tree blob (sets -Hmt automatically)\n"
892 	"\tbin - device tree fragment (may not be a valid .dtb)";
893 
894 /* Helper for usage_short_opts string constant */
895 #define USAGE_COMMON_SHORT_OPTS "hV"
896 
897 /* Helper for aligning long_opts array */
898 #define a_argument required_argument
899 
900 /* Helper for usage_long_opts option array */
901 #define USAGE_COMMON_LONG_OPTS \
902 	{"help",      no_argument, NULL, 'h'}, \
903 	{"version",   no_argument, NULL, 'V'}, \
904 	{NULL,        no_argument, NULL, 0x0}
905 
906 /* Helper for usage_opts_help array */
907 #define USAGE_COMMON_OPTS_HELP \
908 	"Print this help and exit", \
909 	"Print version and exit", \
910 	NULL
911 
912 /* Helper for getopt case statements */
913 #define case_USAGE_COMMON_FLAGS \
914 	case 'h': usage(NULL); \
915 	case 'V': util_version(); \
916 	case '?': usage("unknown option");
917 
918 static const char usage_short_opts[] =
919 		"haAc:b:C:defg:G:HIlLmn:N:o:O:p:P:rRsStTv"
920 		USAGE_COMMON_SHORT_OPTS;
921 static struct option const usage_long_opts[] = {
922 	{"show-address",	no_argument, NULL, 'a'},
923 	{"colour",		no_argument, NULL, 'A'},
924 	{"include-node-with-prop", a_argument, NULL, 'b'},
925 	{"include-compat",	a_argument, NULL, 'c'},
926 	{"exclude-compat",	a_argument, NULL, 'C'},
927 	{"diff",		no_argument, NULL, 'd'},
928 	{"enter-node",		no_argument, NULL, 'e'},
929 	{"show-offset",		no_argument, NULL, 'f'},
930 	{"include-match",	a_argument, NULL, 'g'},
931 	{"exclude-match",	a_argument, NULL, 'G'},
932 	{"show-header",		no_argument, NULL, 'H'},
933 	{"show-version",	no_argument, NULL, 'I'},
934 	{"list-regions",	no_argument, NULL, 'l'},
935 	{"list-strings",	no_argument, NULL, 'L'},
936 	{"include-mem",		no_argument, NULL, 'm'},
937 	{"include-node",	a_argument, NULL, 'n'},
938 	{"exclude-node",	a_argument, NULL, 'N'},
939 	{"include-prop",	a_argument, NULL, 'p'},
940 	{"exclude-prop",	a_argument, NULL, 'P'},
941 	{"remove-strings",	no_argument, NULL, 'r'},
942 	{"include-root",	no_argument, NULL, 'R'},
943 	{"show-subnodes",	no_argument, NULL, 's'},
944 	{"skip-supernodes",	no_argument, NULL, 'S'},
945 	{"show-stringtab",	no_argument, NULL, 't'},
946 	{"show-aliases",	no_argument, NULL, 'T'},
947 	{"out",			a_argument, NULL, 'o'},
948 	{"out-format",		a_argument, NULL, 'O'},
949 	{"invert-match",	no_argument, NULL, 'v'},
950 	USAGE_COMMON_LONG_OPTS,
951 };
952 static const char * const usage_opts_help[] = {
953 	"Display address",
954 	"Show all nodes/tags, colour those that match",
955 	"Include contains containing property",
956 	"Compatible nodes to include in grep",
957 	"Compatible nodes to exclude in grep",
958 	"Diff: Mark matching nodes with +, others with -",
959 	"Enter direct subnode names of matching nodes",
960 	"Display offset",
961 	"Node/property/compatible string to include in grep",
962 	"Node/property/compatible string to exclude in grep",
963 	"Output a header",
964 	"Put \"/dts-v1/;\" on first line of dts output",
965 	"Output a region list",
966 	"List strings in string table",
967 	"Include mem_rsvmap section in binary output",
968 	"Node to include in grep",
969 	"Node to exclude in grep",
970 	"Property to include in grep",
971 	"Property to exclude in grep",
972 	"Remove unused strings from string table",
973 	"Include root node and all properties",
974 	"Show all subnodes matching nodes",
975 	"Don't include supernodes of matching nodes",
976 	"Include string table in binary output",
977 	"Include matching aliases in output",
978 	"-o <output file>",
979 	"-O <output format>",
980 	"Invert the sense of matching (select non-matching lines)",
981 	USAGE_COMMON_OPTS_HELP
982 };
983 
984 /**
985  * Call getopt_long() with standard options
986  *
987  * Since all util code runs getopt in the same way, provide a helper.
988  */
989 #define util_getopt_long() getopt_long(argc, argv, usage_short_opts, \
990 				       usage_long_opts, NULL)
991 
992 void util_usage(const char *errmsg, const char *synopsis,
993 		const char *short_opts, struct option const long_opts[],
994 		const char * const opts_help[])
995 {
996 	FILE *fp = errmsg ? stderr : stdout;
997 	const char a_arg[] = "<arg>";
998 	size_t a_arg_len = strlen(a_arg) + 1;
999 	size_t i;
1000 	int optlen;
1001 
1002 	fprintf(fp,
1003 		"Usage: %s\n"
1004 		"\n"
1005 		"Options: -[%s]\n", synopsis, short_opts);
1006 
1007 	/* prescan the --long opt length to auto-align */
1008 	optlen = 0;
1009 	for (i = 0; long_opts[i].name; ++i) {
1010 		/* +1 is for space between --opt and help text */
1011 		int l = strlen(long_opts[i].name) + 1;
1012 		if (long_opts[i].has_arg == a_argument)
1013 			l += a_arg_len;
1014 		if (optlen < l)
1015 			optlen = l;
1016 	}
1017 
1018 	for (i = 0; long_opts[i].name; ++i) {
1019 		/* helps when adding new applets or options */
1020 		assert(opts_help[i] != NULL);
1021 
1022 		/* first output the short flag if it has one */
1023 		if (long_opts[i].val > '~')
1024 			fprintf(fp, "      ");
1025 		else
1026 			fprintf(fp, "  -%c, ", long_opts[i].val);
1027 
1028 		/* then the long flag */
1029 		if (long_opts[i].has_arg == no_argument) {
1030 			fprintf(fp, "--%-*s", optlen, long_opts[i].name);
1031 		} else {
1032 			fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg,
1033 				(int)(optlen - strlen(long_opts[i].name) -
1034 				a_arg_len), "");
1035 		}
1036 
1037 		/* finally the help text */
1038 		fprintf(fp, "%s\n", opts_help[i]);
1039 	}
1040 
1041 	if (errmsg) {
1042 		fprintf(fp, "\nError: %s\n", errmsg);
1043 		exit(EXIT_FAILURE);
1044 	} else {
1045 		exit(EXIT_SUCCESS);
1046 	}
1047 }
1048 
1049 /**
1050  * Show usage and exit
1051  *
1052  * If you name all your usage variables with usage_xxx, then you can call this
1053  * help macro rather than expanding all arguments yourself.
1054  *
1055  * @param errmsg	If non-NULL, an error message to display
1056  */
1057 #define usage(errmsg) \
1058 	util_usage(errmsg, usage_synopsis, usage_short_opts, \
1059 		   usage_long_opts, usage_opts_help)
1060 
1061 void util_version(void)
1062 {
1063 	printf("Version: %s\n", "(U-Boot)");
1064 	exit(0);
1065 }
1066 
1067 static void scan_args(struct display_info *disp, int argc, char *argv[])
1068 {
1069 	int opt;
1070 
1071 	while ((opt = util_getopt_long()) != EOF) {
1072 		int type = 0;
1073 		int inc = 1;
1074 
1075 		switch (opt) {
1076 		case_USAGE_COMMON_FLAGS
1077 		case 'a':
1078 			disp->show_addr = 1;
1079 			break;
1080 		case 'A':
1081 			disp->all = 1;
1082 			break;
1083 		case 'b':
1084 			type = FDT_NODE_HAS_PROP;
1085 			break;
1086 		case 'C':
1087 			inc = 0;
1088 			/* no break */
1089 		case 'c':
1090 			type = FDT_IS_COMPAT;
1091 			break;
1092 		case 'd':
1093 			disp->diff = 1;
1094 			break;
1095 		case 'e':
1096 			disp->flags |= FDT_REG_DIRECT_SUBNODES;
1097 			break;
1098 		case 'f':
1099 			disp->show_offset = 1;
1100 			break;
1101 		case 'G':
1102 			inc = 0;
1103 			/* no break */
1104 		case 'g':
1105 			type = FDT_ANY_GLOBAL;
1106 			break;
1107 		case 'H':
1108 			disp->header = 1;
1109 			break;
1110 		case 'l':
1111 			disp->region_list = 1;
1112 			break;
1113 		case 'L':
1114 			disp->list_strings = 1;
1115 			break;
1116 		case 'm':
1117 			disp->flags |= FDT_REG_ADD_MEM_RSVMAP;
1118 			break;
1119 		case 'N':
1120 			inc = 0;
1121 			/* no break */
1122 		case 'n':
1123 			type = FDT_IS_NODE;
1124 			break;
1125 		case 'o':
1126 			disp->output_fname = optarg;
1127 			break;
1128 		case 'O':
1129 			if (!strcmp(optarg, "dtb"))
1130 				disp->output = OUT_DTB;
1131 			else if (!strcmp(optarg, "dts"))
1132 				disp->output = OUT_DTS;
1133 			else if (!strcmp(optarg, "bin"))
1134 				disp->output = OUT_BIN;
1135 			else
1136 				usage("Unknown output format");
1137 			break;
1138 		case 'P':
1139 			inc = 0;
1140 			/* no break */
1141 		case 'p':
1142 			type = FDT_IS_PROP;
1143 			break;
1144 		case 'r':
1145 			disp->remove_strings = 1;
1146 			break;
1147 		case 'R':
1148 			disp->include_root = 1;
1149 			break;
1150 		case 's':
1151 			disp->flags |= FDT_REG_ALL_SUBNODES;
1152 			break;
1153 		case 'S':
1154 			disp->flags &= ~FDT_REG_SUPERNODES;
1155 			break;
1156 		case 't':
1157 			disp->flags |= FDT_REG_ADD_STRING_TAB;
1158 			break;
1159 		case 'T':
1160 			disp->add_aliases = 1;
1161 			break;
1162 		case 'v':
1163 			disp->invert = 1;
1164 			break;
1165 		case 'I':
1166 			disp->show_dts_version = 1;
1167 			break;
1168 		}
1169 
1170 		if (type && value_add(disp, &disp->value_head, type, inc,
1171 				      optarg))
1172 			usage("Cannot add value");
1173 	}
1174 
1175 	if (disp->invert && disp->types_exc)
1176 		usage("-v has no meaning when used with 'exclude' conditions");
1177 }
1178 
1179 int main(int argc, char *argv[])
1180 {
1181 	char *filename = NULL;
1182 	struct display_info disp;
1183 	int ret;
1184 
1185 	/* set defaults */
1186 	memset(&disp, '\0', sizeof(disp));
1187 	disp.flags = FDT_REG_SUPERNODES;	/* Default flags */
1188 
1189 	scan_args(&disp, argc, argv);
1190 
1191 	/* Show matched lines in colour if we can */
1192 	disp.colour = disp.all && isatty(0);
1193 
1194 	/* Any additional arguments can match anything, just like -g */
1195 	while (optind < argc - 1) {
1196 		if (value_add(&disp, &disp.value_head, FDT_IS_ANY, 1,
1197 			      argv[optind++]))
1198 			usage("Cannot add value");
1199 	}
1200 
1201 	if (optind < argc)
1202 		filename = argv[optind++];
1203 	if (!filename)
1204 		usage("Missing filename");
1205 
1206 	/* If a valid .dtb is required, set flags to ensure we get one */
1207 	if (disp.output == OUT_DTB) {
1208 		disp.header = 1;
1209 		disp.flags |= FDT_REG_ADD_MEM_RSVMAP | FDT_REG_ADD_STRING_TAB;
1210 	}
1211 
1212 	if (disp.output_fname) {
1213 		disp.fout = fopen(disp.output_fname, "w");
1214 		if (!disp.fout)
1215 			usage("Cannot open output file");
1216 	} else {
1217 		disp.fout = stdout;
1218 	}
1219 
1220 	/* Run the grep and output the results */
1221 	ret = do_fdtgrep(&disp, filename);
1222 	if (disp.output_fname)
1223 		fclose(disp.fout);
1224 	if (ret)
1225 		return 1;
1226 
1227 	return 0;
1228 }
1229