Skip to contentSkip to conversation

lib: sbi: Ensure SBI extension is available

PATCH Superseded Andrew Jones 2 participants 8 messages May 11, 2023 – May 15, 2023

v4 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

v4 cover lib: sbi: Ensure SBI extension is available

Ensure attempts to invoke SBI extension functions fail with SBI_ERR_NOT_SUPPORTED when the extension's probe function has reported that the extension is not available. To avoid invoking probe too frequently, we check single extension ID extensions at init time and even drop them from the extension list when their probe fails. If the probe succeeds, we keep it, and then later seeing that it's a single extension ID extension is enough to know it's available. Extensions which have multiple IDs must have its probe called for each, so rather than try probing at init time we provide another callback allowing the extension to narrow its range or even vanish.

v4:
Almost a total redesign. Patch1 of the v4 (now series) does keep hunk 2 of the v3 patch, but the changes to sbi_ecall_find_extension() of the v3 patch have been dropped. Instead multi-ID extensions can now make use of a new extension callback (Patch2) which gets invoked at init time. This new callback has been applied to vendor extensions with Patch3.

v3: http://lists.infradead.org/pipermail/opensbi/2023-May/004894.html

Andrew Jones (3):
lib: sbi: Don't register unavailable single ID extensions
lib: sbi: Introduce register_extensions extension callback
lib: sbi: Apply register_extensions to vendor extensions

 include/sbi/sbi_ecall.h    |  1 +
 lib/sbi/sbi_ecall.c        | 17 ++++++++++++-----
 lib/sbi/sbi_ecall_vendor.c | 17 +++++++++++++++++
 3 files changed, 30 insertions(+), 5 deletions(-)
Signature · 1 line
2.40.0
#1 lore raw

PATCH v4 1/3 lib: sbi: Don't register unavailable single ID extensions

When an extension provides a probe callback we can check it at init time to see if we should register the extension at all. However, this is only possible for single ID extensions since attempting to probe all IDs of a potentially very large range doesn't make sense.

---
 lib/sbi/sbi_ecall.c | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)
lib/sbi/sbi_ecall.c +8 -5
index 76a1ae9ab733..5a301fb7d403 100644
@@ -148,15 +148,18 @@ int sbi_ecall_handler(struct sbi_trap_regs *regs)
 
 int sbi_ecall_init(void)
 {
-	int ret;
 	struct sbi_ecall_extension *ext;
-	unsigned long i;
+	unsigned long out_val, i;
+	int ret;
 
 	for (i = 0; i < sbi_ecall_exts_size; i++) {
 		ext = sbi_ecall_exts[i];
-		ret = sbi_ecall_register_extension(ext);
-		if (ret)
-			return ret;
+		if (ext->extid_start != ext->extid_end || !ext->probe ||
+		    (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+			ret = sbi_ecall_register_extension(ext);
+			if (ret)
+				return ret;
+		}
 	}
 
 	return 0;
Signature · 1 line
2.40.0
#2 lore raw

PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback

In reply to Andrew Jones

The register_extensions callback is called from sbi_ecall_init() for any extension that provides it. It's purpose is to register the extension with one or more sbi_ecall_register_extension() calls after possibly narrowing the range of extension IDs that should be handled. More than one call of sbi_ecall_register_extension() is necessary when the supported extension ID ranges have gaps. Additionally, when an extension may not be available and has a probe function, then the probe function should be consulted as to whether or not the extension should be registered. In summary, when register_extensions() returns, only valid extension IDs from the initial range, which are also available, have been registered.

---
 include/sbi/sbi_ecall.h | 1 +
 lib/sbi/sbi_ecall.c     | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
include/sbi/sbi_ecall.h +1 -0
index ff9bf8e2b435..fac26429cf5d 100644
@@ -24,6 +24,7 @@ struct sbi_ecall_extension {
 	struct sbi_dlist head;
 	unsigned long extid_start;
 	unsigned long extid_end;
+	int (* register_extensions)(void);
 	int (* probe)(unsigned long extid, unsigned long *out_val);
 	int (* handle)(unsigned long extid, unsigned long funcid,
 		       const struct sbi_trap_regs *regs,
lib/sbi/sbi_ecall.c +6 -2
index 5a301fb7d403..1c4a26fde438 100644
@@ -154,8 +154,12 @@ int sbi_ecall_init(void)
 
 	for (i = 0; i < sbi_ecall_exts_size; i++) {
 		ext = sbi_ecall_exts[i];
-		if (ext->extid_start != ext->extid_end || !ext->probe ||
-		    (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+		if (ext->register_extensions) {
+			ret = ext->register_extensions();
+			if (ret)
+				return ret;
+		} else if (ext->extid_start != ext->extid_end || !ext->probe ||
+			   (!ext->probe(ext->extid_end, &out_val) && out_val)) {
 			ret = sbi_ecall_register_extension(ext);
 			if (ret)
 				return ret;
Signature · 1 line
2.40.0
#3 lore raw

PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback

Quoted 37 lines · On Thu, May 11, 2023 at 9:41?PM Andrew Jones <[email protected]> wrote:

The register_extensions callback is called from sbi_ecall_init() for any extension that provides it. It's purpose is to register the extension with one or more sbi_ecall_register_extension() calls after possibly narrowing the range of extension IDs that should be handled. More than one call of sbi_ecall_register_extension() is necessary when the supported extension ID ranges have gaps. Additionally, when an extension may not be available and has a probe function, then the probe function should be consulted as to whether or not the extension should be registered. In summary, when register_extensions() returns, only valid extension IDs from the initial range, which are also available, have been registered.

---
 include/sbi/sbi_ecall.h | 1 +
 lib/sbi/sbi_ecall.c     | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
include/sbi/sbi_ecall.h +1 -0
index ff9bf8e2b435..fac26429cf5d 100644
@@ -24,6 +24,7 @@ struct sbi_ecall_extension {
        struct sbi_dlist head;
        unsigned long extid_start;
        unsigned long extid_end;
+       int (* register_extensions)(void);
        int (* probe)(unsigned long extid, unsigned long *out_val);
        int (* handle)(unsigned long extid, unsigned long funcid,
                       const struct sbi_trap_regs *regs,
lib/sbi/sbi_ecall.c +0 -0
index 5a301fb7d403..1c4a26fde438 100644
@@ -154,8 +154,12 @@ int sbi_ecall_init(void)
 

lib/sbi/sbi_ecall.c int sbi_ecall_init(void) · line 162

Quoted 10 lines
lib/sbi/sbi_ecall.c +6 -2
        for (i = 0; i < sbi_ecall_exts_size; i++) {
                ext = sbi_ecall_exts[i];
-               if (ext->extid_start != ext->extid_end || !ext->probe ||
-                   (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+               if (ext->register_extensions) {
+                       ret = ext->register_extensions();
+                       if (ret)
+                               return ret;
+               } else if (ext->extid_start != ext->extid_end || !ext->probe ||
+                          (!ext->probe(ext->extid_end, &out_val) && out_val)) {

We should replace probe() callback with register_extensions() and code over here can be something like below:

if (ext->register_extensions)

     ret = ext->register_extensions();
else if (ext->extid_start == ext->extid_end)
     ret = sbi_ecall_register_extension(ext);
else
     ret = SBI_ENODEV;
if (ret)
    return ret;

Basically, register_extensions() is optional for single extension ID but mandatory for extension ID range.

Quoted 6 lines
lib/sbi/sbi_ecall.c +0 -1
                        ret = sbi_ecall_register_extension(ext);
                        if (ret)
                                return ret;
--

2.40.0

Regards,
Anup

#4 lore raw

PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback

Quoted 38 lines · Anup Patel
Quoted 37 lines · On Thu, May 11, 2023 at 9:41?PM Andrew Jones <[email protected]> wrote:

The register_extensions callback is called from sbi_ecall_init() for any extension that provides it. It's purpose is to register the extension with one or more sbi_ecall_register_extension() calls after possibly narrowing the range of extension IDs that should be handled. More than one call of sbi_ecall_register_extension() is necessary when the supported extension ID ranges have gaps. Additionally, when an extension may not be available and has a probe function, then the probe function should be consulted as to whether or not the extension should be registered. In summary, when register_extensions() returns, only valid extension IDs from the initial range, which are also available, have been registered.

---
 include/sbi/sbi_ecall.h | 1 +
 lib/sbi/sbi_ecall.c     | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
include/sbi/sbi_ecall.h +1 -0
index ff9bf8e2b435..fac26429cf5d 100644
@@ -24,6 +24,7 @@ struct sbi_ecall_extension {
        struct sbi_dlist head;
        unsigned long extid_start;
        unsigned long extid_end;
+       int (* register_extensions)(void);
        int (* probe)(unsigned long extid, unsigned long *out_val);
        int (* handle)(unsigned long extid, unsigned long funcid,
                       const struct sbi_trap_regs *regs,
lib/sbi/sbi_ecall.c +0 -0
index 5a301fb7d403..1c4a26fde438 100644
@@ -154,8 +154,12 @@ int sbi_ecall_init(void)
 
Quoted 13 lines

lib/sbi/sbi_ecall.c int sbi_ecall_init(void) · line 162

Quoted 10 lines
lib/sbi/sbi_ecall.c +6 -2
        for (i = 0; i < sbi_ecall_exts_size; i++) {
                ext = sbi_ecall_exts[i];
-               if (ext->extid_start != ext->extid_end || !ext->probe ||
-                   (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+               if (ext->register_extensions) {
+                       ret = ext->register_extensions();
+                       if (ret)
+                               return ret;
+               } else if (ext->extid_start != ext->extid_end || !ext->probe ||
+                          (!ext->probe(ext->extid_end, &out_val) && out_val)) {

We should replace probe() callback with register_extensions() and code over here can be something like below:

We need to keep probe in case an extension wants to implement a nonzero out_val, which can be inspected by S-mode with the Base extension probe function:

"""
Probe SBI extension (FID #3)

Returns 0 if the given SBI extension ID (EID) is not available, or 1 if it is available unless defined as any other non-zero value by the implementation.
"""

Quoted 5 lines

if (ext->register_extensions)

     ret = ext->register_extensions();
else if (ext->extid_start == ext->extid_end)
     ret = sbi_ecall_register_extension(ext);

Also here, if we don't have probe, then we can't know if the single ID extension should be added or not. Not adding the extensions which fail probe to the list, so sbi_ecall_find_extension() can't find them when their functions are invoked, is the main motivation of the series.

Quoted 7 lines

else

     ret = SBI_ENODEV;
if (ret)
    return ret;

Basically, register_extensions() is optional for single extension ID but mandatory for extension ID range.

Oh, right, register_extensions() needs to be mandatory for multi-ID extensions, otherwise we would still need a change in sbi_ecall_find_extension() to ensure we don't return the extension for IDs which aren't available. However, if we make it mandatory for all multi-ID extensions, then the legacy extensions will need to implement it, even though it will just call sbi_ecall_register_extension() without making any changes first. I guess that's fine.

I'll go ahead and make register_extensions() mandatory for multi-ID extensions and add the callback to the legacy range. So, assuming we keep probe for the reasons I stated above, then we'll have this

 if (ext->register_extensions) {
     ret = ext->register_extensions();
 else if (ext->extid_start == ext->extid_end)
     if (!ext->probe || (!ext->probe(ext->extid_end, &out_val) && out_val))
         ret = sbi_ecall_register_extension(ext);
 else
     ret = SBI_ENODEV;

if (ret)

     return ret;

Thanks,
drew

#5 lore raw

PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback

Quoted 58 lines · On Fri, May 12, 2023 at 8:36?PM Andrew Jones <[email protected]> wrote:
Quoted 38 lines · Anup Patel
Quoted 37 lines · On Thu, May 11, 2023 at 9:41?PM Andrew Jones <[email protected]> wrote:

The register_extensions callback is called from sbi_ecall_init() for any extension that provides it. It's purpose is to register the extension with one or more sbi_ecall_register_extension() calls after possibly narrowing the range of extension IDs that should be handled. More than one call of sbi_ecall_register_extension() is necessary when the supported extension ID ranges have gaps. Additionally, when an extension may not be available and has a probe function, then the probe function should be consulted as to whether or not the extension should be registered. In summary, when register_extensions() returns, only valid extension IDs from the initial range, which are also available, have been registered.

---
 include/sbi/sbi_ecall.h | 1 +
 lib/sbi/sbi_ecall.c     | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
include/sbi/sbi_ecall.h +1 -0
index ff9bf8e2b435..fac26429cf5d 100644
@@ -24,6 +24,7 @@ struct sbi_ecall_extension {
        struct sbi_dlist head;
        unsigned long extid_start;
        unsigned long extid_end;
+       int (* register_extensions)(void);
        int (* probe)(unsigned long extid, unsigned long *out_val);
        int (* handle)(unsigned long extid, unsigned long funcid,
                       const struct sbi_trap_regs *regs,
lib/sbi/sbi_ecall.c +0 -0
index 5a301fb7d403..1c4a26fde438 100644
@@ -154,8 +154,12 @@ int sbi_ecall_init(void)
 
Quoted 13 lines

lib/sbi/sbi_ecall.c int sbi_ecall_init(void) · line 162

Quoted 10 lines
lib/sbi/sbi_ecall.c +6 -2
        for (i = 0; i < sbi_ecall_exts_size; i++) {
                ext = sbi_ecall_exts[i];
-               if (ext->extid_start != ext->extid_end || !ext->probe ||
-                   (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+               if (ext->register_extensions) {
+                       ret = ext->register_extensions();
+                       if (ret)
+                               return ret;
+               } else if (ext->extid_start != ext->extid_end || !ext->probe ||
+                          (!ext->probe(ext->extid_end, &out_val) && out_val)) {

We should replace probe() callback with register_extensions() and code over here can be something like below:

We need to keep probe in case an extension wants to implement a nonzero out_val, which can be inspected by S-mode with the Base extension probe function:

Quoted 7 lines

"""
Probe SBI extension (FID #3)

Returns 0 if the given SBI extension ID (EID) is not available, or 1 if it is available unless defined as any other non-zero value by the implementation.
"""

Fair enough, we can keep the probe() callback for custom return values but none of the existing SBI extensions have custom probe return values so don't need probe existing SBI extensions.

Quoted 7 lines
Quoted 6 lines

if (ext->register_extensions)

     ret = ext->register_extensions();
else if (ext->extid_start == ext->extid_end)
     ret = sbi_ecall_register_extension(ext);
Quoted 5 lines

Also here, if we don't have probe, then we can't know if the single ID extension should be added or not. Not adding the extensions which fail probe to the list, so sbi_ecall_find_extension() can't find them when their functions are invoked, is the main motivation of the series.

We should just implemetn register_extensions() for all existing SBI extensions and remove probe() implementation so the code over here will be a simple if-else:

if (ext->register_extensions)

    ret = ext->register_extensions();
else
    ret = SBI_ENODEV;
if (ret)
    return ret;
Quoted 29 lines
Quoted 8 lines

else

     ret = SBI_ENODEV;
if (ret)
    return ret;

Basically, register_extensions() is optional for single extension ID but mandatory for extension ID range.

Oh, right, register_extensions() needs to be mandatory for multi-ID extensions, otherwise we would still need a change in sbi_ecall_find_extension() to ensure we don't return the extension for IDs which aren't available. However, if we make it mandatory for all multi-ID extensions, then the legacy extensions will need to implement it, even though it will just call sbi_ecall_register_extension() without making any changes first. I guess that's fine.

I'll go ahead and make register_extensions() mandatory for multi-ID extensions and add the callback to the legacy range. So, assuming we keep probe for the reasons I stated above, then we'll have this

 if (ext->register_extensions) {
     ret = ext->register_extensions();
 else if (ext->extid_start == ext->extid_end)
     if (!ext->probe || (!ext->probe(ext->extid_end, &out_val) && out_val))
         ret = sbi_ecall_register_extension(ext);
 else
     ret = SBI_ENODEV;
Quoted 6 lines

if (ret)

     return ret;

Thanks,
drew

Regards,
Anup

#6 lore raw

PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback

Quoted 67 lines · Anup Patel
Quoted 58 lines · On Fri, May 12, 2023 at 8:36?PM Andrew Jones <[email protected]> wrote:
Quoted 38 lines · Anup Patel
Quoted 37 lines · On Thu, May 11, 2023 at 9:41?PM Andrew Jones <[email protected]> wrote:

The register_extensions callback is called from sbi_ecall_init() for any extension that provides it. It's purpose is to register the extension with one or more sbi_ecall_register_extension() calls after possibly narrowing the range of extension IDs that should be handled. More than one call of sbi_ecall_register_extension() is necessary when the supported extension ID ranges have gaps. Additionally, when an extension may not be available and has a probe function, then the probe function should be consulted as to whether or not the extension should be registered. In summary, when register_extensions() returns, only valid extension IDs from the initial range, which are also available, have been registered.

---
 include/sbi/sbi_ecall.h | 1 +
 lib/sbi/sbi_ecall.c     | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
include/sbi/sbi_ecall.h +1 -0
index ff9bf8e2b435..fac26429cf5d 100644
@@ -24,6 +24,7 @@ struct sbi_ecall_extension {
        struct sbi_dlist head;
        unsigned long extid_start;
        unsigned long extid_end;
+       int (* register_extensions)(void);
        int (* probe)(unsigned long extid, unsigned long *out_val);
        int (* handle)(unsigned long extid, unsigned long funcid,
                       const struct sbi_trap_regs *regs,
lib/sbi/sbi_ecall.c +0 -0
index 5a301fb7d403..1c4a26fde438 100644
@@ -154,8 +154,12 @@ int sbi_ecall_init(void)
 
Quoted 13 lines

lib/sbi/sbi_ecall.c int sbi_ecall_init(void) · line 162

Quoted 10 lines
lib/sbi/sbi_ecall.c +6 -2
        for (i = 0; i < sbi_ecall_exts_size; i++) {
                ext = sbi_ecall_exts[i];
-               if (ext->extid_start != ext->extid_end || !ext->probe ||
-                   (!ext->probe(ext->extid_end, &out_val) && out_val)) {
+               if (ext->register_extensions) {
+                       ret = ext->register_extensions();
+                       if (ret)
+                               return ret;
+               } else if (ext->extid_start != ext->extid_end || !ext->probe ||
+                          (!ext->probe(ext->extid_end, &out_val) && out_val)) {

We should replace probe() callback with register_extensions() and code over here can be something like below:

We need to keep probe in case an extension wants to implement a nonzero out_val, which can be inspected by S-mode with the Base extension probe function:

Quoted 7 lines

"""
Probe SBI extension (FID #3)

Returns 0 if the given SBI extension ID (EID) is not available, or 1 if it is available unless defined as any other non-zero value by the implementation.
"""

Quoted 4 lines

Fair enough, we can keep the probe() callback for custom return values but none of the existing SBI extensions have custom probe return values so don't need probe existing SBI extensions.

Sounds good. I'll add a patch documenting the probe callback's purpose.

Quoted 18 lines
Quoted 8 lines
Quoted 7 lines

if (ext->register_extensions)

     ret = ext->register_extensions();
else if (ext->extid_start == ext->extid_end)
     ret = sbi_ecall_register_extension(ext);
Quoted 5 lines

Also here, if we don't have probe, then we can't know if the single ID extension should be added or not. Not adding the extensions which fail probe to the list, so sbi_ecall_find_extension() can't find them when their functions are invoked, is the main motivation of the series.

We should just implemetn register_extensions() for all existing SBI extensions and remove probe() implementation so the code over here will be a simple if-else:

Quoted 6 lines

if (ext->register_extensions)

    ret = ext->register_extensions();
else
    ret = SBI_ENODEV;
if (ret)
    return ret;

Works for me.

Thanks,
drew

#7 lore raw

PATCH v4 3/3 lib: sbi: Apply register_extensions to vendor extensions

In reply to Andrew Jones

The vendor extension ID range is large, but at runtime at most a single ID will be available. Apply the register_extensions callback to check if that single ID is available. When it isn't, don't register the vendor extension at all. When it is, then narrow the extension range to the single ID and register it.

---
 lib/sbi/sbi_ecall_vendor.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
lib/sbi/sbi_ecall_vendor.c +17 -0
index 8b8dab00c92d..a64a82a8a3b1 100644
@@ -47,9 +47,26 @@ static int sbi_ecall_vendor_handler(unsigned long extid, unsigned long funcid,
 						out_val, out_trap);
 }
 
+struct sbi_ecall_extension ecall_vendor;
+
+static int sbi_ecall_vendor_register_extensions(void)
+{
+	unsigned long extid = sbi_ecall_vendor_id(), out_val;
+
+	if (sbi_ecall_vendor_probe(extid, &out_val) || !out_val)
+		return 0;
+
+	ecall_vendor.extid_start = extid;
+	ecall_vendor.extid_end = extid;
+	ecall_vendor.register_extensions = NULL;
+
+	return sbi_ecall_register_extension(&ecall_vendor);
+}
+
 struct sbi_ecall_extension ecall_vendor = {
 	.extid_start = SBI_EXT_VENDOR_START,
 	.extid_end = SBI_EXT_VENDOR_END,
 	.probe = sbi_ecall_vendor_probe,
 	.handle = sbi_ecall_vendor_handler,
+	.register_extensions = sbi_ecall_vendor_register_extensions,
 };
Signature · 1 line
2.40.0