of: Check for overlap in reserved memory regions
PATCH v2 1/1 of: Check for overlap in reserved memory regions
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
---
v1..v2:
- Suggestions from Rob Herring (remove superfluous array and print statement)
--- drivers/of/of_reserved_mem.c | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/of/of_reserved_mem.c +42 -1
@@ -1,7 +1,7 @@/* * Device tree based initialization code for reserved memory. * -* Copyright (c) 2013, The Linux Foundation. All Rights Reserved. +* Copyright (c) 2013, 2015 The Linux Foundation. All Rights Reserved. * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd. * http://www.samsung.com * Author: Marek Szyprowski <[email protected]>
@@ -20,6 +20,7 @@#include <linux/mm.h> #include <linux/sizes.h> #include <linux/of_reserved_mem.h> +#include <linux/sort.h> #define MAX_RESERVED_REGIONS 16static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS ];
@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +} + +static void __init __rmem_check_for_overlap (void ) +{ +int i; + +if (reserved_mem_count <2 ) +return ; + +sort (reserved_mem, reserved_mem_count,sizeof (reserved_mem[0 ]), + __rmem_cmp,NULL ); +for (i =0 ; i < reserved_mem_count -1 ; i++) { +struct reserved_mem *this, *next; + + this = &reserved_mem[i]; + next = &reserved_mem[i +1 ]; +if (!(this->base && next->base)) +continue ; +if (this->base + this->size > next->base) { +phys_addr_t this_end, next_end; + + this_end = this->base + this->size; + next_end = next->base + next->size; +WARN (1 , +"Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n" , + this->name, &this->base, &this_end, + next->name, &next->base, &next_end); + } + } +} +/** * fdt_init_reserved_mem - allocate and init all saved reserved memory regions */ void __init fdt_init_reserved_mem (void ) {int i; + +/* check for overlapping reserved regions */ +__rmem_check_for_overlap (); +for (i =0 ; i < reserved_mem_count; i++) {struct reserved_mem *rmem = &reserved_mem[i];unsigned long node = rmem->fdt_node;
Signature · 8 lines
Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 7 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
Signed-off-by Mitchel Humpherys <[email protected]>
Applied this a while ago, but didn't reply here.
Rob
Quoted 87 lines
---
v1..v2:
- Suggestions from Rob Herring (remove superfluous array and print statement)--- drivers/of/of_reserved_mem.c | 43 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-)drivers/of/of_reserved_mem.c +42
-2@@ -1,7 +1,7 @@/* * Device tree based initialization code for reserved memory. * -* Copyright (c) 2013, The Linux Foundation. All Rights Reserved. +* Copyright (c) 2013, 2015 The Linux Foundation. All Rights Reserved. * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd. * http://www.samsung.com * Author: Marek Szyprowski <[email protected]> @@ -20,6 +20,7 @@#include <linux/mm.h> #include <linux/sizes.h> #include <linux/of_reserved_mem.h> +#include <linux/sort.h> #define MAX_RESERVED_REGIONS 16static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS ];@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +} + +static void __init __rmem_check_for_overlap (void ) +{ +int i; + +if (reserved_mem_count <2 ) +return ; + +sort (reserved_mem, reserved_mem_count,sizeof (reserved_mem[0 ]), + __rmem_cmp,NULL ); +for (i =0 ; i < reserved_mem_count -1 ; i++) { +struct reserved_mem *this, *next; + + this = &reserved_mem[i]; + next = &reserved_mem[i +1 ]; +if (!(this->base && next->base)) +continue ; +if (this->base + this->size > next->base) { +phys_addr_t this_end, next_end; + + this_end = this->base + this->size; + next_end = next->base + next->size; +WARN (1 , +"Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n" , + this->name, &this->base, &this_end, + next->name, &next->base, &next_end); + } + } +} +/** * fdt_init_reserved_mem - allocate and init all saved reserved memory regions */ void __init fdt_init_reserved_mem (void ) {int i; + +/* check for overlapping reserved regions */ +__rmem_check_for_overlap (); +for (i =0 ; i < reserved_mem_count; i++) {struct reserved_mem *rmem = &reserved_mem[i];unsigned long node = rmem->fdt_node; --Qualcomm Innovation Center, Inc.
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Quoted 36 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
drivers/of/of_reserved_mem.c +22
-0@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +} + +static void __init __rmem_check_for_overlap (void ) +{ +int i; + +if (reserved_mem_count <2 ) +return ; + +sort (reserved_mem, reserved_mem_count,sizeof (reserved_mem[0 ]), + __rmem_cmp,NULL ); +for (i =0 ; i < reserved_mem_count -1 ; i++) { +struct reserved_mem *this, *next; + + this = &reserved_mem[i]; + next = &reserved_mem[i +1 ]; +if (!(this->base && next->base))
drivers/of/of_reserved_mem.c static int __init __reserved_mem_init_node(struct reserved_mem *rmem) · line 232
Quoted 10 lines
drivers/of/of_reserved_mem.c +10
-0+continue ; +if (this->base + this->size > next->base) { +phys_addr_t this_end, next_end; + + this_end = this->base + this->size; + next_end = next->base + next->size; +WARN (1 , +"Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n" , + this->name, &this->base, &this_end, + next->name, &next->base, &next_end);
This is blowing up on some powerpc machines.
It's too early in boot to call WARN() on these systems.
Can we turn it into a pr_err() for now?
I'll send a patch?
cheers
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 51 lines · Michael Ellerman
Quoted 36 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
drivers/of/of_reserved_mem.c +22
-0@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +} + +static void __init __rmem_check_for_overlap (void ) +{ +int i; + +if (reserved_mem_count <2 ) +return ; + +sort (reserved_mem, reserved_mem_count,sizeof (reserved_mem[0 ]), + __rmem_cmp,NULL ); +for (i =0 ; i < reserved_mem_count -1 ; i++) { +struct reserved_mem *this, *next; + + this = &reserved_mem[i]; + next = &reserved_mem[i +1 ]; +if (!(this->base && next->base))drivers/of/of_reserved_mem.c static int __init __reserved_mem_init_node(struct reserved_mem *rmem) · line 232
Quoted 10 lines
drivers/of/of_reserved_mem.c +10
-0+continue ; +if (this->base + this->size > next->base) { +phys_addr_t this_end, next_end; + + this_end = this->base + this->size; + next_end = next->base + next->size; +WARN (1 , +"Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n" , + this->name, &this->base, &this_end, + next->name, &next->base, &next_end);This is blowing up on some powerpc machines.
Quoted 1 line
It's too early in boot to call
WARN()on these systems.
I didn't realize WARN could not be used early. Good to know.
Quoted 1 line
Can we turn it into a
pr_err()for now?
Sounds fine.
Quoted 1 line
I'll send a patch?
Great.
Rob
_______________________________________________
Linuxppc-dev mailing list
[email protected]
https://lists.ozlabs.org/listinfo/linuxppc-dev
Quoted 51 lines · Rob Herring
Quoted 50 lines · Michael Ellerman
Quoted 36 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
drivers/of/of_reserved_mem.c +22
-0@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +} + +static void __init __rmem_check_for_overlap (void ) +{ +int i; + +if (reserved_mem_count <2 ) +return ; + +sort (reserved_mem, reserved_mem_count,sizeof (reserved_mem[0 ]), + __rmem_cmp,NULL ); +for (i =0 ; i < reserved_mem_count -1 ; i++) { +struct reserved_mem *this, *next; + + this = &reserved_mem[i]; + next = &reserved_mem[i +1 ]; +if (!(this->base && next->base))drivers/of/of_reserved_mem.c static int __init __reserved_mem_init_node(struct reserved_mem *rmem) · line 232
Quoted 10 lines
drivers/of/of_reserved_mem.c +10
-0+continue ; +if (this->base + this->size > next->base) { +phys_addr_t this_end, next_end; + + this_end = this->base + this->size; + next_end = next->base + next->size; +WARN (1 , +"Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n" , + this->name, &this->base, &this_end, + next->name, &next->base, &next_end);This is blowing up on some powerpc machines.
Quoted 3 lines
Quoted 1 line
It's too early in boot to call
WARN()on these systems.I didn't realize WARN could not be used early. Good to know.
Yeah, it's a bit horrible.
It used to be even worse, we'd take a recursive trap and you'd get nothing useful at all. Ben fixed that, which makes BUG work but not WARN, because WARN requires you to take the trap _and return_. We should be able to fix it in the medium term, but not immediately.
Quoted 7 lines
Quoted 1 line
Can we turn it into a
pr_err()for now?Sounds fine.
Quoted 1 line
I'll send a patch?
Great.
Thanks. I'll just test the final version and then send.
cheers
Quoted 2 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug.
Can you expand a bit on why you think it's a bug? I assume it was discussed at some point on the list but I didn't see it sorry.
There's nothing I can see in the binding document[1] about whether regions can overlap, or what it would mean if they did.
If we want to declare that overlapping regions are always a bug then there should be some text in the binding explaining that. There's also the possibility that we have existing device trees in the wild that contain overlapping regions, and whether we think it's OK to retrospectively declare that they're incorrect.
cheers
Quoted 7 lines · Michael Ellerman
Quoted 2 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug.
Can you expand a bit on why you think it's a bug? I assume it was discussed at some point on the list but I didn't see it sorry.
The reason I think it's a bug is because the overlapping memory could be handed out to multiple firmwares, which generally ends in "random" firmware crashes. We've found by sad experience that root-causing such a crash can be quite difficult.
Is there a valid use case for overlapping regions? I can't think of one...
Quoted 2 lines
There's nothing I can see in the binding document[1] about whether regions can overlap, or what it would mean if they did.
You're right, the bindings document doesn't say anything about overlapping memory regions. I can submit something unless someone comes up with a reason why we should allow overlapping memory regions.
Quoted 5 lines
If we want to declare that overlapping regions are always a bug then there should be some text in the binding explaining that. There's also the possibility that we have existing device trees in the wild that contain overlapping regions, and whether we think it's OK to retrospectively declare that they're incorrect.
I did a quick survey of in-tree users of reserved-memory and couldn't find any overlapping regions.
-Mitch
Signature · 3 lines
Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Quoted 11 lines · Mitchel Humpherys
Any overlap in the reserved memory regions (those specified in the reserved-memory DT node) is a bug. These bugs might go undetected as long as the contested region isn't used simultaneously by multiple software agents, which makes such bugs hard to debug. Fix this by printing a scary warning during boot if overlap is detected.
drivers/of/of_reserved_mem.c +0
-0
drivers/of/of_reserved_mem.c static int __init __reserved_mem_init_node(struct reserved_mem *rmem) · line 206
Quoted 9 lines
drivers/of/of_reserved_mem.c +6
-0@@ -197,12 +198,52 @@ static int __init __reserved_mem_init_node(struct reserved_mem *rmem)return -ENOENT ; } +static int __init __rmem_cmp (const void *a,const void *b) +{ +const struct reserved_mem *ra = a, *rb = b; + +return ra->base - rb->base; +}
So on further inspection it seems this is really our problem.
The reserved_mem->base values are u64, so when the unsigned result of the substraction is converted to int we may or may not get the right value. That means the sort fails and the reserved mem check gives false positives.
eg:
Reserved memory: OVERLAP DETECTED!
ibm,slw-image@1ffe600000 (0x0000001ffe600000--0x0000001ffe700000) overlaps with ibm,firmware-allocs-memory@1000000000 (0x0000001000000000--0x0000001000dc0200)
Note there is no overlap:
0x0000001ffe600000--0x0000001ffe700000
vs
0x0000001000000000--0x0000001000dc0200
cheers
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html