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