1 /* 2 * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation. 2007. 3 * 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation; either version 2 of the 8 * License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 18 * USA 19 */ 20 21 #include "dtc.h" 22 23 #ifdef TRACE_CHECKS 24 #define TRACE(c, ...) \ 25 do { \ 26 fprintf(stderr, "=== %s: ", (c)->name); \ 27 fprintf(stderr, __VA_ARGS__); \ 28 fprintf(stderr, "\n"); \ 29 } while (0) 30 #else 31 #define TRACE(c, fmt, ...) do { } while (0) 32 #endif 33 34 enum checklevel { 35 IGNORE = 0, 36 WARN = 1, 37 ERROR = 2, 38 }; 39 40 enum checkstatus { 41 UNCHECKED = 0, 42 PREREQ, 43 PASSED, 44 FAILED, 45 }; 46 47 struct check; 48 49 typedef void (*tree_check_fn)(struct check *c, struct node *dt); 50 typedef void (*node_check_fn)(struct check *c, struct node *dt, struct node *node); 51 typedef void (*prop_check_fn)(struct check *c, struct node *dt, 52 struct node *node, struct property *prop); 53 54 struct check { 55 const char *name; 56 tree_check_fn tree_fn; 57 node_check_fn node_fn; 58 prop_check_fn prop_fn; 59 void *data; 60 enum checklevel level; 61 enum checkstatus status; 62 int inprogress; 63 int num_prereqs; 64 struct check **prereq; 65 }; 66 67 #define CHECK(nm, tfn, nfn, pfn, d, lvl, ...) \ 68 static struct check *nm##_prereqs[] = { __VA_ARGS__ }; \ 69 static struct check nm = { \ 70 .name = #nm, \ 71 .tree_fn = (tfn), \ 72 .node_fn = (nfn), \ 73 .prop_fn = (pfn), \ 74 .data = (d), \ 75 .level = (lvl), \ 76 .status = UNCHECKED, \ 77 .num_prereqs = ARRAY_SIZE(nm##_prereqs), \ 78 .prereq = nm##_prereqs, \ 79 }; 80 81 #define TREE_CHECK(nm, d, lvl, ...) \ 82 CHECK(nm, check_##nm, NULL, NULL, d, lvl, __VA_ARGS__) 83 #define NODE_CHECK(nm, d, lvl, ...) \ 84 CHECK(nm, NULL, check_##nm, NULL, d, lvl, __VA_ARGS__) 85 #define PROP_CHECK(nm, d, lvl, ...) \ 86 CHECK(nm, NULL, NULL, check_##nm, d, lvl, __VA_ARGS__) 87 #define BATCH_CHECK(nm, lvl, ...) \ 88 CHECK(nm, NULL, NULL, NULL, NULL, lvl, __VA_ARGS__) 89 90 #ifdef __GNUC__ 91 static inline void check_msg(struct check *c, const char *fmt, ...) __attribute__((format (printf, 2, 3))); 92 #endif 93 static inline void check_msg(struct check *c, const char *fmt, ...) 94 { 95 va_list ap; 96 va_start(ap, fmt); 97 98 if ((c->level < WARN) || (c->level <= quiet)) 99 return; /* Suppress message */ 100 101 fprintf(stderr, "%s (%s): ", 102 (c->level == ERROR) ? "ERROR" : "Warning", c->name); 103 vfprintf(stderr, fmt, ap); 104 fprintf(stderr, "\n"); 105 } 106 107 #define FAIL(c, ...) \ 108 do { \ 109 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \ 110 (c)->status = FAILED; \ 111 check_msg((c), __VA_ARGS__); \ 112 } while (0) 113 114 static void check_nodes_props(struct check *c, struct node *dt, struct node *node) 115 { 116 struct node *child; 117 struct property *prop; 118 119 TRACE(c, "%s", node->fullpath); 120 if (c->node_fn) 121 c->node_fn(c, dt, node); 122 123 if (c->prop_fn) 124 for_each_property(node, prop) { 125 TRACE(c, "%s\t'%s'", node->fullpath, prop->name); 126 c->prop_fn(c, dt, node, prop); 127 } 128 129 for_each_child(node, child) 130 check_nodes_props(c, dt, child); 131 } 132 133 static int run_check(struct check *c, struct node *dt) 134 { 135 int error = 0; 136 int i; 137 138 assert(!c->inprogress); 139 140 if (c->status != UNCHECKED) 141 goto out; 142 143 c->inprogress = 1; 144 145 for (i = 0; i < c->num_prereqs; i++) { 146 struct check *prq = c->prereq[i]; 147 error |= run_check(prq, dt); 148 if (prq->status != PASSED) { 149 c->status = PREREQ; 150 check_msg(c, "Failed prerequisite '%s'", 151 c->prereq[i]->name); 152 } 153 } 154 155 if (c->status != UNCHECKED) 156 goto out; 157 158 if (c->node_fn || c->prop_fn) 159 check_nodes_props(c, dt, dt); 160 161 if (c->tree_fn) 162 c->tree_fn(c, dt); 163 if (c->status == UNCHECKED) 164 c->status = PASSED; 165 166 TRACE(c, "\tCompleted, status %d", c->status); 167 168 out: 169 c->inprogress = 0; 170 if ((c->status != PASSED) && (c->level == ERROR)) 171 error = 1; 172 return error; 173 } 174 175 /* 176 * Utility check functions 177 */ 178 179 static void check_is_string(struct check *c, struct node *root, 180 struct node *node) 181 { 182 struct property *prop; 183 char *propname = c->data; 184 185 prop = get_property(node, propname); 186 if (!prop) 187 return; /* Not present, assumed ok */ 188 189 if (!data_is_one_string(prop->val)) 190 FAIL(c, "\"%s\" property in %s is not a string", 191 propname, node->fullpath); 192 } 193 #define CHECK_IS_STRING(nm, propname, lvl) \ 194 CHECK(nm, NULL, check_is_string, NULL, (propname), (lvl)) 195 196 static void check_is_cell(struct check *c, struct node *root, 197 struct node *node) 198 { 199 struct property *prop; 200 char *propname = c->data; 201 202 prop = get_property(node, propname); 203 if (!prop) 204 return; /* Not present, assumed ok */ 205 206 if (prop->val.len != sizeof(cell_t)) 207 FAIL(c, "\"%s\" property in %s is not a single cell", 208 propname, node->fullpath); 209 } 210 #define CHECK_IS_CELL(nm, propname, lvl) \ 211 CHECK(nm, NULL, check_is_cell, NULL, (propname), (lvl)) 212 213 /* 214 * Structural check functions 215 */ 216 217 static void check_duplicate_node_names(struct check *c, struct node *dt, 218 struct node *node) 219 { 220 struct node *child, *child2; 221 222 for_each_child(node, child) 223 for (child2 = child->next_sibling; 224 child2; 225 child2 = child2->next_sibling) 226 if (streq(child->name, child2->name)) 227 FAIL(c, "Duplicate node name %s", 228 child->fullpath); 229 } 230 NODE_CHECK(duplicate_node_names, NULL, ERROR); 231 232 static void check_duplicate_property_names(struct check *c, struct node *dt, 233 struct node *node) 234 { 235 struct property *prop, *prop2; 236 237 for_each_property(node, prop) 238 for (prop2 = prop->next; prop2; prop2 = prop2->next) 239 if (streq(prop->name, prop2->name)) 240 FAIL(c, "Duplicate property name %s in %s", 241 prop->name, node->fullpath); 242 } 243 NODE_CHECK(duplicate_property_names, NULL, ERROR); 244 245 #define LOWERCASE "abcdefghijklmnopqrstuvwxyz" 246 #define UPPERCASE "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 247 #define DIGITS "0123456789" 248 #define PROPNODECHARS LOWERCASE UPPERCASE DIGITS ",._+*#?-" 249 250 static void check_node_name_chars(struct check *c, struct node *dt, 251 struct node *node) 252 { 253 int n = strspn(node->name, c->data); 254 255 if (n < strlen(node->name)) 256 FAIL(c, "Bad character '%c' in node %s", 257 node->name[n], node->fullpath); 258 } 259 NODE_CHECK(node_name_chars, PROPNODECHARS "@", ERROR); 260 261 static void check_node_name_format(struct check *c, struct node *dt, 262 struct node *node) 263 { 264 if (strchr(get_unitname(node), '@')) 265 FAIL(c, "Node %s has multiple '@' characters in name", 266 node->fullpath); 267 } 268 NODE_CHECK(node_name_format, NULL, ERROR, &node_name_chars); 269 270 static void check_property_name_chars(struct check *c, struct node *dt, 271 struct node *node, struct property *prop) 272 { 273 int n = strspn(prop->name, c->data); 274 275 if (n < strlen(prop->name)) 276 FAIL(c, "Bad character '%c' in property name \"%s\", node %s", 277 prop->name[n], prop->name, node->fullpath); 278 } 279 PROP_CHECK(property_name_chars, PROPNODECHARS, ERROR); 280 281 static void check_explicit_phandles(struct check *c, struct node *root, 282 struct node *node) 283 { 284 struct property *prop; 285 struct node *other; 286 cell_t phandle; 287 288 prop = get_property(node, "linux,phandle"); 289 if (! prop) 290 return; /* No phandle, that's fine */ 291 292 if (prop->val.len != sizeof(cell_t)) { 293 FAIL(c, "%s has bad length (%d) linux,phandle property", 294 node->fullpath, prop->val.len); 295 return; 296 } 297 298 phandle = propval_cell(prop); 299 if ((phandle == 0) || (phandle == -1)) { 300 FAIL(c, "%s has invalid linux,phandle value 0x%x", 301 node->fullpath, phandle); 302 return; 303 } 304 305 other = get_node_by_phandle(root, phandle); 306 if (other) { 307 FAIL(c, "%s has duplicated phandle 0x%x (seen before at %s)", 308 node->fullpath, phandle, other->fullpath); 309 return; 310 } 311 312 node->phandle = phandle; 313 } 314 NODE_CHECK(explicit_phandles, NULL, ERROR); 315 316 static void check_name_properties(struct check *c, struct node *root, 317 struct node *node) 318 { 319 struct property **pp, *prop = NULL; 320 321 for (pp = &node->proplist; *pp; pp = &((*pp)->next)) 322 if (streq((*pp)->name, "name")) { 323 prop = *pp; 324 break; 325 } 326 327 if (!prop) 328 return; /* No name property, that's fine */ 329 330 if ((prop->val.len != node->basenamelen+1) 331 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) { 332 FAIL(c, "\"name\" property in %s is incorrect (\"%s\" instead" 333 " of base node name)", node->fullpath, prop->val.val); 334 } else { 335 /* The name property is correct, and therefore redundant. 336 * Delete it */ 337 *pp = prop->next; 338 free(prop->name); 339 data_free(prop->val); 340 free(prop); 341 } 342 } 343 CHECK_IS_STRING(name_is_string, "name", ERROR); 344 NODE_CHECK(name_properties, NULL, ERROR, &name_is_string); 345 346 /* 347 * Reference fixup functions 348 */ 349 350 static void fixup_phandle_references(struct check *c, struct node *dt, 351 struct node *node, struct property *prop) 352 { 353 struct marker *m = prop->val.markers; 354 struct node *refnode; 355 cell_t phandle; 356 357 for_each_marker_of_type(m, REF_PHANDLE) { 358 assert(m->offset + sizeof(cell_t) <= prop->val.len); 359 360 refnode = get_node_by_ref(dt, m->ref); 361 if (! refnode) { 362 FAIL(c, "Reference to non-existent node or label \"%s\"\n", 363 m->ref); 364 continue; 365 } 366 367 phandle = get_node_phandle(dt, refnode); 368 *((cell_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle); 369 } 370 } 371 CHECK(phandle_references, NULL, NULL, fixup_phandle_references, NULL, ERROR, 372 &duplicate_node_names, &explicit_phandles); 373 374 static void fixup_path_references(struct check *c, struct node *dt, 375 struct node *node, struct property *prop) 376 { 377 struct marker *m = prop->val.markers; 378 struct node *refnode; 379 char *path; 380 381 for_each_marker_of_type(m, REF_PATH) { 382 assert(m->offset <= prop->val.len); 383 384 refnode = get_node_by_ref(dt, m->ref); 385 if (!refnode) { 386 FAIL(c, "Reference to non-existent node or label \"%s\"\n", 387 m->ref); 388 continue; 389 } 390 391 path = refnode->fullpath; 392 prop->val = data_insert_at_marker(prop->val, m, path, 393 strlen(path) + 1); 394 } 395 } 396 CHECK(path_references, NULL, NULL, fixup_path_references, NULL, ERROR, 397 &duplicate_node_names); 398 399 /* 400 * Semantic checks 401 */ 402 CHECK_IS_CELL(address_cells_is_cell, "#address-cells", WARN); 403 CHECK_IS_CELL(size_cells_is_cell, "#size-cells", WARN); 404 CHECK_IS_CELL(interrupt_cells_is_cell, "#interrupt-cells", WARN); 405 406 CHECK_IS_STRING(device_type_is_string, "device_type", WARN); 407 CHECK_IS_STRING(model_is_string, "model", WARN); 408 CHECK_IS_STRING(status_is_string, "status", WARN); 409 410 static void fixup_addr_size_cells(struct check *c, struct node *dt, 411 struct node *node) 412 { 413 struct property *prop; 414 415 node->addr_cells = -1; 416 node->size_cells = -1; 417 418 prop = get_property(node, "#address-cells"); 419 if (prop) 420 node->addr_cells = propval_cell(prop); 421 422 prop = get_property(node, "#size-cells"); 423 if (prop) 424 node->size_cells = propval_cell(prop); 425 } 426 CHECK(addr_size_cells, NULL, fixup_addr_size_cells, NULL, NULL, WARN, 427 &address_cells_is_cell, &size_cells_is_cell); 428 429 #define node_addr_cells(n) \ 430 (((n)->addr_cells == -1) ? 2 : (n)->addr_cells) 431 #define node_size_cells(n) \ 432 (((n)->size_cells == -1) ? 1 : (n)->size_cells) 433 434 static void check_reg_format(struct check *c, struct node *dt, 435 struct node *node) 436 { 437 struct property *prop; 438 int addr_cells, size_cells, entrylen; 439 440 prop = get_property(node, "reg"); 441 if (!prop) 442 return; /* No "reg", that's fine */ 443 444 if (!node->parent) { 445 FAIL(c, "Root node has a \"reg\" property"); 446 return; 447 } 448 449 if (prop->val.len == 0) 450 FAIL(c, "\"reg\" property in %s is empty", node->fullpath); 451 452 addr_cells = node_addr_cells(node->parent); 453 size_cells = node_size_cells(node->parent); 454 entrylen = (addr_cells + size_cells) * sizeof(cell_t); 455 456 if ((prop->val.len % entrylen) != 0) 457 FAIL(c, "\"reg\" property in %s has invalid length (%d bytes) " 458 "(#address-cells == %d, #size-cells == %d)", 459 node->fullpath, prop->val.len, addr_cells, size_cells); 460 } 461 NODE_CHECK(reg_format, NULL, WARN, &addr_size_cells); 462 463 static void check_ranges_format(struct check *c, struct node *dt, 464 struct node *node) 465 { 466 struct property *prop; 467 int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen; 468 469 prop = get_property(node, "ranges"); 470 if (!prop) 471 return; 472 473 if (!node->parent) { 474 FAIL(c, "Root node has a \"ranges\" property"); 475 return; 476 } 477 478 p_addr_cells = node_addr_cells(node->parent); 479 p_size_cells = node_size_cells(node->parent); 480 c_addr_cells = node_addr_cells(node); 481 c_size_cells = node_size_cells(node); 482 entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t); 483 484 if (prop->val.len == 0) { 485 if (p_addr_cells != c_addr_cells) 486 FAIL(c, "%s has empty \"ranges\" property but its " 487 "#address-cells (%d) differs from %s (%d)", 488 node->fullpath, c_addr_cells, node->parent->fullpath, 489 p_addr_cells); 490 if (p_size_cells != c_size_cells) 491 FAIL(c, "%s has empty \"ranges\" property but its " 492 "#size-cells (%d) differs from %s (%d)", 493 node->fullpath, c_size_cells, node->parent->fullpath, 494 p_size_cells); 495 } else if ((prop->val.len % entrylen) != 0) { 496 FAIL(c, "\"ranges\" property in %s has invalid length (%d bytes) " 497 "(parent #address-cells == %d, child #address-cells == %d, " 498 "#size-cells == %d)", node->fullpath, prop->val.len, 499 p_addr_cells, c_addr_cells, c_size_cells); 500 } 501 } 502 NODE_CHECK(ranges_format, NULL, WARN, &addr_size_cells); 503 504 /* 505 * Style checks 506 */ 507 static void check_avoid_default_addr_size(struct check *c, struct node *dt, 508 struct node *node) 509 { 510 struct property *reg, *ranges; 511 512 if (!node->parent) 513 return; /* Ignore root node */ 514 515 reg = get_property(node, "reg"); 516 ranges = get_property(node, "ranges"); 517 518 if (!reg && !ranges) 519 return; 520 521 if ((node->parent->addr_cells == -1)) 522 FAIL(c, "Relying on default #address-cells value for %s", 523 node->fullpath); 524 525 if ((node->parent->size_cells == -1)) 526 FAIL(c, "Relying on default #size-cells value for %s", 527 node->fullpath); 528 } 529 NODE_CHECK(avoid_default_addr_size, NULL, WARN, &addr_size_cells); 530 531 static void check_obsolete_chosen_interrupt_controller(struct check *c, 532 struct node *dt) 533 { 534 struct node *chosen; 535 struct property *prop; 536 537 chosen = get_node_by_path(dt, "/chosen"); 538 if (!chosen) 539 return; 540 541 prop = get_property(chosen, "interrupt-controller"); 542 if (prop) 543 FAIL(c, "/chosen has obsolete \"interrupt-controller\" " 544 "property"); 545 } 546 TREE_CHECK(obsolete_chosen_interrupt_controller, NULL, WARN); 547 548 static struct check *check_table[] = { 549 &duplicate_node_names, &duplicate_property_names, 550 &node_name_chars, &node_name_format, &property_name_chars, 551 &name_is_string, &name_properties, 552 &explicit_phandles, 553 &phandle_references, &path_references, 554 555 &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell, 556 &device_type_is_string, &model_is_string, &status_is_string, 557 558 &addr_size_cells, ®_format, &ranges_format, 559 560 &avoid_default_addr_size, 561 &obsolete_chosen_interrupt_controller, 562 }; 563 564 void process_checks(int force, struct boot_info *bi) 565 { 566 struct node *dt = bi->dt; 567 int i; 568 int error = 0; 569 570 for (i = 0; i < ARRAY_SIZE(check_table); i++) { 571 struct check *c = check_table[i]; 572 573 if (c->level != IGNORE) 574 error = error || run_check(c, dt); 575 } 576 577 if (error) { 578 if (!force) { 579 fprintf(stderr, "ERROR: Input tree has errors, aborting " 580 "(use -f to force output)\n"); 581 exit(2); 582 } else if (quiet < 3) { 583 fprintf(stderr, "Warning: Input tree has errors, " 584 "output forced\n"); 585 } 586 } 587 } 588