/*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2013 David Chisnall * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) * ("CTSRD"), as part of the DARPA CRASH research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _CHECKING_HH_ #define _CHECKING_HH_ #include <string> #include "fdt.hh" namespace dtc { namespace fdt { namespace checking { /** * Base class for all checkers. This will visit the entire tree and perform * semantic checks defined in subclasses. Note that device trees are generally * small (a few dozen nodes at most) and so we optimise for flexibility and * extensibility here, not for performance. Each checker will visit the entire * tree. */ class checker { /** * The path to the current node being checked. This is used for * printing error messages. */ device_tree::node_path path; /** * The name of the checker. This is used for printing error messages * and for enabling / disabling specific checkers from the command * line. */ const char *checker_name; /** * Visits each node, calling the checker functions on properties and * nodes. */ bool visit_node(device_tree *tree, const node_ptr &n); protected: /** * Prints the error message, along with the path to the node that * caused the error and the name of the checker. */ void report_error(const char *errmsg); public: /** * Constructor. Takes the name of this checker, which is which is used * when reporting errors. */ checker(const char *name) : checker_name(name) {} /** * Virtual destructor in case any subclasses need to do cleanup. */ virtual ~checker() {} /** * Method for checking that a node is valid. The root class version * does nothing, subclasses should override this. */ virtual bool check_node(device_tree *, const node_ptr &) { return true; } /** * Method for checking that a property is valid. The root class * version does nothing, subclasses should override this. */ virtual bool check_property(device_tree *, const node_ptr &, property_ptr ) { return true; } /** * Runs the checker on the specified device tree. */ bool check_tree(fdt::device_tree *tree) { return visit_node(tree, tree->get_root()); } }; /** * Abstract base class for simple property checks. This class defines a check * method for subclasses, which is invoked only when it finds a property with * the matching name. To define simple property checkers, just subclass this * and override the check() method. */ class property_checker : public checker { /** * The name of the property that this checker is looking for. */ std::string key; public: /** * Implementation of the generic property-checking method that checks * for a property with the name specified in the constructor. */ virtual bool check_property(device_tree *tree, const node_ptr &n, property_ptr p); /** * Constructor. Takes the name of the checker and the name of the * property to check. */ property_checker(const char* name, const std::string &property_name) : checker(name), key(property_name) {} /** * The check method, which subclasses should implement. */ virtual bool check(device_tree *tree, const node_ptr &n, property_ptr p) = 0; }; /** * Property type checker. */ template<property_value::value_type T> struct property_type_checker : public property_checker { /** * Constructor, takes the name of the checker and the name of the * property to check as arguments. */ property_type_checker(const char* name, const std::string &property_name) : property_checker(name, property_name) {} virtual bool check(device_tree *tree, const node_ptr &n, property_ptr p) = 0; }; /** * Empty property checker. This checks that the property has no value. */ template<> struct property_type_checker <property_value::EMPTY> : public property_checker { property_type_checker(const char* name, const std::string &property_name) : property_checker(name, property_name) {} virtual bool check(device_tree *, const node_ptr &, property_ptr p) { return p->begin() == p->end(); } }; /** * String property checker. This checks that the property has exactly one * value, which is a string. */ template<> struct property_type_checker <property_value::STRING> : public property_checker { property_type_checker(const char* name, const std::string &property_name) : property_checker(name, property_name) {} virtual bool check(device_tree *, const node_ptr &, property_ptr p) { return (p->begin() + 1 == p->end()) && p->begin()->is_string(); } }; /** * String list property checker. This checks that the property has at least * one value, all of which are strings. */ template<> struct property_type_checker <property_value::STRING_LIST> : public property_checker { property_type_checker(const char* name, const std::string &property_name) : property_checker(name, property_name) {} virtual bool check(device_tree *, const node_ptr &, property_ptr p) { for (property::value_iterator i=p->begin(),e=p->end() ; i!=e ; ++i) { if (!(i->is_string() || i->is_string_list())) { return false; } } return p->begin() != p->end(); } }; /** * Phandle property checker. This checks that the property has exactly one * value, which is a valid phandle. */ template<> struct property_type_checker <property_value::PHANDLE> : public property_checker { property_type_checker(const char* name, const std::string &property_name) : property_checker(name, property_name) {} virtual bool check(device_tree *tree, const node_ptr &, property_ptr p) { return (p->begin() + 1 == p->end()) && (tree->referenced_node(*p->begin()) != 0); } }; /** * Check that a property has the correct size. */ struct property_size_checker : public property_checker { /** * The expected size of the property. */ uint32_t size; public: /** * Constructor, takes the name of the checker, the name of the property * to check, and its expected size as arguments. */ property_size_checker(const char* name, const std::string &property_name, uint32_t bytes) : property_checker(name, property_name), size(bytes) {} /** * Check, validates that the property has the correct size. */ virtual bool check(device_tree *tree, const node_ptr &n, property_ptr p); }; /** * The check manager is the interface to running the checks. This allows * default checks to be enabled, non-default checks to be enabled, and so on. */ class check_manager { /** * The enabled checkers, indexed by their names. The name is used when * disabling checkers from the command line. When this manager runs, * it will only run the checkers from this map. */ std::unordered_map<std::string, checker*> checkers; /** * The disabled checkers. Moving checkers to this list disables them, * but allows them to be easily moved back. */ std::unordered_map<std::string, checker*> disabled_checkers; /** * Helper function for adding a property value checker. */ template<property_value::value_type T> void add_property_type_checker(const char *name, const std::string &prop); /** * Helper function for adding a simple type checker. */ void add_property_type_checker(const char *name, const std::string &prop); /** * Helper function for adding a property value checker. */ void add_property_size_checker(const char *name, const std::string &prop, uint32_t size); public: /** * Delete all of the checkers that are part of this checker manager. */ ~check_manager(); /** * Default constructor, creates check manager containing all of the * default checks. */ check_manager(); /** * Run all of the checks on the specified tree. */ bool run_checks(device_tree *tree, bool keep_going); /** * Disables the named checker. */ bool disable_checker(const std::string &name); /** * Enables the named checker. */ bool enable_checker(const std::string &name); }; } // namespace checking } // namespace fdt } // namespace dtc #endif // !_CHECKING_HH_
