1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Functions for working with device tree overlays 4 * 5 * Copyright (C) 2012 Pantelis Antoniou <panto@antoniou-consulting.com> 6 * Copyright (C) 2012 Texas Instruments Inc. 7 */ 8 9#define pr_fmt(fmt) "OF: overlay: " fmt 10 11#include <linux/kernel.h> 12#include <linux/module.h> 13#include <linux/of.h> 14#include <linux/of_device.h> 15#include <linux/of_fdt.h> 16#include <linux/string.h> 17#include <linux/ctype.h> 18#include <linux/errno.h> 19#include <linux/slab.h> 20#include <linux/libfdt.h> 21#include <linux/err.h> 22#include <linux/idr.h> 23 24#include "of_private.h" 25 26/** 27 * struct target - info about current target node as recursing through overlay 28 * @np: node where current level of overlay will be applied 29 * @in_livetree: @np is a node in the live devicetree 30 * 31 * Used in the algorithm to create the portion of a changeset that describes 32 * an overlay fragment, which is a devicetree subtree. Initially @np is a node 33 * in the live devicetree where the overlay subtree is targeted to be grafted 34 * into. When recursing to the next level of the overlay subtree, the target 35 * also recurses to the next level of the live devicetree, as long as overlay 36 * subtree node also exists in the live devicetree. When a node in the overlay 37 * subtree does not exist at the same level in the live devicetree, target->np 38 * points to a newly allocated node, and all subsequent targets in the subtree 39 * will be newly allocated nodes. 40 */ 41struct target { 42 struct device_node *np; 43 bool in_livetree; 44}; 45 46/** 47 * struct fragment - info about fragment nodes in overlay expanded device tree 48 * @overlay: pointer to the __overlay__ node 49 * @target: target of the overlay operation 50 */ 51struct fragment { 52 struct device_node *overlay; 53 struct device_node *target; 54}; 55 56/** 57 * struct overlay_changeset 58 * @id: changeset identifier 59 * @ovcs_list: list on which we are located 60 * @new_fdt: Memory allocated to hold unflattened aligned FDT 61 * @overlay_mem: the memory chunk that contains @overlay_root 62 * @overlay_root: expanded device tree that contains the fragment nodes 63 * @notify_state: most recent notify action used on overlay 64 * @count: count of fragment structures 65 * @fragments: fragment nodes in the overlay expanded device tree 66 * @symbols_fragment: last element of @fragments[] is the __symbols__ node 67 * @cset: changeset to apply fragments to live device tree 68 */ 69struct overlay_changeset { 70 int id; 71 struct list_head ovcs_list; 72 const void *new_fdt; 73 const void *overlay_mem; 74 struct device_node *overlay_root; 75 enum of_overlay_notify_action notify_state; 76 int count; 77 struct fragment *fragments; 78 bool symbols_fragment; 79 struct of_changeset cset; 80}; 81 82/* flags are sticky - once set, do not reset */ 83static int devicetree_state_flags; 84#define DTSF_APPLY_FAIL 0x01 85#define DTSF_REVERT_FAIL 0x02 86 87/* 88 * If a changeset apply or revert encounters an error, an attempt will 89 * be made to undo partial changes, but may fail. If the undo fails 90 * we do not know the state of the devicetree. 91 */ 92static int devicetree_corrupt(void) 93{ 94 return devicetree_state_flags & 95 (DTSF_APPLY_FAIL | DTSF_REVERT_FAIL); 96} 97 98static int build_changeset_next_level(struct overlay_changeset *ovcs, 99 struct target *target, const struct device_node *overlay_node); 100 101/* 102 * of_resolve_phandles() finds the largest phandle in the live tree. 103 * of_overlay_apply() may add a larger phandle to the live tree. 104 * Do not allow race between two overlays being applied simultaneously: 105 * mutex_lock(&of_overlay_phandle_mutex) 106 * of_resolve_phandles() 107 * of_overlay_apply() 108 * mutex_unlock(&of_overlay_phandle_mutex) 109 */ 110static DEFINE_MUTEX(of_overlay_phandle_mutex); 111 112void of_overlay_mutex_lock(void) 113{ 114 mutex_lock(&of_overlay_phandle_mutex); 115} 116 117void of_overlay_mutex_unlock(void) 118{ 119 mutex_unlock(&of_overlay_phandle_mutex); 120} 121 122static LIST_HEAD(ovcs_list); 123static DEFINE_IDR(ovcs_idr); 124 125static BLOCKING_NOTIFIER_HEAD(overlay_notify_chain); 126 127/** 128 * of_overlay_notifier_register() - Register notifier for overlay operations 129 * @nb: Notifier block to register 130 * 131 * Register for notification on overlay operations on device tree nodes. The 132 * reported actions definied by @of_reconfig_change. The notifier callback 133 * furthermore receives a pointer to the affected device tree node. 134 * 135 * Note that a notifier callback is not supposed to store pointers to a device 136 * tree node or its content beyond @OF_OVERLAY_POST_REMOVE corresponding to the 137 * respective node it received. 138 */ 139int of_overlay_notifier_register(struct notifier_block *nb) 140{ 141 return blocking_notifier_chain_register(&overlay_notify_chain, nb); 142} 143EXPORT_SYMBOL_GPL(of_overlay_notifier_register); 144 145/** 146 * of_overlay_notifier_unregister() - Unregister notifier for overlay operations 147 * @nb: Notifier block to unregister 148 */ 149int of_overlay_notifier_unregister(struct notifier_block *nb) 150{ 151 return blocking_notifier_chain_unregister(&overlay_notify_chain, nb); 152} 153EXPORT_SYMBOL_GPL(of_overlay_notifier_unregister); 154 155static int overlay_notify(struct overlay_changeset *ovcs, 156 enum of_overlay_notify_action action) 157{ 158 struct of_overlay_notify_data nd; 159 int i, ret; 160 161 ovcs->notify_state = action; 162 163 for (i = 0; i < ovcs->count; i++) { 164 struct fragment *fragment = &ovcs->fragments[i]; 165 166 nd.target = fragment->target; 167 nd.overlay = fragment->overlay; 168 169 ret = blocking_notifier_call_chain(&overlay_notify_chain, 170 action, &nd); 171 if (notifier_to_errno(ret)) { 172 ret = notifier_to_errno(ret); 173 pr_err("overlay changeset %s notifier error %d, target: %pOF\n", 174 of_overlay_action_name(action), ret, nd.target); 175 return ret; 176 } 177 } 178 179 return 0; 180} 181 182/* 183 * The values of properties in the "/__symbols__" node are paths in 184 * the ovcs->overlay_root. When duplicating the properties, the paths 185 * need to be adjusted to be the correct path for the live device tree. 186 * 187 * The paths refer to a node in the subtree of a fragment node's "__overlay__" 188 * node, for example "/fragment@0/__overlay__/symbol_path_tail", 189 * where symbol_path_tail can be a single node or it may be a multi-node path. 190 * 191 * The duplicated property value will be modified by replacing the 192 * "/fragment_name/__overlay/" portion of the value with the target 193 * path from the fragment node. 194 */ 195static struct property *dup_and_fixup_symbol_prop( 196 struct overlay_changeset *ovcs, const struct property *prop) 197{ 198 struct fragment *fragment; 199 struct property *new_prop; 200 struct device_node *fragment_node; 201 struct device_node *overlay_node; 202 const char *path; 203 const char *path_tail; 204 const char *target_path; 205 int k; 206 int overlay_name_len; 207 int path_len; 208 int path_tail_len; 209 int target_path_len; 210 211 if (!prop->value) 212 return NULL; 213 if (strnlen(prop->value, prop->length) >= prop->length) 214 return NULL; 215 path = prop->value; 216 path_len = strlen(path); 217 218 if (path_len < 1) 219 return NULL; 220 fragment_node = __of_find_node_by_path(ovcs->overlay_root, path + 1); 221 overlay_node = __of_find_node_by_path(fragment_node, "__overlay__/"); 222 of_node_put(fragment_node); 223 of_node_put(overlay_node); 224 225 for (k = 0; k < ovcs->count; k++) { 226 fragment = &ovcs->fragments[k]; 227 if (fragment->overlay == overlay_node) 228 break; 229 } 230 if (k >= ovcs->count) 231 return NULL; 232 233 overlay_name_len = snprintf(NULL, 0, "%pOF", fragment->overlay); 234 235 if (overlay_name_len > path_len) 236 return NULL; 237 path_tail = path + overlay_name_len; 238 path_tail_len = strlen(path_tail); 239 240 target_path = kasprintf(GFP_KERNEL, "%pOF", fragment->target); 241 if (!target_path) 242 return NULL; 243 target_path_len = strlen(target_path); 244 245 new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL); 246 if (!new_prop) 247 goto err_free_target_path; 248 249 new_prop->name = kstrdup(prop->name, GFP_KERNEL); 250 new_prop->length = target_path_len + path_tail_len + 1; 251 new_prop->value = kzalloc(new_prop->length, GFP_KERNEL); 252 if (!new_prop->name || !new_prop->value) 253 goto err_free_new_prop; 254 255 strcpy(new_prop->value, target_path); 256 strcpy(new_prop->value + target_path_len, path_tail); 257 258 of_property_set_flag(new_prop, OF_DYNAMIC); 259 260 kfree(target_path); 261 262 return new_prop; 263 264err_free_new_prop: 265 kfree(new_prop->name); 266 kfree(new_prop->value); 267 kfree(new_prop); 268err_free_target_path: 269 kfree(target_path); 270 271 return NULL; 272} 273 274/** 275 * add_changeset_property() - add @overlay_prop to overlay changeset 276 * @ovcs: overlay changeset 277 * @target: where @overlay_prop will be placed 278 * @overlay_prop: property to add or update, from overlay tree 279 * @is_symbols_prop: 1 if @overlay_prop is from node "/__symbols__" 280 * 281 * If @overlay_prop does not already exist in live devicetree, add changeset 282 * entry to add @overlay_prop in @target, else add changeset entry to update 283 * value of @overlay_prop. 284 * 285 * @target may be either in the live devicetree or in a new subtree that 286 * is contained in the changeset. 287 * 288 * Some special properties are not added or updated (no error returned): 289 * "name", "phandle", "linux,phandle". 290 * 291 * Properties "#address-cells" and "#size-cells" are not updated if they 292 * are already in the live tree, but if present in the live tree, the values 293 * in the overlay must match the values in the live tree. 294 * 295 * Update of property in symbols node is not allowed. 296 * 297 * Return: 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 298 * invalid @overlay. 299 */ 300static int add_changeset_property(struct overlay_changeset *ovcs, 301 struct target *target, struct property *overlay_prop, 302 bool is_symbols_prop) 303{ 304 struct property *new_prop = NULL, *prop; 305 int ret = 0; 306 307 if (target->in_livetree) 308 if (!of_prop_cmp(overlay_prop->name, "name") || 309 !of_prop_cmp(overlay_prop->name, "phandle") || 310 !of_prop_cmp(overlay_prop->name, "linux,phandle")) 311 return 0; 312 313 if (target->in_livetree) 314 prop = of_find_property(target->np, overlay_prop->name, NULL); 315 else 316 prop = NULL; 317 318 if (prop) { 319 if (!of_prop_cmp(prop->name, "#address-cells")) { 320 if (!of_prop_val_eq(prop, overlay_prop)) { 321 pr_err("ERROR: changing value of #address-cells is not allowed in %pOF\n", 322 target->np); 323 ret = -EINVAL; 324 } 325 return ret; 326 327 } else if (!of_prop_cmp(prop->name, "#size-cells")) { 328 if (!of_prop_val_eq(prop, overlay_prop)) { 329 pr_err("ERROR: changing value of #size-cells is not allowed in %pOF\n", 330 target->np); 331 ret = -EINVAL; 332 } 333 return ret; 334 } 335 } 336 337 if (is_symbols_prop) { 338 if (prop) 339 return -EINVAL; 340 new_prop = dup_and_fixup_symbol_prop(ovcs, overlay_prop); 341 } else { 342 new_prop = __of_prop_dup(overlay_prop, GFP_KERNEL); 343 } 344 345 if (!new_prop) 346 return -ENOMEM; 347 348 if (!prop) { 349 if (!target->in_livetree) { 350 new_prop->next = target->np->deadprops; 351 target->np->deadprops = new_prop; 352 } 353 ret = of_changeset_add_property(&ovcs->cset, target->np, 354 new_prop); 355 } else { 356 ret = of_changeset_update_property(&ovcs->cset, target->np, 357 new_prop); 358 } 359 360 if (!of_node_check_flag(target->np, OF_OVERLAY)) 361 pr_err("WARNING: memory leak will occur if overlay removed, property: %pOF/%s\n", 362 target->np, new_prop->name); 363 364 if (ret) { 365 kfree(new_prop->name); 366 kfree(new_prop->value); 367 kfree(new_prop); 368 } 369 return ret; 370} 371 372/** 373 * add_changeset_node() - add @node (and children) to overlay changeset 374 * @ovcs: overlay changeset 375 * @target: where @node will be placed in live tree or changeset 376 * @node: node from within overlay device tree fragment 377 * 378 * If @node does not already exist in @target, add changeset entry 379 * to add @node in @target. 380 * 381 * If @node already exists in @target, and the existing node has 382 * a phandle, the overlay node is not allowed to have a phandle. 383 * 384 * If @node has child nodes, add the children recursively via 385 * build_changeset_next_level(). 386 * 387 * NOTE_1: A live devicetree created from a flattened device tree (FDT) will 388 * not contain the full path in node->full_name. Thus an overlay 389 * created from an FDT also will not contain the full path in 390 * node->full_name. However, a live devicetree created from Open 391 * Firmware may have the full path in node->full_name. 392 * 393 * add_changeset_node() follows the FDT convention and does not include 394 * the full path in node->full_name. Even though it expects the overlay 395 * to not contain the full path, it uses kbasename() to remove the 396 * full path should it exist. It also uses kbasename() in comparisons 397 * to nodes in the live devicetree so that it can apply an overlay to 398 * a live devicetree created from Open Firmware. 399 * 400 * NOTE_2: Multiple mods of created nodes not supported. 401 * 402 * Return: 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 403 * invalid @overlay. 404 */ 405static int add_changeset_node(struct overlay_changeset *ovcs, 406 struct target *target, struct device_node *node) 407{ 408 const char *node_kbasename; 409 const __be32 *phandle; 410 struct device_node *tchild; 411 struct target target_child; 412 int ret = 0, size; 413 414 node_kbasename = kbasename(node->full_name); 415 416 for_each_child_of_node(target->np, tchild) 417 if (!of_node_cmp(node_kbasename, kbasename(tchild->full_name))) 418 break; 419 420 if (!tchild) { 421 tchild = __of_node_dup(NULL, node_kbasename); 422 if (!tchild) 423 return -ENOMEM; 424 425 tchild->parent = target->np; 426 tchild->name = __of_get_property(node, "name", NULL); 427 428 if (!tchild->name) 429 tchild->name = "<NULL>"; 430 431 /* ignore obsolete "linux,phandle" */ 432 phandle = __of_get_property(node, "phandle", &size); 433 if (phandle && (size == 4)) 434 tchild->phandle = be32_to_cpup(phandle); 435 436 of_node_set_flag(tchild, OF_OVERLAY); 437 438 ret = of_changeset_attach_node(&ovcs->cset, tchild); 439 if (ret) 440 return ret; 441 442 target_child.np = tchild; 443 target_child.in_livetree = false; 444 445 ret = build_changeset_next_level(ovcs, &target_child, node); 446 of_node_put(tchild); 447 return ret; 448 } 449 450 if (node->phandle && tchild->phandle) { 451 ret = -EINVAL; 452 } else { 453 target_child.np = tchild; 454 target_child.in_livetree = target->in_livetree; 455 ret = build_changeset_next_level(ovcs, &target_child, node); 456 } 457 of_node_put(tchild); 458 459 return ret; 460} 461 462/** 463 * build_changeset_next_level() - add level of overlay changeset 464 * @ovcs: overlay changeset 465 * @target: where to place @overlay_node in live tree 466 * @overlay_node: node from within an overlay device tree fragment 467 * 468 * Add the properties (if any) and nodes (if any) from @overlay_node to the 469 * @ovcs->cset changeset. If an added node has child nodes, they will 470 * be added recursively. 471 * 472 * Do not allow symbols node to have any children. 473 * 474 * Return: 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 475 * invalid @overlay_node. 476 */ 477static int build_changeset_next_level(struct overlay_changeset *ovcs, 478 struct target *target, const struct device_node *overlay_node) 479{ 480 struct device_node *child; 481 struct property *prop; 482 int ret; 483 484 for_each_property_of_node(overlay_node, prop) { 485 ret = add_changeset_property(ovcs, target, prop, 0); 486 if (ret) { 487 pr_debug("Failed to apply prop @%pOF/%s, err=%d\n", 488 target->np, prop->name, ret); 489 return ret; 490 } 491 } 492 493 for_each_child_of_node(overlay_node, child) { 494 ret = add_changeset_node(ovcs, target, child); 495 if (ret) { 496 pr_debug("Failed to apply node @%pOF/%pOFn, err=%d\n", 497 target->np, child, ret); 498 of_node_put(child); 499 return ret; 500 } 501 } 502 503 return 0; 504} 505 506/* 507 * Add the properties from __overlay__ node to the @ovcs->cset changeset. 508 */ 509static int build_changeset_symbols_node(struct overlay_changeset *ovcs, 510 struct target *target, 511 const struct device_node *overlay_symbols_node) 512{ 513 struct property *prop; 514 int ret; 515 516 for_each_property_of_node(overlay_symbols_node, prop) { 517 ret = add_changeset_property(ovcs, target, prop, 1); 518 if (ret) { 519 pr_debug("Failed to apply symbols prop @%pOF/%s, err=%d\n", 520 target->np, prop->name, ret); 521 return ret; 522 } 523 } 524 525 return 0; 526} 527 528static int find_dup_cset_node_entry(struct overlay_changeset *ovcs, 529 struct of_changeset_entry *ce_1) 530{ 531 struct of_changeset_entry *ce_2; 532 char *fn_1, *fn_2; 533 int node_path_match; 534 535 if (ce_1->action != OF_RECONFIG_ATTACH_NODE && 536 ce_1->action != OF_RECONFIG_DETACH_NODE) 537 return 0; 538 539 ce_2 = ce_1; 540 list_for_each_entry_continue(ce_2, &ovcs->cset.entries, node) { 541 if ((ce_2->action != OF_RECONFIG_ATTACH_NODE && 542 ce_2->action != OF_RECONFIG_DETACH_NODE) || 543 of_node_cmp(ce_1->np->full_name, ce_2->np->full_name)) 544 continue; 545 546 fn_1 = kasprintf(GFP_KERNEL, "%pOF", ce_1->np); 547 fn_2 = kasprintf(GFP_KERNEL, "%pOF", ce_2->np); 548 node_path_match = !fn_1 || !fn_2 || !strcmp(fn_1, fn_2); 549 kfree(fn_1); 550 kfree(fn_2); 551 if (node_path_match) { 552 pr_err("ERROR: multiple fragments add and/or delete node %pOF\n", 553 ce_1->np); 554 return -EINVAL; 555 } 556 } 557 558 return 0; 559} 560 561static int find_dup_cset_prop(struct overlay_changeset *ovcs, 562 struct of_changeset_entry *ce_1) 563{ 564 struct of_changeset_entry *ce_2; 565 char *fn_1, *fn_2; 566 int node_path_match; 567 568 if (ce_1->action != OF_RECONFIG_ADD_PROPERTY && 569 ce_1->action != OF_RECONFIG_REMOVE_PROPERTY && 570 ce_1->action != OF_RECONFIG_UPDATE_PROPERTY) 571 return 0; 572 573 ce_2 = ce_1; 574 list_for_each_entry_continue(ce_2, &ovcs->cset.entries, node) { 575 if ((ce_2->action != OF_RECONFIG_ADD_PROPERTY && 576 ce_2->action != OF_RECONFIG_REMOVE_PROPERTY && 577 ce_2->action != OF_RECONFIG_UPDATE_PROPERTY) || 578 of_node_cmp(ce_1->np->full_name, ce_2->np->full_name)) 579 continue; 580 581 fn_1 = kasprintf(GFP_KERNEL, "%pOF", ce_1->np); 582 fn_2 = kasprintf(GFP_KERNEL, "%pOF", ce_2->np); 583 node_path_match = !fn_1 || !fn_2 || !strcmp(fn_1, fn_2); 584 kfree(fn_1); 585 kfree(fn_2); 586 if (node_path_match && 587 !of_prop_cmp(ce_1->prop->name, ce_2->prop->name)) { 588 pr_err("ERROR: multiple fragments add, update, and/or delete property %pOF/%s\n", 589 ce_1->np, ce_1->prop->name); 590 return -EINVAL; 591 } 592 } 593 594 return 0; 595} 596 597/** 598 * changeset_dup_entry_check() - check for duplicate entries 599 * @ovcs: Overlay changeset 600 * 601 * Check changeset @ovcs->cset for multiple {add or delete} node entries for 602 * the same node or duplicate {add, delete, or update} properties entries 603 * for the same property. 604 * 605 * Return: 0 on success, or -EINVAL if duplicate changeset entry found. 606 */ 607static int changeset_dup_entry_check(struct overlay_changeset *ovcs) 608{ 609 struct of_changeset_entry *ce_1; 610 int dup_entry = 0; 611 612 list_for_each_entry(ce_1, &ovcs->cset.entries, node) { 613 dup_entry |= find_dup_cset_node_entry(ovcs, ce_1); 614 dup_entry |= find_dup_cset_prop(ovcs, ce_1); 615 } 616 617 return dup_entry ? -EINVAL : 0; 618} 619 620/** 621 * build_changeset() - populate overlay changeset in @ovcs from @ovcs->fragments 622 * @ovcs: Overlay changeset 623 * 624 * Create changeset @ovcs->cset to contain the nodes and properties of the 625 * overlay device tree fragments in @ovcs->fragments[]. If an error occurs, 626 * any portions of the changeset that were successfully created will remain 627 * in @ovcs->cset. 628 * 629 * Return: 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 630 * invalid overlay in @ovcs->fragments[]. 631 */ 632static int build_changeset(struct overlay_changeset *ovcs) 633{ 634 struct fragment *fragment; 635 struct target target; 636 int fragments_count, i, ret; 637 638 /* 639 * if there is a symbols fragment in ovcs->fragments[i] it is 640 * the final element in the array 641 */ 642 if (ovcs->symbols_fragment) 643 fragments_count = ovcs->count - 1; 644 else 645 fragments_count = ovcs->count; 646 647 for (i = 0; i < fragments_count; i++) { 648 fragment = &ovcs->fragments[i]; 649 650 target.np = fragment->target; 651 target.in_livetree = true; 652 ret = build_changeset_next_level(ovcs, &target, 653 fragment->overlay); 654 if (ret) { 655 pr_debug("fragment apply failed '%pOF'\n", 656 fragment->target); 657 return ret; 658 } 659 } 660 661 if (ovcs->symbols_fragment) { 662 fragment = &ovcs->fragments[ovcs->count - 1]; 663 664 target.np = fragment->target; 665 target.in_livetree = true; 666 ret = build_changeset_symbols_node(ovcs, &target, 667 fragment->overlay); 668 if (ret) { 669 pr_debug("symbols fragment apply failed '%pOF'\n", 670 fragment->target); 671 return ret; 672 } 673 } 674 675 return changeset_dup_entry_check(ovcs); 676} 677 678/* 679 * Find the target node using a number of different strategies 680 * in order of preference: 681 * 682 * 1) "target" property containing the phandle of the target 683 * 2) "target-path" property containing the path of the target 684 */ 685static struct device_node *find_target(struct device_node *info_node, 686 struct device_node *target_base) 687{ 688 struct device_node *node; 689 char *target_path; 690 const char *path; 691 u32 val; 692 int ret; 693 694 ret = of_property_read_u32(info_node, "target", &val); 695 if (!ret) { 696 node = of_find_node_by_phandle(val); 697 if (!node) 698 pr_err("find target, node: %pOF, phandle 0x%x not found\n", 699 info_node, val); 700 return node; 701 } 702 703 ret = of_property_read_string(info_node, "target-path", &path); 704 if (!ret) { 705 if (target_base) { 706 target_path = kasprintf(GFP_KERNEL, "%pOF%s", target_base, path); 707 if (!target_path) 708 return NULL; 709 node = of_find_node_by_path(target_path); 710 if (!node) { 711 pr_err("find target, node: %pOF, path '%s' not found\n", 712 info_node, target_path); 713 } 714 kfree(target_path); 715 } else { 716 node = of_find_node_by_path(path); 717 if (!node) { 718 pr_err("find target, node: %pOF, path '%s' not found\n", 719 info_node, path); 720 } 721 } 722 return node; 723 } 724 725 pr_err("find target, node: %pOF, no target property\n", info_node); 726 727 return NULL; 728} 729 730/** 731 * init_overlay_changeset() - initialize overlay changeset from overlay tree 732 * @ovcs: Overlay changeset to build 733 * @target_base: Point to the target node to apply overlay 734 * 735 * Initialize @ovcs. Populate @ovcs->fragments with node information from 736 * the top level of @overlay_root. The relevant top level nodes are the 737 * fragment nodes and the __symbols__ node. Any other top level node will 738 * be ignored. Populate other @ovcs fields. 739 * 740 * Return: 0 on success, -ENOMEM if memory allocation failure, -EINVAL if error 741 * detected in @overlay_root. On error return, the caller of 742 * init_overlay_changeset() must call free_overlay_changeset(). 743 */ 744static int init_overlay_changeset(struct overlay_changeset *ovcs, 745 struct device_node *target_base) 746{ 747 struct device_node *node, *overlay_node; 748 struct fragment *fragment; 749 struct fragment *fragments; 750 int cnt, ret; 751 752 /* 753 * None of the resources allocated by this function will be freed in 754 * the error paths. Instead the caller of this function is required 755 * to call free_overlay_changeset() (which will free the resources) 756 * if error return. 757 */ 758 759 /* 760 * Warn for some issues. Can not return -EINVAL for these until 761 * of_unittest_apply_overlay() is fixed to pass these checks. 762 */ 763 if (!of_node_check_flag(ovcs->overlay_root, OF_DYNAMIC)) 764 pr_debug("%s() ovcs->overlay_root is not dynamic\n", __func__); 765 766 if (!of_node_check_flag(ovcs->overlay_root, OF_DETACHED)) 767 pr_debug("%s() ovcs->overlay_root is not detached\n", __func__); 768 769 if (!of_node_is_root(ovcs->overlay_root)) 770 pr_debug("%s() ovcs->overlay_root is not root\n", __func__); 771 772 cnt = 0; 773 774 /* fragment nodes */ 775 for_each_child_of_node(ovcs->overlay_root, node) { 776 overlay_node = of_get_child_by_name(node, "__overlay__"); 777 if (overlay_node) { 778 cnt++; 779 of_node_put(overlay_node); 780 } 781 } 782 783 node = of_get_child_by_name(ovcs->overlay_root, "__symbols__"); 784 if (node) { 785 cnt++; 786 of_node_put(node); 787 } 788 789 fragments = kcalloc(cnt, sizeof(*fragments), GFP_KERNEL); 790 if (!fragments) { 791 ret = -ENOMEM; 792 goto err_out; 793 } 794 ovcs->fragments = fragments; 795 796 cnt = 0; 797 for_each_child_of_node(ovcs->overlay_root, node) { 798 overlay_node = of_get_child_by_name(node, "__overlay__"); 799 if (!overlay_node) 800 continue; 801 802 fragment = &fragments[cnt]; 803 fragment->overlay = overlay_node; 804 fragment->target = find_target(node, target_base); 805 if (!fragment->target) { 806 of_node_put(fragment->overlay); 807 ret = -EINVAL; 808 of_node_put(node); 809 goto err_out; 810 } 811 812 cnt++; 813 } 814 815 /* 816 * if there is a symbols fragment in ovcs->fragments[i] it is 817 * the final element in the array 818 */ 819 node = of_get_child_by_name(ovcs->overlay_root, "__symbols__"); 820 if (node) { 821 ovcs->symbols_fragment = 1; 822 fragment = &fragments[cnt]; 823 fragment->overlay = node; 824 fragment->target = of_find_node_by_path("/__symbols__"); 825 826 if (!fragment->target) { 827 pr_err("symbols in overlay, but not in live tree\n"); 828 ret = -EINVAL; 829 of_node_put(node); 830 goto err_out; 831 } 832 833 cnt++; 834 } 835 836 if (!cnt) { 837 pr_err("no fragments or symbols in overlay\n"); 838 ret = -EINVAL; 839 goto err_out; 840 } 841 842 ovcs->count = cnt; 843 844 return 0; 845 846err_out: 847 pr_err("%s() failed, ret = %d\n", __func__, ret); 848 849 return ret; 850} 851 852static void free_overlay_changeset(struct overlay_changeset *ovcs) 853{ 854 int i; 855 856 if (ovcs->cset.entries.next) 857 of_changeset_destroy(&ovcs->cset); 858 859 if (ovcs->id) { 860 idr_remove(&ovcs_idr, ovcs->id); 861 list_del(&ovcs->ovcs_list); 862 ovcs->id = 0; 863 } 864 865 866 for (i = 0; i < ovcs->count; i++) { 867 of_node_put(ovcs->fragments[i].target); 868 of_node_put(ovcs->fragments[i].overlay); 869 } 870 kfree(ovcs->fragments); 871 872 /* 873 * There should be no live pointers into ovcs->overlay_mem and 874 * ovcs->new_fdt due to the policy that overlay notifiers are not 875 * allowed to retain pointers into the overlay devicetree other 876 * than during the window from OF_OVERLAY_PRE_APPLY overlay 877 * notifiers until the OF_OVERLAY_POST_REMOVE overlay notifiers. 878 * 879 * A memory leak will occur here if within the window. 880 */ 881 882 if (ovcs->notify_state == OF_OVERLAY_INIT || 883 ovcs->notify_state == OF_OVERLAY_POST_REMOVE) { 884 kfree(ovcs->overlay_mem); 885 kfree(ovcs->new_fdt); 886 } 887 kfree(ovcs); 888} 889 890/* 891 * internal documentation 892 * 893 * of_overlay_apply() - Create and apply an overlay changeset 894 * @ovcs: overlay changeset 895 * @base: point to the target node to apply overlay 896 * 897 * Creates and applies an overlay changeset. 898 * 899 * If an error is returned by an overlay changeset pre-apply notifier 900 * then no further overlay changeset pre-apply notifier will be called. 901 * 902 * If an error is returned by an overlay changeset post-apply notifier 903 * then no further overlay changeset post-apply notifier will be called. 904 * 905 * If more than one notifier returns an error, then the last notifier 906 * error to occur is returned. 907 * 908 * If an error occurred while applying the overlay changeset, then an 909 * attempt is made to revert any changes that were made to the 910 * device tree. If there were any errors during the revert attempt 911 * then the state of the device tree can not be determined, and any 912 * following attempt to apply or remove an overlay changeset will be 913 * refused. 914 * 915 * Returns 0 on success, or a negative error number. On error return, 916 * the caller of of_overlay_apply() must call free_overlay_changeset(). 917 */ 918 919static int of_overlay_apply(struct overlay_changeset *ovcs, 920 struct device_node *base) 921{ 922 int ret = 0, ret_revert, ret_tmp; 923 924 ret = of_resolve_phandles(ovcs->overlay_root); 925 if (ret) 926 goto out; 927 928 ret = init_overlay_changeset(ovcs, base); 929 if (ret) 930 goto out; 931 932 ret = overlay_notify(ovcs, OF_OVERLAY_PRE_APPLY); 933 if (ret) 934 goto out; 935 936 ret = build_changeset(ovcs); 937 if (ret) 938 goto out; 939 940 ret_revert = 0; 941 ret = __of_changeset_apply_entries(&ovcs->cset, &ret_revert); 942 if (ret) { 943 if (ret_revert) { 944 pr_debug("overlay changeset revert error %d\n", 945 ret_revert); 946 devicetree_state_flags |= DTSF_APPLY_FAIL; 947 } 948 goto out; 949 } 950 951 ret = __of_changeset_apply_notify(&ovcs->cset); 952 if (ret) 953 pr_err("overlay apply changeset entry notify error %d\n", ret); 954 /* notify failure is not fatal, continue */ 955 956 ret_tmp = overlay_notify(ovcs, OF_OVERLAY_POST_APPLY); 957 if (ret_tmp) 958 if (!ret) 959 ret = ret_tmp; 960 961out: 962 pr_debug("%s() err=%d\n", __func__, ret); 963 964 return ret; 965} 966 967/** 968 * of_overlay_fdt_apply() - Create and apply an overlay changeset 969 * @overlay_fdt: pointer to overlay FDT 970 * @overlay_fdt_size: number of bytes in @overlay_fdt 971 * @ret_ovcs_id: pointer for returning created changeset id 972 * @base: pointer for the target node to apply overlay 973 * 974 * Creates and applies an overlay changeset. 975 * 976 * See of_overlay_apply() for important behavior information. 977 * 978 * Return: 0 on success, or a negative error number. *@ret_ovcs_id is set to 979 * the value of overlay changeset id, which can be passed to of_overlay_remove() 980 * to remove the overlay. 981 * 982 * On error return, the changeset may be partially applied. This is especially 983 * likely if an OF_OVERLAY_POST_APPLY notifier returns an error. In this case 984 * the caller should call of_overlay_remove() with the value in *@ret_ovcs_id. 985 */ 986 987int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size, 988 int *ret_ovcs_id, struct device_node *base) 989{ 990 void *new_fdt; 991 void *new_fdt_align; 992 void *overlay_mem; 993 int ret; 994 u32 size; 995 struct overlay_changeset *ovcs; 996 997 *ret_ovcs_id = 0; 998 999 if (devicetree_corrupt()) { 1000 pr_err("devicetree state suspect, refuse to apply overlay\n"); 1001 return -EBUSY; 1002 } 1003 1004 if (overlay_fdt_size < sizeof(struct fdt_header) || 1005 fdt_check_header(overlay_fdt)) { 1006 pr_err("Invalid overlay_fdt header\n"); 1007 return -EINVAL; 1008 } 1009 1010 size = fdt_totalsize(overlay_fdt); 1011 if (overlay_fdt_size < size) 1012 return -EINVAL; 1013 1014 ovcs = kzalloc(sizeof(*ovcs), GFP_KERNEL); 1015 if (!ovcs) 1016 return -ENOMEM; 1017 1018 of_overlay_mutex_lock(); 1019 mutex_lock(&of_mutex); 1020 1021 /* 1022 * ovcs->notify_state must be set to OF_OVERLAY_INIT before allocating 1023 * ovcs resources, implicitly set by kzalloc() of ovcs 1024 */ 1025 1026 ovcs->id = idr_alloc(&ovcs_idr, ovcs, 1, 0, GFP_KERNEL); 1027 if (ovcs->id <= 0) { 1028 ret = ovcs->id; 1029 goto err_free_ovcs; 1030 } 1031 1032 INIT_LIST_HEAD(&ovcs->ovcs_list); 1033 list_add_tail(&ovcs->ovcs_list, &ovcs_list); 1034 of_changeset_init(&ovcs->cset); 1035 1036 /* 1037 * Must create permanent copy of FDT because of_fdt_unflatten_tree() 1038 * will create pointers to the passed in FDT in the unflattened tree. 1039 */ 1040 new_fdt = kmalloc(size + FDT_ALIGN_SIZE, GFP_KERNEL); 1041 if (!new_fdt) { 1042 ret = -ENOMEM; 1043 goto err_free_ovcs; 1044 } 1045 ovcs->new_fdt = new_fdt; 1046 1047 new_fdt_align = PTR_ALIGN(new_fdt, FDT_ALIGN_SIZE); 1048 memcpy(new_fdt_align, overlay_fdt, size); 1049 1050 overlay_mem = of_fdt_unflatten_tree(new_fdt_align, NULL, 1051 &ovcs->overlay_root); 1052 if (!overlay_mem) { 1053 pr_err("unable to unflatten overlay_fdt\n"); 1054 ret = -EINVAL; 1055 goto err_free_ovcs; 1056 } 1057 ovcs->overlay_mem = overlay_mem; 1058 1059 ret = of_overlay_apply(ovcs, base); 1060 /* 1061 * If of_overlay_apply() error, calling free_overlay_changeset() may 1062 * result in a memory leak if the apply partly succeeded, so do NOT 1063 * goto err_free_ovcs. Instead, the caller of of_overlay_fdt_apply() 1064 * can call of_overlay_remove(); 1065 */ 1066 *ret_ovcs_id = ovcs->id; 1067 goto out_unlock; 1068 1069err_free_ovcs: 1070 free_overlay_changeset(ovcs); 1071 1072out_unlock: 1073 mutex_unlock(&of_mutex); 1074 of_overlay_mutex_unlock(); 1075 return ret; 1076} 1077EXPORT_SYMBOL_GPL(of_overlay_fdt_apply); 1078 1079/* 1080 * Find @np in @tree. 1081 * 1082 * Returns 1 if @np is @tree or is contained in @tree, else 0 1083 */ 1084static int find_node(struct device_node *tree, struct device_node *np) 1085{ 1086 struct device_node *child; 1087 1088 if (tree == np) 1089 return 1; 1090 1091 for_each_child_of_node(tree, child) { 1092 if (find_node(child, np)) { 1093 of_node_put(child); 1094 return 1; 1095 } 1096 } 1097 1098 return 0; 1099} 1100 1101/* 1102 * Is @remove_ce_node a child of, a parent of, or the same as any 1103 * node in an overlay changeset more topmost than @remove_ovcs? 1104 * 1105 * Returns 1 if found, else 0 1106 */ 1107static int node_overlaps_later_cs(struct overlay_changeset *remove_ovcs, 1108 struct device_node *remove_ce_node) 1109{ 1110 struct overlay_changeset *ovcs; 1111 struct of_changeset_entry *ce; 1112 1113 list_for_each_entry_reverse(ovcs, &ovcs_list, ovcs_list) { 1114 if (ovcs == remove_ovcs) 1115 break; 1116 1117 list_for_each_entry(ce, &ovcs->cset.entries, node) { 1118 if (find_node(ce->np, remove_ce_node)) { 1119 pr_err("%s: #%d overlaps with #%d @%pOF\n", 1120 __func__, remove_ovcs->id, ovcs->id, 1121 remove_ce_node); 1122 return 1; 1123 } 1124 if (find_node(remove_ce_node, ce->np)) { 1125 pr_err("%s: #%d overlaps with #%d @%pOF\n", 1126 __func__, remove_ovcs->id, ovcs->id, 1127 remove_ce_node); 1128 return 1; 1129 } 1130 } 1131 } 1132 1133 return 0; 1134} 1135 1136/* 1137 * We can safely remove the overlay only if it's the top-most one. 1138 * Newly applied overlays are inserted at the tail of the overlay list, 1139 * so a top most overlay is the one that is closest to the tail. 1140 * 1141 * The topmost check is done by exploiting this property. For each 1142 * affected device node in the log list we check if this overlay is 1143 * the one closest to the tail. If another overlay has affected this 1144 * device node and is closest to the tail, then removal is not permitted. 1145 */ 1146static int overlay_removal_is_ok(struct overlay_changeset *remove_ovcs) 1147{ 1148 struct of_changeset_entry *remove_ce; 1149 1150 list_for_each_entry(remove_ce, &remove_ovcs->cset.entries, node) { 1151 if (node_overlaps_later_cs(remove_ovcs, remove_ce->np)) { 1152 pr_err("overlay #%d is not topmost\n", remove_ovcs->id); 1153 return 0; 1154 } 1155 } 1156 1157 return 1; 1158} 1159 1160/** 1161 * of_overlay_remove() - Revert and free an overlay changeset 1162 * @ovcs_id: Pointer to overlay changeset id 1163 * 1164 * Removes an overlay if it is permissible. @ovcs_id was previously returned 1165 * by of_overlay_fdt_apply(). 1166 * 1167 * If an error occurred while attempting to revert the overlay changeset, 1168 * then an attempt is made to re-apply any changeset entry that was 1169 * reverted. If an error occurs on re-apply then the state of the device 1170 * tree can not be determined, and any following attempt to apply or remove 1171 * an overlay changeset will be refused. 1172 * 1173 * A non-zero return value will not revert the changeset if error is from: 1174 * - parameter checks 1175 * - overlay changeset pre-remove notifier 1176 * - overlay changeset entry revert 1177 * 1178 * If an error is returned by an overlay changeset pre-remove notifier 1179 * then no further overlay changeset pre-remove notifier will be called. 1180 * 1181 * If more than one notifier returns an error, then the last notifier 1182 * error to occur is returned. 1183 * 1184 * A non-zero return value will revert the changeset if error is from: 1185 * - overlay changeset entry notifier 1186 * - overlay changeset post-remove notifier 1187 * 1188 * If an error is returned by an overlay changeset post-remove notifier 1189 * then no further overlay changeset post-remove notifier will be called. 1190 * 1191 * Return: 0 on success, or a negative error number. *@ovcs_id is set to 1192 * zero after reverting the changeset, even if a subsequent error occurs. 1193 */ 1194int of_overlay_remove(int *ovcs_id) 1195{ 1196 struct overlay_changeset *ovcs; 1197 int ret, ret_apply, ret_tmp; 1198 1199 if (devicetree_corrupt()) { 1200 pr_err("suspect devicetree state, refuse to remove overlay\n"); 1201 ret = -EBUSY; 1202 goto out; 1203 } 1204 1205 mutex_lock(&of_mutex); 1206 1207 ovcs = idr_find(&ovcs_idr, *ovcs_id); 1208 if (!ovcs) { 1209 ret = -ENODEV; 1210 pr_err("remove: Could not find overlay #%d\n", *ovcs_id); 1211 goto err_unlock; 1212 } 1213 1214 if (!overlay_removal_is_ok(ovcs)) { 1215 ret = -EBUSY; 1216 goto err_unlock; 1217 } 1218 1219 ret = overlay_notify(ovcs, OF_OVERLAY_PRE_REMOVE); 1220 if (ret) 1221 goto err_unlock; 1222 1223 ret_apply = 0; 1224 ret = __of_changeset_revert_entries(&ovcs->cset, &ret_apply); 1225 if (ret) { 1226 if (ret_apply) 1227 devicetree_state_flags |= DTSF_REVERT_FAIL; 1228 goto err_unlock; 1229 } 1230 1231 ret = __of_changeset_revert_notify(&ovcs->cset); 1232 if (ret) 1233 pr_err("overlay remove changeset entry notify error %d\n", ret); 1234 /* notify failure is not fatal, continue */ 1235 1236 *ovcs_id = 0; 1237 1238 /* 1239 * Note that the overlay memory will be kfree()ed by 1240 * free_overlay_changeset() even if the notifier for 1241 * OF_OVERLAY_POST_REMOVE returns an error. 1242 */ 1243 ret_tmp = overlay_notify(ovcs, OF_OVERLAY_POST_REMOVE); 1244 if (ret_tmp) 1245 if (!ret) 1246 ret = ret_tmp; 1247 1248 free_overlay_changeset(ovcs); 1249 1250err_unlock: 1251 /* 1252 * If jumped over free_overlay_changeset(), then did not kfree() 1253 * overlay related memory. This is a memory leak unless a subsequent 1254 * of_overlay_remove() of this overlay is successful. 1255 */ 1256 mutex_unlock(&of_mutex); 1257 1258out: 1259 pr_debug("%s() err=%d\n", __func__, ret); 1260 1261 return ret; 1262} 1263EXPORT_SYMBOL_GPL(of_overlay_remove); 1264 1265/** 1266 * of_overlay_remove_all() - Reverts and frees all overlay changesets 1267 * 1268 * Removes all overlays from the system in the correct order. 1269 * 1270 * Return: 0 on success, or a negative error number 1271 */ 1272int of_overlay_remove_all(void) 1273{ 1274 struct overlay_changeset *ovcs, *ovcs_n; 1275 int ret; 1276 1277 /* the tail of list is guaranteed to be safe to remove */ 1278 list_for_each_entry_safe_reverse(ovcs, ovcs_n, &ovcs_list, ovcs_list) { 1279 ret = of_overlay_remove(&ovcs->id); 1280 if (ret) 1281 return ret; 1282 } 1283 1284 return 0; 1285} 1286EXPORT_SYMBOL_GPL(of_overlay_remove_all); 1287