| Message ID | 1560198837-18857-2-git-send-email-nayna@linux.ibm.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | powerpc: Enabling IMA arch specific secure boot policies | expand |
Nayna Jain <nayna@linux.ibm.com> writes: > From: Claudio Carvalho <cclaudio@linux.ibm.com> > > The X.509 certificates trusted by the platform and other information > required to secure boot the OS kernel are wrapped in secure variables, > which are controlled by OPAL. > > This patch adds support to read OPAL secure variables through > OPAL_SECVAR_GET call. It returns the metadata and data for a given secure > variable based on the unique key. > > Since OPAL can support different types of backend which can vary in the > variable interpretation, a new OPAL API call named OPAL_SECVAR_BACKEND, is > added to retrieve the supported backend version. This helps the consumer > to know how to interpret the variable. > (Firstly, apologies that I haven't got around to asking about this yet!) Are pluggable/versioned backend a good idea? There are a few things that worry me about the idea: - It adds complexity in crypto (or crypto-adjacent) code, and that increases the likelihood that we'll accidentally add a bug with bad consequences. - Under what circumstances would would we change the kernel-visible behaviour of skiboot? Are we expecting to change the behaviour, content or names of the variables in future? Otherwise the only relevant change I can think of is a change to hardware platforms, and I'm not sure how a change in hardware would lead to change in behaviour in the kernel. Wouldn't Skiboot hide h/w differences? - If we are worried about a long-term-future change to how secure-boot works, would it be better to just add more get/set calls to opal at the point at which we actually implement the new system? - UEFI added EFI_VARIABLE_AUTHENTICATION_3 in a way that - as far as I know - didn't break backwards compatibility. Is there a reason we cannot add features that way instead? (It also dropped v1 of the authentication header.) - What is the correct fallback behaviour if a kernel receives a result that it does not expect? If a kernel expecting BackendV1 is instead informed that it is running on BackendV2, then the cannot access the secure variable at all, so it cannot load keys that are potentially required to successfully boot (e.g. to validate the module for network card or graphics!) Kind regards, Daniel > This support can be enabled using CONFIG_OPAL_SECVAR > > Signed-off-by: Claudio Carvalho <cclaudio@linux.ibm.com> > Signed-off-by: Nayna Jain <nayna@linux.ibm.com> > --- > This patch depends on a new OPAL call that is being added to skiboot. > The patch set that implements the new call has been posted to > https://patchwork.ozlabs.org/project/skiboot/list/?series=112868 > > arch/powerpc/include/asm/opal-api.h | 4 +- > arch/powerpc/include/asm/opal-secvar.h | 23 ++++++ > arch/powerpc/include/asm/opal.h | 6 ++ > arch/powerpc/platforms/powernv/Kconfig | 6 ++ > arch/powerpc/platforms/powernv/Makefile | 1 + > arch/powerpc/platforms/powernv/opal-call.c | 2 + > arch/powerpc/platforms/powernv/opal-secvar.c | 85 ++++++++++++++++++++ > 7 files changed, 126 insertions(+), 1 deletion(-) > create mode 100644 arch/powerpc/include/asm/opal-secvar.h > create mode 100644 arch/powerpc/platforms/powernv/opal-secvar.c > > diff --git a/arch/powerpc/include/asm/opal-api.h b/arch/powerpc/include/asm/opal-api.h > index e1577cfa7186..a505e669b4b6 100644 > --- a/arch/powerpc/include/asm/opal-api.h > +++ b/arch/powerpc/include/asm/opal-api.h > @@ -212,7 +212,9 @@ > #define OPAL_HANDLE_HMI2 166 > #define OPAL_NX_COPROC_INIT 167 > #define OPAL_XIVE_GET_VP_STATE 170 > -#define OPAL_LAST 170 > +#define OPAL_SECVAR_GET 173 > +#define OPAL_SECVAR_BACKEND 177 > +#define OPAL_LAST 177 > > #define QUIESCE_HOLD 1 /* Spin all calls at entry */ > #define QUIESCE_REJECT 2 /* Fail all calls with OPAL_BUSY */ > diff --git a/arch/powerpc/include/asm/opal-secvar.h b/arch/powerpc/include/asm/opal-secvar.h > new file mode 100644 > index 000000000000..b677171a0368 > --- /dev/null > +++ b/arch/powerpc/include/asm/opal-secvar.h > @@ -0,0 +1,23 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * PowerNV definitions for secure variables OPAL API. > + * > + * Copyright (C) 2019 IBM Corporation > + * Author: Claudio Carvalho <cclaudio@linux.ibm.com> > + * > + */ > +#ifndef OPAL_SECVAR_H > +#define OPAL_SECVAR_H > + > +enum { > + BACKEND_NONE = 0, > + BACKEND_TC_COMPAT_V1, > +}; > + > +extern int opal_get_variable(u8 *key, unsigned long ksize, > + u8 *metadata, unsigned long *mdsize, > + u8 *data, unsigned long *dsize); > + > +extern int opal_variable_version(unsigned long *backend); > + > +#endif > diff --git a/arch/powerpc/include/asm/opal.h b/arch/powerpc/include/asm/opal.h > index 4cc37e708bc7..57d2c2356eda 100644 > --- a/arch/powerpc/include/asm/opal.h > +++ b/arch/powerpc/include/asm/opal.h > @@ -394,6 +394,12 @@ void opal_powercap_init(void); > void opal_psr_init(void); > void opal_sensor_groups_init(void); > > +extern int opal_secvar_get(uint64_t k_key, uint64_t k_key_len, > + uint64_t k_metadata, uint64_t k_metadata_size, > + uint64_t k_data, uint64_t k_data_size); > + > +extern int opal_secvar_backend(uint64_t k_backend); > + > #endif /* __ASSEMBLY__ */ > > #endif /* _ASM_POWERPC_OPAL_H */ > diff --git a/arch/powerpc/platforms/powernv/Kconfig b/arch/powerpc/platforms/powernv/Kconfig > index 850eee860cf2..65b060539b5c 100644 > --- a/arch/powerpc/platforms/powernv/Kconfig > +++ b/arch/powerpc/platforms/powernv/Kconfig > @@ -47,3 +47,9 @@ config PPC_VAS > VAS adapters are found in POWER9 based systems. > > If unsure, say N. > + > +config OPAL_SECVAR > + bool "OPAL Secure Variables" > + depends on PPC_POWERNV > + help > + This enables the kernel to access OPAL secure variables. > diff --git a/arch/powerpc/platforms/powernv/Makefile b/arch/powerpc/platforms/powernv/Makefile > index da2e99efbd04..6651c742e530 100644 > --- a/arch/powerpc/platforms/powernv/Makefile > +++ b/arch/powerpc/platforms/powernv/Makefile > @@ -16,3 +16,4 @@ obj-$(CONFIG_PERF_EVENTS) += opal-imc.o > obj-$(CONFIG_PPC_MEMTRACE) += memtrace.o > obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o > obj-$(CONFIG_OCXL_BASE) += ocxl.o > +obj-$(CONFIG_OPAL_SECVAR) += opal-secvar.o > diff --git a/arch/powerpc/platforms/powernv/opal-call.c b/arch/powerpc/platforms/powernv/opal-call.c > index 36c8fa3647a2..0445980f294f 100644 > --- a/arch/powerpc/platforms/powernv/opal-call.c > +++ b/arch/powerpc/platforms/powernv/opal-call.c > @@ -288,3 +288,5 @@ OPAL_CALL(opal_pci_set_pbcq_tunnel_bar, OPAL_PCI_SET_PBCQ_TUNNEL_BAR); > OPAL_CALL(opal_sensor_read_u64, OPAL_SENSOR_READ_U64); > OPAL_CALL(opal_sensor_group_enable, OPAL_SENSOR_GROUP_ENABLE); > OPAL_CALL(opal_nx_coproc_init, OPAL_NX_COPROC_INIT); > +OPAL_CALL(opal_secvar_get, OPAL_SECVAR_GET); > +OPAL_CALL(opal_secvar_backend, OPAL_SECVAR_BACKEND); > diff --git a/arch/powerpc/platforms/powernv/opal-secvar.c b/arch/powerpc/platforms/powernv/opal-secvar.c > new file mode 100644 > index 000000000000..dba441dd5af1 > --- /dev/null > +++ b/arch/powerpc/platforms/powernv/opal-secvar.c > @@ -0,0 +1,85 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * PowerNV code for secure variables > + * > + * Copyright (C) 2019 IBM Corporation > + * Author: Claudio Carvalho <cclaudio@linux.ibm.com> > + * > + */ > + > +/* > + * The opal wrappers in this file treat the @name, @vendor, and @data > + * parameters as little endian blobs. > + * @name is a ucs2 string > + * @vendor is the vendor GUID. It is converted to LE in the kernel > + * @data variable data, which layout may be different for each variable > + */ > + > +#define pr_fmt(fmt) "secvar: "fmt > + > +#include <linux/types.h> > +#include <asm/opal.h> > +#include <asm/opal-secvar.h> > + > +static bool is_opal_secvar_supported(void) > +{ > + static bool opal_secvar_supported; > + static bool initialized; > + > + if (initialized) > + return opal_secvar_supported; > + > + if (!opal_check_token(OPAL_SECVAR_GET) > + || !opal_check_token(OPAL_SECVAR_BACKEND)) { > + pr_err("OPAL doesn't support secure variables\n"); > + opal_secvar_supported = false; > + } else { > + opal_secvar_supported = true; > + } > + > + initialized = true; > + > + return opal_secvar_supported; > +} > + > +int opal_get_variable(u8 *key, unsigned long ksize, u8 *metadata, > + unsigned long *mdsize, u8 *data, unsigned long *dsize) > +{ > + int rc; > + > + if (!is_opal_secvar_supported()) > + return OPAL_UNSUPPORTED; > + > + if (mdsize) > + *mdsize = cpu_to_be64(*mdsize); > + if (dsize) > + *dsize = cpu_to_be64(*dsize); > + > + rc = opal_secvar_get(__pa(key), ksize, __pa(metadata), __pa(mdsize), > + __pa(data), __pa(dsize)); > + > + if (mdsize) > + *mdsize = be64_to_cpu(*mdsize); > + if (dsize) > + *dsize = be64_to_cpu(*dsize); > + > + return rc; > +} > + > +int opal_variable_version(unsigned long *backend) > +{ > + int rc; > + > + if (!is_opal_secvar_supported()) > + return OPAL_UNSUPPORTED; > + > + if (backend) > + *backend = cpu_to_be64(*backend); > + > + rc = opal_secvar_backend(__pa(backend)); > + > + if (backend) > + *backend = be64_to_cpu(*backend); > + > + return rc; > +} > -- > 2.20.1
Hi Nayna, >>> Since OPAL can support different types of backend which can vary in the >>> variable interpretation, a new OPAL API call named OPAL_SECVAR_BACKEND, is >>> added to retrieve the supported backend version. This helps the consumer >>> to know how to interpret the variable. >>> >> (Firstly, apologies that I haven't got around to asking about this yet!) >> >> Are pluggable/versioned backend a good idea? >> >> There are a few things that worry me about the idea: >> >> - It adds complexity in crypto (or crypto-adjacent) code, and that >> increases the likelihood that we'll accidentally add a bug with bad >> consequences. > > Sorry, I think I am not clear on what exactly you mean here.Can you > please elaborate or give specifics ? Cryptosystems with greater flexibility can have new kinds of vulnerabilities arise from the greater complexity. The first sort of thing that comes to mind is a downgrade attack like from TLS. I think you're protected from this because the mode cannot be negotiatied at run time, but in general it's security sensitive code so I'd like it to be as simple as possible. >> - If we are worried about a long-term-future change to how secure-boot >> works, would it be better to just add more get/set calls to opal at >> the point at which we actually implement the new system? > > The intention is to avoid to re-implement the key/value interface for > each scheme. Do you mean to deprecate the old APIs and add new APIs with > every scheme ? Yes, because I expect the scheme would change very, very rarely. >> - Under what circumstances would would we change the kernel-visible >> behaviour of skiboot? Are we expecting to change the behaviour, >> content or names of the variables in future? Otherwise the only >> relevant change I can think of is a change to hardware platforms, and >> I'm not sure how a change in hardware would lead to change in >> behaviour in the kernel. Wouldn't Skiboot hide h/w differences? > > Backends are intended to be an agreement for firmware, kernel and > userspace on what the format of variables are, what variables should be > expected, how they should be signed, etc. Though we don't expect it to > happen very often, we want to anticipate possible changes in the > firmware which may affect the kernel such as new features, support of > new authentication mechanisms, addition of new variables. Corresponding > skiboot patches are on - > https://lists.ozlabs.org/pipermail/skiboot/2019-June/014641.html I still feel like this is holding onto ongoing complexity for very little gain, but perhaps this is because I can't picture a specific change that would actually require a wholesale change to the scheme. You mention new features, support for new authentication mechanisms, and addition of new variables. - New features is a bit too generic to answer specifically. In general I accept that there exists some new feature that would be sufficiently backwards-incompatible as to require a new version. I just can't think of one off the top of my head and so I'm not convinced it's worth the complexity. Did you have something in mind? - By support for new authentication mechanisms, I assume you mean new mechanisms for authenticating variable updates? This is communicated in edk2 via the attributes field. Looking at patch 5 from the skiboot series: + * When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is set, + * then the Data buffer shall begin with an instance of a complete (and + * serialized) EFI_VARIABLE_AUTHENTICATION_2 descriptor. Could a new authentication scheme be communicated by setting a different attribute value? Or are we not carrying attributes in the metadata blob? - For addition of new variables, I'm confused as to why this would require a new API - wouldn't it just be exposed in the normal way via opal_secvar_get(_next)? I guess I also somewhat object to calling it a 'backend' if we're using it as a version scheme. I think the skiboot storage backends are true backends - they provide different implementations of the same functionality with the same API, but this seems like you're using it to indicate different functionality. It seems like we're using it as if it were called OPAL_SECVAR_VERSION. >> - What is the correct fallback behaviour if a kernel receives a result >> that it does not expect? If a kernel expecting BackendV1 is instead >> informed that it is running on BackendV2, then the cannot access the >> secure variable at all, so it cannot load keys that are potentially >> required to successfully boot (e.g. to validate the module for >> network card or graphics!) > > The backend is declaredby the firmware, and is set at compile-time. The > kernel queriesfirmware on whichbackend is in use, and the backend will > not change at runtime.If the backend in use by the firmware is not > supported by the kernel (e.g. kernel is too old), the kernel does not > attempt to read any secure variables, as it won't understand what the > format is. This is a secure boot failure condition, as we cannot verify > the next kernel. With addition of new backends in the skiboot, the > support will be added to the kernel. Note: skiboot and skiroot should > always be in sync with backend support. Seems reasonable. I'm thinking specifically about the kernel loaded after skiroot; and yes, on reflection just failing to boot is the only sensible thing you can do. Regards, Daniel
On 06/12/2019 07:04 PM, Daniel Axtens wrote: > Hi Nayna, > >>>> Since OPAL can support different types of backend which can vary in the >>>> variable interpretation, a new OPAL API call named OPAL_SECVAR_BACKEND, is >>>> added to retrieve the supported backend version. This helps the consumer >>>> to know how to interpret the variable. >>>> >>> (Firstly, apologies that I haven't got around to asking about this yet!) >>> >>> Are pluggable/versioned backend a good idea? >>> >>> There are a few things that worry me about the idea: >>> >>> - It adds complexity in crypto (or crypto-adjacent) code, and that >>> increases the likelihood that we'll accidentally add a bug with bad >>> consequences. >> Sorry, I think I am not clear on what exactly you mean here.Can you >> please elaborate or give specifics ? > Cryptosystems with greater flexibility can have new kinds of > vulnerabilities arise from the greater complexity. The first sort of > thing that comes to mind is a downgrade attack like from TLS. I think > you're protected from this because the mode cannot be negotiatied at run > time, but in general it's security sensitive code so I'd like it to be > as simple as possible. > >>> - If we are worried about a long-term-future change to how secure-boot >>> works, would it be better to just add more get/set calls to opal at >>> the point at which we actually implement the new system? >> The intention is to avoid to re-implement the key/value interface for >> each scheme. Do you mean to deprecate the old APIs and add new APIs with >> every scheme ? > Yes, because I expect the scheme would change very, very rarely. So, the design is not making the assumption that a particular scheme will change often. It is just allowing the flexibility for addition of new schemes or enhancements if needed. > >>> - Under what circumstances would would we change the kernel-visible >>> behaviour of skiboot? Are we expecting to change the behaviour, >>> content or names of the variables in future? Otherwise the only >>> relevant change I can think of is a change to hardware platforms, and >>> I'm not sure how a change in hardware would lead to change in >>> behaviour in the kernel. Wouldn't Skiboot hide h/w differences? >> Backends are intended to be an agreement for firmware, kernel and >> userspace on what the format of variables are, what variables should be >> expected, how they should be signed, etc. Though we don't expect it to >> happen very often, we want to anticipate possible changes in the >> firmware which may affect the kernel such as new features, support of >> new authentication mechanisms, addition of new variables. Corresponding >> skiboot patches are on - >> https://lists.ozlabs.org/pipermail/skiboot/2019-June/014641.html > I still feel like this is holding onto ongoing complexity for very > little gain, but perhaps this is because I can't picture a specific > change that would actually require a wholesale change to the scheme. That is the exact reason for having pluggable backend, because we cannot determine now if there will be a need of new scheme in future or not. > > You mention new features, support for new authentication mechanisms, and > addition of new variables. > > - New features is a bit too generic to answer specifically. In general > I accept that there exists some new feature that would be > sufficiently backwards-incompatible as to require a new version. I > just can't think of one off the top of my head and so I'm not > convinced it's worth the complexity. Did you have something in mind? That is the idea to keep the design flexible to be able to handle future additions with maximum reuse. Example, supporting new algorithms or a different handling of secure variable updates by different vendors. > > - By support for new authentication mechanisms, I assume you mean new > mechanisms for authenticating variable updates? This is communicated > in edk2 via the attributes field. Looking at patch 5 from the skiboot > series: > > + * When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is set, > + * then the Data buffer shall begin with an instance of a complete (and > + * serialized) EFI_VARIABLE_AUTHENTICATION_2 descriptor. > > Could a new authentication scheme be communicated by setting a > different attribute value? Or are we not carrying attributes in the > metadata blob? > > - For addition of new variables, I'm confused as to why this would > require a new API - wouldn't it just be exposed in the normal way via > opal_secvar_get(_next)? Sorry, probably it wasn't clear. By addition of new variables, we meant that over time we might have to add new "volatile" variables that "fine tunes" secure boot state. This might impact the kernel if it needs to understand new variables to define its policies. However, this will not result in change of API, it will result in change of the version. > > I guess I also somewhat object to calling it a 'backend' if we're using > it as a version scheme. I think the skiboot storage backends are true > backends - they provide different implementations of the same > functionality with the same API, but this seems like you're using it to > indicate different functionality. It seems like we're using it as if it > were called OPAL_SECVAR_VERSION. We are changing how we are exposing the version to the kernel. The version will be exposed as device-tree entry rather than a OPAL runtime service. We are not tied to the name "backend", we can switch to calling it as "scheme" unless there is a better name. Thanks & Regards, - Nayna
Hi Nayna, >> I guess I also somewhat object to calling it a 'backend' if we're using >> it as a version scheme. I think the skiboot storage backends are true >> backends - they provide different implementations of the same >> functionality with the same API, but this seems like you're using it to >> indicate different functionality. It seems like we're using it as if it >> were called OPAL_SECVAR_VERSION. > > We are changing how we are exposing the version to the kernel. The > version will be exposed as device-tree entry rather than a OPAL runtime > service. We are not tied to the name "backend", we can switch to calling > it as "scheme" unless there is a better name. This sounds like a good approach to me. Kind regards, Daniel > > Thanks & Regards, > - Nayna
diff --git a/arch/powerpc/include/asm/opal-api.h b/arch/powerpc/include/asm/opal-api.h index e1577cfa7186..a505e669b4b6 100644 --- a/arch/powerpc/include/asm/opal-api.h +++ b/arch/powerpc/include/asm/opal-api.h @@ -212,7 +212,9 @@ #define OPAL_HANDLE_HMI2 166 #define OPAL_NX_COPROC_INIT 167 #define OPAL_XIVE_GET_VP_STATE 170 -#define OPAL_LAST 170 +#define OPAL_SECVAR_GET 173 +#define OPAL_SECVAR_BACKEND 177 +#define OPAL_LAST 177 #define QUIESCE_HOLD 1 /* Spin all calls at entry */ #define QUIESCE_REJECT 2 /* Fail all calls with OPAL_BUSY */ diff --git a/arch/powerpc/include/asm/opal-secvar.h b/arch/powerpc/include/asm/opal-secvar.h new file mode 100644 index 000000000000..b677171a0368 --- /dev/null +++ b/arch/powerpc/include/asm/opal-secvar.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * PowerNV definitions for secure variables OPAL API. + * + * Copyright (C) 2019 IBM Corporation + * Author: Claudio Carvalho <cclaudio@linux.ibm.com> + * + */ +#ifndef OPAL_SECVAR_H +#define OPAL_SECVAR_H + +enum { + BACKEND_NONE = 0, + BACKEND_TC_COMPAT_V1, +}; + +extern int opal_get_variable(u8 *key, unsigned long ksize, + u8 *metadata, unsigned long *mdsize, + u8 *data, unsigned long *dsize); + +extern int opal_variable_version(unsigned long *backend); + +#endif diff --git a/arch/powerpc/include/asm/opal.h b/arch/powerpc/include/asm/opal.h index 4cc37e708bc7..57d2c2356eda 100644 --- a/arch/powerpc/include/asm/opal.h +++ b/arch/powerpc/include/asm/opal.h @@ -394,6 +394,12 @@ void opal_powercap_init(void); void opal_psr_init(void); void opal_sensor_groups_init(void); +extern int opal_secvar_get(uint64_t k_key, uint64_t k_key_len, + uint64_t k_metadata, uint64_t k_metadata_size, + uint64_t k_data, uint64_t k_data_size); + +extern int opal_secvar_backend(uint64_t k_backend); + #endif /* __ASSEMBLY__ */ #endif /* _ASM_POWERPC_OPAL_H */ diff --git a/arch/powerpc/platforms/powernv/Kconfig b/arch/powerpc/platforms/powernv/Kconfig index 850eee860cf2..65b060539b5c 100644 --- a/arch/powerpc/platforms/powernv/Kconfig +++ b/arch/powerpc/platforms/powernv/Kconfig @@ -47,3 +47,9 @@ config PPC_VAS VAS adapters are found in POWER9 based systems. If unsure, say N. + +config OPAL_SECVAR + bool "OPAL Secure Variables" + depends on PPC_POWERNV + help + This enables the kernel to access OPAL secure variables. diff --git a/arch/powerpc/platforms/powernv/Makefile b/arch/powerpc/platforms/powernv/Makefile index da2e99efbd04..6651c742e530 100644 --- a/arch/powerpc/platforms/powernv/Makefile +++ b/arch/powerpc/platforms/powernv/Makefile @@ -16,3 +16,4 @@ obj-$(CONFIG_PERF_EVENTS) += opal-imc.o obj-$(CONFIG_PPC_MEMTRACE) += memtrace.o obj-$(CONFIG_PPC_VAS) += vas.o vas-window.o vas-debug.o obj-$(CONFIG_OCXL_BASE) += ocxl.o +obj-$(CONFIG_OPAL_SECVAR) += opal-secvar.o diff --git a/arch/powerpc/platforms/powernv/opal-call.c b/arch/powerpc/platforms/powernv/opal-call.c index 36c8fa3647a2..0445980f294f 100644 --- a/arch/powerpc/platforms/powernv/opal-call.c +++ b/arch/powerpc/platforms/powernv/opal-call.c @@ -288,3 +288,5 @@ OPAL_CALL(opal_pci_set_pbcq_tunnel_bar, OPAL_PCI_SET_PBCQ_TUNNEL_BAR); OPAL_CALL(opal_sensor_read_u64, OPAL_SENSOR_READ_U64); OPAL_CALL(opal_sensor_group_enable, OPAL_SENSOR_GROUP_ENABLE); OPAL_CALL(opal_nx_coproc_init, OPAL_NX_COPROC_INIT); +OPAL_CALL(opal_secvar_get, OPAL_SECVAR_GET); +OPAL_CALL(opal_secvar_backend, OPAL_SECVAR_BACKEND); diff --git a/arch/powerpc/platforms/powernv/opal-secvar.c b/arch/powerpc/platforms/powernv/opal-secvar.c new file mode 100644 index 000000000000..dba441dd5af1 --- /dev/null +++ b/arch/powerpc/platforms/powernv/opal-secvar.c @@ -0,0 +1,85 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * PowerNV code for secure variables + * + * Copyright (C) 2019 IBM Corporation + * Author: Claudio Carvalho <cclaudio@linux.ibm.com> + * + */ + +/* + * The opal wrappers in this file treat the @name, @vendor, and @data + * parameters as little endian blobs. + * @name is a ucs2 string + * @vendor is the vendor GUID. It is converted to LE in the kernel + * @data variable data, which layout may be different for each variable + */ + +#define pr_fmt(fmt) "secvar: "fmt + +#include <linux/types.h> +#include <asm/opal.h> +#include <asm/opal-secvar.h> + +static bool is_opal_secvar_supported(void) +{ + static bool opal_secvar_supported; + static bool initialized; + + if (initialized) + return opal_secvar_supported; + + if (!opal_check_token(OPAL_SECVAR_GET) + || !opal_check_token(OPAL_SECVAR_BACKEND)) { + pr_err("OPAL doesn't support secure variables\n"); + opal_secvar_supported = false; + } else { + opal_secvar_supported = true; + } + + initialized = true; + + return opal_secvar_supported; +} + +int opal_get_variable(u8 *key, unsigned long ksize, u8 *metadata, + unsigned long *mdsize, u8 *data, unsigned long *dsize) +{ + int rc; + + if (!is_opal_secvar_supported()) + return OPAL_UNSUPPORTED; + + if (mdsize) + *mdsize = cpu_to_be64(*mdsize); + if (dsize) + *dsize = cpu_to_be64(*dsize); + + rc = opal_secvar_get(__pa(key), ksize, __pa(metadata), __pa(mdsize), + __pa(data), __pa(dsize)); + + if (mdsize) + *mdsize = be64_to_cpu(*mdsize); + if (dsize) + *dsize = be64_to_cpu(*dsize); + + return rc; +} + +int opal_variable_version(unsigned long *backend) +{ + int rc; + + if (!is_opal_secvar_supported()) + return OPAL_UNSUPPORTED; + + if (backend) + *backend = cpu_to_be64(*backend); + + rc = opal_secvar_backend(__pa(backend)); + + if (backend) + *backend = be64_to_cpu(*backend); + + return rc; +}