s390: virtio: let arch choose to accept devices without IOMMU feature
Subsystems (4)
v3 cover s390: virtio: let arch choose to accept devices without IOMMU feature
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices without VIRTIO_F_IOMMU_PLATFORM.
Pierre Morel (1):
s390: virtio: let arch accept devices without IOMMU feature
arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)
Signature · 25 lines
2.25.1 Changelog to v3: - add warning (Connie, Christian) - add comment (Connie) - change hook name (Halil, Connie) to v2: - put the test in virtio_finalize_features() (Connie) - put the test inside VIRTIO core (Jason) - pass a virtio device as parameter (Halil)
PATCH v3 1/1 s390: virtio: let arch accept devices without IOMMU feature
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices without VIRTIO_F_IOMMU_PLATFORM.
--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)
arch/s390/mm/init.c +6 -0
@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);
@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {
drivers/virtio/virtio.c +22 -0
@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);
@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {
include/linux/virtio.h +2 -0
@@ -195,4 +195,6 @@ void unregister_virtio_driver(struct virtio_driver *drv);#define module_virtio_driver (__virtio_driver) \ module_driver(__virtio_driver, register_virtio_driver, \ unregister_virtio_driver) + +int arch_needs_virtio_iommu_platform (struct virtio_device *dev);#endif /* _LINUX_VIRTIO_H */
Signature · 1 line
2.25.1
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 29 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +1
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);
arch/s390/mm/init.c bool force_dma_unencrypted(struct device *dev) · line 171
Quoted 10 lines
arch/s390/mm/init.c +5
-0@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void )
Can we please stop dumping random code to arch/s390/mm/init.c?
All the protected virtualization functions should go into a separate file (e.g. mem_encrypt.c like on x86), some of which could also be in header files.
Please consider this a comment for the future.. just go ahead with this patch as-is.
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 43 lines · Heiko Carstens
Quoted 29 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +1
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);arch/s390/mm/init.c bool force_dma_unencrypted(struct device *dev) · line 171
Quoted 10 lines
arch/s390/mm/init.c +5
-0@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void )Can we please stop dumping random code to
arch/s390/mm/init.c?
Quoted 7 lines
All the protected virtualization functions should go into a separate file (e.g.
mem_encrypt.clike on x86), some of which could also be in header files.Please consider this a comment for the future.. just go ahead with this patch as-is.
OK, thanks Heiko,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Pierre MorelQuoted 67 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +6
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {drivers/virtio/virtio.c +15
-0@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 198
Quoted 5 lines
drivers/virtio/virtio.c +2
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) {
Just a style nit, but the "!virtio..." should be directly under the "arch_...", not tabbed out.
Thanks,
Tom
Quoted 20 lines
drivers/virtio/virtio.c +5
-0+dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {include/linux/virtio.h +2
-0@@ -195,4 +195,6 @@ void unregister_virtio_driver(struct virtio_driver *drv);#define module_virtio_driver (__virtio_driver) \ module_driver(__virtio_driver, register_virtio_driver, \ unregister_virtio_driver) + +int arch_needs_virtio_iommu_platform (struct virtio_device *dev);#endif /* _LINUX_VIRTIO_H */
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 71 lines · Tom Lendacky
Quoted 70 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +6
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {drivers/virtio/virtio.c +15
-0@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
Quoted 5 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 198
Quoted 2 lines
drivers/virtio/virtio.c +2
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) {Just a style nit, but the "!virtio..." should be directly under the "
arch_...", not tabbed out.
Oh right, thanks!
Pierre
Quoted 4 lines
Thanks,
Tom
...snip...
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Pierre MorelQuoted 7 lines · On Wed, 17 Jun 2020 12:43:57 +0200 Pierre Morel <[email protected]> wrote:
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.
[..]
I'm still not really satisfied with your commit message, furthermore I did some thinking about the abstraction you introduce here. I will give a short analysis of that, but first things first. Your patch does the job of preventing calamity, and the details can be changed any time, thus:
Regarding the interaction of architecture specific code with virtio core, I believe we could have made the interface more generic.
One option is to introduce virtio_arch_finalize_features(), a hook that could reject any feature that is inappropriate.
Another option would be to find a common name for is_prot_virt_guest() (arch/s390) sev_active() (arch/x86) and is_secure_guest() (arch/powerpc) and use that instead of arch_needs_virtio_iommu_platform() and where-ever appropriate. Currently we seem to want this info in driver code only for virtio, but if the virtio driver has a legitimate need to know, other drivers may as well have a legitimate need to know. For example if we wanted to protect ourselves in ccw device drivers from somebody setting up a vfio-ccw device and attach it to the prot-virt guest (AFAICT we only lack guest enablement for this) such a function could be useful.
But since this can be rewritten any time, let's go with the option people already agree with, instead of more discussion.
Just another question. Do we want this backported? Do we need cc stable? [..]
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 11 lines
int
virtio_finalize_features(struct virtio_device *dev){drivers/virtio/virtio.c +4
-0int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );
I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device"
Regards,
Halil
Cornelia Huck
Acked-byRe: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 19 lines · On Thu, 18 Jun 2020 00:29:56 +0200 Halil Pasic <[email protected]> wrote:
Quoted 7 lines · On Wed, 17 Jun 2020 12:43:57 +0200 Pierre Morel <[email protected]> wrote:
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.[..]
I'm still not really satisfied with your commit message, furthermore I did some thinking about the abstraction you introduce here. I will give a short analysis of that, but first things first. Your patch does the job of preventing calamity, and the details can be changed any time, thus:
Quoted 7 lines
Acked-by Halil Pasic <[email protected]>Regarding the interaction of architecture specific code with virtio core, I believe we could have made the interface more generic.
One option is to introduce
virtio_arch_finalize_features(), a hook that could reject any feature that is inappropriate.
s/any feature/any combination of features/
This sounds like a good idea (for a later update).
Quoted 10 lines
Another option would be to find a common name for
is_prot_virt_guest()(arch/s390)sev_active()(arch/x86) andis_secure_guest()(arch/powerpc) and use that instead ofarch_needs_virtio_iommu_platform()and where-ever appropriate. Currently we seem to want this info in driver code only for virtio, but if the virtio driver has a legitimate need to know, other drivers may as well have a legitimate need to know. For example if we wanted to protect ourselves in ccw device drivers from somebody setting up a vfio-ccw device and attach it to the prot-virt guest (AFAICT we only lack guest enablement for this) such a function could be useful.
I'm not really sure if we can find enough commonality between architectures, unless you propose to have a function for checking things like device memory only.
Quoted 3 lines
But since this can be rewritten any time, let's go with the option people already agree with, instead of more discussion.
Yes, there's nothing wrong with the patch as-is.
Which tree should this go through? Virtio? s390?
Quoted 2 lines
Just another question. Do we want this backported? Do we need cc stable?
It does change behaviour of virtio-ccw devices; but then, it only fences off configurations that would not have worked anyway. Distributions should probably pick this; but I do not consider it strictly a "fix" (more a mitigation for broken configurations), so I'm not sure whether stable applies.
Quoted 10 lines
[..]
Quoted 7 lines
int
virtio_finalize_features(struct virtio_device *dev){drivers/virtio/virtio.c +0
-0int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
Quoted 7 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 4 lines
drivers/virtio/virtio.c +4
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new ACCESS_PLATFORM define and keep the old one, but that would still mean some churn.
Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device"
"virtio: device does not work with limited memory access" ?
But no issue with keeping the current message.
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 12 lines · On Fri, 19 Jun 2020 11:20:51 +0200 Cornelia Huck <[email protected]> wrote:
Quoted 7 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 4 lines
drivers/virtio/virtio.c +4
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new
ACCESS_PLATFORMdefine and keep the old one, but that would still mean some churn.
Quoted 7 lines
Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device""virtio: device does not work with limited memory access" ?
But no issue with keeping the current message.
I think I prefer Conny's version, but no strong feelings here.
Halil
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 19 lines · Halil Pasic
Quoted 16 lines · On Fri, 19 Jun 2020 11:20:51 +0200 Cornelia Huck <[email protected]> wrote:
Quoted 7 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 4 lines
drivers/virtio/virtio.c +4
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new
ACCESS_PLATFORMdefine and keep the old one, but that would still mean some churn.Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device"
Quoted 6 lines
Quoted 3 lines
"virtio: device does not work with limited memory access" ?
But no issue with keeping the current message.
I think I prefer Conny's version, but no strong feelings here.
The reason why the device is not accepted without IOMMU_PLATFORM is arch specific, I think it should be clearly stated. If no strong oposition...
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Cornelia HuckQuoted 5 lines · Cornelia Huck
Quoted 2 lines · On Thu, 18 Jun 2020 00:29:56 +0200 Halil Pasic <[email protected]> wrote:
On Wed, 17 Jun 2020 12:43:57 +0200
Pierre Morel <[email protected]> wrote:
...
Quoted 7 lines
Quoted 3 lines
But since this can be rewritten any time, let's go with the option people already agree with, instead of more discussion.
Yes, there's nothing wrong with the patch as-is.
Acked-by Cornelia Huck <[email protected]>
Thanks,
Quoted 33 lines
Which tree should this go through? Virtio? s390? >
Quoted 2 lines
Just another question. Do we want this backported? Do we need cc stable?
It does change behaviour of virtio-ccw devices; but then, it only fences off configurations that would not have worked anyway. Distributions should probably pick this; but I do not consider it strictly a "fix" (more a mitigation for broken configurations), so I'm not sure whether stable applies.
Quoted 10 lines
[..]
Quoted 7 lines
int virtio_finalize_features(struct virtio_device *dev) { int ret = dev->config->finalize_features(dev);drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;Quoted 7 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 4 lines
drivers/virtio/virtio.c +4
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new
ACCESS_PLATFORMdefine and keep the old one, but that would still mean some churn.
Quoted 8 lines
Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device""virtio: device does not work with limited memory access" ?
But no issue with keeping the current message.
If it is OK, I would like to specify that the arch is responsible to accept or not the device. The reason why the device is not accepted without IOMMU_PLATFORM is arch specific.
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 7 lines · On Mon, 29 Jun 2020 15:14:04 +0200 Pierre Morel <[email protected]> wrote:
Quoted 5 lines · Cornelia Huck
Quoted 2 lines · On Thu, 18 Jun 2020 00:29:56 +0200 Halil Pasic <[email protected]> wrote:
On Wed, 17 Jun 2020 12:43:57 +0200
Pierre Morel <[email protected]> wrote:
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 8 lines
drivers/virtio/virtio.c +4
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );
[Side note: wasn't there a patch renaming this bit on the list? I think this name is only kept for userspace compat.]
Quoted 14 lines
Quoted 14 lines
Quoted 3 lines
I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new
ACCESS_PLATFORMdefine and keep the old one, but that would still mean some churn.Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device""virtio: device does not work with limited memory access" ?
Quoted 7 lines
Quoted 2 lines
But no issue with keeping the current message.
If it is OK, I would like to specify that the arch is responsible to accept or not the device.
The reason why the device is not accepted withoutIOMMU_PLATFORMis arch specific.
Hm, I'd think the reason is always the same (the device cannot access the memory directly), just the way to figure out whether that is the case or not is arch-specific, as with so many other things. No real need to go into detail here, I think.
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 14 lines · Cornelia Huck
Quoted 11 lines · On Mon, 29 Jun 2020 15:14:04 +0200 Pierre Morel <[email protected]> wrote:
Quoted 10 lines · Cornelia Huck
Quoted 7 lines · On Thu, 18 Jun 2020 00:29:56 +0200 Halil Pasic <[email protected]> wrote:
Quoted 4 lines · On Wed, 17 Jun 2020 12:43:57 +0200 Pierre Morel <[email protected]> wrote:
drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 200
Quoted 4 lines
drivers/virtio/virtio.c +4
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" );[Side note: wasn't there a patch renaming this bit on the list? I think this name is only kept for userspace compat.]
Sorry, I do not understand what you expect from me. On which mailing list you think there is a patch on?
Quoted 23 lines
Quoted 15 lines
Quoted 15 lines
Quoted 4 lines
I'm not sure, divulging the current Linux name of this feature bit is a good idea, but if everybody else is fine with this, I don't care that
Not sure if that feature name will ever change, as it is exported in headers. At most, we might want to add the new
ACCESS_PLATFORMdefine and keep the old one, but that would still mean some churn.Quoted 3 lines
much. An alternative would be:
"virtio: device falsely claims to have full access to the memory, aborting the device""virtio: device does not work with limited memory access" ?
Quoted 7 lines
Quoted 2 lines
But no issue with keeping the current message.
If it is OK, I would like to specify that the arch is responsible to accept or not the device.
The reason why the device is not accepted withoutIOMMU_PLATFORMis arch specific.
Quoted 5 lines
Hm, I'd think the reason is always the same (the device cannot access the memory directly), just the way to figure out whether that is the case or not is arch-specific, as with so many other things. No real need to go into detail here, I think.
As you like, so I rename the subject to:
"virtio: device does not work with limited memory access"
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Halil PasicQuoted 13 lines · Halil Pasic
Quoted 7 lines · On Wed, 17 Jun 2020 12:43:57 +0200 Pierre Morel <[email protected]> wrote:
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.[..]
Quoted 7 lines
I'm still not really satisfied with your commit message, furthermore I did some thinking about the abstraction you introduce here. I will give a short analysis of that, but first things first. Your patch does the job of preventing calamity, and the details can be changed any time, thus:
Acked-by Halil Pasic <[email protected]>
Thanks,
Connie already answered the other points you raised and I have nothing to add on it.
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Michael S. Tsirkin
maintainerRe: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Pierre MorelQuoted 70 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +6
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {drivers/virtio/virtio.c +15
-0@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {
Well don't you need to check it *before* VIRTIO_F_VERSION_1, not after?
Quoted 13 lines
include/linux/virtio.h +2
-0@@ -195,4 +195,6 @@ void unregister_virtio_driver(struct virtio_driver *drv);#define module_virtio_driver (__virtio_driver) \ module_driver(__virtio_driver, register_virtio_driver, \ unregister_virtio_driver) + +int arch_needs_virtio_iommu_platform (struct virtio_device *dev);#endif /* _LINUX_VIRTIO_H */ Signature · 1 line
2.25.1
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 21 lines · On Mon, 29 Jun 2020 11:57:14 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 20 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
Quoted 12 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?
But it's only available with VERSION_1 anyway, isn't it? So it probably also needs to fail when this feature is needed if VERSION_1 has not been negotiated, I think.
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 37 lines · Cornelia Huck
Quoted 21 lines · On Mon, 29 Jun 2020 11:57:14 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 20 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;Quoted 12 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?
Quoted 4 lines
But it's only available with
VERSION_1anyway, isn't it? So it probably also needs to fail when this feature is needed ifVERSION_1has not been negotiated, I think.
Yes, clearly, I will add this.
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 40 lines · Pierre Morel
Quoted 37 lines · Cornelia Huck
Quoted 33 lines · On Mon, 29 Jun 2020 11:57:14 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 20 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>---
arch/s390/mm/init.c | 6 ++++++drivers/virtio/virtio.c| 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++3 files changed, 30 insertions(+)drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0;drivers/virtio/virtio.c int virtio_finalize_features(struct · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+ if (arch_needs_virtio_iommu_platform(dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) { + dev_warn(&dev->dev, + "virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n"); + return -ENODEV; + } + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev); if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?
Quoted 3 lines
Quoted 3 lines
But it's only available with
VERSION_1anyway, isn't it? So it probably also needs to fail when this feature is needed ifVERSION_1has not been negotiated, I think.
would be something like:
- if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1))
- return 0;
+ if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) {
+ ret = arch_accept_virtio_features(dev);
+ if (ret)
+ dev_warn(&dev->dev,
+ "virtio: device must provide VIRTIO_F_VERSION_1\n");
+ return ret;
+ }
just a thought on the function name:
It becomes more general than just IOMMU_PLATFORM related.
What do you think of:
arch_accept_virtio_features()
?
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 56 lines · On Mon, 6 Jul 2020 15:37:37 +0200 Pierre Morel <[email protected]> wrote:
Quoted 40 lines · Pierre Morel
Quoted 37 lines · Cornelia Huck
Quoted 33 lines · On Mon, 29 Jun 2020 11:57:14 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 20 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>---
arch/s390/mm/init.c | 6 ++++++drivers/virtio/virtio.c| 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++3 files changed, 30 insertions(+)drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0;drivers/virtio/virtio.c int virtio_finalize_features(struct · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+ if (arch_needs_virtio_iommu_platform(dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) { + dev_warn(&dev->dev, + "virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n"); + return -ENODEV; + } + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev); if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?Quoted 3 lines
Quoted 3 lines
But it's only available with
VERSION_1anyway, isn't it? So it probably also needs to fail when this feature is needed ifVERSION_1has not been negotiated, I think.would be something like:
(quoted diff) +5
-2- if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) - return 0; + if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) { + ret = arch_accept_virtio_features(dev); + if (ret) + dev_warn(&dev->dev, + "virtio: device must provideVIRTIO_F_VERSION_1\n");
Review
Quoted 2 lines
(quoted diff) +2
-0+ return ret; + }
That looks wrong; I think we want to validate in all cases. What about:
ret = arch_accept_virtio_features(dev); // this can include checking for
// older or newer features if (ret) // assume that the arch callback moaned already return ret;
if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1))
return 0;
// do the virtio-1 only FEATURES_OK dance
Quoted 8 lines
just a thought on the function name:
It becomes more general than justIOMMU_PLATFORMrelated.What do you think of:
arch_accept_virtio_features()
Or maybe arch_validate_virtio_features()?
Quoted 7 lines
?
Regards,
Pierre
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 70 lines · Cornelia Huck
Quoted 56 lines · On Mon, 6 Jul 2020 15:37:37 +0200 Pierre Morel <[email protected]> wrote:
Quoted 40 lines · Pierre Morel
Quoted 37 lines · Cornelia Huck
Quoted 33 lines · On Mon, 29 Jun 2020 11:57:14 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 20 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)drivers/virtio/virtio.c +0
-0@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0;drivers/virtio/virtio.c int virtio_finalize_features(struct · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+ if (arch_needs_virtio_iommu_platform(dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) { + dev_warn(&dev->dev, + "virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n"); + return -ENODEV; + } + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev); if (!(status & VIRTIO_CONFIG_S_FEATURES_OK)) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?Quoted 3 lines
Quoted 3 lines
But it's only available with
VERSION_1anyway, isn't it? So it probably also needs to fail when this feature is needed ifVERSION_1has not been negotiated, I think.would be something like:
(quoted diff) +5
-2- if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) - return 0; + if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) { + ret = arch_accept_virtio_features(dev); + if (ret) + dev_warn(&dev->dev, + "virtio: device must provideVIRTIO_F_VERSION_1\n");
Review
Quoted 2 lines
(quoted diff) +2
-0+ return ret; + }That looks wrong; I think we want to validate in all cases. What about:
ret =
arch_accept_virtio_features(dev); // this can include checking for// older or newer features if (ret) // assume that the arch callback moaned already return ret;
Quoted 4 lines
if (!virtio_has_feature(dev,
VIRTIO_F_VERSION_1))return 0;// do the virtio-1 only
FEATURES_OKdance
hum, you are right, I was too focused on keeping my simple arch_accept_virtio_features() function unchanged. It must be more general.
Quoted 11 lines
Quoted 9 lines
just a thought on the function name:
It becomes more general than justIOMMU_PLATFORMrelated.What do you think of:
arch_accept_virtio_features()Or maybe
arch_validate_virtio_features()?
OK validated.
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Michael S. TsirkinQuoted 71 lines · Michael S. Tsirkin
Quoted 70 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.Let's give a chance to the architecture to accept or not devices without
VIRTIO_F_IOMMU_PLATFORM.Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +6
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {drivers/virtio/virtio.c +15
-0@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ;
Quoted 12 lines
drivers/virtio/virtio.c int virtio_finalize_features(struct virtio_device *dev) · line 206
Quoted 10 lines
drivers/virtio/virtio.c +7
-0+if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {Well don't you need to check it *before*
VIRTIO_F_VERSION_1, not after?
Yes, you are right,
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Michael S. Tsirkin
maintainerRe: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
In reply to Pierre MorelQuoted 5 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices withoutVIRTIO_F_IOMMU_PLATFORM.
I agree it's a bit misleading. Protection is enforced by memory encryption, you can't trust the hypervisor to report the bit correctly so using that as a securoty measure would be pointless.
The real gain here is that broken configs are easier to debug.
Here's an attempt at a better description:
On some architectures, guest knows that VIRTIO_F_IOMMU_PLATFORM is required for virtio to function: e.g. this is the case on s390 protected virt guests, since otherwise guest passes encrypted guest memory to devices, which the device can't read. Without VIRTIO_F_IOMMU_PLATFORM the result is that affected memory (or even a whole page containing it is corrupted). Detect and fail probe instead - that is easier to debug.
however, now that we have described what it is (hypervisor misconfiguration) I ask a question: can we be sure this will never ever work? E.g. what if some future hypervisor gains ability to access the protected guest memory in some abstractly secure manner? We are blocking this here, and it's hard to predict the future, and a broken hypervisor can always find ways to crash the guest ...
IMHO it would be safer to just print a warning.
What do you think?
Quoted 87 lines
Signed-off-by Pierre Morel <[email protected]>Acked-by Jason Wang <[email protected]>--- arch/s390/mm/init.c | 6 ++++++ drivers/virtio/virtio.c | 22 ++++++++++++++++++++++ include/linux/virtio.h | 2 ++ 3 files changed, 30 insertions(+)arch/s390/mm/init.c +6
-0@@ -45,6 +45,7 @@#include <asm/kasan.h> #include <asm/dma-mapping.h> #include <asm/uv.h> +#include <linux/virtio.h> pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(.bss..swapper_pg_dir);@@ -161,6 +162,11 @@ bool force_dma_unencrypted(struct device *dev)return is_prot_virt_guest (); } +int arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return is_prot_virt_guest (); +} +/* protected virtualization */ static void pv_init (void ) {drivers/virtio/virtio.c +22
-0@@ -167,6 +167,21 @@ void virtio_add_status(struct virtio_device *dev, unsigned int status) }EXPORT_SYMBOL_GPL (virtio_add_status); +/* +* arch_needs_virtio_iommu_platform - provide arch specific hook when finalizing +* features for VIRTIO device dev +* @dev: the VIRTIO device being added +* +* Permits the platform to provide architecture specific functionality when +* devices features are finalized. This is the default implementation. +* Architecture implementations can override this. +*/ + +int __weak arch_needs_virtio_iommu_platform (struct virtio_device *dev) +{ +return 0 ; +} +int virtio_finalize_features (struct virtio_device *dev) {int ret = dev->config->finalize_features (dev);@@ -179,6 +194,13 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (arch_needs_virtio_iommu_platform (dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) { +dev_warn (&dev->dev, +"virtio: device must provide VIRTIO_F_IOMMU_PLATFORM\n" ); +return -ENODEV ; + } +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {include/linux/virtio.h +2
-0@@ -195,4 +195,6 @@ void unregister_virtio_driver(struct virtio_driver *drv);#define module_virtio_driver (__virtio_driver) \ module_driver(__virtio_driver, register_virtio_driver, \ unregister_virtio_driver) + +int arch_needs_virtio_iommu_platform (struct virtio_device *dev);#endif /* _LINUX_VIRTIO_H */ Signature · 1 line
2.25.1
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 15 lines · Michael S. Tsirkin
Quoted 5 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices withoutVIRTIO_F_IOMMU_PLATFORM.I agree it's a bit misleading. Protection is enforced by memory encryption, you can't trust the hypervisor to report the bit correctly so using that as a securoty measure would be pointless.
The real gain here is that broken configs are easier to debug.Here's an attempt at a better description:
Quoted 7 lines
On some architectures, guest knows that
VIRTIO_F_IOMMU_PLATFORMis required for virtio to function: e.g. this is the case on s390 protected virt guests, since otherwise guest passes encrypted guest memory to devices, which the device can't read. WithoutVIRTIO_F_IOMMU_PLATFORMthe result is that affected memory (or even a whole page containing it is corrupted). Detect and fail probe instead - that is easier to debug.
Thanks indeed better aside from the "encrypted guest memory": the mechanism used to avoid the access to the guest memory from the host by s390 is not encryption but a hardware feature denying the general host access and allowing pieces of memory to be shared between guest and host. As a consequence the data read from memory is not corrupted but not read at all and the read error kills the hypervizor with a SIGSEGV.
Quoted 5 lines
however, now that we have described what it is (hypervisor misconfiguration) I ask a question: can we be sure this will never ever work? E.g. what if some future hypervisor gains ability to access the protected guest memory in some abstractly secure manner?
The goal of the s390 PV feature is to avoid this possibility so I don't think so; however, there is a possibility that some hardware VIRTIO device gain access to the guest's protected memory, even such device does not exist yet.
At the moment such device exists we will need a driver for it, at least to enable the feature and apply policies, it is also one of the reasons why a hook to the architecture is interesting.
Quoted 2 lines
We are blocking this here, and it's hard to predict the future, and a broken hypervisor can always find ways to crash the guest ...
yes, this is also something to fix on the hypervizor side, Halil is working on it.
Quoted 3 lines
IMHO it would be safer to just print a warning.
What do you think?
Sadly, putting a warning may not help as qemu is killed if it accesses the protected memory. Also note that the crash occurs not only on start but also on hotplug.
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Michael S. Tsirkin
maintainerRe: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 26 lines · Pierre Morel
Quoted 15 lines · Michael S. Tsirkin
Quoted 5 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices withoutVIRTIO_F_IOMMU_PLATFORM.I agree it's a bit misleading. Protection is enforced by memory encryption, you can't trust the hypervisor to report the bit correctly so using that as a securoty measure would be pointless.
The real gain here is that broken configs are easier to debug.Here's an attempt at a better description:
Quoted 7 lines
On some architectures, guest knows that
VIRTIO_F_IOMMU_PLATFORMis required for virtio to function: e.g. this is the case on s390 protected virt guests, since otherwise guest passes encrypted guest memory to devices, which the device can't read. WithoutVIRTIO_F_IOMMU_PLATFORMthe result is that affected memory (or even a whole page containing it is corrupted). Detect and fail probe instead - that is easier to debug.
Quoted 4 lines
Thanks indeed better aside from the "encrypted guest memory": the mechanism used to avoid the access to the guest memory from the host by s390 is not encryption but a hardware feature denying the general host access and allowing pieces of memory to be shared between guest and host.
s/encrypted/protected/
Quoted 2 lines
As a consequence the data read from memory is not corrupted but not read at all and the read error kills the hypervizor with a SIGSEGV.
s/(or even a whole page containing it is corrupted)/can not be
read and the read error kills the hypervizor with a SIGSEGV/
As an aside, we could maybe handle that more gracefully on the hypervisor side.
Quoted 7 lines
Quoted 6 lines
however, now that we have described what it is (hypervisor misconfiguration) I ask a question: can we be sure this will never ever work? E.g. what if some future hypervisor gains ability to access the protected guest memory in some abstractly secure manner?
Quoted 8 lines
The goal of the s390 PV feature is to avoid this possibility so I don't think so; however, there is a possibility that some hardware VIRTIO device gain access to the guest's protected memory, even such device does not exist yet.
At the moment such device exists we will need a driver for it, at least to enable the feature and apply policies, it is also one of the reasons why a hook to the architecture is interesting.
Not neessarily, it could also be fully transparent. See e.g. recent AMD andvances allowing unmodified guests with SEV.
Quoted 10 lines
Quoted 2 lines
We are blocking this here, and it's hard to predict the future, and a broken hypervisor can always find ways to crash the guest ...
yes, this is also something to fix on the hypervizor side, Halil is working on it.
Quoted 3 lines
IMHO it would be safer to just print a warning.
What do you think?
Quoted 6 lines
Sadly, putting a warning may not help as qemu is killed if it accesses the protected memory.
Also note that the crash occurs not only on start but also on hotplug.Thanks,
Pierre
Well that depends on where does the warning go. If it's on a serial port it might be reported host side before the crash triggers. But interesting point generally. How about a feature to send a warning code or string to host then?
Quoted 3 lines
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Re: [PATCH v3 1/1] s390: virtio: let arch accept devices without IOMMU feature
Quoted 19 lines · On Mon, 29 Jun 2020 17:18:09 -0400 "Michael S. Tsirkin" <[email protected]> wrote:
Quoted 18 lines · Pierre Morel
Quoted 15 lines · Michael S. Tsirkin
Quoted 5 lines · Pierre Morel
An architecture protecting the guest memory against unauthorized host access may want to enforce VIRTIO I/O device protection through the use of
VIRTIO_F_IOMMU_PLATFORM.
Let's give a chance to the architecture to accept or not devices withoutVIRTIO_F_IOMMU_PLATFORM.I agree it's a bit misleading. Protection is enforced by memory encryption, you can't trust the hypervisor to report the bit correctly so using that as a securoty measure would be pointless.
The real gain here is that broken configs are easier to debug.Here's an attempt at a better description:
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
On some architectures, guest knows that
VIRTIO_F_IOMMU_PLATFORMis required for virtio to function: e.g. this is the case on s390 protected virt guests, since otherwise guest passes encrypted guest memory to devices, which the device can't read. WithoutVIRTIO_F_IOMMU_PLATFORMthe result is that affected memory (or even a whole page containing it is corrupted). Detect and fail probe instead - that is easier to debug.
s/guest/the guest/ (x2)
Quoted 6 lines
Quoted 5 lines
Thanks indeed better aside from the "encrypted guest memory": the mechanism used to avoid the access to the guest memory from the host by s390 is not encryption but a hardware feature denying the general host access and allowing pieces of memory to be shared between guest and host.
Quoted 7 lines
s/encrypted/protected/
Quoted 2 lines
As a consequence the data read from memory is not corrupted but not read at all and the read error kills the hypervizor with a SIGSEGV.
s/(or even a whole page containing it is corrupted)/can not be
read and the read error kills the hypervizor with a SIGSEGV/
s/hypervizor/hypervisor/
Quoted 17 lines
As an aside, we could maybe handle that more gracefully on the hypervisor side.
Quoted 12 lines
Quoted 6 lines
however, now that we have described what it is (hypervisor misconfiguration) I ask a question: can we be sure this will never ever work? E.g. what if some future hypervisor gains ability to access the protected guest memory in some abstractly secure manner?
The goal of the s390 PV feature is to avoid this possibility so I don't think so; however, there is a possibility that some hardware VIRTIO device gain access to the guest's protected memory, even such device does not exist yet.
Quoted 7 lines
Quoted 3 lines
At the moment such device exists we will need a driver for it, at least to enable the feature and apply policies, it is also one of the reasons why a hook to the architecture is interesting.
Not neessarily, it could also be fully transparent. See e.g. recent AMD andvances allowing unmodified guests with SEV.
I guess it depends on the architecture's protection mechanism and threat model whether this makes sense.
Quoted 9 lines
Quoted 9 lines
Quoted 4 lines
We are blocking this here, and it's hard to predict the future, and a broken hypervisor can always find ways to crash the guest ...
yes, this is also something to fix on the hypervizor side, Halil is working on it.
Quoted 1 line
Quoted 6 lines
Quoted 6 lines
Quoted 2 lines
IMHO it would be safer to just print a warning.
What do you think?Sadly, putting a warning may not help as qemu is killed if it accesses the protected memory.
Also note that the crash occurs not only on start but also on hotplug.
Failing to start a guest is not that bad IMHO, but crashing a guest that is running perfectly fine is. I vote for just failing the probe if preconditions are not met.
Quoted 8 lines
Quoted 3 lines
Thanks,
PierreWell that depends on where does the warning go. If it's on a serial port it might be reported host side before the crash triggers. But interesting point generally. How about a feature to send a warning code or string to host then?
I would generally expect a guest warning to stay on the guest side -- especially as the host admin and the guest admin may be different persons. So having a general way to send an alert to from a guest to the host is not uninteresting, although we need to be careful to avoid the guest being able to DOS the host.