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