~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/dtc/checks.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 checkstatus {
 35         UNCHECKED = 0,
 36         PREREQ,
 37         PASSED,
 38         FAILED,
 39 };
 40 
 41 struct check;
 42 
 43 typedef void (*tree_check_fn)(struct check *c, struct node *dt);
 44 typedef void (*node_check_fn)(struct check *c, struct node *dt, struct node *node);
 45 typedef void (*prop_check_fn)(struct check *c, struct node *dt,
 46                               struct node *node, struct property *prop);
 47 
 48 struct check {
 49         const char *name;
 50         tree_check_fn tree_fn;
 51         node_check_fn node_fn;
 52         prop_check_fn prop_fn;
 53         void *data;
 54         bool warn, error;
 55         enum checkstatus status;
 56         bool inprogress;
 57         int num_prereqs;
 58         struct check **prereq;
 59 };
 60 
 61 #define CHECK_ENTRY(nm, tfn, nfn, pfn, d, w, e, ...)           \
 62         static struct check *nm##_prereqs[] = { __VA_ARGS__ }; \
 63         static struct check nm = { \
 64                 .name = #nm, \
 65                 .tree_fn = (tfn), \
 66                 .node_fn = (nfn), \
 67                 .prop_fn = (pfn), \
 68                 .data = (d), \
 69                 .warn = (w), \
 70                 .error = (e), \
 71                 .status = UNCHECKED, \
 72                 .num_prereqs = ARRAY_SIZE(nm##_prereqs), \
 73                 .prereq = nm##_prereqs, \
 74         };
 75 #define WARNING(nm, tfn, nfn, pfn, d, ...) \
 76         CHECK_ENTRY(nm, tfn, nfn, pfn, d, true, false, __VA_ARGS__)
 77 #define ERROR(nm, tfn, nfn, pfn, d, ...) \
 78         CHECK_ENTRY(nm, tfn, nfn, pfn, d, false, true, __VA_ARGS__)
 79 #define CHECK(nm, tfn, nfn, pfn, d, ...) \
 80         CHECK_ENTRY(nm, tfn, nfn, pfn, d, false, false, __VA_ARGS__)
 81 
 82 #define TREE_WARNING(nm, d, ...) \
 83         WARNING(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
 84 #define TREE_ERROR(nm, d, ...) \
 85         ERROR(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
 86 #define TREE_CHECK(nm, d, ...) \
 87         CHECK(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
 88 #define NODE_WARNING(nm, d, ...) \
 89         WARNING(nm, NULL, check_##nm, NULL, d,  __VA_ARGS__)
 90 #define NODE_ERROR(nm, d, ...) \
 91         ERROR(nm, NULL, check_##nm, NULL, d, __VA_ARGS__)
 92 #define NODE_CHECK(nm, d, ...) \
 93         CHECK(nm, NULL, check_##nm, NULL, d, __VA_ARGS__)
 94 #define PROP_WARNING(nm, d, ...) \
 95         WARNING(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
 96 #define PROP_ERROR(nm, d, ...) \
 97         ERROR(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
 98 #define PROP_CHECK(nm, d, ...) \
 99         CHECK(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
100 
101 #ifdef __GNUC__
102 static inline void check_msg(struct check *c, const char *fmt, ...) __attribute__((format (printf, 2, 3)));
103 #endif
104 static inline void check_msg(struct check *c, const char *fmt, ...)
105 {
106         va_list ap;
107         va_start(ap, fmt);
108 
109         if ((c->warn && (quiet < 1))
110             || (c->error && (quiet < 2))) {
111                 fprintf(stderr, "%s (%s): ",
112                         (c->error) ? "ERROR" : "Warning", c->name);
113                 vfprintf(stderr, fmt, ap);
114                 fprintf(stderr, "\n");
115         }
116         va_end(ap);
117 }
118 
119 #define FAIL(c, ...) \
120         do { \
121                 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
122                 (c)->status = FAILED; \
123                 check_msg((c), __VA_ARGS__); \
124         } while (0)
125 
126 static void check_nodes_props(struct check *c, struct node *dt, struct node *node)
127 {
128         struct node *child;
129         struct property *prop;
130 
131         TRACE(c, "%s", node->fullpath);
132         if (c->node_fn)
133                 c->node_fn(c, dt, node);
134 
135         if (c->prop_fn)
136                 for_each_property(node, prop) {
137                         TRACE(c, "%s\t'%s'", node->fullpath, prop->name);
138                         c->prop_fn(c, dt, node, prop);
139                 }
140 
141         for_each_child(node, child)
142                 check_nodes_props(c, dt, child);
143 }
144 
145 static bool run_check(struct check *c, struct node *dt)
146 {
147         bool error = false;
148         int i;
149 
150         assert(!c->inprogress);
151 
152         if (c->status != UNCHECKED)
153                 goto out;
154 
155         c->inprogress = true;
156 
157         for (i = 0; i < c->num_prereqs; i++) {
158                 struct check *prq = c->prereq[i];
159                 error = error || run_check(prq, dt);
160                 if (prq->status != PASSED) {
161                         c->status = PREREQ;
162                         check_msg(c, "Failed prerequisite '%s'",
163                                   c->prereq[i]->name);
164                 }
165         }
166 
167         if (c->status != UNCHECKED)
168                 goto out;
169 
170         if (c->node_fn || c->prop_fn)
171                 check_nodes_props(c, dt, dt);
172 
173         if (c->tree_fn)
174                 c->tree_fn(c, dt);
175         if (c->status == UNCHECKED)
176                 c->status = PASSED;
177 
178         TRACE(c, "\tCompleted, status %d", c->status);
179 
180 out:
181         c->inprogress = false;
182         if ((c->status != PASSED) && (c->error))
183                 error = true;
184         return error;
185 }
186 
187 /*
188  * Utility check functions
189  */
190 
191 /* A check which always fails, for testing purposes only */
192 static inline void check_always_fail(struct check *c, struct node *dt)
193 {
194         FAIL(c, "always_fail check");
195 }
196 TREE_CHECK(always_fail, NULL);
197 
198 static void check_is_string(struct check *c, struct node *root,
199                             struct node *node)
200 {
201         struct property *prop;
202         char *propname = c->data;
203 
204         prop = get_property(node, propname);
205         if (!prop)
206                 return; /* Not present, assumed ok */
207 
208         if (!data_is_one_string(prop->val))
209                 FAIL(c, "\"%s\" property in %s is not a string",
210                      propname, node->fullpath);
211 }
212 #define WARNING_IF_NOT_STRING(nm, propname) \
213         WARNING(nm, NULL, check_is_string, NULL, (propname))
214 #define ERROR_IF_NOT_STRING(nm, propname) \
215         ERROR(nm, NULL, check_is_string, NULL, (propname))
216 
217 static void check_is_cell(struct check *c, struct node *root,
218                           struct node *node)
219 {
220         struct property *prop;
221         char *propname = c->data;
222 
223         prop = get_property(node, propname);
224         if (!prop)
225                 return; /* Not present, assumed ok */
226 
227         if (prop->val.len != sizeof(cell_t))
228                 FAIL(c, "\"%s\" property in %s is not a single cell",
229                      propname, node->fullpath);
230 }
231 #define WARNING_IF_NOT_CELL(nm, propname) \
232         WARNING(nm, NULL, check_is_cell, NULL, (propname))
233 #define ERROR_IF_NOT_CELL(nm, propname) \
234         ERROR(nm, NULL, check_is_cell, NULL, (propname))
235 
236 /*
237  * Structural check functions
238  */
239 
240 static void check_duplicate_node_names(struct check *c, struct node *dt,
241                                        struct node *node)
242 {
243         struct node *child, *child2;
244 
245         for_each_child(node, child)
246                 for (child2 = child->next_sibling;
247                      child2;
248                      child2 = child2->next_sibling)
249                         if (streq(child->name, child2->name))
250                                 FAIL(c, "Duplicate node name %s",
251                                      child->fullpath);
252 }
253 NODE_ERROR(duplicate_node_names, NULL);
254 
255 static void check_duplicate_property_names(struct check *c, struct node *dt,
256                                            struct node *node)
257 {
258         struct property *prop, *prop2;
259 
260         for_each_property(node, prop) {
261                 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
262                         if (prop2->deleted)
263                                 continue;
264                         if (streq(prop->name, prop2->name))
265                                 FAIL(c, "Duplicate property name %s in %s",
266                                      prop->name, node->fullpath);
267                 }
268         }
269 }
270 NODE_ERROR(duplicate_property_names, NULL);
271 
272 #define LOWERCASE       "abcdefghijklmnopqrstuvwxyz"
273 #define UPPERCASE       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
274 #define DIGITS          "0123456789"
275 #define PROPNODECHARS   LOWERCASE UPPERCASE DIGITS ",._+*#?-"
276 
277 static void check_node_name_chars(struct check *c, struct node *dt,
278                                   struct node *node)
279 {
280         int n = strspn(node->name, c->data);
281 
282         if (n < strlen(node->name))
283                 FAIL(c, "Bad character '%c' in node %s",
284                      node->name[n], node->fullpath);
285 }
286 NODE_ERROR(node_name_chars, PROPNODECHARS "@");
287 
288 static void check_node_name_format(struct check *c, struct node *dt,
289                                    struct node *node)
290 {
291         if (strchr(get_unitname(node), '@'))
292                 FAIL(c, "Node %s has multiple '@' characters in name",
293                      node->fullpath);
294 }
295 NODE_ERROR(node_name_format, NULL, &node_name_chars);
296 
297 static void check_unit_address_vs_reg(struct check *c, struct node *dt,
298                              struct node *node)
299 {
300         const char *unitname = get_unitname(node);
301         struct property *prop = get_property(node, "reg");
302 
303         if (!prop) {
304                 prop = get_property(node, "ranges");
305                 if (prop && !prop->val.len)
306                         prop = NULL;
307         }
308 
309         if (prop) {
310                 if (!unitname[0])
311                         FAIL(c, "Node %s has a reg or ranges property, but no unit name",
312                             node->fullpath);
313         } else {
314                 if (unitname[0])
315                         FAIL(c, "Node %s has a unit name, but no reg property",
316                             node->fullpath);
317         }
318 }
319 NODE_WARNING(unit_address_vs_reg, NULL);
320 
321 static void check_property_name_chars(struct check *c, struct node *dt,
322                                       struct node *node, struct property *prop)
323 {
324         int n = strspn(prop->name, c->data);
325 
326         if (n < strlen(prop->name))
327                 FAIL(c, "Bad character '%c' in property name \"%s\", node %s",
328                      prop->name[n], prop->name, node->fullpath);
329 }
330 PROP_ERROR(property_name_chars, PROPNODECHARS);
331 
332 #define DESCLABEL_FMT   "%s%s%s%s%s"
333 #define DESCLABEL_ARGS(node,prop,mark)          \
334         ((mark) ? "value of " : ""),            \
335         ((prop) ? "'" : ""), \
336         ((prop) ? (prop)->name : ""), \
337         ((prop) ? "' in " : ""), (node)->fullpath
338 
339 static void check_duplicate_label(struct check *c, struct node *dt,
340                                   const char *label, struct node *node,
341                                   struct property *prop, struct marker *mark)
342 {
343         struct node *othernode = NULL;
344         struct property *otherprop = NULL;
345         struct marker *othermark = NULL;
346 
347         othernode = get_node_by_label(dt, label);
348 
349         if (!othernode)
350                 otherprop = get_property_by_label(dt, label, &othernode);
351         if (!othernode)
352                 othermark = get_marker_label(dt, label, &othernode,
353                                                &otherprop);
354 
355         if (!othernode)
356                 return;
357 
358         if ((othernode != node) || (otherprop != prop) || (othermark != mark))
359                 FAIL(c, "Duplicate label '%s' on " DESCLABEL_FMT
360                      " and " DESCLABEL_FMT,
361                      label, DESCLABEL_ARGS(node, prop, mark),
362                      DESCLABEL_ARGS(othernode, otherprop, othermark));
363 }
364 
365 static void check_duplicate_label_node(struct check *c, struct node *dt,
366                                        struct node *node)
367 {
368         struct label *l;
369 
370         for_each_label(node->labels, l)
371                 check_duplicate_label(c, dt, l->label, node, NULL, NULL);
372 }
373 static void check_duplicate_label_prop(struct check *c, struct node *dt,
374                                        struct node *node, struct property *prop)
375 {
376         struct marker *m = prop->val.markers;
377         struct label *l;
378 
379         for_each_label(prop->labels, l)
380                 check_duplicate_label(c, dt, l->label, node, prop, NULL);
381 
382         for_each_marker_of_type(m, LABEL)
383                 check_duplicate_label(c, dt, m->ref, node, prop, m);
384 }
385 ERROR(duplicate_label, NULL, check_duplicate_label_node,
386       check_duplicate_label_prop, NULL);
387 
388 static void check_explicit_phandles(struct check *c, struct node *root,
389                                     struct node *node, struct property *prop)
390 {
391         struct marker *m;
392         struct node *other;
393         cell_t phandle;
394 
395         if (!streq(prop->name, "phandle")
396             && !streq(prop->name, "linux,phandle"))
397                 return;
398 
399         if (prop->val.len != sizeof(cell_t)) {
400                 FAIL(c, "%s has bad length (%d) %s property",
401                      node->fullpath, prop->val.len, prop->name);
402                 return;
403         }
404 
405         m = prop->val.markers;
406         for_each_marker_of_type(m, REF_PHANDLE) {
407                 assert(m->offset == 0);
408                 if (node != get_node_by_ref(root, m->ref))
409                         /* "Set this node's phandle equal to some
410                          * other node's phandle".  That's nonsensical
411                          * by construction. */ {
412                         FAIL(c, "%s in %s is a reference to another node",
413                              prop->name, node->fullpath);
414                         return;
415                 }
416                 /* But setting this node's phandle equal to its own
417                  * phandle is allowed - that means allocate a unique
418                  * phandle for this node, even if it's not otherwise
419                  * referenced.  The value will be filled in later, so
420                  * no further checking for now. */
421                 return;
422         }
423 
424         phandle = propval_cell(prop);
425 
426         if ((phandle == 0) || (phandle == -1)) {
427                 FAIL(c, "%s has bad value (0x%x) in %s property",
428                      node->fullpath, phandle, prop->name);
429                 return;
430         }
431 
432         if (node->phandle && (node->phandle != phandle))
433                 FAIL(c, "%s has %s property which replaces existing phandle information",
434                      node->fullpath, prop->name);
435 
436         other = get_node_by_phandle(root, phandle);
437         if (other && (other != node)) {
438                 FAIL(c, "%s has duplicated phandle 0x%x (seen before at %s)",
439                      node->fullpath, phandle, other->fullpath);
440                 return;
441         }
442 
443         node->phandle = phandle;
444 }
445 PROP_ERROR(explicit_phandles, NULL);
446 
447 static void check_name_properties(struct check *c, struct node *root,
448                                   struct node *node)
449 {
450         struct property **pp, *prop = NULL;
451 
452         for (pp = &node->proplist; *pp; pp = &((*pp)->next))
453                 if (streq((*pp)->name, "name")) {
454                         prop = *pp;
455                         break;
456                 }
457 
458         if (!prop)
459                 return; /* No name property, that's fine */
460 
461         if ((prop->val.len != node->basenamelen+1)
462             || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
463                 FAIL(c, "\"name\" property in %s is incorrect (\"%s\" instead"
464                      " of base node name)", node->fullpath, prop->val.val);
465         } else {
466                 /* The name property is correct, and therefore redundant.
467                  * Delete it */
468                 *pp = prop->next;
469                 free(prop->name);
470                 data_free(prop->val);
471                 free(prop);
472         }
473 }
474 ERROR_IF_NOT_STRING(name_is_string, "name");
475 NODE_ERROR(name_properties, NULL, &name_is_string);
476 
477 /*
478  * Reference fixup functions
479  */
480 
481 static void fixup_phandle_references(struct check *c, struct node *dt,
482                                      struct node *node, struct property *prop)
483 {
484         struct marker *m = prop->val.markers;
485         struct node *refnode;
486         cell_t phandle;
487 
488         for_each_marker_of_type(m, REF_PHANDLE) {
489                 assert(m->offset + sizeof(cell_t) <= prop->val.len);
490 
491                 refnode = get_node_by_ref(dt, m->ref);
492                 if (! refnode) {
493                         FAIL(c, "Reference to non-existent node or label \"%s\"\n",
494                              m->ref);
495                         continue;
496                 }
497 
498                 phandle = get_node_phandle(dt, refnode);
499                 *((cell_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
500         }
501 }
502 ERROR(phandle_references, NULL, NULL, fixup_phandle_references, NULL,
503       &duplicate_node_names, &explicit_phandles);
504 
505 static void fixup_path_references(struct check *c, struct node *dt,
506                                   struct node *node, struct property *prop)
507 {
508         struct marker *m = prop->val.markers;
509         struct node *refnode;
510         char *path;
511 
512         for_each_marker_of_type(m, REF_PATH) {
513                 assert(m->offset <= prop->val.len);
514 
515                 refnode = get_node_by_ref(dt, m->ref);
516                 if (!refnode) {
517                         FAIL(c, "Reference to non-existent node or label \"%s\"\n",
518                              m->ref);
519                         continue;
520                 }
521 
522                 path = refnode->fullpath;
523                 prop->val = data_insert_at_marker(prop->val, m, path,
524                                                   strlen(path) + 1);
525         }
526 }
527 ERROR(path_references, NULL, NULL, fixup_path_references, NULL,
528       &duplicate_node_names);
529 
530 /*
531  * Semantic checks
532  */
533 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
534 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
535 WARNING_IF_NOT_CELL(interrupt_cells_is_cell, "#interrupt-cells");
536 
537 WARNING_IF_NOT_STRING(device_type_is_string, "device_type");
538 WARNING_IF_NOT_STRING(model_is_string, "model");
539 WARNING_IF_NOT_STRING(status_is_string, "status");
540 
541 static void fixup_addr_size_cells(struct check *c, struct node *dt,
542                                   struct node *node)
543 {
544         struct property *prop;
545 
546         node->addr_cells = -1;
547         node->size_cells = -1;
548 
549         prop = get_property(node, "#address-cells");
550         if (prop)
551                 node->addr_cells = propval_cell(prop);
552 
553         prop = get_property(node, "#size-cells");
554         if (prop)
555                 node->size_cells = propval_cell(prop);
556 }
557 WARNING(addr_size_cells, NULL, fixup_addr_size_cells, NULL, NULL,
558         &address_cells_is_cell, &size_cells_is_cell);
559 
560 #define node_addr_cells(n) \
561         (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
562 #define node_size_cells(n) \
563         (((n)->size_cells == -1) ? 1 : (n)->size_cells)
564 
565 static void check_reg_format(struct check *c, struct node *dt,
566                              struct node *node)
567 {
568         struct property *prop;
569         int addr_cells, size_cells, entrylen;
570 
571         prop = get_property(node, "reg");
572         if (!prop)
573                 return; /* No "reg", that's fine */
574 
575         if (!node->parent) {
576                 FAIL(c, "Root node has a \"reg\" property");
577                 return;
578         }
579 
580         if (prop->val.len == 0)
581                 FAIL(c, "\"reg\" property in %s is empty", node->fullpath);
582 
583         addr_cells = node_addr_cells(node->parent);
584         size_cells = node_size_cells(node->parent);
585         entrylen = (addr_cells + size_cells) * sizeof(cell_t);
586 
587         if (!entrylen || (prop->val.len % entrylen) != 0)
588                 FAIL(c, "\"reg\" property in %s has invalid length (%d bytes) "
589                      "(#address-cells == %d, #size-cells == %d)",
590                      node->fullpath, prop->val.len, addr_cells, size_cells);
591 }
592 NODE_WARNING(reg_format, NULL, &addr_size_cells);
593 
594 static void check_ranges_format(struct check *c, struct node *dt,
595                                 struct node *node)
596 {
597         struct property *prop;
598         int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen;
599 
600         prop = get_property(node, "ranges");
601         if (!prop)
602                 return;
603 
604         if (!node->parent) {
605                 FAIL(c, "Root node has a \"ranges\" property");
606                 return;
607         }
608 
609         p_addr_cells = node_addr_cells(node->parent);
610         p_size_cells = node_size_cells(node->parent);
611         c_addr_cells = node_addr_cells(node);
612         c_size_cells = node_size_cells(node);
613         entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t);
614 
615         if (prop->val.len == 0) {
616                 if (p_addr_cells != c_addr_cells)
617                         FAIL(c, "%s has empty \"ranges\" property but its "
618                              "#address-cells (%d) differs from %s (%d)",
619                              node->fullpath, c_addr_cells, node->parent->fullpath,
620                              p_addr_cells);
621                 if (p_size_cells != c_size_cells)
622                         FAIL(c, "%s has empty \"ranges\" property but its "
623                              "#size-cells (%d) differs from %s (%d)",
624                              node->fullpath, c_size_cells, node->parent->fullpath,
625                              p_size_cells);
626         } else if ((prop->val.len % entrylen) != 0) {
627                 FAIL(c, "\"ranges\" property in %s has invalid length (%d bytes) "
628                      "(parent #address-cells == %d, child #address-cells == %d, "
629                      "#size-cells == %d)", node->fullpath, prop->val.len,
630                      p_addr_cells, c_addr_cells, c_size_cells);
631         }
632 }
633 NODE_WARNING(ranges_format, NULL, &addr_size_cells);
634 
635 /*
636  * Style checks
637  */
638 static void check_avoid_default_addr_size(struct check *c, struct node *dt,
639                                           struct node *node)
640 {
641         struct property *reg, *ranges;
642 
643         if (!node->parent)
644                 return; /* Ignore root node */
645 
646         reg = get_property(node, "reg");
647         ranges = get_property(node, "ranges");
648 
649         if (!reg && !ranges)
650                 return;
651 
652         if (node->parent->addr_cells == -1)
653                 FAIL(c, "Relying on default #address-cells value for %s",
654                      node->fullpath);
655 
656         if (node->parent->size_cells == -1)
657                 FAIL(c, "Relying on default #size-cells value for %s",
658                      node->fullpath);
659 }
660 NODE_WARNING(avoid_default_addr_size, NULL, &addr_size_cells);
661 
662 static void check_obsolete_chosen_interrupt_controller(struct check *c,
663                                                        struct node *dt)
664 {
665         struct node *chosen;
666         struct property *prop;
667 
668         chosen = get_node_by_path(dt, "/chosen");
669         if (!chosen)
670                 return;
671 
672         prop = get_property(chosen, "interrupt-controller");
673         if (prop)
674                 FAIL(c, "/chosen has obsolete \"interrupt-controller\" "
675                      "property");
676 }
677 TREE_WARNING(obsolete_chosen_interrupt_controller, NULL);
678 
679 static struct check *check_table[] = {
680         &duplicate_node_names, &duplicate_property_names,
681         &node_name_chars, &node_name_format, &property_name_chars,
682         &name_is_string, &name_properties,
683 
684         &duplicate_label,
685 
686         &explicit_phandles,
687         &phandle_references, &path_references,
688 
689         &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,
690         &device_type_is_string, &model_is_string, &status_is_string,
691 
692         &addr_size_cells, &reg_format, &ranges_format,
693 
694         &unit_address_vs_reg,
695 
696         &avoid_default_addr_size,
697         &obsolete_chosen_interrupt_controller,
698 
699         &always_fail,
700 };
701 
702 static void enable_warning_error(struct check *c, bool warn, bool error)
703 {
704         int i;
705 
706         /* Raising level, also raise it for prereqs */
707         if ((warn && !c->warn) || (error && !c->error))
708                 for (i = 0; i < c->num_prereqs; i++)
709                         enable_warning_error(c->prereq[i], warn, error);
710 
711         c->warn = c->warn || warn;
712         c->error = c->error || error;
713 }
714 
715 static void disable_warning_error(struct check *c, bool warn, bool error)
716 {
717         int i;
718 
719         /* Lowering level, also lower it for things this is the prereq
720          * for */
721         if ((warn && c->warn) || (error && c->error)) {
722                 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
723                         struct check *cc = check_table[i];
724                         int j;
725 
726                         for (j = 0; j < cc->num_prereqs; j++)
727                                 if (cc->prereq[j] == c)
728                                         disable_warning_error(cc, warn, error);
729                 }
730         }
731 
732         c->warn = c->warn && !warn;
733         c->error = c->error && !error;
734 }
735 
736 void parse_checks_option(bool warn, bool error, const char *arg)
737 {
738         int i;
739         const char *name = arg;
740         bool enable = true;
741 
742         if ((strncmp(arg, "no-", 3) == 0)
743             || (strncmp(arg, "no_", 3) == 0)) {
744                 name = arg + 3;
745                 enable = false;
746         }
747 
748         for (i = 0; i < ARRAY_SIZE(check_table); i++) {
749                 struct check *c = check_table[i];
750 
751                 if (streq(c->name, name)) {
752                         if (enable)
753                                 enable_warning_error(c, warn, error);
754                         else
755                                 disable_warning_error(c, warn, error);
756                         return;
757                 }
758         }
759 
760         die("Unrecognized check name \"%s\"\n", name);
761 }
762 
763 void process_checks(bool force, struct boot_info *bi)
764 {
765         struct node *dt = bi->dt;
766         int i;
767         int error = 0;
768 
769         for (i = 0; i < ARRAY_SIZE(check_table); i++) {
770                 struct check *c = check_table[i];
771 
772                 if (c->warn || c->error)
773                         error = error || run_check(c, dt);
774         }
775 
776         if (error) {
777                 if (!force) {
778                         fprintf(stderr, "ERROR: Input tree has errors, aborting "
779                                 "(use -f to force output)\n");
780                         exit(2);
781                 } else if (quiet < 3) {
782                         fprintf(stderr, "Warning: Input tree has errors, "
783                                 "output forced\n");
784                 }
785         }
786 }
787 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp