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