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 fragment - info about fragment nodes in overlay expanded device tree 28 * @target: target of the overlay operation 29 * @overlay: pointer to the __overlay__ node 30 */ 31 struct fragment { 32 struct device_node *target; 33 struct device_node *overlay; 34 }; 35 36 /** 37 * struct overlay_changeset 38 * @id: changeset identifier 39 * @ovcs_list: list on which we are located 40 * @fdt: FDT that was unflattened to create @overlay_tree 41 * @overlay_tree: expanded device tree that contains the fragment nodes 42 * @count: count of fragment structures 43 * @fragments: fragment nodes in the overlay expanded device tree 44 * @symbols_fragment: last element of @fragments[] is the __symbols__ node 45 * @cset: changeset to apply fragments to live device tree 46 */ 47 struct overlay_changeset { 48 int id; 49 struct list_head ovcs_list; 50 const void *fdt; 51 struct device_node *overlay_tree; 52 int count; 53 struct fragment *fragments; 54 bool symbols_fragment; 55 struct of_changeset cset; 56 }; 57 58 /* flags are sticky - once set, do not reset */ 59 static int devicetree_state_flags; 60 #define DTSF_APPLY_FAIL 0x01 61 #define DTSF_REVERT_FAIL 0x02 62 63 /* 64 * If a changeset apply or revert encounters an error, an attempt will 65 * be made to undo partial changes, but may fail. If the undo fails 66 * we do not know the state of the devicetree. 67 */ 68 static int devicetree_corrupt(void) 69 { 70 return devicetree_state_flags & 71 (DTSF_APPLY_FAIL | DTSF_REVERT_FAIL); 72 } 73 74 static int build_changeset_next_level(struct overlay_changeset *ovcs, 75 struct device_node *target_node, 76 const struct device_node *overlay_node); 77 78 /* 79 * of_resolve_phandles() finds the largest phandle in the live tree. 80 * of_overlay_apply() may add a larger phandle to the live tree. 81 * Do not allow race between two overlays being applied simultaneously: 82 * mutex_lock(&of_overlay_phandle_mutex) 83 * of_resolve_phandles() 84 * of_overlay_apply() 85 * mutex_unlock(&of_overlay_phandle_mutex) 86 */ 87 static DEFINE_MUTEX(of_overlay_phandle_mutex); 88 89 void of_overlay_mutex_lock(void) 90 { 91 mutex_lock(&of_overlay_phandle_mutex); 92 } 93 94 void of_overlay_mutex_unlock(void) 95 { 96 mutex_unlock(&of_overlay_phandle_mutex); 97 } 98 99 100 static LIST_HEAD(ovcs_list); 101 static DEFINE_IDR(ovcs_idr); 102 103 static BLOCKING_NOTIFIER_HEAD(overlay_notify_chain); 104 105 int of_overlay_notifier_register(struct notifier_block *nb) 106 { 107 return blocking_notifier_chain_register(&overlay_notify_chain, nb); 108 } 109 EXPORT_SYMBOL_GPL(of_overlay_notifier_register); 110 111 int of_overlay_notifier_unregister(struct notifier_block *nb) 112 { 113 return blocking_notifier_chain_unregister(&overlay_notify_chain, nb); 114 } 115 EXPORT_SYMBOL_GPL(of_overlay_notifier_unregister); 116 117 static char *of_overlay_action_name[] = { 118 "pre-apply", 119 "post-apply", 120 "pre-remove", 121 "post-remove", 122 }; 123 124 static int overlay_notify(struct overlay_changeset *ovcs, 125 enum of_overlay_notify_action action) 126 { 127 struct of_overlay_notify_data nd; 128 int i, ret; 129 130 for (i = 0; i < ovcs->count; i++) { 131 struct fragment *fragment = &ovcs->fragments[i]; 132 133 nd.target = fragment->target; 134 nd.overlay = fragment->overlay; 135 136 ret = blocking_notifier_call_chain(&overlay_notify_chain, 137 action, &nd); 138 if (ret == NOTIFY_OK || ret == NOTIFY_STOP) 139 return 0; 140 if (ret) { 141 ret = notifier_to_errno(ret); 142 pr_err("overlay changeset %s notifier error %d, target: %pOF\n", 143 of_overlay_action_name[action], ret, nd.target); 144 return ret; 145 } 146 } 147 148 return 0; 149 } 150 151 /* 152 * The values of properties in the "/__symbols__" node are paths in 153 * the ovcs->overlay_tree. When duplicating the properties, the paths 154 * need to be adjusted to be the correct path for the live device tree. 155 * 156 * The paths refer to a node in the subtree of a fragment node's "__overlay__" 157 * node, for example "/fragment@0/__overlay__/symbol_path_tail", 158 * where symbol_path_tail can be a single node or it may be a multi-node path. 159 * 160 * The duplicated property value will be modified by replacing the 161 * "/fragment_name/__overlay/" portion of the value with the target 162 * path from the fragment node. 163 */ 164 static struct property *dup_and_fixup_symbol_prop( 165 struct overlay_changeset *ovcs, const struct property *prop) 166 { 167 struct fragment *fragment; 168 struct property *new_prop; 169 struct device_node *fragment_node; 170 struct device_node *overlay_node; 171 const char *path; 172 const char *path_tail; 173 const char *target_path; 174 int k; 175 int overlay_name_len; 176 int path_len; 177 int path_tail_len; 178 int target_path_len; 179 180 if (!prop->value) 181 return NULL; 182 if (strnlen(prop->value, prop->length) >= prop->length) 183 return NULL; 184 path = prop->value; 185 path_len = strlen(path); 186 187 if (path_len < 1) 188 return NULL; 189 fragment_node = __of_find_node_by_path(ovcs->overlay_tree, path + 1); 190 overlay_node = __of_find_node_by_path(fragment_node, "__overlay__/"); 191 of_node_put(fragment_node); 192 of_node_put(overlay_node); 193 194 for (k = 0; k < ovcs->count; k++) { 195 fragment = &ovcs->fragments[k]; 196 if (fragment->overlay == overlay_node) 197 break; 198 } 199 if (k >= ovcs->count) 200 return NULL; 201 202 overlay_name_len = snprintf(NULL, 0, "%pOF", fragment->overlay); 203 204 if (overlay_name_len > path_len) 205 return NULL; 206 path_tail = path + overlay_name_len; 207 path_tail_len = strlen(path_tail); 208 209 target_path = kasprintf(GFP_KERNEL, "%pOF", fragment->target); 210 if (!target_path) 211 return NULL; 212 target_path_len = strlen(target_path); 213 214 new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL); 215 if (!new_prop) 216 goto err_free_target_path; 217 218 new_prop->name = kstrdup(prop->name, GFP_KERNEL); 219 new_prop->length = target_path_len + path_tail_len + 1; 220 new_prop->value = kzalloc(new_prop->length, GFP_KERNEL); 221 if (!new_prop->name || !new_prop->value) 222 goto err_free_new_prop; 223 224 strcpy(new_prop->value, target_path); 225 strcpy(new_prop->value + target_path_len, path_tail); 226 227 of_property_set_flag(new_prop, OF_DYNAMIC); 228 229 return new_prop; 230 231 err_free_new_prop: 232 kfree(new_prop->name); 233 kfree(new_prop->value); 234 kfree(new_prop); 235 err_free_target_path: 236 kfree(target_path); 237 238 return NULL; 239 } 240 241 /** 242 * add_changeset_property() - add @overlay_prop to overlay changeset 243 * @ovcs: overlay changeset 244 * @target_node: where to place @overlay_prop in live tree 245 * @overlay_prop: property to add or update, from overlay tree 246 * @is_symbols_prop: 1 if @overlay_prop is from node "/__symbols__" 247 * 248 * If @overlay_prop does not already exist in @target_node, add changeset entry 249 * to add @overlay_prop in @target_node, else add changeset entry to update 250 * value of @overlay_prop. 251 * 252 * Some special properties are not updated (no error returned). 253 * 254 * Update of property in symbols node is not allowed. 255 * 256 * Returns 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 257 * invalid @overlay. 258 */ 259 static int add_changeset_property(struct overlay_changeset *ovcs, 260 struct device_node *target_node, 261 struct property *overlay_prop, 262 bool is_symbols_prop) 263 { 264 struct property *new_prop = NULL, *prop; 265 int ret = 0; 266 267 prop = of_find_property(target_node, overlay_prop->name, NULL); 268 269 if (!of_prop_cmp(overlay_prop->name, "name") || 270 !of_prop_cmp(overlay_prop->name, "phandle") || 271 !of_prop_cmp(overlay_prop->name, "linux,phandle")) 272 return 0; 273 274 if (is_symbols_prop) { 275 if (prop) 276 return -EINVAL; 277 new_prop = dup_and_fixup_symbol_prop(ovcs, overlay_prop); 278 } else { 279 new_prop = __of_prop_dup(overlay_prop, GFP_KERNEL); 280 } 281 282 if (!new_prop) 283 return -ENOMEM; 284 285 if (!prop) 286 ret = of_changeset_add_property(&ovcs->cset, target_node, 287 new_prop); 288 else 289 ret = of_changeset_update_property(&ovcs->cset, target_node, 290 new_prop); 291 292 if (ret) { 293 kfree(new_prop->name); 294 kfree(new_prop->value); 295 kfree(new_prop); 296 } 297 return ret; 298 } 299 300 /** 301 * add_changeset_node() - add @node (and children) to overlay changeset 302 * @ovcs: overlay changeset 303 * @target_node: where to place @node in live tree 304 * @node: node from within overlay device tree fragment 305 * 306 * If @node does not already exist in @target_node, add changeset entry 307 * to add @node in @target_node. 308 * 309 * If @node already exists in @target_node, and the existing node has 310 * a phandle, the overlay node is not allowed to have a phandle. 311 * 312 * If @node has child nodes, add the children recursively via 313 * build_changeset_next_level(). 314 * 315 * NOTE: Multiple mods of created nodes not supported. 316 * If more than one fragment contains a node that does not already exist 317 * in the live tree, then for each fragment of_changeset_attach_node() 318 * will add a changeset entry to add the node. When the changeset is 319 * applied, __of_attach_node() will attach the node twice (once for 320 * each fragment). At this point the device tree will be corrupted. 321 * 322 * TODO: add integrity check to ensure that multiple fragments do not 323 * create the same node. 324 * 325 * Returns 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 326 * invalid @overlay. 327 */ 328 static int add_changeset_node(struct overlay_changeset *ovcs, 329 struct device_node *target_node, struct device_node *node) 330 { 331 const char *node_kbasename; 332 struct device_node *tchild; 333 int ret = 0; 334 335 node_kbasename = kbasename(node->full_name); 336 337 for_each_child_of_node(target_node, tchild) 338 if (!of_node_cmp(node_kbasename, kbasename(tchild->full_name))) 339 break; 340 341 if (!tchild) { 342 tchild = __of_node_dup(node, "%pOF/%s", 343 target_node, node_kbasename); 344 if (!tchild) 345 return -ENOMEM; 346 347 tchild->parent = target_node; 348 349 ret = of_changeset_attach_node(&ovcs->cset, tchild); 350 if (ret) 351 return ret; 352 353 return build_changeset_next_level(ovcs, tchild, node); 354 } 355 356 if (node->phandle && tchild->phandle) 357 ret = -EINVAL; 358 else 359 ret = build_changeset_next_level(ovcs, tchild, node); 360 of_node_put(tchild); 361 362 return ret; 363 } 364 365 /** 366 * build_changeset_next_level() - add level of overlay changeset 367 * @ovcs: overlay changeset 368 * @target_node: where to place @overlay_node in live tree 369 * @overlay_node: node from within an overlay device tree fragment 370 * 371 * Add the properties (if any) and nodes (if any) from @overlay_node to the 372 * @ovcs->cset changeset. If an added node has child nodes, they will 373 * be added recursively. 374 * 375 * Do not allow symbols node to have any children. 376 * 377 * Returns 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 378 * invalid @overlay_node. 379 */ 380 static int build_changeset_next_level(struct overlay_changeset *ovcs, 381 struct device_node *target_node, 382 const struct device_node *overlay_node) 383 { 384 struct device_node *child; 385 struct property *prop; 386 int ret; 387 388 for_each_property_of_node(overlay_node, prop) { 389 ret = add_changeset_property(ovcs, target_node, prop, 0); 390 if (ret) { 391 pr_debug("Failed to apply prop @%pOF/%s, err=%d\n", 392 target_node, prop->name, ret); 393 return ret; 394 } 395 } 396 397 for_each_child_of_node(overlay_node, child) { 398 ret = add_changeset_node(ovcs, target_node, child); 399 if (ret) { 400 pr_debug("Failed to apply node @%pOF/%s, err=%d\n", 401 target_node, child->name, ret); 402 of_node_put(child); 403 return ret; 404 } 405 } 406 407 return 0; 408 } 409 410 /* 411 * Add the properties from __overlay__ node to the @ovcs->cset changeset. 412 */ 413 static int build_changeset_symbols_node(struct overlay_changeset *ovcs, 414 struct device_node *target_node, 415 const struct device_node *overlay_symbols_node) 416 { 417 struct property *prop; 418 int ret; 419 420 for_each_property_of_node(overlay_symbols_node, prop) { 421 ret = add_changeset_property(ovcs, target_node, prop, 1); 422 if (ret) { 423 pr_debug("Failed to apply prop @%pOF/%s, err=%d\n", 424 target_node, prop->name, ret); 425 return ret; 426 } 427 } 428 429 return 0; 430 } 431 432 /** 433 * build_changeset() - populate overlay changeset in @ovcs from @ovcs->fragments 434 * @ovcs: Overlay changeset 435 * 436 * Create changeset @ovcs->cset to contain the nodes and properties of the 437 * overlay device tree fragments in @ovcs->fragments[]. If an error occurs, 438 * any portions of the changeset that were successfully created will remain 439 * in @ovcs->cset. 440 * 441 * Returns 0 on success, -ENOMEM if memory allocation failure, or -EINVAL if 442 * invalid overlay in @ovcs->fragments[]. 443 */ 444 static int build_changeset(struct overlay_changeset *ovcs) 445 { 446 struct fragment *fragment; 447 int fragments_count, i, ret; 448 449 /* 450 * if there is a symbols fragment in ovcs->fragments[i] it is 451 * the final element in the array 452 */ 453 if (ovcs->symbols_fragment) 454 fragments_count = ovcs->count - 1; 455 else 456 fragments_count = ovcs->count; 457 458 for (i = 0; i < fragments_count; i++) { 459 fragment = &ovcs->fragments[i]; 460 461 ret = build_changeset_next_level(ovcs, fragment->target, 462 fragment->overlay); 463 if (ret) { 464 pr_debug("apply failed '%pOF'\n", fragment->target); 465 return ret; 466 } 467 } 468 469 if (ovcs->symbols_fragment) { 470 fragment = &ovcs->fragments[ovcs->count - 1]; 471 ret = build_changeset_symbols_node(ovcs, fragment->target, 472 fragment->overlay); 473 if (ret) { 474 pr_debug("apply failed '%pOF'\n", fragment->target); 475 return ret; 476 } 477 } 478 479 return 0; 480 } 481 482 /* 483 * Find the target node using a number of different strategies 484 * in order of preference: 485 * 486 * 1) "target" property containing the phandle of the target 487 * 2) "target-path" property containing the path of the target 488 */ 489 static struct device_node *find_target_node(struct device_node *info_node) 490 { 491 struct device_node *node; 492 const char *path; 493 u32 val; 494 int ret; 495 496 ret = of_property_read_u32(info_node, "target", &val); 497 if (!ret) { 498 node = of_find_node_by_phandle(val); 499 if (!node) 500 pr_err("find target, node: %pOF, phandle 0x%x not found\n", 501 info_node, val); 502 return node; 503 } 504 505 ret = of_property_read_string(info_node, "target-path", &path); 506 if (!ret) { 507 node = of_find_node_by_path(path); 508 if (!node) 509 pr_err("find target, node: %pOF, path '%s' not found\n", 510 info_node, path); 511 return node; 512 } 513 514 pr_err("find target, node: %pOF, no target property\n", info_node); 515 516 return NULL; 517 } 518 519 /** 520 * init_overlay_changeset() - initialize overlay changeset from overlay tree 521 * @ovcs: Overlay changeset to build 522 * @fdt: the FDT that was unflattened to create @tree 523 * @tree: Contains all the overlay fragments and overlay fixup nodes 524 * 525 * Initialize @ovcs. Populate @ovcs->fragments with node information from 526 * the top level of @tree. The relevant top level nodes are the fragment 527 * nodes and the __symbols__ node. Any other top level node will be ignored. 528 * 529 * Returns 0 on success, -ENOMEM if memory allocation failure, -EINVAL if error 530 * detected in @tree, or -ENOSPC if idr_alloc() error. 531 */ 532 static int init_overlay_changeset(struct overlay_changeset *ovcs, 533 const void *fdt, struct device_node *tree) 534 { 535 struct device_node *node, *overlay_node; 536 struct fragment *fragment; 537 struct fragment *fragments; 538 int cnt, id, ret; 539 540 /* 541 * Warn for some issues. Can not return -EINVAL for these until 542 * of_unittest_apply_overlay() is fixed to pass these checks. 543 */ 544 if (!of_node_check_flag(tree, OF_DYNAMIC)) 545 pr_debug("%s() tree is not dynamic\n", __func__); 546 547 if (!of_node_check_flag(tree, OF_DETACHED)) 548 pr_debug("%s() tree is not detached\n", __func__); 549 550 if (!of_node_is_root(tree)) 551 pr_debug("%s() tree is not root\n", __func__); 552 553 ovcs->overlay_tree = tree; 554 ovcs->fdt = fdt; 555 556 INIT_LIST_HEAD(&ovcs->ovcs_list); 557 558 of_changeset_init(&ovcs->cset); 559 560 id = idr_alloc(&ovcs_idr, ovcs, 1, 0, GFP_KERNEL); 561 if (id <= 0) 562 return id; 563 564 cnt = 0; 565 566 /* fragment nodes */ 567 for_each_child_of_node(tree, node) { 568 overlay_node = of_get_child_by_name(node, "__overlay__"); 569 if (overlay_node) { 570 cnt++; 571 of_node_put(overlay_node); 572 } 573 } 574 575 node = of_get_child_by_name(tree, "__symbols__"); 576 if (node) { 577 cnt++; 578 of_node_put(node); 579 } 580 581 fragments = kcalloc(cnt, sizeof(*fragments), GFP_KERNEL); 582 if (!fragments) { 583 ret = -ENOMEM; 584 goto err_free_idr; 585 } 586 587 cnt = 0; 588 for_each_child_of_node(tree, node) { 589 overlay_node = of_get_child_by_name(node, "__overlay__"); 590 if (!overlay_node) 591 continue; 592 593 fragment = &fragments[cnt]; 594 fragment->overlay = overlay_node; 595 fragment->target = find_target_node(node); 596 if (!fragment->target) { 597 of_node_put(fragment->overlay); 598 ret = -EINVAL; 599 goto err_free_fragments; 600 } 601 602 cnt++; 603 } 604 605 /* 606 * if there is a symbols fragment in ovcs->fragments[i] it is 607 * the final element in the array 608 */ 609 node = of_get_child_by_name(tree, "__symbols__"); 610 if (node) { 611 ovcs->symbols_fragment = 1; 612 fragment = &fragments[cnt]; 613 fragment->overlay = node; 614 fragment->target = of_find_node_by_path("/__symbols__"); 615 616 if (!fragment->target) { 617 pr_err("symbols in overlay, but not in live tree\n"); 618 ret = -EINVAL; 619 goto err_free_fragments; 620 } 621 622 cnt++; 623 } 624 625 if (!cnt) { 626 pr_err("no fragments or symbols in overlay\n"); 627 ret = -EINVAL; 628 goto err_free_fragments; 629 } 630 631 ovcs->id = id; 632 ovcs->count = cnt; 633 ovcs->fragments = fragments; 634 635 return 0; 636 637 err_free_fragments: 638 kfree(fragments); 639 err_free_idr: 640 idr_remove(&ovcs_idr, id); 641 642 pr_err("%s() failed, ret = %d\n", __func__, ret); 643 644 return ret; 645 } 646 647 static void free_overlay_changeset(struct overlay_changeset *ovcs) 648 { 649 int i; 650 651 if (ovcs->cset.entries.next) 652 of_changeset_destroy(&ovcs->cset); 653 654 if (ovcs->id) 655 idr_remove(&ovcs_idr, ovcs->id); 656 657 for (i = 0; i < ovcs->count; i++) { 658 of_node_put(ovcs->fragments[i].target); 659 of_node_put(ovcs->fragments[i].overlay); 660 } 661 kfree(ovcs->fragments); 662 663 /* 664 * TODO 665 * 666 * would like to: kfree(ovcs->overlay_tree); 667 * but can not since drivers may have pointers into this data 668 * 669 * would like to: kfree(ovcs->fdt); 670 * but can not since drivers may have pointers into this data 671 */ 672 673 kfree(ovcs); 674 } 675 676 /* 677 * internal documentation 678 * 679 * of_overlay_apply() - Create and apply an overlay changeset 680 * @fdt: the FDT that was unflattened to create @tree 681 * @tree: Expanded overlay device tree 682 * @ovcs_id: Pointer to overlay changeset id 683 * 684 * Creates and applies an overlay changeset. 685 * 686 * If an error occurs in a pre-apply notifier, then no changes are made 687 * to the device tree. 688 * 689 690 * A non-zero return value will not have created the changeset if error is from: 691 * - parameter checks 692 * - building the changeset 693 * - overlay changeset pre-apply notifier 694 * 695 * If an error is returned by an overlay changeset pre-apply notifier 696 * then no further overlay changeset pre-apply notifier will be called. 697 * 698 * A non-zero return value will have created the changeset if error is from: 699 * - overlay changeset entry notifier 700 * - overlay changeset post-apply notifier 701 * 702 * If an error is returned by an overlay changeset post-apply notifier 703 * then no further overlay changeset post-apply notifier will be called. 704 * 705 * If more than one notifier returns an error, then the last notifier 706 * error to occur is returned. 707 * 708 * If an error occurred while applying the overlay changeset, then an 709 * attempt is made to revert any changes that were made to the 710 * device tree. If there were any errors during the revert attempt 711 * then the state of the device tree can not be determined, and any 712 * following attempt to apply or remove an overlay changeset will be 713 * refused. 714 * 715 * Returns 0 on success, or a negative error number. Overlay changeset 716 * id is returned to *ovcs_id. 717 */ 718 719 static int of_overlay_apply(const void *fdt, struct device_node *tree, 720 int *ovcs_id) 721 { 722 struct overlay_changeset *ovcs; 723 int ret = 0, ret_revert, ret_tmp; 724 725 /* 726 * As of this point, fdt and tree belong to the overlay changeset. 727 * overlay changeset code is responsible for freeing them. 728 */ 729 730 if (devicetree_corrupt()) { 731 pr_err("devicetree state suspect, refuse to apply overlay\n"); 732 kfree(fdt); 733 kfree(tree); 734 ret = -EBUSY; 735 goto out; 736 } 737 738 ovcs = kzalloc(sizeof(*ovcs), GFP_KERNEL); 739 if (!ovcs) { 740 kfree(fdt); 741 kfree(tree); 742 ret = -ENOMEM; 743 goto out; 744 } 745 746 of_overlay_mutex_lock(); 747 mutex_lock(&of_mutex); 748 749 ret = of_resolve_phandles(tree); 750 if (ret) 751 goto err_free_tree; 752 753 ret = init_overlay_changeset(ovcs, fdt, tree); 754 if (ret) 755 goto err_free_tree; 756 757 /* 758 * after overlay_notify(), ovcs->overlay_tree related pointers may have 759 * leaked to drivers, so can not kfree() tree, aka ovcs->overlay_tree; 760 * and can not free fdt, aka ovcs->fdt 761 */ 762 ret = overlay_notify(ovcs, OF_OVERLAY_PRE_APPLY); 763 if (ret) { 764 pr_err("overlay changeset pre-apply notify error %d\n", ret); 765 goto err_free_overlay_changeset; 766 } 767 768 ret = build_changeset(ovcs); 769 if (ret) 770 goto err_free_overlay_changeset; 771 772 ret_revert = 0; 773 ret = __of_changeset_apply_entries(&ovcs->cset, &ret_revert); 774 if (ret) { 775 if (ret_revert) { 776 pr_debug("overlay changeset revert error %d\n", 777 ret_revert); 778 devicetree_state_flags |= DTSF_APPLY_FAIL; 779 } 780 goto err_free_overlay_changeset; 781 } 782 783 ret = __of_changeset_apply_notify(&ovcs->cset); 784 if (ret) 785 pr_err("overlay changeset entry notify error %d\n", ret); 786 /* notify failure is not fatal, continue */ 787 788 list_add_tail(&ovcs->ovcs_list, &ovcs_list); 789 *ovcs_id = ovcs->id; 790 791 ret_tmp = overlay_notify(ovcs, OF_OVERLAY_POST_APPLY); 792 if (ret_tmp) { 793 pr_err("overlay changeset post-apply notify error %d\n", 794 ret_tmp); 795 if (!ret) 796 ret = ret_tmp; 797 } 798 799 goto out_unlock; 800 801 err_free_tree: 802 kfree(fdt); 803 kfree(tree); 804 805 err_free_overlay_changeset: 806 free_overlay_changeset(ovcs); 807 808 out_unlock: 809 mutex_unlock(&of_mutex); 810 of_overlay_mutex_unlock(); 811 812 out: 813 pr_debug("%s() err=%d\n", __func__, ret); 814 815 return ret; 816 } 817 818 int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size, 819 int *ovcs_id) 820 { 821 const void *new_fdt; 822 int ret; 823 u32 size; 824 struct device_node *overlay_root; 825 826 *ovcs_id = 0; 827 ret = 0; 828 829 if (overlay_fdt_size < sizeof(struct fdt_header) || 830 fdt_check_header(overlay_fdt)) { 831 pr_err("Invalid overlay_fdt header\n"); 832 return -EINVAL; 833 } 834 835 size = fdt_totalsize(overlay_fdt); 836 if (overlay_fdt_size < size) 837 return -EINVAL; 838 839 /* 840 * Must create permanent copy of FDT because of_fdt_unflatten_tree() 841 * will create pointers to the passed in FDT in the unflattened tree. 842 */ 843 new_fdt = kmemdup(overlay_fdt, size, GFP_KERNEL); 844 if (!new_fdt) 845 return -ENOMEM; 846 847 of_fdt_unflatten_tree(new_fdt, NULL, &overlay_root); 848 if (!overlay_root) { 849 pr_err("unable to unflatten overlay_fdt\n"); 850 ret = -EINVAL; 851 goto out_free_new_fdt; 852 } 853 854 ret = of_overlay_apply(new_fdt, overlay_root, ovcs_id); 855 if (ret < 0) { 856 /* 857 * new_fdt and overlay_root now belong to the overlay 858 * changeset. 859 * overlay changeset code is responsible for freeing them. 860 */ 861 goto out; 862 } 863 864 return 0; 865 866 867 out_free_new_fdt: 868 kfree(new_fdt); 869 870 out: 871 return ret; 872 } 873 EXPORT_SYMBOL_GPL(of_overlay_fdt_apply); 874 875 /* 876 * Find @np in @tree. 877 * 878 * Returns 1 if @np is @tree or is contained in @tree, else 0 879 */ 880 static int find_node(struct device_node *tree, struct device_node *np) 881 { 882 struct device_node *child; 883 884 if (tree == np) 885 return 1; 886 887 for_each_child_of_node(tree, child) { 888 if (find_node(child, np)) { 889 of_node_put(child); 890 return 1; 891 } 892 } 893 894 return 0; 895 } 896 897 /* 898 * Is @remove_ce_node a child of, a parent of, or the same as any 899 * node in an overlay changeset more topmost than @remove_ovcs? 900 * 901 * Returns 1 if found, else 0 902 */ 903 static int node_overlaps_later_cs(struct overlay_changeset *remove_ovcs, 904 struct device_node *remove_ce_node) 905 { 906 struct overlay_changeset *ovcs; 907 struct of_changeset_entry *ce; 908 909 list_for_each_entry_reverse(ovcs, &ovcs_list, ovcs_list) { 910 if (ovcs == remove_ovcs) 911 break; 912 913 list_for_each_entry(ce, &ovcs->cset.entries, node) { 914 if (find_node(ce->np, remove_ce_node)) { 915 pr_err("%s: #%d overlaps with #%d @%pOF\n", 916 __func__, remove_ovcs->id, ovcs->id, 917 remove_ce_node); 918 return 1; 919 } 920 if (find_node(remove_ce_node, ce->np)) { 921 pr_err("%s: #%d overlaps with #%d @%pOF\n", 922 __func__, remove_ovcs->id, ovcs->id, 923 remove_ce_node); 924 return 1; 925 } 926 } 927 } 928 929 return 0; 930 } 931 932 /* 933 * We can safely remove the overlay only if it's the top-most one. 934 * Newly applied overlays are inserted at the tail of the overlay list, 935 * so a top most overlay is the one that is closest to the tail. 936 * 937 * The topmost check is done by exploiting this property. For each 938 * affected device node in the log list we check if this overlay is 939 * the one closest to the tail. If another overlay has affected this 940 * device node and is closest to the tail, then removal is not permited. 941 */ 942 static int overlay_removal_is_ok(struct overlay_changeset *remove_ovcs) 943 { 944 struct of_changeset_entry *remove_ce; 945 946 list_for_each_entry(remove_ce, &remove_ovcs->cset.entries, node) { 947 if (node_overlaps_later_cs(remove_ovcs, remove_ce->np)) { 948 pr_err("overlay #%d is not topmost\n", remove_ovcs->id); 949 return 0; 950 } 951 } 952 953 return 1; 954 } 955 956 /** 957 * of_overlay_remove() - Revert and free an overlay changeset 958 * @ovcs_id: Pointer to overlay changeset id 959 * 960 * Removes an overlay if it is permissible. @ovcs_id was previously returned 961 * by of_overlay_apply(). 962 * 963 * If an error occurred while attempting to revert the overlay changeset, 964 * then an attempt is made to re-apply any changeset entry that was 965 * reverted. If an error occurs on re-apply then the state of the device 966 * tree can not be determined, and any following attempt to apply or remove 967 * an overlay changeset will be refused. 968 * 969 * A non-zero return value will not revert the changeset if error is from: 970 * - parameter checks 971 * - overlay changeset pre-remove notifier 972 * - overlay changeset entry revert 973 * 974 * If an error is returned by an overlay changeset pre-remove notifier 975 * then no further overlay changeset pre-remove notifier will be called. 976 * 977 * If more than one notifier returns an error, then the last notifier 978 * error to occur is returned. 979 * 980 * A non-zero return value will revert the changeset if error is from: 981 * - overlay changeset entry notifier 982 * - overlay changeset post-remove notifier 983 * 984 * If an error is returned by an overlay changeset post-remove notifier 985 * then no further overlay changeset post-remove notifier will be called. 986 * 987 * Returns 0 on success, or a negative error number. *ovcs_id is set to 988 * zero after reverting the changeset, even if a subsequent error occurs. 989 */ 990 int of_overlay_remove(int *ovcs_id) 991 { 992 struct overlay_changeset *ovcs; 993 int ret, ret_apply, ret_tmp; 994 995 ret = 0; 996 997 if (devicetree_corrupt()) { 998 pr_err("suspect devicetree state, refuse to remove overlay\n"); 999 ret = -EBUSY; 1000 goto out; 1001 } 1002 1003 mutex_lock(&of_mutex); 1004 1005 ovcs = idr_find(&ovcs_idr, *ovcs_id); 1006 if (!ovcs) { 1007 ret = -ENODEV; 1008 pr_err("remove: Could not find overlay #%d\n", *ovcs_id); 1009 goto out_unlock; 1010 } 1011 1012 if (!overlay_removal_is_ok(ovcs)) { 1013 ret = -EBUSY; 1014 goto out_unlock; 1015 } 1016 1017 ret = overlay_notify(ovcs, OF_OVERLAY_PRE_REMOVE); 1018 if (ret) { 1019 pr_err("overlay changeset pre-remove notify error %d\n", ret); 1020 goto out_unlock; 1021 } 1022 1023 list_del(&ovcs->ovcs_list); 1024 1025 ret_apply = 0; 1026 ret = __of_changeset_revert_entries(&ovcs->cset, &ret_apply); 1027 if (ret) { 1028 if (ret_apply) 1029 devicetree_state_flags |= DTSF_REVERT_FAIL; 1030 goto out_unlock; 1031 } 1032 1033 ret = __of_changeset_revert_notify(&ovcs->cset); 1034 if (ret) 1035 pr_err("overlay changeset entry notify error %d\n", ret); 1036 /* notify failure is not fatal, continue */ 1037 1038 *ovcs_id = 0; 1039 1040 ret_tmp = overlay_notify(ovcs, OF_OVERLAY_POST_REMOVE); 1041 if (ret_tmp) { 1042 pr_err("overlay changeset post-remove notify error %d\n", 1043 ret_tmp); 1044 if (!ret) 1045 ret = ret_tmp; 1046 } 1047 1048 free_overlay_changeset(ovcs); 1049 1050 out_unlock: 1051 mutex_unlock(&of_mutex); 1052 1053 out: 1054 pr_debug("%s() err=%d\n", __func__, ret); 1055 1056 return ret; 1057 } 1058 EXPORT_SYMBOL_GPL(of_overlay_remove); 1059 1060 /** 1061 * of_overlay_remove_all() - Reverts and frees all overlay changesets 1062 * 1063 * Removes all overlays from the system in the correct order. 1064 * 1065 * Returns 0 on success, or a negative error number 1066 */ 1067 int of_overlay_remove_all(void) 1068 { 1069 struct overlay_changeset *ovcs, *ovcs_n; 1070 int ret; 1071 1072 /* the tail of list is guaranteed to be safe to remove */ 1073 list_for_each_entry_safe_reverse(ovcs, ovcs_n, &ovcs_list, ovcs_list) { 1074 ret = of_overlay_remove(&ovcs->id); 1075 if (ret) 1076 return ret; 1077 } 1078 1079 return 0; 1080 } 1081 EXPORT_SYMBOL_GPL(of_overlay_remove_all); 1082