lib: sbi: Ensure SBI extension is available
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
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
@@ -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
PATCH v4 2/3 lib: sbi: Introduce register_extensions extension callback
In reply to Andrew JonesThe 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
@@ -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
@@ -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
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_extensionscallback is called fromsbi_ecall_init()for any extension that provides it. It's purpose is to register the extension with one or moresbi_ecall_register_extension()calls after possibly narrowing the range of extension IDs that should be handled. More than one call ofsbi_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, whenregister_extensions()returns, only valid extension IDs from the initial range, which are also available, have been registered.Signed-off-by Andrew Jones <[email protected]>--- 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@@ -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@@ -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
-2for (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
-1ret =sbi_ecall_register_extension (ext);if (ret)return ret; --2.40.0
Regards,
Anup
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_extensionscallback is called fromsbi_ecall_init()for any extension that provides it. It's purpose is to register the extension with one or moresbi_ecall_register_extension()calls after possibly narrowing the range of extension IDs that should be handled. More than one call ofsbi_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, whenregister_extensions()returns, only valid extension IDs from the initial range, which are also available, have been registered.Signed-off-by Andrew Jones <[email protected]>--- 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@@ -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@@ -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
-2for (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 withregister_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
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_extensionscallback is called fromsbi_ecall_init()for any extension that provides it. It's purpose is to register the extension with one or moresbi_ecall_register_extension()calls after possibly narrowing the range of extension IDs that should be handled. More than one call ofsbi_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, whenregister_extensions()returns, only valid extension IDs from the initial range, which are also available, have been registered.Signed-off-by Andrew Jones <[email protected]>--- 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@@ -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@@ -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
-2for (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 withregister_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 insbi_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 callsbi_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 thisif (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
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_extensionscallback is called fromsbi_ecall_init()for any extension that provides it. It's purpose is to register the extension with one or moresbi_ecall_register_extension()calls after possibly narrowing the range of extension IDs that should be handled. More than one call ofsbi_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, whenregister_extensions()returns, only valid extension IDs from the initial range, which are also available, have been registered.Signed-off-by Andrew Jones <[email protected]>--- 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@@ -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@@ -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
-2for (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 withregister_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 removeprobe()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
PATCH v4 3/3 lib: sbi: Apply register_extensions to vendor extensions
In reply to Andrew JonesThe 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
@@ -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