Skip to contentSkip to conversation

Putting some basic order on isa extension lists

PATCH In review Conor Dooley 5 participants 18 messages Nov 30, 2022 – Dec 2, 2022

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover Putting some basic order on isa extension lists

From: Conor Dooley <[email protected]>

I don't know for sure that I have not re-ordered something that is sacrosanct. It seems that all of these are internal use structs, and should be okay, barring the obvious exception of the, intentionally re-ordered, isa_ext_arr.

With that caveat out of the way - all I did here was try to make things consistent so that it'd be easier to point patch submitters at a "do this order please".

I never know which of these can be moved without breaking stuff - but they all seem to be internal use stuff since they're not in uapi?

For v2, I added another path with some uapi docs & switched to Drew's suggested ordering of alphabetically, except in the /proc/cpuinfo array, as per the discussion today in the pw-sync call. I also added a sprinkling of comments around which things should be sorted in which way.

I guess consider this an RFS, with the S being Screaming in the case of me doing something you abhor :)

Thanks,
Conor.

Conor Dooley (3):
RISC-V: clarify ISA string ordering rules in cpu.c
RISC-V: resort all extensions in consistent orders
Documentation: riscv: add a section about ISA string ordering in
/proc/cpuinfo

 Documentation/riscv/uabi.rst   | 42 +++++++++++++++++++++++++++
 arch/riscv/include/asm/hwcap.h | 12 ++++----
 arch/riscv/kernel/cpu.c        | 53 ++++++++++++++++++++++++----------
 arch/riscv/kernel/cpufeature.c |  6 ++--
 4 files changed, 91 insertions(+), 22 deletions(-)
Signature · 1 line
2.38.1
#1 lore raw

PATCH 1/3 RISC-V: clarify ISA string ordering rules in cpu.c

From: Conor Dooley <[email protected]>

While the current list of rules may have been accurate when created it now lacks some clarity in the face of isa-manual updates. Instead of trying to continuously align this rule-set with the one in the specifications, change the role of this comment.

This particular comment is important, as the array it "decorates" defines the order in which the ISA string appears to userspace in /proc/cpuinfo.

Re-jig and strengthen the wording to provide contributors with a set order in which to add entries & note why this particular struct needs more attention than others.

While in the area, add some whitespace and tweak some wording for readability's sake.

---
 arch/riscv/kernel/cpu.c | 49 ++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 13 deletions(-)
arch/riscv/kernel/cpu.c +36 -13
index 852ecccd8920..68b2bd0cc3bc 100644
@@ -120,22 +120,45 @@ device_initcall(riscv_cpuinfo_init);
 		.uprop = #UPROP,				\
 		.isa_ext_id = EXTID,				\
 	}
+
 /*
- * Here are the ordering rules of extension naming defined by RISC-V
- * specification :
- * 1. All extensions should be separated from other multi-letter extensions
- *    by an underscore.
- * 2. The first letter following the 'Z' conventionally indicates the most
+ * The canonical order of ISA extension names in the ISA string is defined in
+ * chapter 27 of the unprivileged specification.
+ *
+ * Ordinarily, for in-kernel data structures, this order is unimportant but
+ * isa_ext_arr defines the order of the ISA string in /proc/cpuinfo.
+ *
+ * The specification uses vague wording, such as should, when it comes to
+ * ordering so for our purposes the following rules apply:
+ *
+ * 1. All multi-letter extensions must be separated from other multi-letter
+ *    extensions by an underscore.
+ *
+ * 2. Additional standard extensions (starting with 'Z') must be sorted after
+ *    single-letter extensions and before any higher-privileged extensions.
+
+ * 3. The first letter following the 'Z' conventionally indicates the most
  *    closely related alphabetical extension category, IMAFDQLCBKJTPVH.
- *    If multiple 'Z' extensions are named, they should be ordered first
- *    by category, then alphabetically within a category.
- * 3. Standard supervisor-level extensions (starts with 'S') should be
- *    listed after standard unprivileged extensions.  If multiple
- *    supervisor-level extensions are listed, they should be ordered
+ *    If multiple 'Z' extensions are named, they should be ordered first by
+ *    category, then alphabetically within a category.
+ *
+ * 3. Standard supervisor-level extensions (starting with 'S') must be listed
+ *    after standard unprivileged extensions.  If multiple
+ *    supervisor-level extensions are listed, they must be ordered
  *    alphabetically.
- * 4. Non-standard extensions (starts with 'X') must be listed after all
- *    standard extensions. They must be separated from other multi-letter
- *    extensions by an underscore.
+ *
+ * 4. Standard machine-level extensions (starting with 'Zxm') must be listed
+ *    after any lower-privileged, standard extensions.  If multiple
+ *    machine-level extensions are listed, they must be ordered
+ *    alphabetically.
+ *
+ * 5. Non-standard extensions (starts with 'X') must be listed after all
+ *    standard extensions.
+ *
+ * An example string following the order is:
+ *    rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+ *
+ * New entries to this struct should follow the ordering rules described above.
  */
 static struct riscv_isa_ext_data isa_ext_arr[] = {
 	__RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
Signature · 1 line
2.38.1
#4 lore raw

PATCH 2/3 RISC-V: resort all extensions in consistent orders

In reply to Conor Dooley

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

---
I could not decide between adding an alphabetical comment to each alphabetical site or not. I did it anyway. Scream if you hate it!

I also moved a static branch thingy in this version, but that should not matter, right? riightt?

---
 arch/riscv/include/asm/hwcap.h | 12 +++++++-----
 arch/riscv/kernel/cpu.c        |  4 ++--
 arch/riscv/kernel/cpufeature.c |  6 ++++--
 3 files changed, 13 insertions(+), 9 deletions(-)
arch/riscv/include/asm/hwcap.h +7 -5
index b22525290073..ce522aad641a 100644
@@ -51,14 +51,15 @@ extern unsigned long elf_hwcap;
  * RISCV_ISA_EXT_MAX. 0-25 range is reserved for single letter
  * extensions while all the multi-letter extensions should define the next
  * available logical extension id.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_id {
 	RISCV_ISA_EXT_SSCOFPMF = RISCV_ISA_EXT_BASE,
+	RISCV_ISA_EXT_SSTC,
+	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_SVPBMT,
 	RISCV_ISA_EXT_ZICBOM,
 	RISCV_ISA_EXT_ZIHINTPAUSE,
-	RISCV_ISA_EXT_SSTC,
-	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
 };
 
@@ -66,11 +67,12 @@ enum riscv_isa_ext_id {
  * This enum represents the logical ID for each RISC-V ISA extension static
  * keys. We can use static key to optimize code path if some ISA extensions
  * are available.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_key {
 	RISCV_ISA_EXT_KEY_FPU,		/* For 'F' and 'D' */
-	RISCV_ISA_EXT_KEY_ZIHINTPAUSE,
 	RISCV_ISA_EXT_KEY_SVINVAL,
+	RISCV_ISA_EXT_KEY_ZIHINTPAUSE,
 	RISCV_ISA_EXT_KEY_MAX,
 };
 
@@ -90,10 +92,10 @@ static __always_inline int riscv_isa_ext2key(int num)
 		return RISCV_ISA_EXT_KEY_FPU;
 	case RISCV_ISA_EXT_d:
 		return RISCV_ISA_EXT_KEY_FPU;
-	case RISCV_ISA_EXT_ZIHINTPAUSE:
-		return RISCV_ISA_EXT_KEY_ZIHINTPAUSE;
 	case RISCV_ISA_EXT_SVINVAL:
 		return RISCV_ISA_EXT_KEY_SVINVAL;
+	case RISCV_ISA_EXT_ZIHINTPAUSE:
+		return RISCV_ISA_EXT_KEY_ZIHINTPAUSE;
 	default:
 		return -EINVAL;
 	}
arch/riscv/kernel/cpu.c +2 -2
index 68b2bd0cc3bc..686d41b14206 100644
@@ -161,12 +161,12 @@ device_initcall(riscv_cpuinfo_init);
  * New entries to this struct should follow the ordering rules described above.
  */
 static struct riscv_isa_ext_data isa_ext_arr[] = {
+	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
+	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
 	__RISCV_ISA_EXT_DATA(sstc, RISCV_ISA_EXT_SSTC),
 	__RISCV_ISA_EXT_DATA(svinval, RISCV_ISA_EXT_SVINVAL),
 	__RISCV_ISA_EXT_DATA(svpbmt, RISCV_ISA_EXT_SVPBMT),
-	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
-	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA("", RISCV_ISA_EXT_MAX),
 };
 
arch/riscv/kernel/cpufeature.c +4 -2
index 694267d1fe81..8a76a6ce70cf 100644
@@ -199,12 +199,13 @@ void __init riscv_fill_hwcap(void)
 				this_hwcap |= isa2hwcap[(unsigned char)(*ext)];
 				set_bit(*ext - 'a', this_isa);
 			} else {
+				/* sorted alphabetically */
 				SET_ISA_EXT_MAP("sscofpmf", RISCV_ISA_EXT_SSCOFPMF);
+				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
+				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 				SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT);
 				SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM);
 				SET_ISA_EXT_MAP("zihintpause", RISCV_ISA_EXT_ZIHINTPAUSE);
-				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
-				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 			}
 #undef SET_ISA_EXT_MAP
 		}
@@ -284,6 +285,7 @@ static bool __init_or_module cpufeature_probe_zicbom(unsigned int stage)
  * This code may also be executed before kernel relocation, so we cannot use
  * addresses generated by the address-of operator as they won't be valid in
  * this context.
+ * Tests, unless otherwise required, are to be added in alphabetical order.
  */
 static u32 __init_or_module cpufeature_probe(unsigned int stage)
 {
Signature · 1 line
2.38.1
#11 lore raw

PATCH 3/3 Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

In reply to Conor Dooley

From: Conor Dooley <[email protected]>

The RISC-V specs are permissive in what they allow as the ISA string, but how we output this to userspace in /proc/cpuinfo is quasi uAPI.

Formalise this as part of the uAPI, by documenting the list of rules we use at this point in time.

---
I've not "tested" these docs. The NIPA-esque pwbot should go and test it AFAICT. If it doesn't, I'll go add that.

---
 Documentation/riscv/uabi.rst | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
Documentation/riscv/uabi.rst +42 -0
index 21a82cfb6c4d..bc3c8ced644b 100644
@@ -3,4 +3,46 @@
 RISC-V Linux User ABI
 =====================
 
+Misaligned accesses
+-------------------
+
 Misaligned accesses are supported in userspace, but they may perform poorly.
+
+ISA string ordering in /proc/cpuinfo
+------------------------------------
+
+The canonical order of ISA extension names in the ISA string is defined in
+chapter 27 of the unprivileged specification.
+The specification uses vague wording, such as should, when it comes to
+ordering, so for our purposes the following rules apply:
+
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".
+
+#. All multi-letter extensions will be separated from other multi-letter
+   extensions by an underscore.
+
+#. Additional standard extensions (starting with 'Z') will be sorted after
+   single-letter extensions and before any higher-privileged extensions.
+
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+
+#. Standard supervisor-level extensions (starting with 'S') will be listed
+   after standard unprivileged extensions.  If multiple
+   supervisor-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Standard machine-level extensions (starting with 'Zxm') will be listed
+   after any lower-privileged, standard extensions.  If multiple
+   machine-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Non-standard extensions (starts with 'X') will be listed after all
+   standard extensions.
+
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+
Signature · 1 line
2.38.1
#12 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

Quoted 52 lines · Conor Dooley

From: Conor Dooley <[email protected]>

The RISC-V specs are permissive in what they allow as the ISA string, but how we output this to userspace in /proc/cpuinfo is quasi uAPI.

Formalise this as part of the uAPI, by documenting the list of rules we use at this point in time.

---
I've not "tested" these docs. The NIPA-esque pwbot should go and test it AFAICT. If it doesn't, I'll go add that.

---
 Documentation/riscv/uabi.rst | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
Documentation/riscv/uabi.rst +27 -0
index 21a82cfb6c4d..bc3c8ced644b 100644
@@ -3,4 +3,46 @@
 RISC-V Linux User ABI
 =====================
 
+Misaligned accesses
+-------------------
+
 Misaligned accesses are supported in userspace, but they may perform poorly.
+
+ISA string ordering in /proc/cpuinfo
+------------------------------------
+
+The canonical order of ISA extension names in the ISA string is defined in
+chapter 27 of the unprivileged specification.
+The specification uses vague wording, such as should, when it comes to
+ordering, so for our purposes the following rules apply:
+
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".
+
+#. All multi-letter extensions will be separated from other multi-letter
+   extensions by an underscore.
+
+#. Additional standard extensions (starting with 'Z') will be sorted after
+   single-letter extensions and before any higher-privileged extensions.
+
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+
+#. Standard supervisor-level extensions (starting with 'S') will be listed

Documentation/riscv/uabi.rst line 43

Quoted 10 lines
Documentation/riscv/uabi.rst +10 -0
+   after standard unprivileged extensions.  If multiple
+   supervisor-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Standard machine-level extensions (starting with 'Zxm') will be listed
+   after any lower-privileged, standard extensions.  If multiple
+   machine-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Non-standard extensions (starts with 'X') will be listed after all

Ehh, it's always the read *after* sending something that I notice the inconsistency. This should be s/starts/starting/ for consistency.

Quoted 8 lines
Documentation/riscv/uabi.rst +5 -0
+   standard extensions.
+
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+
Signature · 1 line
2.38.1
#13 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

In reply to Conor Dooley

Review

Quoted 2 lines · Conor Dooley
(quoted diff) +2 -0
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".

"..., that is ... ."

Review

Quoted 5 lines
(quoted diff) +5 -0
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+

Did you mean "most closely related alphabetical extension category in canonical order"?

Review

Quoted 3 lines
(quoted diff) +3 -0
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+

IMO literal code block should be better fit for the example above, rather than definition list:

---- >8 ----

Documentation/riscv/uabi.rst +2 -1
index bc3c8ced644bcf..8005add855dc43 100644
@@ -43,6 +43,7 @@ ordering, so for our purposes the following rules apply:
 #. Non-standard extensions (starts with 'X') will be listed after all
    standard extensions.
 
-An example string following the order is:
+An example string following the order is::
+
    rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
 

Thanks.

Signature · 1 line
An old man doll... just what I always wanted! - Clara
#14 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

Quoted 5 lines · Bagas Sanjaya

Review

Quoted 2 lines · Conor Dooley
(quoted diff) +2 -0
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".

"..., that is ... ."

Hmm, that reads strangely to me. s/that/which/.

Quoted 9 lines

Review

Quoted 6 lines
(quoted diff) +5 -0
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+

Did you mean "most closely related alphabetical extension category in canonical order"?

I am not 100% sure what you are suggesting a replacement of here. I think I may reword this as:
For additional standard extensions, the first letter following the 'Z' conventionally indicates the most closely related alphabetical extension category. If multiple 'Z' extensions are named, they will be ordered first by category, in canonical order as listed above, then alphabetically within a category.

Quoted 6 lines

Review

Quoted 3 lines
(quoted diff) +3 -0
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+

IMO literal code block should be better fit for the example above, rather than definition list:

Uh, sure? I'm not sure what impact that has on the output, but I can switch to a pre-formatted block.

Thanks,
Conor.

Reviewed-by on v1 1/3
#2 lore raw

Re: [PATCH v1 1/3] RISC-V: clarify ISA string ordering rules in cpu.c

In reply to Conor Dooley
Quoted 39 lines · Conor Dooley

From: Conor Dooley <[email protected]>

While the current list of rules may have been accurate when created it now lacks some clarity in the face of isa-manual updates. Instead of trying to continuously align this rule-set with the one in the specifications, change the role of this comment.

This particular comment is important, as the array it "decorates" defines the order in which the ISA string appears to userspace in /proc/cpuinfo.

Re-jig and strengthen the wording to provide contributors with a set order in which to add entries & note why this particular struct needs more attention than others.

While in the area, add some whitespace and tweak some wording for readability's sake.

---
 arch/riscv/kernel/cpu.c | 49 ++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 13 deletions(-)
arch/riscv/kernel/cpu.c +1 -5
index 852ecccd8920..68b2bd0cc3bc 100644
@@ -120,22 +120,45 @@ device_initcall(riscv_cpuinfo_init);
 		.uprop = #UPROP,				\
 		.isa_ext_id = EXTID,				\
 	}
+
 /*
- * Here are the ordering rules of extension naming defined by RISC-V
- * specification :
- * 1. All extensions should be separated from other multi-letter extensions
- *    by an underscore.
- * 2. The first letter following the 'Z' conventionally indicates the most

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 134

Quoted 10 lines
arch/riscv/kernel/cpu.c +10 -0
+ * The canonical order of ISA extension names in the ISA string is defined in
+ * chapter 27 of the unprivileged specification.
+ *
+ * Ordinarily, for in-kernel data structures, this order is unimportant but
+ * isa_ext_arr defines the order of the ISA string in /proc/cpuinfo.
+ *
+ * The specification uses vague wording, such as should, when it comes to
+ * ordering so for our purposes the following rules apply:
+ *
+ * 1. All multi-letter extensions must be separated from other multi-letter

1. All multi-letter extensions must be separated from other extensions by an underscore.

(Because we always lead multi-letter extensions with underscore, even the first one, which follows the single-letter extensions.)

Quoted 20 lines
arch/riscv/kernel/cpu.c +12 -6
+ *    extensions by an underscore.
+ *
+ * 2. Additional standard extensions (starting with 'Z') must be sorted after
+ *    single-letter extensions and before any higher-privileged extensions.
+
+ * 3. The first letter following the 'Z' conventionally indicates the most
  *    closely related alphabetical extension category, IMAFDQLCBKJTPVH.
- *    If multiple 'Z' extensions are named, they should be ordered first
- *    by category, then alphabetically within a category.
- * 3. Standard supervisor-level extensions (starts with 'S') should be
- *    listed after standard unprivileged extensions.  If multiple
- *    supervisor-level extensions are listed, they should be ordered
+ *    If multiple 'Z' extensions are named, they should be ordered first by
+ *    category, then alphabetically within a category.
+ *
+ * 3. Standard supervisor-level extensions (starting with 'S') must be listed
+ *    after standard unprivileged extensions.  If multiple
+ *    supervisor-level extensions are listed, they must be ordered
  *    alphabetically.
- * 4. Non-standard extensions (starts with 'X') must be listed after all

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 156

Quoted 10 lines
arch/riscv/kernel/cpu.c +8 -2
- *    standard extensions. They must be separated from other multi-letter
- *    extensions by an underscore.
+ *
+ * 4. Standard machine-level extensions (starting with 'Zxm') must be listed
+ *    after any lower-privileged, standard extensions.  If multiple
+ *    machine-level extensions are listed, they must be ordered
+ *    alphabetically.
+ *
+ * 5. Non-standard extensions (starts with 'X') must be listed after all
+ *    standard extensions.

^and alphabetically.

Quoted 11 lines
arch/riscv/kernel/cpu.c +5 -0
+ *
+ * An example string following the order is:
+ *    rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+ *
+ * New entries to this struct should follow the ordering rules described above.
  */
 static struct riscv_isa_ext_data isa_ext_arr[] = {
 	__RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
Signature · 1 line
2.38.1

Otherwise,

Thanks,
drew

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv

#3 lore raw

Re: [PATCH v1 1/3] RISC-V: clarify ISA string ordering rules in cpu.c

Quoted 54 lines · Andrew Jones
Quoted 39 lines · Conor Dooley

From: Conor Dooley <[email protected]>

While the current list of rules may have been accurate when created it now lacks some clarity in the face of isa-manual updates. Instead of trying to continuously align this rule-set with the one in the specifications, change the role of this comment.

This particular comment is important, as the array it "decorates" defines the order in which the ISA string appears to userspace in /proc/cpuinfo.

Re-jig and strengthen the wording to provide contributors with a set order in which to add entries & note why this particular struct needs more attention than others.

While in the area, add some whitespace and tweak some wording for readability's sake.

---
 arch/riscv/kernel/cpu.c | 49 ++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 13 deletions(-)
arch/riscv/kernel/cpu.c +1 -5
index 852ecccd8920..68b2bd0cc3bc 100644
@@ -120,22 +120,45 @@ device_initcall(riscv_cpuinfo_init);
 		.uprop = #UPROP,				\
 		.isa_ext_id = EXTID,				\
 	}
+
 /*
- * Here are the ordering rules of extension naming defined by RISC-V
- * specification :
- * 1. All extensions should be separated from other multi-letter extensions
- *    by an underscore.
- * 2. The first letter following the 'Z' conventionally indicates the most

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 134

Quoted 10 lines
arch/riscv/kernel/cpu.c +10 -0
+ * The canonical order of ISA extension names in the ISA string is defined in
+ * chapter 27 of the unprivileged specification.
+ *
+ * Ordinarily, for in-kernel data structures, this order is unimportant but
+ * isa_ext_arr defines the order of the ISA string in /proc/cpuinfo.
+ *
+ * The specification uses vague wording, such as should, when it comes to
+ * ordering so for our purposes the following rules apply:
+ *
+ * 1. All multi-letter extensions must be separated from other multi-letter

1. All multi-letter extensions must be separated from other extensions by an underscore.

Quoted 2 lines

(Because we always lead multi-letter extensions with underscore, even the first one, which follows the single-letter extensions.)

Yah, I need to think as if I am using De Morgan's... The DT ABI requires "should" and permits this. The uAPI is "must"/"will" and always has an _. I'll propagate that change to the docs patch too.

Quoted 30 lines
Quoted 20 lines
arch/riscv/kernel/cpu.c +12 -6
+ *    extensions by an underscore.
+ *
+ * 2. Additional standard extensions (starting with 'Z') must be sorted after
+ *    single-letter extensions and before any higher-privileged extensions.
+
+ * 3. The first letter following the 'Z' conventionally indicates the most
  *    closely related alphabetical extension category, IMAFDQLCBKJTPVH.
- *    If multiple 'Z' extensions are named, they should be ordered first
- *    by category, then alphabetically within a category.
- * 3. Standard supervisor-level extensions (starts with 'S') should be
- *    listed after standard unprivileged extensions.  If multiple
- *    supervisor-level extensions are listed, they should be ordered
+ *    If multiple 'Z' extensions are named, they should be ordered first by
+ *    category, then alphabetically within a category.
+ *
+ * 3. Standard supervisor-level extensions (starting with 'S') must be listed
+ *    after standard unprivileged extensions.  If multiple
+ *    supervisor-level extensions are listed, they must be ordered
  *    alphabetically.
- * 4. Non-standard extensions (starts with 'X') must be listed after all

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 156

Quoted 10 lines
arch/riscv/kernel/cpu.c +8 -2
- *    standard extensions. They must be separated from other multi-letter
- *    extensions by an underscore.
+ *
+ * 4. Standard machine-level extensions (starting with 'Zxm') must be listed
+ *    after any lower-privileged, standard extensions.  If multiple
+ *    machine-level extensions are listed, they must be ordered
+ *    alphabetically.
+ *
+ * 5. Non-standard extensions (starts with 'X') must be listed after all
+ *    standard extensions.
Quoted 1 line

^and alphabetically.

"If multiple non-standard extensions are listed, they must be ordered alphabetically." I'll also propagate this to the doc one, if I have not already.

Quoted 3 lines

Otherwise,

Cool. I'll give it a bit before respinning, but I think we are at least getting less ambiguous as time goes on..

Thanks,
Conor.

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv

Reviewed-by on v1 2/3
#5 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

In reply to Conor Dooley
Quoted 17 lines · Conor Dooley

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

Quoted 6 lines

---
I could not decide between adding an alphabetical comment to each alphabetical site or not. I did it anyway. Scream if you hate it!

I also moved a static branch thingy in this version, but that should not matter, right? riightt?

riiighttt. And it goes away with [1] anyway.

[1] https://lore.kernel.org/all/[email protected]/

Quoted 17 lines
---
 arch/riscv/include/asm/hwcap.h | 12 +++++++-----
 arch/riscv/kernel/cpu.c        |  4 ++--
 arch/riscv/kernel/cpufeature.c |  6 ++++--
 3 files changed, 13 insertions(+), 9 deletions(-)
arch/riscv/include/asm/hwcap.h +1 -0
index b22525290073..ce522aad641a 100644
@@ -51,14 +51,15 @@ extern unsigned long elf_hwcap;
  * RISCV_ISA_EXT_MAX. 0-25 range is reserved for single letter
  * extensions while all the multi-letter extensions should define the next
  * available logical extension id.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_id {

arch/riscv/include/asm/hwcap.h extern unsigned long elf_hwcap; · line 64

Quoted 10 lines
arch/riscv/include/asm/hwcap.h +2 -2
 	RISCV_ISA_EXT_SSCOFPMF = RISCV_ISA_EXT_BASE,
+	RISCV_ISA_EXT_SSTC,
+	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_SVPBMT,
 	RISCV_ISA_EXT_ZICBOM,
 	RISCV_ISA_EXT_ZIHINTPAUSE,
-	RISCV_ISA_EXT_SSTC,
-	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
 };

Unrelated to this patch, but every time I look at this enum I want to post the diff below, but I haven't bothered, because this enum also goes away with [1].

@@ -59,8 +59,9 @@ enum riscv_isa_ext_id {
RISCV_ISA_EXT_ZIHINTPAUSE, RISCV_ISA_EXT_SSTC, RISCV_ISA_EXT_SVINVAL,
- RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
+ RISCV_ISA_EXT_ID_MAX
};
+static_assert(RISCV_ISA_EXT_ID_MAX <= RISCV_ISA_EXT_MAX);

/*
* This enum represents the logical ID for each RISC-V ISA extension static

Quoted 16 lines
arch/riscv/include/asm/hwcap.h +2 -1
@@ -66,11 +67,12 @@ enum riscv_isa_ext_id {
  * This enum represents the logical ID for each RISC-V ISA extension static
  * keys. We can use static key to optimize code path if some ISA extensions
  * are available.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_key {
 	RISCV_ISA_EXT_KEY_FPU,		/* For 'F' and 'D' */
-	RISCV_ISA_EXT_KEY_ZIHINTPAUSE,
 	RISCV_ISA_EXT_KEY_SVINVAL,
+	RISCV_ISA_EXT_KEY_ZIHINTPAUSE,
 	RISCV_ISA_EXT_KEY_MAX,
 };
 

arch/riscv/include/asm/hwcap.h static __always_inline int riscv_isa_ext2key(int num) · line 92

Quoted 1 line
arch/riscv/include/asm/hwcap.h +0 -0
@@ -90,10 +92,10 @@ static __always_inline int riscv_isa_ext2key(int num)
 		return RISCV_ISA_EXT_KEY_FPU;

And every time I look at this switch I want to delete the return line above...

Quoted 19 lines
arch/riscv/include/asm/hwcap.h +2 -2
 	case RISCV_ISA_EXT_d:
 		return RISCV_ISA_EXT_KEY_FPU;
-	case RISCV_ISA_EXT_ZIHINTPAUSE:
-		return RISCV_ISA_EXT_KEY_ZIHINTPAUSE;
 	case RISCV_ISA_EXT_SVINVAL:
 		return RISCV_ISA_EXT_KEY_SVINVAL;
+	case RISCV_ISA_EXT_ZIHINTPAUSE:
+		return RISCV_ISA_EXT_KEY_ZIHINTPAUSE;
 	default:
 		return -EINVAL;
 	}
arch/riscv/kernel/cpu.c +0 -0
index 68b2bd0cc3bc..686d41b14206 100644
@@ -161,12 +161,12 @@ device_initcall(riscv_cpuinfo_init);
  * New entries to this struct should follow the ordering rules described above.
  */
 static struct riscv_isa_ext_data isa_ext_arr[] = {

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 171

Quoted 10 lines
arch/riscv/kernel/cpu.c +2 -2
+	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
+	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
 	__RISCV_ISA_EXT_DATA(sstc, RISCV_ISA_EXT_SSTC),
 	__RISCV_ISA_EXT_DATA(svinval, RISCV_ISA_EXT_SVINVAL),
 	__RISCV_ISA_EXT_DATA(svpbmt, RISCV_ISA_EXT_SVPBMT),
-	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
-	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA("", RISCV_ISA_EXT_MAX),
 };

Technically we should have leave these in the wrong order if we want to be strict about the ISA string published to userspace, but I'm in favor of changing this array as necessary and hoping we teach userspace to use flexible parsers. Actually, IMO, we shouldn't teach userspace to parse this at all. We should instead create sysfs nodes:

.../isa/zicbom
.../isa/zihintpause
.../isa/sscofpmf

and teach userspace to list .../isa/ to learn about extensions. That would also allow us to publish extension version numbers which we are not current doing with the proc isa string.

.../isa/zicbom/major
.../isa/zicbom/minor

and we could add other properties if necessary too, e.g.

.../isa/zicbom/block_size

Quoted 32 lines
arch/riscv/kernel/cpufeature.c +4 -2
index 694267d1fe81..8a76a6ce70cf 100644
@@ -199,12 +199,13 @@ void __init riscv_fill_hwcap(void)
 				this_hwcap |= isa2hwcap[(unsigned char)(*ext)];
 				set_bit(*ext - 'a', this_isa);
 			} else {
+				/* sorted alphabetically */
 				SET_ISA_EXT_MAP("sscofpmf", RISCV_ISA_EXT_SSCOFPMF);
+				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
+				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 				SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT);
 				SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM);
 				SET_ISA_EXT_MAP("zihintpause", RISCV_ISA_EXT_ZIHINTPAUSE);
-				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
-				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 			}
 #undef SET_ISA_EXT_MAP
 		}
@@ -284,6 +285,7 @@ static bool __init_or_module cpufeature_probe_zicbom(unsigned int stage)
  * This code may also be executed before kernel relocation, so we cannot use
  * addresses generated by the address-of operator as they won't be valid in
  * this context.
+ * Tests, unless otherwise required, are to be added in alphabetical order.
  */
 static u32 __init_or_module cpufeature_probe(unsigned int stage)
 {
Signature · 1 line
2.38.1

I realize that I have a suggested-by tag in the commit message, but I don't really have a strong opinion on how we order extensions where the order doesn't matter. A consistent policy of alphabetical or always at the bottom both work for me. I personally prefer alphabetical when reading the lists, but I realize we'll eventually merge stuff out of order and then that'll generate some churn to reorder (but hopefully not too frequently).

My biggest concern is how much we need to care about the order of the string in proc and whether or not we're allowed to fix its order like we're doing with this patch. I hope we can, and I vote we do.

Anyway, none of my comments apply directly to this patch, so

Thanks,
drew

#17 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

In reply to Conor Dooley
Quoted 4 lines · Conor Dooley

From: Conor Dooley <[email protected]>

The RISC-V specs are permissive in what they allow as the ISA string, but how we output this to userspace in /proc/cpuinfo is quasi uAPI.

uABI

Quoted 2 lines

Formalise this as part of the uAPI, by documenting the list of rules

uABI

Quoted 37 lines

we use at this point in time.

---
I've not "tested" these docs. The NIPA-esque pwbot should go and test it AFAICT. If it doesn't, I'll go add that.

---
 Documentation/riscv/uabi.rst | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
Documentation/riscv/uabi.rst +18 -0
index 21a82cfb6c4d..bc3c8ced644b 100644
@@ -3,4 +3,46 @@
 RISC-V Linux User ABI
 =====================
 
+Misaligned accesses
+-------------------
+
 Misaligned accesses are supported in userspace, but they may perform poorly.
+
+ISA string ordering in /proc/cpuinfo
+------------------------------------
+
+The canonical order of ISA extension names in the ISA string is defined in
+chapter 27 of the unprivileged specification.
+The specification uses vague wording, such as should, when it comes to
+ordering, so for our purposes the following rules apply:
+
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".
+
+#. All multi-letter extensions will be separated from other multi-letter
+   extensions by an underscore.
+

Documentation/riscv/uabi.rst line 34

Quoted 10 lines
Documentation/riscv/uabi.rst +10 -0
+#. Additional standard extensions (starting with 'Z') will be sorted after
+   single-letter extensions and before any higher-privileged extensions.
+
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+
+#. Standard supervisor-level extensions (starting with 'S') will be listed
+   after standard unprivileged extensions.  If multiple

nit: Seems like a short line, at what character are we required to wrap at in this file?

Quoted 17 lines
Documentation/riscv/uabi.rst +14 -0
+   supervisor-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Standard machine-level extensions (starting with 'Zxm') will be listed
+   after any lower-privileged, standard extensions.  If multiple
+   machine-level extensions are listed, they will be ordered
+   alphabetically.
+
+#. Non-standard extensions (starts with 'X') will be listed after all
+   standard extensions.
+
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+
Signature · 1 line
2.38.1

If this uABI hasn't "shipped" yet, giving us the freedom to discuss it more, then I'd prefer we don't publish this (which looks like "shipping" it) until we're 100% sure that this is the uABI we want.

(I feel like if we can still change the order in proc, as the previous patch did, then we haven't yet shipped it.)

Thanks,
drew

#6 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

In reply to Andrew Jones

Am Donnerstag, 1. Dezember 2022, 10:00:41 CET schrieb Andrew Jones:

Quoted 22 lines · Conor Dooley
Quoted 21 lines

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

---
I could not decide between adding an alphabetical comment to each alphabetical site or not. I did it anyway. Scream if you hate it!

Quoted 6 lines
Quoted 2 lines

I also moved a static branch thingy in this version, but that should not matter, right? riightt?

riiighttt. And it goes away with [1] anyway.

[1] https://lore.kernel.org/all/[email protected]/

I'm not sure what became of that series since mid october, though noting that tightly coupling the patching to extensions alone might cause issues [2] which some of the "features" like fast-unaligned access, that are not directly bound to a isa-extension but to an implementation detail

[2] https://lore.kernel.org/all/1991071.yIU609i1g2@phil/

Quoted 34 lines
Quoted 18 lines
---
 arch/riscv/include/asm/hwcap.h | 12 +++++++-----
 arch/riscv/kernel/cpu.c        |  4 ++--
 arch/riscv/kernel/cpufeature.c |  6 ++++--
 3 files changed, 13 insertions(+), 9 deletions(-)
arch/riscv/include/asm/hwcap.h +1 -0
index b22525290073..ce522aad641a 100644
@@ -51,14 +51,15 @@ extern unsigned long elf_hwcap;
  * RISCV_ISA_EXT_MAX. 0-25 range is reserved for single letter
  * extensions while all the multi-letter extensions should define the next
  * available logical extension id.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_id {

arch/riscv/include/asm/hwcap.h extern unsigned long elf_hwcap; · line 64

Quoted 10 lines
arch/riscv/include/asm/hwcap.h +2 -2
 	RISCV_ISA_EXT_SSCOFPMF = RISCV_ISA_EXT_BASE,
+	RISCV_ISA_EXT_SSTC,
+	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_SVPBMT,
 	RISCV_ISA_EXT_ZICBOM,
 	RISCV_ISA_EXT_ZIHINTPAUSE,
-	RISCV_ISA_EXT_SSTC,
-	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
 };

Unrelated to this patch, but every time I look at this enum I want to post the diff below, but I haven't bothered, because this enum also goes away with [1].

Review enum riscv_isa_ext_id { · line 64

Quoted 7 lines
(quoted diff) +2 -1
@@ -59,8 +59,9 @@ enum riscv_isa_ext_id {
        RISCV_ISA_EXT_ZIHINTPAUSE,
        RISCV_ISA_EXT_SSTC,
        RISCV_ISA_EXT_SVINVAL,
-       RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
+       RISCV_ISA_EXT_ID_MAX
 };
+static_assert(RISCV_ISA_EXT_ID_MAX <= RISCV_ISA_EXT_MAX);

that sounds like a very reasonable idea ... what's keeping you? :-)

Heiko

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv

Reviewed-by Heiko Stuebner on v1 2/3
#10 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

In reply to Conor Dooley

Am Donnerstag, 1. Dezember 2022, 00:41:25 CET schrieb Conor Dooley:

Quoted 9 lines

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

Quoted 8 lines

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv

#7 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

In reply to Heiko Stübner
Quoted 28 lines · Heiko Stübner

Am Donnerstag, 1. Dezember 2022, 10:00:41 CET schrieb Andrew Jones:

Quoted 27 lines · Conor Dooley
Quoted 17 lines

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

Quoted 6 lines

---
I could not decide between adding an alphabetical comment to each alphabetical site or not. I did it anyway. Scream if you hate it!

I also moved a static branch thingy in this version, but that should not matter, right? riightt?

riiighttt. And it goes away with [1] anyway.

Quoted 8 lines
Quoted 1 line

[1] https://lore.kernel.org/all/[email protected]/

I'm not sure what became of that series since mid october, though noting that tightly coupling the patching to extensions alone might cause issues [2] which some of the "features" like fast-unaligned access, that are not directly bound to a isa-extension but to an implementation detail

[2] https://lore.kernel.org/all/1991071.yIU609i1g2@phil/

Jisheng said he'd send a refresh soon. Hopefully your comments will be taken into consideration. It seems like we need both the concepts of cpufeatures and extensions. Where many times a cpufeature directly maps to an extension, but not always. Or, we could shoehorn the non-extension cpufeatures into the extension framework by calling them "derived extensions" or something.

Quoted 35 lines
Quoted 35 lines
Quoted 20 lines


---
 arch/riscv/include/asm/hwcap.h | 12 +++++++-----
 arch/riscv/kernel/cpu.c        |  4 ++--
 arch/riscv/kernel/cpufeature.c |  6 ++++--
 3 files changed, 13 insertions(+), 9 deletions(-)
arch/riscv/include/asm/hwcap.h +1 -0
index b22525290073..ce522aad641a 100644
@@ -51,14 +51,15 @@ extern unsigned long elf_hwcap;
  * RISCV_ISA_EXT_MAX. 0-25 range is reserved for single letter
  * extensions while all the multi-letter extensions should define the next
  * available logical extension id.
+ * Entries are sorted alphabetically.
  */
 enum riscv_isa_ext_id {

arch/riscv/include/asm/hwcap.h extern unsigned long elf_hwcap; · line 64

Quoted 10 lines
arch/riscv/include/asm/hwcap.h +2 -2
 	RISCV_ISA_EXT_SSCOFPMF = RISCV_ISA_EXT_BASE,
+	RISCV_ISA_EXT_SSTC,
+	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_SVPBMT,
 	RISCV_ISA_EXT_ZICBOM,
 	RISCV_ISA_EXT_ZIHINTPAUSE,
-	RISCV_ISA_EXT_SSTC,
-	RISCV_ISA_EXT_SVINVAL,
 	RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
 };

Unrelated to this patch, but every time I look at this enum I want to post the diff below, but I haven't bothered, because this enum also goes away with [1].

Quoted 10 lines

Review enum riscv_isa_ext_id { · line 64

Quoted 8 lines
(quoted diff) +2 -1
@@ -59,8 +59,9 @@ enum riscv_isa_ext_id {
        RISCV_ISA_EXT_ZIHINTPAUSE,
        RISCV_ISA_EXT_SSTC,
        RISCV_ISA_EXT_SVINVAL,
-       RISCV_ISA_EXT_ID_MAX = RISCV_ISA_EXT_MAX,
+       RISCV_ISA_EXT_ID_MAX
 };
+static_assert(RISCV_ISA_EXT_ID_MAX <= RISCV_ISA_EXT_MAX);

that sounds like a very reasonable idea ... what's keeping you? :-)

Posted :-)

Thanks,
drew

#8 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

In reply to Andrew Jones
Quoted 53 lines · Andrew Jones
Quoted 27 lines · Conor Dooley

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

---

arch/riscv/kernel/cpu.c +0 -0
index 68b2bd0cc3bc..686d41b14206 100644
@@ -161,12 +161,12 @@ device_initcall(riscv_cpuinfo_init);
  * New entries to this struct should follow the ordering rules described above.
  */
 static struct riscv_isa_ext_data isa_ext_arr[] = {

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 171

Quoted 10 lines
arch/riscv/kernel/cpu.c +2 -2
+	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
+	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
 	__RISCV_ISA_EXT_DATA(sstc, RISCV_ISA_EXT_SSTC),
 	__RISCV_ISA_EXT_DATA(svinval, RISCV_ISA_EXT_SVINVAL),
 	__RISCV_ISA_EXT_DATA(svpbmt, RISCV_ISA_EXT_SVPBMT),
-	__RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
-	__RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
 	__RISCV_ISA_EXT_DATA("", RISCV_ISA_EXT_MAX),
 };

Technically we should have leave these in the wrong order if we want to be strict about the ISA string published to userspace, but I'm in favor of changing this array as necessary and hoping we teach userspace to use flexible parsers. Actually, IMO, we shouldn't teach userspace to parse this at all. We should instead create sysfs nodes:

.../isa/zicbom
.../isa/zihintpause
.../isa/sscofpmf

and teach userspace to list .../isa/ to learn about extensions. That would also allow us to publish extension version numbers which we are not current doing with the proc isa string.

Quoted 6 lines

.../isa/zicbom/major
.../isa/zicbom/minor

and we could add other properties if necessary too, e.g.

.../isa/zicbom/block_size

Yah, this all kinda ties in with Palmer's RFC set that does the hwcap stuff. Kinda been holding off on any thoughts on the isa string as a valuable anything until that sees a proper respin.

Quoted 25 lines
Quoted 25 lines
arch/riscv/kernel/cpufeature.c +4 -2
index 694267d1fe81..8a76a6ce70cf 100644
@@ -199,12 +199,13 @@ void __init riscv_fill_hwcap(void)
 				this_hwcap |= isa2hwcap[(unsigned char)(*ext)];
 				set_bit(*ext - 'a', this_isa);
 			} else {
+				/* sorted alphabetically */
 				SET_ISA_EXT_MAP("sscofpmf", RISCV_ISA_EXT_SSCOFPMF);
+				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
+				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 				SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT);
 				SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM);
 				SET_ISA_EXT_MAP("zihintpause", RISCV_ISA_EXT_ZIHINTPAUSE);
-				SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
-				SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
 			}
 #undef SET_ISA_EXT_MAP
 		}
@@ -284,6 +285,7 @@ static bool __init_or_module cpufeature_probe_zicbom(unsigned int stage)
  * This code may also be executed before kernel relocation, so we cannot use
  * addresses generated by the address-of operator as they won't be valid in
  * this context.
+ * Tests, unless otherwise required, are to be added in alphabetical order.
Quoted 8 lines
Quoted 6 lines
arch/riscv/kernel/cpufeature.c +0 -0
  */
 static u32 __init_or_module cpufeature_probe(unsigned int stage)
 {
Signature · 1 line
2.38.1

I realize that I have a suggested-by tag in the commit message, but I

I did one thing as a "putting it out there" in the responses to another series and you suggested something different entirely. Ordinarily, I'd not put review comments in a suggested-by, but figured it was okay this time.

Quoted 6 lines

don't really have a strong opinion on how we order extensions where the order doesn't matter. A consistent policy of alphabetical or always at the bottom both work for me. I personally prefer alphabetical when reading the lists, but I realize we'll eventually merge stuff out of order and then that'll generate some churn to reorder (but hopefully not too frequently).

Think I said it at the yoke yesterday, but I don't think that this is much of a problem. If it gets out of order, we just get someone that's sending a patchset already to fix things up.

Quoted 3 lines

My biggest concern is how much we need to care about the order of the string in proc and whether or not we're allowed to fix its order like we're doing with this patch. I hope we can, and I vote we do.

Being a bit hard-nosed about it:
- the spec has said for years that this order is not correct

- their parser cannot assume any given extension is even present, so the index at which the extension starts was only ever going to vary wildly

- to break a parser, it must expect to see extension Abcd before Efgh & that order has to change for them

- expecting that a given pair of extensions that appeared one after another would always do so is not something we should worry about breaking as it was always noted in the comment (and by the specs?) that new extensions would be added in alphabetical order (I'd like to think that if a clairvoyant wrote a parser and knew that there'd be nothing in the gap between the extensions we have now & what may be produced they'd also account for this re-ordering...)

- the re-order of sstc is going to land for v6.1 & the addition of sstc out of order landed in v6.0, so either that is an issue too or this is fine

I guess I sent the patches, so my opinion is fairly obvious, but I think we change it & see if someone complains about an issue that something other than a re-jig would break.

Thanks,
Conor.

#9 lore raw

Re: [PATCH v1 2/3] RISC-V: resort all extensions in consistent orders

Quoted 138 lines · Conor Dooley

EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe

Quoted 53 lines · Andrew Jones
Quoted 27 lines · Conor Dooley

From: Conor Dooley <[email protected]>

Ordering between each and every list of extensions is wildly inconsistent. Per discussion on the lists pick the following policy:

- The array defining order in /proc/cpuinfo follows a narrow interpretation of the ISA specifications, described in a comment immediately presiding it.

- All other lists of extensions are sorted alphabetically.

This will hopefully allow for easier review & future additions, and reduce conflicts between patchsets as the number of extensions grows.

---

arch/riscv/kernel/cpu.c +0 -0
index 68b2bd0cc3bc..686d41b14206 100644
@@ -161,12 +161,12 @@ device_initcall(riscv_cpuinfo_init);
   * New entries to this struct should follow the ordering rules described above.
   */
  static struct riscv_isa_ext_data isa_ext_arr[] = {

arch/riscv/kernel/cpu.c device_initcall(riscv_cpuinfo_init); · line 171

Quoted 10 lines
arch/riscv/kernel/cpu.c +2 -2
+   __RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
+   __RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
     __RISCV_ISA_EXT_DATA(sscofpmf, RISCV_ISA_EXT_SSCOFPMF),
     __RISCV_ISA_EXT_DATA(sstc, RISCV_ISA_EXT_SSTC),
     __RISCV_ISA_EXT_DATA(svinval, RISCV_ISA_EXT_SVINVAL),
     __RISCV_ISA_EXT_DATA(svpbmt, RISCV_ISA_EXT_SVPBMT),
-   __RISCV_ISA_EXT_DATA(zicbom, RISCV_ISA_EXT_ZICBOM),
-   __RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE),
     __RISCV_ISA_EXT_DATA("", RISCV_ISA_EXT_MAX),
  };

Technically we should have leave these in the wrong order if we want to be strict about the ISA string published to userspace, but I'm in favor of changing this array as necessary and hoping we teach userspace to use flexible parsers. Actually, IMO, we shouldn't teach userspace to parse this at all. We should instead create sysfs nodes:

.../isa/zicbom
.../isa/zihintpause
.../isa/sscofpmf

and teach userspace to list .../isa/ to learn about extensions. That would also allow us to publish extension version numbers which we are not current doing with the proc isa string.

Quoted 6 lines

.../isa/zicbom/major
.../isa/zicbom/minor

and we could add other properties if necessary too, e.g.

.../isa/zicbom/block_size

Yah, this all kinda ties in with Palmer's RFC set that does the hwcap stuff. Kinda been holding off on any thoughts on the isa string as a valuable anything until that sees a proper respin.

Quoted 25 lines
Quoted 25 lines
arch/riscv/kernel/cpufeature.c +4 -2
index 694267d1fe81..8a76a6ce70cf 100644
@@ -199,12 +199,13 @@ void __init riscv_fill_hwcap(void)
                             this_hwcap |= isa2hwcap[(unsigned char)(*ext)];
                             set_bit(*ext - 'a', this_isa);
                     } else {
+                           /* sorted alphabetically */
                             SET_ISA_EXT_MAP("sscofpmf", RISCV_ISA_EXT_SSCOFPMF);
+                           SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
+                           SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
                             SET_ISA_EXT_MAP("svpbmt", RISCV_ISA_EXT_SVPBMT);
                             SET_ISA_EXT_MAP("zicbom", RISCV_ISA_EXT_ZICBOM);
                             SET_ISA_EXT_MAP("zihintpause", RISCV_ISA_EXT_ZIHINTPAUSE);
-                           SET_ISA_EXT_MAP("sstc", RISCV_ISA_EXT_SSTC);
-                           SET_ISA_EXT_MAP("svinval", RISCV_ISA_EXT_SVINVAL);
                     }
  #undef SET_ISA_EXT_MAP
             }
@@ -284,6 +285,7 @@ static bool __init_or_module cpufeature_probe_zicbom(unsigned int stage)
   * This code may also be executed before kernel relocation, so we cannot use
   * addresses generated by the address-of operator as they won't be valid in
   * this context.
+ * Tests, unless otherwise required, are to be added in alphabetical order.
Quoted 8 lines
Quoted 6 lines
arch/riscv/kernel/cpufeature.c +0 -1
   */
  static u32 __init_or_module cpufeature_probe(unsigned int stage)
  {
--

2.38.1

I realize that I have a suggested-by tag in the commit message, but I

I did one thing as a "putting it out there" in the responses to another series and you suggested something different entirely. Ordinarily, I'd not put review comments in a suggested-by, but figured it was okay this time.

Quoted 6 lines

don't really have a strong opinion on how we order extensions where the order doesn't matter. A consistent policy of alphabetical or always at the bottom both work for me. I personally prefer alphabetical when reading the lists, but I realize we'll eventually merge stuff out of order and then that'll generate some churn to reorder (but hopefully not too frequently).

Think I said it at the yoke yesterday, but I don't think that this is much of a problem. If it gets out of order, we just get someone that's sending a patchset already to fix things up.

Quoted 3 lines

My biggest concern is how much we need to care about the order of the string in proc and whether or not we're allowed to fix its order like we're doing with this patch. I hope we can, and I vote we do.

Being a bit hard-nosed about it:
- the spec has said for years that this order is not correct

- their parser cannot assume any given extension is even present, so the index at which the extension starts was only ever going to vary wildly

- to break a parser, it must expect to see extension Abcd before Efgh & that order has to change for them

- expecting that a given pair of extensions that appeared one after another would always do so is not something we should worry about breaking as it was always noted in the comment (and by the specs?) that new extensions would be added in alphabetical order (I'd like to think that if a clairvoyant wrote a parser and knew that there'd be nothing in the gap between the extensions we have now & what may be produced they'd also account for this re-ordering...)

Quoted 7 lines

- the re-order of sstc is going to land for v6.1 & the addition of sstc out of order landed in v6.0, so either that is an issue too or this is fine

I guess I sent the patches, so my opinion is fairly obvious, but I think we change it & see if someone complains about an issue that something other than a re-jig would break.

typo: s/would/wouldn't/, that changes the meaning of my comment. If a valid addition would break their parser, that's not really a "uAPI breakage". It's only something that this re-order would break but additions or valid change of the string based on cpu capability would not that we need to worry about IMO.

#15 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

In reply to Conor Dooley
Quoted 9 lines · Conor Dooley
Quoted 5 lines · Bagas Sanjaya

Review

Quoted 2 lines · Conor Dooley
(quoted diff) +2 -0
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".

"..., that is ... ."

Hmm, that reads strangely to me. s/that/which/.

OK.

Quoted 10 lines
Quoted 9 lines

Review

Quoted 6 lines
(quoted diff) +5 -0
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+

Did you mean "most closely related alphabetical extension category in canonical order"?

Quoted 8 lines

I am not 100% sure what you are suggesting a replacement of here. I think I may reword this as:
For additional standard extensions, the first letter following the 'Z' conventionally indicates the most closely related alphabetical extension category. If multiple 'Z' extensions are named, they will be ordered first by category, in canonical order as listed above, then alphabetically within a category.

That LGTM.

Quoted 10 lines
Quoted 6 lines

Review

Quoted 3 lines
(quoted diff) +3 -0
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+

IMO literal code block should be better fit for the example above, rather than definition list:

Uh, sure? I'm not sure what impact that has on the output, but I can switch to a pre-formatted block.

Something like ``foo``?

Thanks.

Signature · 1 line
An old man doll... just what I always wanted! - Clara
#16 lore raw

Re: [PATCH v1 3/3] Documentation: riscv: add a section about ISA string ordering in /proc/cpuinfo

Quoted 41 lines · Bagas Sanjaya
Quoted 9 lines · Conor Dooley
Quoted 5 lines · Bagas Sanjaya

Review

Quoted 2 lines · Conor Dooley
(quoted diff) +2 -0
+#. Single-letter extensions come first, in "canonical order", so
+   "IMAFDQLCBKJTPVH".

"..., that is ... ."

Hmm, that reads strangely to me. s/that/which/.

OK.

Quoted 10 lines
Quoted 9 lines

Review

Quoted 6 lines
(quoted diff) +5 -0
+#. The first letter following the 'Z' conventionally indicates the most
+   closely related alphabetical extension category, IMAFDQLCBKJTPVH.
+   If multiple 'Z' extensions are named, they should be ordered first by
+   category, then alphabetically within a category.
+

Did you mean "most closely related alphabetical extension category in canonical order"?

Quoted 8 lines

I am not 100% sure what you are suggesting a replacement of here. I think I may reword this as:
For additional standard extensions, the first letter following the 'Z' conventionally indicates the most closely related alphabetical extension category. If multiple 'Z' extensions are named, they will be ordered first by category, in canonical order as listed above, then alphabetically within a category.

That LGTM.

Quoted 7 lines
Quoted 6 lines

Review

Quoted 3 lines
(quoted diff) +3 -0
+An example string following the order is:
+   rv64imadc_zifoo_zigoo_zafoo_sbar_scar_zxmbaz_xqux_xrux
+

IMO literal code block should be better fit for the example above, rather than definition list:

Quoted 5 lines
Quoted 3 lines

Uh, sure? I'm not sure what impact that has on the output, but I can switch to a pre-formatted block.

Something like ``foo``?

Not posting a v2 for another few days, but this is what I currently have:
https://git.kernel.org/pub/scm/linux/kernel/git/conor/linux.git/tree/Documentation/riscv/uabi.rst?h=riscv-uabi_docs

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv