s390: protvirt: virtio: Refuse device without IOMMU
Subsystems (4)
PATCH 1/1 s390: protvirt: virtio: Refuse device without IOMMU
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/s390/virtio/virtio_ccw.c +5 -0
@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ; +/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +/* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code =CCW_CMD_WRITE_STATUS ;
Signature · 1 line
2.25.1
Cornelia Huck
maintainerQuoted 16 lines · On Wed, 10 Jun 2020 15:11:51 +0200 Pierre Morel <[email protected]> wrote:
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0
drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status) · line 993
Quoted 8 lines
drivers/s390/virtio/virtio_ccw.c +5
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ; +/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +
set_status seems like an odd place to look at features; shouldn't that rather be done in finalize_features?
Quoted 3 lines
drivers/s390/virtio/virtio_ccw.c +0
-0/* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code =CCW_CMD_WRITE_STATUS ;
Quoted 22 lines · Cornelia Huck
Quoted 19 lines · On Wed, 10 Jun 2020 15:11:51 +0200 Pierre Morel <[email protected]> wrote:
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ;
Quoted 8 lines
drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status) · line 993
Quoted 5 lines
drivers/s390/virtio/virtio_ccw.c +5
-0+/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +
set_statusseems like an odd place to look at features; shouldn't that rather be done infinalize_features?
Right, looks better to me too.
What about:
drivers/s390/virtio/virtio_ccw.c +5 -0
@@ -833,6 +833,11 @@ static int virtio_ccw_finalize_features(struct virtio_device *vdev) ret = -ENOMEM ; goto out_free; } + +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) +return -EIO ; +/* Give virtio_ring a chance to accept features. */ vring_transport_features (vdev);
Thanks,
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Cornelia Huck
maintainerQuoted 43 lines · On Wed, 10 Jun 2020 16:37:55 +0200 Pierre Morel <[email protected]> wrote:
Quoted 22 lines · Cornelia Huck
Quoted 19 lines · On Wed, 10 Jun 2020 15:11:51 +0200 Pierre Morel <[email protected]> wrote:
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ;Quoted 8 lines
drivers/s390/virtio/virtio_ccw.c static int virtio_ccw_finalize_features(struct virtio_device *vdev) · line 840
Quoted 5 lines
drivers/s390/virtio/virtio_ccw.c +5
-0+/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +
set_statusseems like an odd place to look at features; shouldn't that rather be done infinalize_features?Right, looks better to me too.
What about:drivers/s390/virtio/virtio_ccw.c +0
-0
drivers/s390/virtio/virtio_ccw.c static int virtio_ccw_finalize_features(struct · line 839
Quoted 7 lines
drivers/s390/virtio/virtio_ccw.c +3
-0@@ -833,6 +833,11 @@ static int virtio_ccw_finalize_features(struct virtio_device *vdev) ret = -ENOMEM ; goto out_free; } + +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM ))
Add a comment, and (maybe) a message?
Otherwise, I think this is fine, as it should fail the probe, which is what we want.
Quoted 12 lines
drivers/s390/virtio/virtio_ccw.c +2
-0+return -EIO ; +/* Give virtio_ring a chance to accept features. */ vring_transport_features (vdev);Thanks,
Regards,
Pierre
Quoted 56 lines · Cornelia Huck
Quoted 43 lines · On Wed, 10 Jun 2020 16:37:55 +0200 Pierre Morel <[email protected]> wrote:
Quoted 22 lines · Cornelia Huck
Quoted 19 lines · On Wed, 10 Jun 2020 15:11:51 +0200 Pierre Morel <[email protected]> wrote:
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ;Quoted 8 lines
drivers/s390/virtio/virtio_ccw.c static int virtio_ccw_finalize_features(struct virtio_device *vdev) · line 840
Quoted 5 lines
drivers/s390/virtio/virtio_ccw.c +5
-0+/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +
set_statusseems like an odd place to look at features; shouldn't that rather be done infinalize_features?Right, looks better to me too.
What about:drivers/s390/virtio/virtio_ccw.c +0
-0drivers/s390/virtio/virtio_ccw.c static int virtio_ccw_finalize_features(struct · line 839
Quoted 7 lines
drivers/s390/virtio/virtio_ccw.c +3
-0@@ -833,6 +833,11 @@ static int virtio_ccw_finalize_features(struct virtio_device *vdev) ret = -ENOMEM ; goto out_free; } + +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM ))Add a comment, and (maybe) a message?
Quoted 2 lines
Otherwise, I think this is fine, as it should fail the probe, which is what we want.
yes right a message is needed.
and I extend a little the comment I had before.
thanks
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Halil Pasic
maintainerQuoted 6 lines · On Wed, 10 Jun 2020 15:11:51 +0200 Pierre Morel <[email protected]> wrote:
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Should we ever get a virtio-ccw device implemented in hardware, we could in theory have a trusted device, i.e. one that is not affected by the memory protection.
IMHO this restriction applies to paravitualized devices, that is devices realized by the hypervisor. In that sense this is not about ccw, but could in the future affect PCI as well. Thus the transport code may not be the best place to fence this, but frankly looking at how the QEMU discussion is going (the one where I try to prevent this condition) I would be glad to have something like this as a safety net.
I would however like the commit message to reflect what is written above.
Do we need backports (and cc-stable) for this? Connie what do you think?
Quoted 10 lines
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0
drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status) · line 991
Quoted 6 lines
drivers/s390/virtio/virtio_ccw.c +3
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ; +/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM ))
If you were to add && !__virtio_test_bit(vdev, VIRTIO_F_ORDER_PLATFORM) we could confine this check and the bail out to paravirtualized devices, because a device realized in HW is expected to give us both F_ACCESS_PLATFORM and F_ORDER_PLATFORM. I would not bet it will ever matter for virtio-ccw though.
Connie, do you have an opinion on this?
Regards,
Halil
Quoted 5 lines
drivers/s390/virtio/virtio_ccw.c +2
-0+ status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +/* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code =CCW_CMD_WRITE_STATUS ;
Quoted 17 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)
drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status) · line 996
Quoted 10 lines
drivers/s390/virtio/virtio_ccw.c +5
-0return ; +/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +/* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code =CCW_CMD_WRITE_STATUS ;
I wonder whether we need move it to virtio core instead of ccw.
I think the other memory protection technologies may suffer from this as well.
Thanks
Quoted 33 lines · Jason Wang
Quoted 17 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>---
drivers/s390/virtio/virtio_ccw.c| 5 +++++1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct · line 996
Quoted 10 lines
drivers/s390/virtio/virtio_ccw.c +5
-0if (!ccw) return; + /* Protected Virtualisation guest needs IOMMU */ + if (is_prot_virt_guest() && + !__virtio_test_bit(vdev, VIRTIO_F_IOMMU_PLATFORM)) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK; + /* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code = CCW_CMD_WRITE_STATUS;I wonder whether we need move it to virtio core instead of ccw.
Quoted 4 lines
I think the other memory protection technologies may suffer from this as well.
Thanks
What would you think of the following, also taking into account Connie's comment on where the test should be done:
- declare a weak function in virtio.c code, returning that memory protection is not in use.
- overwrite the function in the arch code
- call this function inside core virtio_finalize_features() and if required fail if the device don't have VIRTIO_F_IOMMU_PLATFORM.
Alternative could be to test a global variable that the architecture would overwrite if needed but I find the weak function solution more flexible.
With a function, we also have the possibility to provide the device as argument and take actions depending it, this may answer Halil's concern.
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Quoted 52 lines · Pierre Morel
Quoted 33 lines · Jason Wang
Quoted 17 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>---
drivers/s390/virtio/virtio_ccw.c| 5 +++++1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct · line 996
Quoted 10 lines
drivers/s390/virtio/virtio_ccw.c +5
-0if (!ccw) return; + /* Protected Virtualisation guest needs IOMMU */ + if (is_prot_virt_guest() && + !__virtio_test_bit(vdev, VIRTIO_F_IOMMU_PLATFORM)) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK; + /* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code = CCW_CMD_WRITE_STATUS;I wonder whether we need move it to virtio core instead of ccw.
Quoted 4 lines
I think the other memory protection technologies may suffer from this as well.
Thanks
What would you think of the following, also taking into account Connie's comment on where the test should be done:
- declare a weak function in
virtio.ccode, returning that memory protection is not in use.- overwrite the function in the arch code
- call this function inside core
virtio_finalize_features()and if required fail if the device don't haveVIRTIO_F_IOMMU_PLATFORM.
Quoted 7 lines
Alternative could be to test a global variable that the architecture would overwrite if needed but I find the weak function solution more flexible.
With a function, we also have the possibility to provide the device as argument and take actions depending it, this may answer Halil's concern.
Regards,
Pierre
hum, in between I found another way which seems to me much better:
We already have the force_dma_unencrypted() function available which AFAIU is what we want for encrypted memory protection and is already used by power and x86 SEV/SME in a way that seems AFAIU compatible with our problem.
Even DMA and IOMMU are different things, I think they should be used together in our case.
What do you think?
The patch would then be something like:
drivers/virtio/virtio.c +5 -0
@@ -4,6 +4,7 @@#include <linux/virtio_config.h> #include <linux/module.h> #include <linux/idr.h> +#include <linux/dma-direct.h> #include <uapi/linux/virtio_ids.h> /* Unique numbering for virtio devices. */
@@ -179,6 +180,10 @@ int virtio_finalize_features(struct virtio_device *dev)if (!virtio_has_feature (dev,VIRTIO_F_VERSION_1 ))return 0 ; +if (force_dma_unencrypted (&dev->dev) && + !virtio_has_feature (dev,VIRTIO_F_IOMMU_PLATFORM )) +return -EIO ; +virtio_add_status (dev,VIRTIO_CONFIG_S_FEATURES_OK ); status = dev->config->get_status (dev);if (!(status &VIRTIO_CONFIG_S_FEATURES_OK )) {
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Quoted 47 lines · Pierre Morel
Quoted 44 lines · Pierre Morel
Quoted 33 lines · Jason Wang
Quoted 17 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>---
drivers/s390/virtio/virtio_ccw.c| 5 +++++1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct · line 996
Quoted 10 lines
drivers/s390/virtio/virtio_ccw.c +5
-0if (!ccw) return; + /* Protected Virtualisation guest needs IOMMU */ + if (is_prot_virt_guest() && + !__virtio_test_bit(vdev, VIRTIO_F_IOMMU_PLATFORM)) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK; + /* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code = CCW_CMD_WRITE_STATUS;I wonder whether we need move it to virtio core instead of ccw.
Quoted 4 lines
I think the other memory protection technologies may suffer from this as well.
Thanks
What would you think of the following, also taking into account Connie's comment on where the test should be done:
Quoted 7 lines
Quoted 7 lines
- declare a weak function in
virtio.ccode, returning that memory protection is not in use.- overwrite the function in the arch code
- call this function inside core
virtio_finalize_features()and if required fail if the device don't haveVIRTIO_F_IOMMU_PLATFORM.
I think this is fine.
Quoted 42 lines
Quoted 8 lines
Alternative could be to test a global variable that the architecture would overwrite if needed but I find the weak function solution more flexible.
With a function, we also have the possibility to provide the device as argument and take actions depending it, this may answer Halil's concern.
Regards,
Pierrehum, in between I found another way which seems to me much better:
We already have the
force_dma_unencrypted()function available which AFAIU is what we want for encrypted memory protection and is already used by power and x86 SEV/SME in a way that seems AFAIU compatible with our problem.Even DMA and IOMMU are different things, I think they should be used together in our case.
What do you think?
The patch would then be something like:
drivers/virtio/virtio.c +5
-0@@ -4,6 +4,7 @@ #include <linux/virtio_config.h> #include <linux/module.h> #include <linux/idr.h> +#include <linux/dma-direct.h> #include <uapi/linux/virtio_ids.h> /* Unique numbering for virtio devices. */@@ -179,6 +180,10 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0; + if (force_dma_unencrypted(&dev->dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) + return -EIO; + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev);
Quoted 1 line
if (!(status &
VIRTIO_CONFIG_S_FEATURES_OK)) {
I think this can work but need to listen from Michael.
Thanks
Quoted 5 lines
Regards,
Pierre
Halil Pasic
maintainerQuoted 31 lines · On Mon, 15 Jun 2020 11:01:55 +0800 Jason Wang <[email protected]> wrote:
Quoted 31 lines
hum, in between I found another way which seems to me much better:
We already have the
force_dma_unencrypted()function available which AFAIU is what we want for encrypted memory protection and is already used by power and x86 SEV/SME in a way that seems AFAIU compatible with our problem.Even DMA and IOMMU are different things, I think they should be used together in our case.
What do you think?
The patch would then be something like:
drivers/virtio/virtio.c +1
-0@@ -4,6 +4,7 @@ #include <linux/virtio_config.h> #include <linux/module.h> #include <linux/idr.h> +#include <linux/dma-direct.h> #include <uapi/linux/virtio_ids.h> /* Unique numbering for virtio devices. */@@ -179,6 +180,10 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0;
Quoted 10 lines
Quoted 7 lines
drivers/virtio/virtio.c +4
-0+ if (force_dma_unencrypted(&dev->dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) + return -EIO; + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev);if (!(status &
VIRTIO_CONFIG_S_FEATURES_OK)) {I think this can work but need to listen from Michael
I don't think Christoph Hellwig will like force_dma_unencrypted() in virtio code:
https://lkml.org/lkml/2020/2/20/630
Regards,
Halil
Quoted 45 lines · Halil Pasic
Quoted 31 lines · On Mon, 15 Jun 2020 11:01:55 +0800 Jason Wang <[email protected]> wrote:
Quoted 31 lines
hum, in between I found another way which seems to me much better:
We already have the
force_dma_unencrypted()function available which AFAIU is what we want for encrypted memory protection and is already used by power and x86 SEV/SME in a way that seems AFAIU compatible with our problem.Even DMA and IOMMU are different things, I think they should be used together in our case.
What do you think?
The patch would then be something like:
drivers/virtio/virtio.c +1
-0@@ -4,6 +4,7 @@ #include <linux/virtio_config.h> #include <linux/module.h> #include <linux/idr.h> +#include <linux/dma-direct.h> #include <uapi/linux/virtio_ids.h> /* Unique numbering for virtio devices. */@@ -179,6 +180,10 @@ int virtio_finalize_features(struct virtio_device *dev) if (!virtio_has_feature(dev, VIRTIO_F_VERSION_1)) return 0;Quoted 10 lines
Quoted 7 lines
drivers/virtio/virtio.c +4
-0+ if (force_dma_unencrypted(&dev->dev) && + !virtio_has_feature(dev, VIRTIO_F_IOMMU_PLATFORM)) + return -EIO; + virtio_add_status(dev, VIRTIO_CONFIG_S_FEATURES_OK); status = dev->config->get_status(dev);if (!(status &
VIRTIO_CONFIG_S_FEATURES_OK)) {I think this can work but need to listen from Michael
Quoted 7 lines
I don't think Christoph Hellwig will like
force_dma_unencrypted()in virtio code:
https://lkml.org/lkml/2020/2/20/630Regards,
Halil
OK, then back to the first idea.
Thanks,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen
Quoted 52 lines · Jason Wang
Quoted 50 lines · Pierre Morel
Quoted 47 lines · Pierre Morel
Quoted 33 lines · Jason Wang
Quoted 17 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Signed-off-by Pierre Morel <[email protected]>---
drivers/s390/virtio/virtio_ccw.c| 5 +++++1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +0
-0@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)drivers/s390/virtio/virtio_ccw.c static void virtio_ccw_set_status(struct · line 996
Quoted 10 lines
drivers/s390/virtio/virtio_ccw.c +5
-0if (!ccw) return; + /* Protected Virtualisation guest needs IOMMU */ + if (is_prot_virt_guest() && + !__virtio_test_bit(vdev, VIRTIO_F_IOMMU_PLATFORM)) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK; + /* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code = CCW_CMD_WRITE_STATUS;I wonder whether we need move it to virtio core instead of ccw.
Quoted 4 lines
I think the other memory protection technologies may suffer from this as well.
Thanks
What would you think of the following, also taking into account Connie's comment on where the test should be done:
- declare a weak function in
virtio.ccode, returning that memory protection is not in use.
Quoted 8 lines
Quoted 4 lines
Quoted 4 lines
- overwrite the function in the arch code
- call this function inside core
virtio_finalize_features()and if required fail if the device don't haveVIRTIO_F_IOMMU_PLATFORM.I think this is fine.
Thanks,
I try this.
Regards,
Pierre
Signature · 6 lines
Pierre Morel IBM Lab Boeblingen _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Quoted 7 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Stupid questions:
1. Do all CPU families we care about (which are?) support IOMMU? Ex:
would it recognize an ARM thingie with SMMU? [1]
2. Would it make sense to have some kind of yes-I-know-the-consequences-but-I-need-to-have-a-virtio-device-without-iommu-in-this-guest flag?
Quoted 22 lines
Signed-off-by Pierre Morel <[email protected]>--- drivers/s390/virtio/virtio_ccw.c | 5 +++++ 1 file changed, 5 insertions(+)drivers/s390/virtio/virtio_ccw.c +5
-1@@ -986,6 +986,11 @@ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)if (!ccw)return ; +/* Protected Virtualisation guest needs IOMMU */ +if (is_prot_virt_guest () && + !__virtio_test_bit (vdev,VIRTIO_F_IOMMU_PLATFORM )) + status &= ~VIRTIO_CONFIG_S_FEATURES_OK ; +/* Write the status to the host. */ vcdev->dma_area->status = status; ccw->cmd_code =CCW_CMD_WRITE_STATUS ; --
Quoted 2 lines
2.25.1
[1] https://developer.arm.com/architectures/system-architectures/system-components/system-mmu-support
Quoted 9 lines · Mauricio Tavares
Quoted 7 lines · Pierre Morel
Protected Virtualisation protects the memory of the guest and do not allow a the host to access all of its memory.
Let's refuse a VIRTIO device which does not use IOMMU protected access.
Stupid questions:
not stupid at all. :)
Quoted 3 lines
1. Do all CPU families we care about (which are?) support IOMMU? Ex:
would it recognize an ARM thingie with SMMU? [1]
In Message-ID: <[email protected]>
(as answer to Jason) I modified the patch and propose to take care of this problem by using force_dma_unencrypted() inside virtio core instead of a S390 specific test.
If we use force_dma_unencrypted(dev) to check if we must refuse a device without the VIRTIO_F_IOMMU_PLATFORM feature, we are safe:
only architectures defining CONFIG_ARCH_HAS_FORCE_DMA_UNENCRYPTED will have to define force_dma_unencrypted(dev), and they can choose what to do by checking the architecture functionalities and/or the device.
Quoted 3 lines
2. Would it make sense to have some kind of yes-I-know-the-consequences-but-I-need-to-have-a-virtio-device-without-iommu-in-this-guest flag?
Yes, two ways:
Never refuse a device without VIRTIO_F_IOMMU_PLATFORM, by not defining CONFIG_ARCH_HAS_FORCE_DMA_UNENCRYPTED or by always return 0 in force_dma_unencrypted()
have force_dma_unencrypted() selectively answer by checking the device and/or architecture state.
Quoted 1 line
...snip...
Quoted 4 lines
Quoted 1 line
[1] https://developer.arm.com/architectures/system-architectures/system-components/system-mmu-support
Regards,
Pierre
Signature · 2 lines
Pierre Morel IBM Lab Boeblingen