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