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 = ®ion[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 ®ion[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 ? ®ion[count] : NULL, 659 path, path_len, disp->flags, &state); 660 if (!ret) 661 count++; 662 } 663 664 /* Find all the aliases and add those regions back in */ 665 if (disp->add_aliases && count < max_regions) { 666 int new_count; 667 668 new_count = fdt_add_alias_regions(fdt, region, count, 669 max_regions, &state); 670 if (new_count > max_regions) { 671 region = malloc(new_count * sizeof(struct fdt_region)); 672 if (!region) { 673 fprintf(stderr, 674 "Out of memory for %d regions\n", 675 count); 676 return -1; 677 } 678 memcpy(region, state.region, 679 count * sizeof(struct fdt_region)); 680 free(state.region); 681 new_count = fdt_add_alias_regions(fdt, region, count, 682 max_regions, &state); 683 } 684 685 /* 686 * The alias regions will now be at the end of the list. Sort 687 * the regions by offset to get things into the right order 688 */ 689 qsort(region, new_count, sizeof(struct fdt_region), 690 h_cmp_region); 691 count = new_count; 692 } 693 694 if (ret != -FDT_ERR_NOTFOUND) 695 return ret; 696 697 return count; 698 } 699 700 int utilfdt_read_err_len(const char *filename, char **buffp, off_t *len) 701 { 702 int fd = 0; /* assume stdin */ 703 char *buf = NULL; 704 off_t bufsize = 1024, offset = 0; 705 int ret = 0; 706 707 *buffp = NULL; 708 if (strcmp(filename, "-") != 0) { 709 fd = open(filename, O_RDONLY); 710 if (fd < 0) 711 return errno; 712 } 713 714 /* Loop until we have read everything */ 715 buf = malloc(bufsize); 716 if (!buf) 717 return -ENOMEM; 718 do { 719 /* Expand the buffer to hold the next chunk */ 720 if (offset == bufsize) { 721 bufsize *= 2; 722 buf = realloc(buf, bufsize); 723 if (!buf) 724 return -ENOMEM; 725 } 726 727 ret = read(fd, &buf[offset], bufsize - offset); 728 if (ret < 0) { 729 ret = errno; 730 break; 731 } 732 offset += ret; 733 } while (ret != 0); 734 735 /* Clean up, including closing stdin; return errno on error */ 736 close(fd); 737 if (ret) 738 free(buf); 739 else 740 *buffp = buf; 741 *len = bufsize; 742 return ret; 743 } 744 745 int utilfdt_read_err(const char *filename, char **buffp) 746 { 747 off_t len; 748 return utilfdt_read_err_len(filename, buffp, &len); 749 } 750 751 char *utilfdt_read_len(const char *filename, off_t *len) 752 { 753 char *buff; 754 int ret = utilfdt_read_err_len(filename, &buff, len); 755 756 if (ret) { 757 fprintf(stderr, "Couldn't open blob from '%s': %s\n", filename, 758 strerror(ret)); 759 return NULL; 760 } 761 /* Successful read */ 762 return buff; 763 } 764 765 char *utilfdt_read(const char *filename) 766 { 767 off_t len; 768 return utilfdt_read_len(filename, &len); 769 } 770 771 /** 772 * Run the main fdtgrep operation, given a filename and valid arguments 773 * 774 * @param disp Display information / options 775 * @param filename Filename of blob file 776 * @param return 0 if ok, -ve on error 777 */ 778 static int do_fdtgrep(struct display_info *disp, const char *filename) 779 { 780 struct fdt_region *region; 781 int max_regions; 782 int count = 100; 783 char path[1024]; 784 char *blob; 785 int i, ret; 786 787 blob = utilfdt_read(filename); 788 if (!blob) 789 return -1; 790 ret = fdt_check_header(blob); 791 if (ret) { 792 fprintf(stderr, "Error: %s\n", fdt_strerror(ret)); 793 return ret; 794 } 795 796 /* Allow old files, but they are untested */ 797 if (fdt_version(blob) < 17 && disp->value_head) { 798 fprintf(stderr, 799 "Warning: fdtgrep does not fully support version %d files\n", 800 fdt_version(blob)); 801 } 802 803 /* 804 * We do two passes, since we don't know how many regions we need. 805 * The first pass will count the regions, but if it is too many, 806 * we do another pass to actually record them. 807 */ 808 for (i = 0; i < 2; i++) { 809 region = malloc(count * sizeof(struct fdt_region)); 810 if (!region) { 811 fprintf(stderr, "Out of memory for %d regions\n", 812 count); 813 return -1; 814 } 815 max_regions = count; 816 count = fdtgrep_find_regions(blob, 817 h_include, disp, 818 region, max_regions, path, sizeof(path), 819 disp->flags); 820 if (count < 0) { 821 report_error("fdt_find_regions", count); 822 return -1; 823 } 824 if (count <= max_regions) 825 break; 826 free(region); 827 } 828 829 /* Optionally print a list of regions */ 830 if (disp->region_list) 831 show_region_list(region, count); 832 833 /* Output either source .dts or binary .dtb */ 834 if (disp->output == OUT_DTS) { 835 ret = display_fdt_by_regions(disp, blob, region, count); 836 } else { 837 void *fdt; 838 /* Allow reserved memory section to expand slightly */ 839 int size = fdt_totalsize(blob) + 16; 840 841 fdt = malloc(size); 842 if (!fdt) { 843 fprintf(stderr, "Out_of_memory\n"); 844 ret = -1; 845 goto err; 846 } 847 size = dump_fdt_regions(disp, blob, region, count, fdt); 848 if (disp->remove_strings) { 849 void *out; 850 851 out = malloc(size); 852 if (!out) { 853 fprintf(stderr, "Out_of_memory\n"); 854 ret = -1; 855 goto err; 856 } 857 ret = fdt_remove_unused_strings(fdt, out); 858 if (ret < 0) { 859 fprintf(stderr, 860 "Failed to remove unused strings: err=%d\n", 861 ret); 862 goto err; 863 } 864 free(fdt); 865 fdt = out; 866 ret = fdt_pack(fdt); 867 if (ret < 0) { 868 fprintf(stderr, "Failed to pack: err=%d\n", 869 ret); 870 goto err; 871 } 872 size = fdt_totalsize(fdt); 873 } 874 875 if (size != fwrite(fdt, 1, size, disp->fout)) { 876 fprintf(stderr, "Write failure, %d bytes\n", size); 877 free(fdt); 878 ret = 1; 879 goto err; 880 } 881 free(fdt); 882 } 883 err: 884 free(blob); 885 free(region); 886 887 return ret; 888 } 889 890 static const char usage_synopsis[] = 891 "fdtgrep - extract portions from device tree\n" 892 "\n" 893 "Usage:\n" 894 " fdtgrep <options> <dt file>|-\n\n" 895 "Output formats are:\n" 896 "\tdts - device tree soure text\n" 897 "\tdtb - device tree blob (sets -Hmt automatically)\n" 898 "\tbin - device tree fragment (may not be a valid .dtb)"; 899 900 /* Helper for usage_short_opts string constant */ 901 #define USAGE_COMMON_SHORT_OPTS "hV" 902 903 /* Helper for aligning long_opts array */ 904 #define a_argument required_argument 905 906 /* Helper for usage_long_opts option array */ 907 #define USAGE_COMMON_LONG_OPTS \ 908 {"help", no_argument, NULL, 'h'}, \ 909 {"version", no_argument, NULL, 'V'}, \ 910 {NULL, no_argument, NULL, 0x0} 911 912 /* Helper for usage_opts_help array */ 913 #define USAGE_COMMON_OPTS_HELP \ 914 "Print this help and exit", \ 915 "Print version and exit", \ 916 NULL 917 918 /* Helper for getopt case statements */ 919 #define case_USAGE_COMMON_FLAGS \ 920 case 'h': usage(NULL); \ 921 case 'V': util_version(); \ 922 case '?': usage("unknown option"); 923 924 static const char usage_short_opts[] = 925 "haAc:b:C:defg:G:HIlLmn:N:o:O:p:P:rRsStTv" 926 USAGE_COMMON_SHORT_OPTS; 927 static struct option const usage_long_opts[] = { 928 {"show-address", no_argument, NULL, 'a'}, 929 {"colour", no_argument, NULL, 'A'}, 930 {"include-node-with-prop", a_argument, NULL, 'b'}, 931 {"include-compat", a_argument, NULL, 'c'}, 932 {"exclude-compat", a_argument, NULL, 'C'}, 933 {"diff", no_argument, NULL, 'd'}, 934 {"enter-node", no_argument, NULL, 'e'}, 935 {"show-offset", no_argument, NULL, 'f'}, 936 {"include-match", a_argument, NULL, 'g'}, 937 {"exclude-match", a_argument, NULL, 'G'}, 938 {"show-header", no_argument, NULL, 'H'}, 939 {"show-version", no_argument, NULL, 'I'}, 940 {"list-regions", no_argument, NULL, 'l'}, 941 {"list-strings", no_argument, NULL, 'L'}, 942 {"include-mem", no_argument, NULL, 'm'}, 943 {"include-node", a_argument, NULL, 'n'}, 944 {"exclude-node", a_argument, NULL, 'N'}, 945 {"include-prop", a_argument, NULL, 'p'}, 946 {"exclude-prop", a_argument, NULL, 'P'}, 947 {"remove-strings", no_argument, NULL, 'r'}, 948 {"include-root", no_argument, NULL, 'R'}, 949 {"show-subnodes", no_argument, NULL, 's'}, 950 {"skip-supernodes", no_argument, NULL, 'S'}, 951 {"show-stringtab", no_argument, NULL, 't'}, 952 {"show-aliases", no_argument, NULL, 'T'}, 953 {"out", a_argument, NULL, 'o'}, 954 {"out-format", a_argument, NULL, 'O'}, 955 {"invert-match", no_argument, NULL, 'v'}, 956 USAGE_COMMON_LONG_OPTS, 957 }; 958 static const char * const usage_opts_help[] = { 959 "Display address", 960 "Show all nodes/tags, colour those that match", 961 "Include contains containing property", 962 "Compatible nodes to include in grep", 963 "Compatible nodes to exclude in grep", 964 "Diff: Mark matching nodes with +, others with -", 965 "Enter direct subnode names of matching nodes", 966 "Display offset", 967 "Node/property/compatible string to include in grep", 968 "Node/property/compatible string to exclude in grep", 969 "Output a header", 970 "Put \"/dts-v1/;\" on first line of dts output", 971 "Output a region list", 972 "List strings in string table", 973 "Include mem_rsvmap section in binary output", 974 "Node to include in grep", 975 "Node to exclude in grep", 976 "Property to include in grep", 977 "Property to exclude in grep", 978 "Remove unused strings from string table", 979 "Include root node and all properties", 980 "Show all subnodes matching nodes", 981 "Don't include supernodes of matching nodes", 982 "Include string table in binary output", 983 "Include matching aliases in output", 984 "-o <output file>", 985 "-O <output format>", 986 "Invert the sense of matching (select non-matching lines)", 987 USAGE_COMMON_OPTS_HELP 988 }; 989 990 /** 991 * Call getopt_long() with standard options 992 * 993 * Since all util code runs getopt in the same way, provide a helper. 994 */ 995 #define util_getopt_long() getopt_long(argc, argv, usage_short_opts, \ 996 usage_long_opts, NULL) 997 998 void util_usage(const char *errmsg, const char *synopsis, 999 const char *short_opts, struct option const long_opts[], 1000 const char * const opts_help[]) 1001 { 1002 FILE *fp = errmsg ? stderr : stdout; 1003 const char a_arg[] = "<arg>"; 1004 size_t a_arg_len = strlen(a_arg) + 1; 1005 size_t i; 1006 int optlen; 1007 1008 fprintf(fp, 1009 "Usage: %s\n" 1010 "\n" 1011 "Options: -[%s]\n", synopsis, short_opts); 1012 1013 /* prescan the --long opt length to auto-align */ 1014 optlen = 0; 1015 for (i = 0; long_opts[i].name; ++i) { 1016 /* +1 is for space between --opt and help text */ 1017 int l = strlen(long_opts[i].name) + 1; 1018 if (long_opts[i].has_arg == a_argument) 1019 l += a_arg_len; 1020 if (optlen < l) 1021 optlen = l; 1022 } 1023 1024 for (i = 0; long_opts[i].name; ++i) { 1025 /* helps when adding new applets or options */ 1026 assert(opts_help[i] != NULL); 1027 1028 /* first output the short flag if it has one */ 1029 if (long_opts[i].val > '~') 1030 fprintf(fp, " "); 1031 else 1032 fprintf(fp, " -%c, ", long_opts[i].val); 1033 1034 /* then the long flag */ 1035 if (long_opts[i].has_arg == no_argument) { 1036 fprintf(fp, "--%-*s", optlen, long_opts[i].name); 1037 } else { 1038 fprintf(fp, "--%s %s%*s", long_opts[i].name, a_arg, 1039 (int)(optlen - strlen(long_opts[i].name) - 1040 a_arg_len), ""); 1041 } 1042 1043 /* finally the help text */ 1044 fprintf(fp, "%s\n", opts_help[i]); 1045 } 1046 1047 if (errmsg) { 1048 fprintf(fp, "\nError: %s\n", errmsg); 1049 exit(EXIT_FAILURE); 1050 } else { 1051 exit(EXIT_SUCCESS); 1052 } 1053 } 1054 1055 /** 1056 * Show usage and exit 1057 * 1058 * If you name all your usage variables with usage_xxx, then you can call this 1059 * help macro rather than expanding all arguments yourself. 1060 * 1061 * @param errmsg If non-NULL, an error message to display 1062 */ 1063 #define usage(errmsg) \ 1064 util_usage(errmsg, usage_synopsis, usage_short_opts, \ 1065 usage_long_opts, usage_opts_help) 1066 1067 void util_version(void) 1068 { 1069 printf("Version: %s\n", "(U-Boot)"); 1070 exit(0); 1071 } 1072 1073 static void scan_args(struct display_info *disp, int argc, char *argv[]) 1074 { 1075 int opt; 1076 1077 while ((opt = util_getopt_long()) != EOF) { 1078 int type = 0; 1079 int inc = 1; 1080 1081 switch (opt) { 1082 case_USAGE_COMMON_FLAGS 1083 case 'a': 1084 disp->show_addr = 1; 1085 break; 1086 case 'A': 1087 disp->all = 1; 1088 break; 1089 case 'b': 1090 type = FDT_NODE_HAS_PROP; 1091 break; 1092 case 'C': 1093 inc = 0; 1094 /* no break */ 1095 case 'c': 1096 type = FDT_IS_COMPAT; 1097 break; 1098 case 'd': 1099 disp->diff = 1; 1100 break; 1101 case 'e': 1102 disp->flags |= FDT_REG_DIRECT_SUBNODES; 1103 break; 1104 case 'f': 1105 disp->show_offset = 1; 1106 break; 1107 case 'G': 1108 inc = 0; 1109 /* no break */ 1110 case 'g': 1111 type = FDT_ANY_GLOBAL; 1112 break; 1113 case 'H': 1114 disp->header = 1; 1115 break; 1116 case 'l': 1117 disp->region_list = 1; 1118 break; 1119 case 'L': 1120 disp->list_strings = 1; 1121 break; 1122 case 'm': 1123 disp->flags |= FDT_REG_ADD_MEM_RSVMAP; 1124 break; 1125 case 'N': 1126 inc = 0; 1127 /* no break */ 1128 case 'n': 1129 type = FDT_IS_NODE; 1130 break; 1131 case 'o': 1132 disp->output_fname = optarg; 1133 break; 1134 case 'O': 1135 if (!strcmp(optarg, "dtb")) 1136 disp->output = OUT_DTB; 1137 else if (!strcmp(optarg, "dts")) 1138 disp->output = OUT_DTS; 1139 else if (!strcmp(optarg, "bin")) 1140 disp->output = OUT_BIN; 1141 else 1142 usage("Unknown output format"); 1143 break; 1144 case 'P': 1145 inc = 0; 1146 /* no break */ 1147 case 'p': 1148 type = FDT_IS_PROP; 1149 break; 1150 case 'r': 1151 disp->remove_strings = 1; 1152 break; 1153 case 'R': 1154 disp->include_root = 1; 1155 break; 1156 case 's': 1157 disp->flags |= FDT_REG_ALL_SUBNODES; 1158 break; 1159 case 'S': 1160 disp->flags &= ~FDT_REG_SUPERNODES; 1161 break; 1162 case 't': 1163 disp->flags |= FDT_REG_ADD_STRING_TAB; 1164 break; 1165 case 'T': 1166 disp->add_aliases = 1; 1167 break; 1168 case 'v': 1169 disp->invert = 1; 1170 break; 1171 case 'I': 1172 disp->show_dts_version = 1; 1173 break; 1174 } 1175 1176 if (type && value_add(disp, &disp->value_head, type, inc, 1177 optarg)) 1178 usage("Cannot add value"); 1179 } 1180 1181 if (disp->invert && disp->types_exc) 1182 usage("-v has no meaning when used with 'exclude' conditions"); 1183 } 1184 1185 int main(int argc, char *argv[]) 1186 { 1187 char *filename = NULL; 1188 struct display_info disp; 1189 int ret; 1190 1191 /* set defaults */ 1192 memset(&disp, '\0', sizeof(disp)); 1193 disp.flags = FDT_REG_SUPERNODES; /* Default flags */ 1194 1195 scan_args(&disp, argc, argv); 1196 1197 /* Show matched lines in colour if we can */ 1198 disp.colour = disp.all && isatty(0); 1199 1200 /* Any additional arguments can match anything, just like -g */ 1201 while (optind < argc - 1) { 1202 if (value_add(&disp, &disp.value_head, FDT_IS_ANY, 1, 1203 argv[optind++])) 1204 usage("Cannot add value"); 1205 } 1206 1207 if (optind < argc) 1208 filename = argv[optind++]; 1209 if (!filename) 1210 usage("Missing filename"); 1211 1212 /* If a valid .dtb is required, set flags to ensure we get one */ 1213 if (disp.output == OUT_DTB) { 1214 disp.header = 1; 1215 disp.flags |= FDT_REG_ADD_MEM_RSVMAP | FDT_REG_ADD_STRING_TAB; 1216 } 1217 1218 if (disp.output_fname) { 1219 disp.fout = fopen(disp.output_fname, "w"); 1220 if (!disp.fout) 1221 usage("Cannot open output file"); 1222 } else { 1223 disp.fout = stdout; 1224 } 1225 1226 /* Run the grep and output the results */ 1227 ret = do_fdtgrep(&disp, filename); 1228 if (disp.output_fname) 1229 fclose(disp.fout); 1230 if (ret) 1231 return 1; 1232 1233 return 0; 1234 } 1235