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