Skip to contentSkip to conversation

libfdt: Make fdt{32,64}_ld() default to assuming unaligned access is safe

PATCH In review Tom Rini 2 participants 3 messages Nov 4, 2020 2 messages not in the archive

lore
Share & tools
lore

Tom Rini

author
#0 lore raw

PATCH 1/1 libfdt: Make fdt{32,64}_ld() default to assuming unaligned access is safe

Commits 6dcb8ba4 "libfdt: Add helpers for accessing unaligned words" introduced changes to support unaligned reads for ARM platforms and 11738cf01f15 "libfdt: Don't use memcpy to handle unaligned reads on ARM" improved the performance of these helpers.

On further discussion, while there are potential cases where we could be used on platforms that do not fixup unaligned reads for us, making this choice the default is very expensive in terms of binary size and access time. To address this, suffix the existing fdt{32,64}_ld functions with _unaligned and introduce new load functions that call fdt{32,64}_to_cpu() as was done prior to the above mentioned commits.

---
 libfdt/libfdt.h | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)
libfdt/libfdt.h +15 -6
index b600c8d6dd41..307ba745c92f 100644
@@ -126,13 +126,22 @@ static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
 
 /*
- * Alignment helpers:
- *     These helpers access words from a device tree blob.  They're
- *     built to work even with unaligned pointers on platforms (ike
- *     ARM) that don't like unaligned loads and stores
+ * Load functions.  Assume that we are on a platform where unaligned memory
+ * reads will be handled in a graceful manner and that we do not need to ensure
+ * our reads are aligned.  If this is not the case there are _unaligned
+ * versions of these functions that follow and can be used.
  */
-
 static inline uint32_t fdt32_ld(const fdt32_t *p)
+{
+	return fdt32_to_cpu(*p);
+}
+
+static inline uint64_t fdt64_ld(const fdt64_t *p)
+{
+	return fdt64_to_cpu(*p);
+}
+
+static inline uint32_t fdt32_ld_unaligned(const fdt32_t *p)
 {
 	const uint8_t *bp = (const uint8_t *)p;
 
@@ -152,7 +161,7 @@ static inline void fdt32_st(void *property, uint32_t value)
 	bp[3] = value & 0xff;
 }
 
-static inline uint64_t fdt64_ld(const fdt64_t *p)
+static inline uint64_t fdt64_ld_unaligned(const fdt64_t *p)
 {
 	const uint8_t *bp = (const uint8_t *)p;
 
Signature · 1 line
2.17.1

A message that is not in the archive (sent off-list or not yet received): 20201104134645.30138-1-trini-OWPKS81ov/FWk0Htik3J/[email protected]

#2 lore raw
Quoted 29 lines · Tom Rini

Commits 6dcb8ba4 "libfdt: Add helpers for accessing unaligned words" introduced changes to support unaligned reads for ARM platforms and 11738cf01f15 "libfdt: Don't use memcpy to handle unaligned reads on ARM" improved the performance of these helpers.

On further discussion, while there are potential cases where we could be used on platforms that do not fixup unaligned reads for us, making this choice the default is very expensive in terms of binary size and access time. To address this, suffix the existing fdt{32,64}_ld functions with _unaligned and introduce new load functions that call fdt{32,64}_to_cpu() as was done prior to the above mentioned commits.

---
 libfdt/libfdt.h | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)
libfdt/libfdt.h +0 -3
index b600c8d6dd41..307ba745c92f 100644
@@ -126,13 +126,22 @@ static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
 
 /*
- * Alignment helpers:
- *     These helpers access words from a device tree blob.  They're
- *     built to work even with unaligned pointers on platforms (ike

libfdt/libfdt.h static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen) · line 136

Quoted 10 lines
libfdt/libfdt.h +6 -2
- *     ARM) that don't like unaligned loads and stores
+ * Load functions.  Assume that we are on a platform where unaligned memory
+ * reads will be handled in a graceful manner and that we do not need to ensure
+ * our reads are aligned.  If this is not the case there are _unaligned
+ * versions of these functions that follow and can be used.
  */
-
 static inline uint32_t fdt32_ld(const fdt32_t *p)
+{
+       return fdt32_to_cpu(*p);

This changes the public behavior of fdt32_ld() which is one of the things David was against.

I think we want a _fdt32_ld or fdt32_ld_internal or ?? which is internal only and doesn't create another ABI.

Rob

A message that is not in the archive (sent off-list or not yet received): CAL_JsqL30DTr4reQ0r98Z7vO6CNaKZPFNWMYzDVN+QPzUq3APw-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

author
#4 lore raw
Quoted 44 lines · Rob Herring
Quoted 29 lines · Tom Rini

Commits 6dcb8ba4 "libfdt: Add helpers for accessing unaligned words" introduced changes to support unaligned reads for ARM platforms and 11738cf01f15 "libfdt: Don't use memcpy to handle unaligned reads on ARM" improved the performance of these helpers.

On further discussion, while there are potential cases where we could be used on platforms that do not fixup unaligned reads for us, making this choice the default is very expensive in terms of binary size and access time. To address this, suffix the existing fdt{32,64}_ld functions with _unaligned and introduce new load functions that call fdt{32,64}_to_cpu() as was done prior to the above mentioned commits.

---
 libfdt/libfdt.h | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)
libfdt/libfdt.h +0 -3
index b600c8d6dd41..307ba745c92f 100644
@@ -126,13 +126,22 @@ static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
 uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
 
 /*
- * Alignment helpers:
- *     These helpers access words from a device tree blob.  They're
- *     built to work even with unaligned pointers on platforms (ike

libfdt/libfdt.h static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen) · line 136

Quoted 10 lines
libfdt/libfdt.h +6 -2
- *     ARM) that don't like unaligned loads and stores
+ * Load functions.  Assume that we are on a platform where unaligned memory
+ * reads will be handled in a graceful manner and that we do not need to ensure
+ * our reads are aligned.  If this is not the case there are _unaligned
+ * versions of these functions that follow and can be used.
  */
-
 static inline uint32_t fdt32_ld(const fdt32_t *p)
+{
+       return fdt32_to_cpu(*p);

This changes the public behavior of fdt32_ld() which is one of the things David was against.

Quoted 2 lines

I think we want a _fdt32_ld or fdt32_ld_internal or ?? which is internal only and doesn't create another ABI.

I thought it was minimal code change? But anyhow, yes, I can easily respin things. Should I do that now or wait for David's comments?

Signature · 1 line
Tom