The current design for AP pass-through does not support making dynamic
changes to the AP matrix of a running guest resulting in a few
deficiencies this patch series is intended to mitigate:
1. Adapters, domains and control domains can not be added to or removed
from a running guest. In order to modify a guest's AP configuration,
the guest must be terminated; only then can AP resources be assigned
to or unassigned from the guest's matrix mdev. The new AP
configuration becomes available to the guest when it is subsequently
restarted.
2. The AP bus's /sys/bus/ap/apmask and /sys/bus/ap/aqmask interfaces can
be modified by a root user without any restrictions. A change to
either mask can result in AP queue devices being unbound from the
vfio_ap device driver and bound to a zcrypt device driver even if a
guest is using the queues, thus giving the host access to the guest's
private crypto data and vice versa.
3. The APQNs derived from the Cartesian product of the APIDs of the
adapters and APQIs of the domains assigned to a matrix mdev must
reference an AP queue device bound to the vfio_ap device driver. The
AP architecture allows assignment of AP resources that are not
available to the system, so this artificial restriction is not
compliant with the architecture.
4. The AP configuration profile can be dynamically changed for the linux
host after a KVM guest is started. For example, a new domain can be
dynamically added to the configuration profile via the SE or an HMC
connected to a DPM enabled lpar. Likewise, AP adapters can be
dynamically configured (online state) and deconfigured (standby state)
using the SE, an SCLP command or an HMC connected to a DPM enabled
lpar. This can result in inadvertent sharing of AP queues between the
guest and host.
5. A root user can manually unbind an AP queue device representing a
queue in use by a KVM guest via the vfio_ap device driver's sysfs
unbind attribute. In this case, the guest will be using a queue that
is not bound to the driver which violates the device model.
This patch series introduces the following changes to the current design
to alleviate the shortcomings described above as well as to implement
more of the AP architecture:
1. A root user will be prevented from making edits to the AP bus's
/sys/bus/ap/apmask or /sys/bus/ap/aqmask if the change would transfer
ownership of an APQN from the vfio_ap device driver to a zcrypt driver
while the APQN is assigned to a matrix mdev.
2. Allow a root user to hot plug/unplug AP adapters, domains and control
domains for a KVM guest using the matrix mdev via its sysfs
assign/unassign attributes.
4. Allow assignment of an AP adapter or domain to a matrix mdev even if
it results in assignment of an APQN that does not reference an AP
queue device bound to the vfio_ap device driver, as long as the APQN
is not reserved for use by the default zcrypt drivers (also known as
over-provisioning of AP resources). Allowing over-provisioning of AP
resources better models the architecture which does not preclude
assigning AP resources that are not yet available in the system. Such
APQNs, however, will not be assigned to the guest using the matrix
mdev; only APQNs referencing AP queue devices bound to the vfio_ap
device driver will actually get assigned to the guest.
5. Handle dynamic changes to the AP device model.
1. Rationale for changes to AP bus's apmask/aqmask interfaces:
----------------------------------------------------------
Due to the extremely sensitive nature of cryptographic data, it is
imperative that great care be taken to ensure that such data is secured.
Allowing a root user, either inadvertently or maliciously, to configure
these masks such that a queue is shared between the host and a guest is
not only avoidable, it is advisable. It was suggested that this scenario
is better handled in user space with management software, but that does
not preclude a malicious administrator from using the sysfs interfaces
to gain access to a guest's crypto data. It was also suggested that this
scenario could be avoided by taking access to the adapter away from the
guest and zeroing out the queues prior to the vfio_ap driver releasing the
device; however, stealing an adapter in use from a guest as a by-product
of an operation is bad and will likely cause problems for the guest
unnecessarily. It was decided that the most effective solution with the
least number of negative side effects is to prevent the situation at the
source.
2. Rationale for hot plug/unplug using matrix mdev sysfs interfaces:
----------------------------------------------------------------
Allowing a user to hot plug/unplug AP resources using the matrix mdev
sysfs interfaces circumvents the need to terminate the guest in order to
modify its AP configuration. Allowing dynamic configuration makes
reconfiguring a guest's AP matrix much less disruptive.
3. Rationale for allowing over-provisioning of AP resources:
-----------------------------------------------------------
Allowing assignment of AP resources to a matrix mdev and ultimately to a
guest better models the AP architecture. The architecture does not
preclude assignment of unavailable AP resources. If a queue subsequently
becomes available while a guest using the matrix mdev to which its APQN
is assigned, the guest will be given access to it. If an APQN
is dynamically unassigned from the underlying host system, it will
automatically become unavailable to the guest.
Change log v18-v19:
------------------
* Changed name of vfio_ap_mdev_hotplug_apcb (vfio_ap_ops.c) to
vfio_ap_mdev_update_guest_apcb
(Suggested by Jason: review of patch 10/18)
* Replace call to kvm_arch_crypto_set_masks in vfio_ap_mdev_set_kvm with
call to vfio_ap_mdev_update_guest_apcb
(Suggested by Jason: review of patch 10/18)
* Moved changes related to new locking scheme into its own set of
patches (Suggested by Jason: review of patch 10/18)
* Consolidated some of the lock acquisition code into macros called by the
functions that update a KVM guest's APCB.
* Refactored vfio_ap_mdev_unlink_adapter() and
vfio_ap_unlink_apqn_fr_mdev() functions according to Jason's sample
code. (Suggested by Jason: review of patch 12/18)
* Require callers of the AP bus ap_apqn_in_matrix_owned_by_def_drv and
ap_owned_by_def_drv - only called by the vfio_ap driver - to take the
ap_perms_mutex lock. The adapter/domain assignment interfaces will take
the ap_perms_mutex lock prior to other required locks to maintain a
proper locking order and avoid circular locking dependencies when the
vfio_ap device driver's in_use callback is invoked simultaneously with
the adapter/domain assignment interfaces. (Suggested by Jason)
* Refactored patch 15/18: handle config changed and scan complete
notification (Suggested by Jason)
* Refactored filtering of the matrix to reduce redundant processing of
APQNs:
- Inspect only the new APIDs or APQIs assigned to the matrix mdev or
added to the host's AP configuration
- Automatically removing APIDs or APQIs unassigned from the matrix mdev
or removed from the host's AP configuration.
(Suggested by Halil)
Tony Krowiak (20):
s390/vfio-ap: use new AP bus interface to search for queue devices
s390/vfio-ap: move probe and remove callbacks to vfio_ap_ops.c
s390/vfio-ap: manage link between queue struct and matrix mdev
s390/vfio-ap: introduce shadow APCB
s390/vfio-ap: refresh guest's APCB by filtering AP resources assigned
to mdev
s390/vfio-ap: allow assignment of unavailable AP queues to mdev device
s390/vfio-ap: rename matrix_dev->lock mutex to matrix_dev->mdevs_lock
s390/vfio-ap: introduce new mutex to control access to the KVM pointer
s390/vfio-ap: use proper locking order when setting/clearing KVM
pointer
s390/vfio-ap: prepare for dynamic update of guest's APCB on
assign/unassign
s390/vfio-ap: prepare for dynamic update of guest's APCB on queue
probe/remove
s390/vfio-ap: allow hot plug/unplug of AP devices when
assigned/unassigned
s390/vfio-ap: hot plug/unplug of AP devices when probed/removed
s390/vfio-ap: reset queues after adapter/domain unassignment
s390/vfio-ap: implement in-use callback for vfio_ap driver
s390/vfio-ap: sysfs attribute to display the guest's matrix
s390/vfio-ap: handle config changed and scan complete notification
s390/vfio-ap: update docs to include dynamic config support
s390/Docs: new doc describing lock usage by the vfio_ap device driver
MAINTAINERS: pick up all vfio_ap docs for VFIO AP maintainers
Documentation/s390/vfio-ap-locking.rst | 389 +++++++
Documentation/s390/vfio-ap.rst | 492 ++++++---
MAINTAINERS | 6 +-
drivers/s390/crypto/ap_bus.c | 31 +-
drivers/s390/crypto/vfio_ap_drv.c | 69 +-
drivers/s390/crypto/vfio_ap_ops.c | 1321 ++++++++++++++++++------
drivers/s390/crypto/vfio_ap_private.h | 47 +-
7 files changed, 1820 insertions(+), 535 deletions(-)
create mode 100644 Documentation/s390/vfio-ap-locking.rst
--
2.31.1
The matrix of adapters and domains configured in a guest's APCB may
differ from the matrix of adapters and domains assigned to the matrix mdev,
so this patch introduces a sysfs attribute to display the matrix of
adapters and domains that are or will be assigned to the APCB of a guest
that is or will be using the matrix mdev. For a matrix mdev denoted by
$uuid, the guest matrix can be displayed as follows:
cat /sys/devices/vfio_ap/matrix/$uuid/guest_matrix
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Jason J. Herne <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 50 +++++++++++++++++++++++--------
1 file changed, 37 insertions(+), 13 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 3ece2cd9f1e7..3e1a7f191c43 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -1423,28 +1423,24 @@ static ssize_t control_domains_show(struct device *dev,
}
static DEVICE_ATTR_RO(control_domains);
-static ssize_t matrix_show(struct device *dev, struct device_attribute *attr,
- char *buf)
+static ssize_t vfio_ap_mdev_matrix_show(struct ap_matrix *matrix, char *buf)
{
- struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
char *bufpos = buf;
unsigned long apid;
unsigned long apqi;
unsigned long apid1;
unsigned long apqi1;
- unsigned long napm_bits = matrix_mdev->matrix.apm_max + 1;
- unsigned long naqm_bits = matrix_mdev->matrix.aqm_max + 1;
+ unsigned long napm_bits = matrix->apm_max + 1;
+ unsigned long naqm_bits = matrix->aqm_max + 1;
int nchars = 0;
int n;
- apid1 = find_first_bit_inv(matrix_mdev->matrix.apm, napm_bits);
- apqi1 = find_first_bit_inv(matrix_mdev->matrix.aqm, naqm_bits);
-
- mutex_lock(&matrix_dev->mdevs_lock);
+ apid1 = find_first_bit_inv(matrix->apm, napm_bits);
+ apqi1 = find_first_bit_inv(matrix->aqm, naqm_bits);
if ((apid1 < napm_bits) && (apqi1 < naqm_bits)) {
- for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, napm_bits) {
- for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm,
+ for_each_set_bit_inv(apid, matrix->apm, napm_bits) {
+ for_each_set_bit_inv(apqi, matrix->aqm,
naqm_bits) {
n = sprintf(bufpos, "%02lx.%04lx\n", apid,
apqi);
@@ -1453,25 +1449,52 @@ static ssize_t matrix_show(struct device *dev, struct device_attribute *attr,
}
}
} else if (apid1 < napm_bits) {
- for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, napm_bits) {
+ for_each_set_bit_inv(apid, matrix->apm, napm_bits) {
n = sprintf(bufpos, "%02lx.\n", apid);
bufpos += n;
nchars += n;
}
} else if (apqi1 < naqm_bits) {
- for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm, naqm_bits) {
+ for_each_set_bit_inv(apqi, matrix->aqm, naqm_bits) {
n = sprintf(bufpos, ".%04lx\n", apqi);
bufpos += n;
nchars += n;
}
}
+ return nchars;
+}
+
+static ssize_t matrix_show(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ ssize_t nchars;
+ struct mdev_device *mdev = mdev_from_dev(dev);
+ struct ap_matrix_mdev *matrix_mdev = mdev_get_drvdata(mdev);
+
+ mutex_lock(&matrix_dev->mdevs_lock);
+ nchars = vfio_ap_mdev_matrix_show(&matrix_mdev->matrix, buf);
mutex_unlock(&matrix_dev->mdevs_lock);
return nchars;
}
static DEVICE_ATTR_RO(matrix);
+static ssize_t guest_matrix_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ ssize_t nchars;
+ struct mdev_device *mdev = mdev_from_dev(dev);
+ struct ap_matrix_mdev *matrix_mdev = mdev_get_drvdata(mdev);
+
+ mutex_lock(&matrix_dev->mdevs_lock);
+ nchars = vfio_ap_mdev_matrix_show(&matrix_mdev->shadow_apcb, buf);
+ mutex_unlock(&matrix_dev->mdevs_lock);
+
+ return nchars;
+}
+static DEVICE_ATTR_RO(guest_matrix);
+
static struct attribute *vfio_ap_mdev_attrs[] = {
&dev_attr_assign_adapter.attr,
&dev_attr_unassign_adapter.attr,
@@ -1481,6 +1504,7 @@ static struct attribute *vfio_ap_mdev_attrs[] = {
&dev_attr_unassign_control_domain.attr,
&dev_attr_control_domains.attr,
&dev_attr_matrix.attr,
+ &dev_attr_guest_matrix.attr,
NULL,
};
--
2.31.1
The matrix_dev->lock mutex is being renamed to matrix_dev->mdevs_lock to
better reflect its purpose, which is to control access to the state of the
mediated devices under the control of the vfio_ap device driver.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_drv.c | 6 +--
drivers/s390/crypto/vfio_ap_ops.c | 72 ++++++++++++++-------------
drivers/s390/crypto/vfio_ap_private.h | 4 +-
3 files changed, 42 insertions(+), 40 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
index 9a300dd3b6f7..0a5acd151a9b 100644
--- a/drivers/s390/crypto/vfio_ap_drv.c
+++ b/drivers/s390/crypto/vfio_ap_drv.c
@@ -72,7 +72,7 @@ static ssize_t status_show(struct device *dev,
struct ap_matrix_mdev *matrix_mdev;
struct ap_device *apdev = to_ap_dev(dev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
q = dev_get_drvdata(&apdev->device);
matrix_mdev = vfio_ap_mdev_for_queue(q);
@@ -88,7 +88,7 @@ static ssize_t status_show(struct device *dev,
AP_QUEUE_UNASSIGNED);
}
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return nchars;
}
@@ -159,7 +159,7 @@ static int vfio_ap_matrix_dev_create(void)
goto matrix_alloc_err;
}
- mutex_init(&matrix_dev->lock);
+ mutex_init(&matrix_dev->mdevs_lock);
INIT_LIST_HEAD(&matrix_dev->mdev_list);
dev_set_name(&matrix_dev->device, "%s", VFIO_AP_DEV_NAME);
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index f937f38031f0..077b8c9c831b 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -394,10 +394,12 @@ static int handle_pqap(struct kvm_vcpu *vcpu)
return -EOPNOTSUPP;
}
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
+
if (!vcpu->kvm->arch.crypto.pqap_hook) {
VFIO_AP_DBF_WARN("%s: PQAP(AQIC) hook not registered with the vfio_ap driver: apqn=0x%04x\n",
__func__, apqn);
+
goto out_unlock;
}
@@ -432,7 +434,7 @@ static int handle_pqap(struct kvm_vcpu *vcpu)
out_unlock:
memcpy(&vcpu->run->s.regs.gprs[1], &qstatus, sizeof(qstatus));
vcpu->run->s.regs.gprs[1] >>= 32;
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return 0;
}
@@ -528,9 +530,9 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
hash_init(matrix_mdev->qtable.queues);
mdev_set_drvdata(mdev, matrix_mdev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
ret = vfio_register_emulated_iommu_dev(&matrix_mdev->vdev);
if (ret)
@@ -539,9 +541,9 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
return 0;
err_list:
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
list_del(&matrix_mdev->node);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
vfio_uninit_group_dev(&matrix_mdev->vdev);
kfree(matrix_mdev);
err_dec_available:
@@ -604,11 +606,11 @@ static void vfio_ap_mdev_remove(struct mdev_device *mdev)
vfio_unregister_group_dev(&matrix_mdev->vdev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
vfio_ap_mdev_reset_queues(matrix_mdev);
vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
list_del(&matrix_mdev->node);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
vfio_uninit_group_dev(&matrix_mdev->vdev);
kfree(matrix_mdev);
atomic_inc(&matrix_dev->available_instances);
@@ -784,7 +786,7 @@ static ssize_t assign_adapter_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If the KVM guest is running, disallow assignment of adapter */
if (matrix_mdev->kvm) {
@@ -816,7 +818,7 @@ static ssize_t assign_adapter_store(struct device *dev,
matrix_mdev->matrix.aqm, matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
@@ -859,7 +861,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
unsigned long apid;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If the KVM guest is running, disallow unassignment of adapter */
if (matrix_mdev->kvm) {
@@ -884,7 +886,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
static DEVICE_ATTR_WO(unassign_adapter);
@@ -939,7 +941,7 @@ static ssize_t assign_domain_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_apqi = matrix_mdev->matrix.aqm_max;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If the KVM guest is running, disallow assignment of domain */
if (matrix_mdev->kvm) {
@@ -970,7 +972,7 @@ static ssize_t assign_domain_store(struct device *dev,
matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
@@ -1013,7 +1015,7 @@ static ssize_t unassign_domain_store(struct device *dev,
unsigned long apqi;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If the KVM guest is running, disallow unassignment of domain */
if (matrix_mdev->kvm) {
@@ -1039,7 +1041,7 @@ static ssize_t unassign_domain_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
static DEVICE_ATTR_WO(unassign_domain);
@@ -1066,7 +1068,7 @@ static ssize_t assign_control_domain_store(struct device *dev,
unsigned long id;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If the KVM guest is running, disallow assignment of control domain */
if (matrix_mdev->kvm) {
@@ -1092,7 +1094,7 @@ static ssize_t assign_control_domain_store(struct device *dev,
vfio_ap_mdev_filter_cdoms(matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
static DEVICE_ATTR_WO(assign_control_domain);
@@ -1120,7 +1122,7 @@ static ssize_t unassign_control_domain_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_domid = matrix_mdev->matrix.adm_max;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
/* If a KVM guest is running, disallow unassignment of control domain */
if (matrix_mdev->kvm) {
@@ -1143,7 +1145,7 @@ static ssize_t unassign_control_domain_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
static DEVICE_ATTR_WO(unassign_control_domain);
@@ -1159,13 +1161,13 @@ static ssize_t control_domains_show(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_domid = matrix_mdev->matrix.adm_max;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
for_each_set_bit_inv(id, matrix_mdev->matrix.adm, max_domid + 1) {
n = sprintf(bufpos, "%04lx\n", id);
bufpos += n;
nchars += n;
}
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return nchars;
}
@@ -1188,7 +1190,7 @@ static ssize_t matrix_show(struct device *dev, struct device_attribute *attr,
apid1 = find_first_bit_inv(matrix_mdev->matrix.apm, napm_bits);
apqi1 = find_first_bit_inv(matrix_mdev->matrix.aqm, naqm_bits);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
if ((apid1 < napm_bits) && (apqi1 < naqm_bits)) {
for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, napm_bits) {
@@ -1214,7 +1216,7 @@ static ssize_t matrix_show(struct device *dev, struct device_attribute *attr,
}
}
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return nchars;
}
@@ -1262,12 +1264,12 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
up_write(&kvm->arch.crypto.pqap_hook_rwsem);
mutex_lock(&kvm->lock);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
list_for_each_entry(m, &matrix_dev->mdev_list, node) {
if (m != matrix_mdev && m->kvm == kvm) {
mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return -EPERM;
}
}
@@ -1279,7 +1281,7 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
matrix_mdev->shadow_apcb.adm);
mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
}
return 0;
@@ -1331,7 +1333,7 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev)
up_write(&kvm->arch.crypto.pqap_hook_rwsem);
mutex_lock(&kvm->lock);
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
kvm_arch_crypto_clear_masks(kvm);
vfio_ap_mdev_reset_queues(matrix_mdev);
@@ -1339,7 +1341,7 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev)
matrix_mdev->kvm = NULL;
mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
}
}
@@ -1516,7 +1518,7 @@ static ssize_t vfio_ap_mdev_ioctl(struct vfio_device *vdev,
container_of(vdev, struct ap_matrix_mdev, vdev);
int ret;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
switch (cmd) {
case VFIO_DEVICE_GET_INFO:
ret = vfio_ap_mdev_get_device_info(arg);
@@ -1528,7 +1530,7 @@ static ssize_t vfio_ap_mdev_ioctl(struct vfio_device *vdev,
ret = -EOPNOTSUPP;
break;
}
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return ret;
}
@@ -1612,7 +1614,7 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
q = kzalloc(sizeof(*q), GFP_KERNEL);
if (!q)
return -ENOMEM;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
q->apqn = to_ap_queue(&apdev->device)->qid;
q->saved_isc = VFIO_AP_ISC_INVALID;
vfio_ap_queue_link_mdev(q);
@@ -1624,7 +1626,7 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
q->matrix_mdev);
}
dev_set_drvdata(&apdev->device, q);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
return 0;
}
@@ -1634,7 +1636,7 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
unsigned long apid;
struct vfio_ap_queue *q;
- mutex_lock(&matrix_dev->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
q = dev_get_drvdata(&apdev->device);
if (q->matrix_mdev) {
@@ -1648,5 +1650,5 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
vfio_ap_mdev_reset_queue(q, 1);
dev_set_drvdata(&apdev->device, NULL);
kfree(q);
- mutex_unlock(&matrix_dev->lock);
+ mutex_unlock(&matrix_dev->mdevs_lock);
}
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index fa11a7e91e24..5262e02192a4 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -33,7 +33,7 @@
* @available_instances: number of mediated matrix devices that can be created
* @info: the struct containing the output from the PQAP(QCI) instruction
* @mdev_list: the list of mediated matrix devices created
- * @lock: mutex for locking the AP matrix device. This lock will be
+ * @mdevs_lock: mutex for locking the AP matrix device. This lock will be
* taken every time we fiddle with state managed by the vfio_ap
* driver, be it using @mdev_list or writing the state of a
* single ap_matrix_mdev device. It's quite coarse but we don't
@@ -45,7 +45,7 @@ struct ap_matrix_dev {
atomic_t available_instances;
struct ap_config_info info;
struct list_head mdev_list;
- struct mutex lock;
+ struct mutex mdevs_lock;
struct ap_driver *vfio_ap_drv;
};
--
2.31.1
Introduces a new document describing the locks used by the vfio_ap device
driver and how to use them so as to avoid lockdep reports and deadlock
situations.
Signed-off-by: Tony Krowiak <[email protected]>
---
Documentation/s390/vfio-ap-locking.rst | 389 +++++++++++++++++++++++++
1 file changed, 389 insertions(+)
create mode 100644 Documentation/s390/vfio-ap-locking.rst
diff --git a/Documentation/s390/vfio-ap-locking.rst b/Documentation/s390/vfio-ap-locking.rst
new file mode 100644
index 000000000000..ba5db6689f14
--- /dev/null
+++ b/Documentation/s390/vfio-ap-locking.rst
@@ -0,0 +1,389 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+======================
+VFIO AP Locks Overview
+======================
+This document describes the locks that are pertinent to the secure operation
+of the vfio_ap device driver. Throughout this document, the following variables
+will be used to denote instances of the structures herein described:
+
+struct ap_matrix_dev *matrix_dev;
+struct ap_matrix_mdev *matrix_mdev;
+struct kvm *kvm;
+
+The Matrix Devices Lock (drivers/s390/crypto/vfio_ap_private.h)
+--------------------------------------------------------------
+
+struct ap_matrix_dev {
+ ...
+ struct list_head mdev_list;
+ struct mutex mdevs_lock;
+ ...
+}
+
+The Matrix Devices Lock (matrix_dev->mdevs_lock) is implemented as a global
+mutex contained within the single object of struct ap_matrix_dev. This lock
+controls access to all fields contained within each matrix_mdev
+(matrix_dev->mdev_list). This lock must be held while reading from, writing to
+or using the data from a field contained within a matrix_mdev instance
+representing one of the vfio_ap device driver's mediated devices.
+
+The KVM Lock (include/linux/kvm_host.h)
+---------------------------------------
+
+struct kvm {
+ ...
+ struct mutex lock;
+ ...
+}
+
+The KVM Lock (kvm->lock) controls access to the state data for a KVM guest. This
+lock must be held by the vfio_ap device driver while one or more AP adapters,
+domains or control domains are being plugged into or unplugged from the guest.
+
+The vfio_ap device driver registers a function to be notified when the pointer
+to the kvm instance has been set. The KVM pointer is passed to the handler by
+the notifier and is stored in the in the matrix_mdev instance
+(matrix_mdev->kvm = kvm) containing the state of the mediated device that has
+been passed through to the KVM guest.
+
+The Guests Lock (drivers/s390/crypto/vfio_ap_private.h)
+-----------------------------------------------------------
+
+struct ap_matrix_dev {
+ ...
+ struct list_head mdev_list;
+ struct mutex guests_lock;
+ ...
+}
+
+The Guests Lock (matrix_dev->guests_lock) controls access to the
+matrix_mdev instances (matrix_dev->mdev_list) that represent mediated devices
+that hold the state for the mediated devices that have been passed through to a
+KVM guest. This lock must be held:
+
+1. To control access to the KVM pointer (matrix_mdev->kvm) while the vfio_ap
+ device driver is using it to plug/unplug AP devices passed through to the KVM
+ guest.
+
+2. To add matrix_mdev instances to or remove them from matrix_dev->mdev_list.
+ This is necessary to ensure the proper locking order when the list is perused
+ to find an ap_matrix_mdev instance for the purpose of plugging/unplugging
+ AP devices passed through to a KVM guest.
+
+ For example, when a queue device is removed from the vfio_ap device driver,
+ if the adapter is passed through to a KVM guest, it will have to be
+ unplugged. In order to figure out whether the adapter is passed through,
+ the matrix_mdev object to which the queue is assigned will have to be
+ found. The KVM pointer (matrix_mdev->kvm) can then be used to determine if
+ the mediated device is passed through (matrix_mdev->kvm != NULL) and if so,
+ to unplug the adapter.
+
+It is not necessary to take the Guests Lock to access the KVM pointer if the
+pointer is not used to plug/unplug devices passed through to the KVM guest;
+however, in this case, the Matrix Devices Lock (matrix_dev->mdevs_lock) must be
+held in order to access the KVM pointer since it set and cleared under the
+protection of the Matrix Devices Lock. A case in point is the function that
+handles interception of the PQAP(AQIC) instruction sub-function. This handler
+needs to access the KVM pointer only for the purposes of setting or clearing IRQ
+resources, so only the matrix_dev->mdevs_lock needs to be held.
+
+The PQAP Hook Lock (arch/s390/include/asm/kvm_host.h)
+-----------------------------------------------------
+
+typedef int (*crypto_hook)(struct kvm_vcpu *vcpu);
+
+struct kvm_s390_crypto {
+ ...
+ struct rw_semaphore pqap_hook_rwsem;
+ crypto_hook *pqap_hook;
+ ...
+};
+
+The PQAP Hook Lock is a r/w semaphore that controls access to the function
+pointer of the handler (*kvm->arch.crypto.pqap_hook) to invoke when the
+PQAP(AQIC) instruction sub-function is intercepted by the host. The lock must be
+held in write mode when pqap_hook value is set, and in read mode when the
+pqap_hook function is called.
+
+Locking Order
+-------------
+
+If the various locks are not taken in the proper order, it could potentially
+result in a deadlock or lockdep splat. In general the Guests Lock
+(matrix_dev->guests_lock) must be taken outside of the KVM Lock (kvm->lock)
+which in turn must be taken outside of the Matrix Devices Lock
+(matrix_dev->mdevs_lock).
+
+The following describes the various operations under which the various locks are
+taken, the purpose for taking them and the order in which they must be taken.
+
+* Operations: Setting or clearing the KVM pointer (matrix_mdev->kvm):
+
+ 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem):
+
+ This semaphore must be held in write mode while setting or clearing the
+ reference to the function pointer (kvm->arch.crypt.pqap_hook) to call
+ when the PQAP(AQIC) instruction sub-function is intercepted by the host.
+ The function pointer is set when the KVM pointer is being set and
+ cleared when the KVM pointer is being cleared.
+
+ 2.Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held while accessing the KVM pointer
+ (matrix_mdev->kvm) to plug/unplug AP devices passed through to the
+ KVM guest
+
+ 3. KVM Lock (kvm->lock):
+
+ This mutex must be held while the AP devices passed through to the KVM
+ guest are plugged/unplugged.
+
+ 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held to prevent access to the matrix_mdev state
+ while writing/reading state values during the operation.
+
+* Operations: Assign or unassign an adapter, domain or control domain of a
+ mediated device under the control of the vfio_ap device driver:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held while accessing the KVM pointer
+ (matrix_dev->kvm) to plug/unplug AP devices passed through to the
+ KVM guest as a result of the assignment/unassignment operation.
+ Assignment of an AP device may result in additional queue devices
+ or control domains being plugged into the guest. Similarly, unassignment
+ may result in unplugging queue devices or control domains from the
+ guest
+
+ 3. KVM Lock (matrix_mdev->kvm->lock):
+
+ This mutex must be held while the AP devices passed through to the KVM
+ guest are plugged in or unplugged.
+
+ 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held to prevent access to the matrix_mdev state
+ while writing/reading state values during the operation. For example, to
+ determine which AP devices need to be plugged/unplugged, the lock
+ must be held to prevent other operations from changing the data used
+ to construct the guest's AP configuration.
+
+* Operations: Probe or remove an AP queue device:
+
+ When a queue device is bound to the vfio_ap device driver, the driver's probe
+ callback is invoked. Similarly, when a queue device is unbound from the
+ driver it's remove callback is invoked. The probe and remove functions will
+ take locks in the following order:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held for the duration of this operation.
+
+ At the time of the operation, the vfio_ap device driver will only have
+ the APQN of the queue being probed or removed, so the
+ matrix_dev->mdevs_list must be perused to locate the matrix_mdev
+ instance to which the queue is assigned. The Guests Lock must be held
+ during this time to prevent the list from being changed while processing
+ the probe/remove.
+
+ Once the matrix_mdev is found, the operation must determine whether the
+ mediated device is passed through to a guest (matrix_mdev->kvm != NULL),
+ then use the KVM pointer to perform the plug/unplug operation. Here
+ again, the lock must be held to prevent other operations from accessing
+ the KVM pointer for the same purpose.
+
+ 2. KVM Lock (kvm->lock):
+
+ This mutex must be held while the AP devices passed through to the KVM
+ guest are plugged in or unplugged to prevent other operations from
+ accessing the guest's state while it is in flux.
+
+ 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held to prevent access to the matrix_mdev state
+ while writing/reading state values during the operation, such as the
+ masks used to construct the KVM guest's AP configuration.
+
+* Operations: Probe or remove a mediated device:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held while adding the matrix_mdev to the
+ matrix_dev->mdev_list during the probe operation or when removing it
+ from the list during the remove operation. This is to prevent access by
+ other functions that must traverse the list to find a matrix_mdev for
+ the purpose of plugging/unplugging AP devices passed through to a KVM
+ guest (i.e., probe/remove queue callbacks), while the list is being
+ modified.
+
+ 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held to prevent access to the matrix_mdev state
+ while writing/reading state values during the probe or remove operations
+ such as initializing the hashtable of queue devices
+ (matrix_mdev->qtable.queues) assigned to the matrix_mdev.
+
+* Operation: Handle interception of the PQAP(AQIC) instruction sub-function:
+
+ 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem)
+
+ This semaphore must be held in read mode while retrieving the function
+ pointer (kvm->arch.crypto.pqap_hook) and executing the function that
+ handles the interception of the PQAP(AQIC) instruction sub-function by
+ the host.
+
+ 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held to prevent access to the matrix_mdev state
+ while writing/reading state values during the execution of the
+ PQAP(AQIC) instruction sub-function interception handler. For example,
+ the handler must iterate over the matrix_mdev->qtable.queues hashtable
+ to find the vfio_ap_queue object representing the queue for which
+ interrupts are being enabled or disabled.
+
+ Note: It is not necessary to take the Guests Lock (matrix_dev->guests_lock)
+ or the KVM Lock (matrix_mdev->kvm->lock) because the KVM pointer
+ will not be accessed to plug/unplug AP devices passed through to the
+ guest; it will only be used to allocate or free resources for processing
+ interrupts.
+
+* Operation: Handle AP configuration changed notification:
+
+ The vfio_ap device driver registers a callback function to be notified when
+ the AP bus detects that the host's AP configuration has changed. This can
+ occur due to the addition or removal of AP adapters, domains or control
+ domains via an SE or HMC connected to a DPM enabled LPAR. The objective of the
+ handler is to remove the queues no longer accessible via the host in bulk
+ rather than one queue at a time via the driver's queue device remove callback.
+ The locks and the order in which they must be taken by this operation are:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held for the duration of the operation to:
+
+ * Iterate over the matrix_dev->mdev_list to find each matrix_mdev from
+ which a queue device to be removed is assigned and prevent other
+ operations from modifying the list while processing the affected
+ matrix_mdev instances.
+
+ * Prevent other operations from acquiring access to the KVM pointer in
+ each affected matrix_mdev instance (matrix_mdev->kvm) for the purpose
+ of plugging/unplugging AP devices passed through to the KVM guest via
+ that instance.
+
+2. KVM Lock (kvm->lock):
+
+ This mutex must be held for each affected matrix_mdev instance while
+ the AP devices passed through to the KVM guest are unplugged to prevent
+ other operations from accessing the guest's state while it is in flux.
+
+ Note: This lock must be re-acquired for each matrix_mdev instance.
+
+ 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
+
+ This lock must be held for each affected matrix_mdev to prevent access
+ to the matrix_mdev state while writing/reading state values during the
+ operation, such as the masks used to construct the KVM guest's AP
+ configuration.
+
+ Note: This lock must be re-acquired for each matrix_mdev instance.
+
+Operation: Handle AP bus scan complete notification:
+
+ The vfio_ap device driver registers a callback function to be notified when
+ the AP bus scan completes after detecting the addition or removal of AP
+ adapters, domains or control domains. The objective of the handler is t
+ add the new queues accessible via the host in bulk rather than one queue
+ at a time via the driver's queue device probe callback. The locks and the
+ order in which they must be taken by this operation are:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held for the duration of the operation to:
+
+ * Iterate over the matrix_dev->mdev_list to find each matrix_mdev to
+ which a queue device added is assigned and prevent other operations
+ from modifying the list while processing each affected matrix_mdev
+ object.
+
+ * Prevent other operations from acquiring access to the KVM pointer in
+ each affected matrix_mdev instance (matrix_mdev->kvm) for the purpose
+ of plugging/unplugging AP devices passed through to the KVM guest via
+ that instance.
+
+ 2. KVM Lock (kvm->lock):
+
+ This mutex must be held for each affected matrix_mdev instance while
+ the AP devices passed through to the KVM guest are plugged in to prevent
+ other operations from accessing the guest's state while it is in flux.
+
+ Note: This lock must be re-acquired for each matrix_mdev instance.
+
+ 3. Matrix Devices Lock (matrix_dev->mdevs_lock):
+
+ This lock must be held for each affected matrix_mdev to prevent access
+ to the matrix_mdev state while writing/reading state values during the
+ operation, such as the masks used to construct the KVM guest's AP
+ configuration.
+
+ Note: This lock must be re-acquired for each matrix_mdev instance.
+
+Operation: Handle resource in use query:
+
+ The vfio_ap device driver registers a callback function with the AP bus to be
+ called when changes to the bus's sysfs /sys/bus/ap/apmask or
+ /sys/bus/ap/aqmask attributes would result in one or more AP queue devices
+ getting unbound from the vfio_ap device driver to verify none of them are in
+ use by the driver (i.e., assigned to a matrix_mdev instance). If this function
+ is called while an adapter or domain is also being assigned to a mediated
+ device, this could result in a deadlock; for example:
+
+ 1. A system administrator assigns an adapter to a mediated device under the
+ control of the vfio_ap device driver. The driver will need to first take
+ the matrix_dev->guests_lock to potentially hot plug the adapter into
+ the KVM guest.
+ 2. At the same time, a system administrator sets a bit in the sysfs
+ /sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
+ must:
+ a. Take the ap_perms_mutex lock to update the object storing the values
+ for the /sys/bus/ap/ap_mask attribute.
+ b. Call the vfio_ap device driver's in-use callback to verify that no
+ queues now being reserved for the default zcrypt drivers are
+ in use by the vfio_ap device driver. To do the verification, the in-use
+ callback function takes the matrix_dev->guests_lock, but has to wait
+ because it is already held by the operation in 1 above.
+ 3. The vfio_ap device driver calls an AP bus function to verify that the
+ new queues resulting from the assignment of the adapter in step 1 are
+ not reserved for the default zcrypt device driver. This AP bus function
+ tries to take the ap_perms_mutex lock but gets stuck waiting for the
+ it due to step 2a above.
+
+ Consequently, we have the following deadlock situation:
+
+ matrix_dev->guests_lock locked (1)
+ ap_perms_mutex lock locked (2a)
+ Waiting for matrix_dev->lock (2b) which is currently held (1)
+ Waiting for ap_perms_mutex lock (3) which is currently held (2a)
+
+ To prevent the deadlock scenario, the in_use operation will take the
+ required locks using the mutex_trylock() function and if the lock can not be
+ acquired will terminate and return -EBUSY to indicate the driver is busy
+ processing another request.
+
+ The locks required to respond to the handle resource in use query and the
+ order in which they must be taken are:
+
+ 1. Guests Lock (matrix_dev->guests_lock):
+
+ This mutex must be held for the duration of the operation to iterate over the
+ matrix_dev->mdev_list to determine whether any of the queues to be unbound
+ are assigned to a matrix_mdev instance.
+
+ 2. Matrix Devices Lock (matrix_dev->mdevs_lock):
+
+ This mutex must be held for the duration of the operation to ensure that the
+ AP configuration of each matrix_mdev instance does not change while verifying
+ that none of the queue devices to be removed from the vfio_ap driver are
+ assigned to it.
--
2.31.1
Let's implement the callback to indicate when an APQN
is in use by the vfio_ap device driver. The callback is
invoked whenever a change to the apmask or aqmask would
result in one or more queue devices being removed from the driver. The
vfio_ap device driver will indicate a resource is in use
if the APQN of any of the queue devices to be removed are assigned to
any of the matrix mdevs under the driver's control.
There is potential for a deadlock condition between the
matrix_dev->guests_lock used to lock the guest during assignment of
adapters and domains and the ap_perms_mutex locked by the AP bus when
changes are made to the sysfs apmask/aqmask attributes.
The AP Perms lock controls access to the objects that store the adapter
numbers (ap_perms) and domain numbers (aq_perms) for the sysfs
/sys/bus/ap/apmask and /sys/bus/ap/aqmask attributes. These attributes
identify which queues are reserved for the zcrypt default device drivers.
Before allowing a bit to be removed from either mask, the AP bus must check
with the vfio_ap device driver to verify that none of the queues are
assigned to any of its mediated devices.
The apmask/aqmask attributes can be written or read at any time from
userspace, so care must be taken to prevent a deadlock with asynchronous
operations that might be taking place in the vfio_ap device driver. For
example, consider the following:
1. A system administrator assigns an adapter to a mediated device under the
control of the vfio_ap device driver. The driver will need to first take
the matrix_dev->guests_lock to potentially hot plug the adapter into
the KVM guest.
2. At the same time, a system administrator sets a bit in the sysfs
/sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
must:
a. Take the ap_perms_mutex lock to update the object storing the values
for the /sys/bus/ap/ap_mask attribute.
b. Call the vfio_ap device driver's in-use callback to verify that the
queues now being reserved for the default zcrypt drivers are not
assigned to a mediated device owned by the vfio_ap device driver. To
do the verification, the in-use callback function takes the
matrix_dev->guests_lock, but has to wait because it is already held
by the operation in 1 above.
3. The vfio_ap device driver calls an AP bus function to verify that the
new queues resulting from the assignment of the adapter in step 1 are
not reserved for the default zcrypt device driver. This AP bus function
tries to take the ap_perms_mutex lock but gets stuck waiting for the
waiting for the lock due to step 2a above.
Consequently, we have the following deadlock situation:
matrix_dev->guests_lock locked (1)
ap_perms_mutex lock locked (2a)
Waiting for matrix_dev->gusts_lock (2b) which is currently held (1)
Waiting for ap_perms_mutex lock (3) which is currently held (2a)
To prevent this deadlock scenario, the function called in step 3 will no
longer take the ap_perms_mutex lock and require the caller to take the
lock. The lock will be the first taken by the adapter/domain assignment
functions in the vfio_ap device driver to maintain the proper locking
order.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/ap_bus.c | 31 ++++++++----
drivers/s390/crypto/vfio_ap_drv.c | 1 +
drivers/s390/crypto/vfio_ap_ops.c | 68 +++++++++++++++++++++++++++
drivers/s390/crypto/vfio_ap_private.h | 2 +
4 files changed, 94 insertions(+), 8 deletions(-)
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index fdf16cb70881..f48552e900a2 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -817,6 +817,17 @@ static void ap_bus_revise_bindings(void)
bus_for_each_dev(&ap_bus_type, NULL, NULL, __ap_revise_reserved);
}
+/**
+ * ap_apqn_in_matrix_owned_by_def_drv: indicates whether an APQN c is reserved
+ * for the host drivers or not.
+ * @card: the APID of the adapter card to check
+ * @queue: the APQI of the queue to check
+ *
+ * Note: the ap_perms_mutex must be locked by the caller of this function.
+ *
+ * Return: an int specifying whether the APQN is reserved for the host (1) or
+ * not (0)
+ */
int ap_owned_by_def_drv(int card, int queue)
{
int rc = 0;
@@ -824,25 +835,31 @@ int ap_owned_by_def_drv(int card, int queue)
if (card < 0 || card >= AP_DEVICES || queue < 0 || queue >= AP_DOMAINS)
return -EINVAL;
- mutex_lock(&ap_perms_mutex);
-
if (test_bit_inv(card, ap_perms.apm)
&& test_bit_inv(queue, ap_perms.aqm))
rc = 1;
- mutex_unlock(&ap_perms_mutex);
-
return rc;
}
EXPORT_SYMBOL(ap_owned_by_def_drv);
+/**
+ * ap_apqn_in_matrix_owned_by_def_drv: indicates whether every APQN contained in
+ * a set is reserved for the host drivers
+ * or not.
+ * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check
+ * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check
+ *
+ * Note: the ap_perms_mutex must be locked by the caller of this function.
+ *
+ * Return: an int specifying whether each APQN is reserved for the host (1) or
+ * not (0)
+ */
int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
unsigned long *aqm)
{
int card, queue, rc = 0;
- mutex_lock(&ap_perms_mutex);
-
for (card = 0; !rc && card < AP_DEVICES; card++)
if (test_bit_inv(card, apm) &&
test_bit_inv(card, ap_perms.apm))
@@ -851,8 +868,6 @@ int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
test_bit_inv(queue, ap_perms.aqm))
rc = 1;
- mutex_unlock(&ap_perms_mutex);
-
return rc;
}
EXPORT_SYMBOL(ap_apqn_in_matrix_owned_by_def_drv);
diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
index c258e5f7fdfc..2c3084589347 100644
--- a/drivers/s390/crypto/vfio_ap_drv.c
+++ b/drivers/s390/crypto/vfio_ap_drv.c
@@ -107,6 +107,7 @@ static const struct attribute_group vfio_queue_attr_group = {
static struct ap_driver vfio_ap_drv = {
.probe = vfio_ap_mdev_probe_queue,
.remove = vfio_ap_mdev_remove_queue,
+ .in_use = vfio_ap_mdev_resource_in_use,
.ids = ap_queue_ids,
};
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 49ed54dc9e05..3ece2cd9f1e7 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -902,6 +902,21 @@ static int vfio_ap_mdev_verify_no_sharing(unsigned long *mdev_apm,
return 0;
}
+/**
+ * vfio_ap_mdev_validate_masks - verify that the APQNs assigned to the mdev are
+ * not reserved for the default zcrypt driver and
+ * are not assigned to another mdev.
+ *
+ * @matrix_mdev: the mdev to which the APQNs being validated are assigned.
+ *
+ * Return: One of the following values:
+ * o the error returned from the ap_apqn_in_matrix_owned_by_def_drv() function,
+ * most likely -EBUSY indicating the ap_perms_mutex lock is already held.
+ * o EADDRNOTAVAIL if an APQN assigned to @matrix_mdev is reserved for the
+ * zcrypt default driver.
+ * o EADDRINUSE if an APQN assigned to @matrix_mdev is assigned to another mdev
+ * o A zero indicating validation succeeded.
+ */
static int vfio_ap_mdev_validate_masks(struct ap_matrix_mdev *matrix_mdev)
{
if (ap_apqn_in_matrix_owned_by_def_drv(matrix_mdev->matrix.apm,
@@ -951,6 +966,10 @@ static void vfio_ap_mdev_link_adapter(struct ap_matrix_mdev *matrix_mdev,
* An APQN derived from the cross product of the APID being assigned
* and the APQIs previously assigned is being used by another mediated
* matrix device
+ *
+ * 5. -EAGAIN
+ * A lock required to validate the mdev's AP configuration could not
+ * be obtained.
*/
static ssize_t assign_adapter_store(struct device *dev,
struct device_attribute *attr,
@@ -961,6 +980,7 @@ static ssize_t assign_adapter_store(struct device *dev,
DECLARE_BITMAP(apm_delta, AP_DEVICES);
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
+ mutex_lock(&ap_perms_mutex);
get_update_locks_for_mdev(matrix_mdev);
ret = kstrtoul(buf, 0, &apid);
@@ -991,6 +1011,7 @@ static ssize_t assign_adapter_store(struct device *dev,
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
+ mutex_unlock(&ap_perms_mutex);
return ret;
}
@@ -1144,6 +1165,10 @@ static void vfio_ap_mdev_link_domain(struct ap_matrix_mdev *matrix_mdev,
* An APQN derived from the cross product of the APQI being assigned
* and the APIDs previously assigned is being used by another mediated
* matrix device
+ *
+ * 5. -EAGAIN
+ * The lock required to validate the mdev's AP configuration could not
+ * be obtained.
*/
static ssize_t assign_domain_store(struct device *dev,
struct device_attribute *attr,
@@ -1154,6 +1179,7 @@ static ssize_t assign_domain_store(struct device *dev,
DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
+ mutex_lock(&ap_perms_mutex);
get_update_locks_for_mdev(matrix_mdev);
ret = kstrtoul(buf, 0, &apqi);
@@ -1184,6 +1210,7 @@ static ssize_t assign_domain_store(struct device *dev,
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
+ mutex_unlock(&ap_perms_mutex);
return ret;
}
@@ -1868,3 +1895,44 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
kfree(q);
release_update_locks_for_mdev(matrix_mdev);
}
+
+/**
+ * vfio_ap_mdev_resource_in_use: check whether any of a set of APQNs is
+ * assigned to a mediated device under the control
+ * of the vfio_ap device driver.
+ *
+ * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check.
+ * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check.
+ *
+ * This function is invoked by the AP bus when changes to the apmask/aqmask
+ * attributes will result in giving control of the queue devices specified via
+ * @apm and @aqm to the default zcrypt device driver. Prior to calling this
+ * function, the AP bus locks the ap_perms_mutex. If this function is called
+ * while an adapter or domain is being assigned to a mediated device, the
+ * assignment operations will take the matrix_dev->guests_lock and
+ * matrix_dev->mdevs_lock then call the ap_apqn_in_matrix_owned_by_def_drv
+ * function, which also locks the ap_perms_mutex. This could result in a
+ * deadlock.
+ *
+ * To avoid a deadlock, this function will verify that the
+ * matrix_dev->guests_lock and matrix_dev->mdevs_lock are not currently held and
+ * will return -EBUSY if the locks can not be obtained.
+ *
+ * Return:
+ * * -EBUSY if the locks required by this function are already locked.
+ * * -EADDRINUSE if one or more of the APQNs specified via @apm/@aqm are
+ * assigned to a mediated device under the control of the vfio_ap
+ * device driver.
+ */
+int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm)
+{
+ int ret;
+
+ mutex_lock(&matrix_dev->guests_lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
+ ret = vfio_ap_mdev_verify_no_sharing(apm, aqm);
+ mutex_unlock(&matrix_dev->mdevs_lock);
+ mutex_unlock(&matrix_dev->guests_lock);
+
+ return ret;
+}
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index 6d4ca39f783b..cbffa0bd01da 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -147,4 +147,6 @@ void vfio_ap_mdev_unregister(void);
int vfio_ap_mdev_probe_queue(struct ap_device *queue);
void vfio_ap_mdev_remove_queue(struct ap_device *queue);
+int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm);
+
#endif /* _VFIO_AP_PRIVATE_H_ */
--
2.31.1
When an AP queue device is probed or removed, if the mediated device is
attached to a KVM guest, the mediated device's adapter, domain and
control domain bitmaps must be filtered to update the guest's APCB and if
any changes are detected, the guest's APCB must then be hot plugged into
the guest to reflect those changes to the guest.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 23 +++++++++++++++++------
1 file changed, 17 insertions(+), 6 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 47f808122ed2..ec5f37d726ec 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -1752,9 +1752,11 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
vfio_ap_mdev_link_queue(matrix_mdev, q);
memset(apm_delta, 0, sizeof(apm_delta));
set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
- vfio_ap_mdev_filter_matrix(apm_delta,
- matrix_mdev->matrix.aqm,
- matrix_mdev);
+
+ if (vfio_ap_mdev_filter_matrix(apm_delta,
+ matrix_mdev->matrix.aqm,
+ matrix_mdev))
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
}
dev_set_drvdata(&apdev->device, q);
release_update_locks_for_mdev(matrix_mdev);
@@ -1764,7 +1766,7 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
{
- unsigned long apid;
+ unsigned long apid, apqi;
struct vfio_ap_queue *q;
struct ap_matrix_mdev *matrix_mdev;
@@ -1776,8 +1778,17 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
vfio_ap_unlink_queue_fr_mdev(q);
apid = AP_QID_CARD(q->apqn);
- if (test_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm))
- clear_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm);
+ apqi = AP_QID_QUEUE(q->apqn);
+
+ /*
+ * If the queue is assigned to the guest's APCB, then remove
+ * the adapter's APID from the APCB and hot it into the guest.
+ */
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm) &&
+ test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm)) {
+ clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
}
vfio_ap_mdev_reset_queue(q, 1);
--
2.31.1
This patch refactors the vfio_ap device driver to use the AP bus's
ap_get_qdev() function to retrieve the vfio_ap_queue struct containing
information about a queue that is bound to the vfio_ap device driver.
The bus's ap_get_qdev() function retrieves the queue device from a
hashtable keyed by APQN. This is much more efficient than looping over
the list of devices attached to the AP bus by several orders of
magnitude.
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Halil Pasic <[email protected]>
Reviewed-by: Jason J. Herne <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 23 +++++++++--------------
1 file changed, 9 insertions(+), 14 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 6e08d04b605d..2227919fde13 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -30,13 +30,6 @@ static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev);
static struct vfio_ap_queue *vfio_ap_find_queue(int apqn);
static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
-static int match_apqn(struct device *dev, const void *data)
-{
- struct vfio_ap_queue *q = dev_get_drvdata(dev);
-
- return (q->apqn == *(int *)(data)) ? 1 : 0;
-}
-
/**
* vfio_ap_get_queue - retrieve a queue with a specific APQN from a list
* @matrix_mdev: the associated mediated matrix
@@ -1306,15 +1299,17 @@ static int vfio_ap_mdev_group_notifier(struct notifier_block *nb,
static struct vfio_ap_queue *vfio_ap_find_queue(int apqn)
{
- struct device *dev;
+ struct ap_queue *queue;
struct vfio_ap_queue *q = NULL;
- dev = driver_find_device(&matrix_dev->vfio_ap_drv->driver, NULL,
- &apqn, match_apqn);
- if (dev) {
- q = dev_get_drvdata(dev);
- put_device(dev);
- }
+ queue = ap_get_qdev(apqn);
+ if (!queue)
+ return NULL;
+
+ if (queue->ap_dev.device.driver == &matrix_dev->vfio_ap_drv->driver)
+ q = dev_get_drvdata(&queue->ap_dev.device);
+
+ put_device(&queue->ap_dev.device);
return q;
}
--
2.31.1
The functions backing the matrix mdev's sysfs attribute interfaces to
assign/unassign adapters, domains and control domains must take and
release the locks required to perform a dynamic update of a guest's APCB
in the proper order.
The proper order for taking the locks is:
matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
The proper order for releasing the locks is:
matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
Two new macros are introduced for this purpose: One to take the locks and
the other to release the locks. These macros will be used by the
assignment/unassignment functions to prepare for dynamic update of
the KVM guest's APCB.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 69 +++++++++++++++++++++++++------
1 file changed, 57 insertions(+), 12 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 757bbf449b04..2219b1069ceb 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -71,6 +71,51 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
mutex_unlock(&matrix_dev->guests_lock); \
})
+/**
+ * get_update_locks_for_mdev: Acquire the locks required to dynamically update a
+ * KVM guest's APCB in the proper order.
+ *
+ * @matrix_mdev: a pointer to a struct ap_matrix_mdev object containing the AP
+ * configuration data to use to update a KVM guest's APCB.
+ *
+ * The proper locking order is:
+ * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
+ * guest's APCB.
+ * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
+ * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
+ *
+ * Note: If @matrix_mdev is NULL or is not attached to a KVM guest, the KVM
+ * lock will not be taken.
+ */
+#define get_update_locks_for_mdev(matrix_mdev) ({ \
+ mutex_lock(&matrix_dev->guests_lock); \
+ if (matrix_mdev && matrix_mdev->kvm) \
+ mutex_lock(&matrix_mdev->kvm->lock); \
+ mutex_lock(&matrix_dev->mdevs_lock); \
+})
+
+/**
+ * release_update_locks_for_mdev: Release the locks used to dynamically update a
+ * KVM guest's APCB in the proper order.
+ *
+ * @matrix_mdev: a pointer to a struct ap_matrix_mdev object containing the AP
+ * configuration data to use to update a KVM guest's APCB.
+ *
+ * The proper unlocking order is:
+ * 1. matrix_dev->mdevs_lock
+ * 2. matrix_mdev->kvm->lock
+ * 3. matrix_dev->guests_lock
+ *
+ * Note: If @matrix_mdev is NULL or is not attached to a KVM guest, the KVM
+ * lock will not be released.
+ */
+#define release_update_locks_for_mdev(matrix_mdev) ({ \
+ mutex_unlock(&matrix_dev->mdevs_lock); \
+ if (matrix_mdev && matrix_mdev->kvm) \
+ mutex_unlock(&matrix_mdev->kvm->lock); \
+ mutex_unlock(&matrix_dev->guests_lock); \
+})
+
/**
* vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
* hash table of queues assigned to a matrix mdev
@@ -827,7 +872,7 @@ static ssize_t assign_adapter_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If the KVM guest is running, disallow assignment of adapter */
if (matrix_mdev->kvm) {
@@ -859,7 +904,7 @@ static ssize_t assign_adapter_store(struct device *dev,
matrix_mdev->matrix.aqm, matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
@@ -902,7 +947,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
unsigned long apid;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If the KVM guest is running, disallow unassignment of adapter */
if (matrix_mdev->kvm) {
@@ -927,7 +972,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
static DEVICE_ATTR_WO(unassign_adapter);
@@ -982,7 +1027,7 @@ static ssize_t assign_domain_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_apqi = matrix_mdev->matrix.aqm_max;
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If the KVM guest is running, disallow assignment of domain */
if (matrix_mdev->kvm) {
@@ -1013,7 +1058,7 @@ static ssize_t assign_domain_store(struct device *dev,
matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
@@ -1056,7 +1101,7 @@ static ssize_t unassign_domain_store(struct device *dev,
unsigned long apqi;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If the KVM guest is running, disallow unassignment of domain */
if (matrix_mdev->kvm) {
@@ -1082,7 +1127,7 @@ static ssize_t unassign_domain_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
static DEVICE_ATTR_WO(unassign_domain);
@@ -1109,7 +1154,7 @@ static ssize_t assign_control_domain_store(struct device *dev,
unsigned long id;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If the KVM guest is running, disallow assignment of control domain */
if (matrix_mdev->kvm) {
@@ -1135,7 +1180,7 @@ static ssize_t assign_control_domain_store(struct device *dev,
vfio_ap_mdev_filter_cdoms(matrix_mdev);
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
static DEVICE_ATTR_WO(assign_control_domain);
@@ -1163,7 +1208,7 @@ static ssize_t unassign_control_domain_store(struct device *dev,
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_domid = matrix_mdev->matrix.adm_max;
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_mdev(matrix_mdev);
/* If a KVM guest is running, disallow unassignment of control domain */
if (matrix_mdev->kvm) {
@@ -1186,7 +1231,7 @@ static ssize_t unassign_control_domain_store(struct device *dev,
ret = count;
done:
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return ret;
}
static DEVICE_ATTR_WO(unassign_control_domain);
--
2.31.1
Let's hot plug an adapter, domain or control domain into the guest when it
is assigned to a matrix mdev that is attached to a KVM guest. Likewise,
let's hot unplug an adapter, domain or control domain from the guest when
it is unassigned from a matrix_mdev that is attached to a KVM guest.
Whenever an assignment or unassignment of an adapter, domain or control
domain is performed, the APQNs and control domains assigned to the matrix
mdev will be filtered and assigned to the AP control block
(APCB) that supplies the AP configuration to the guest so that no
adapter, domain or control domain that is not in the host's AP
configuration nor any APQN that does not reference a queue device bound
to the vfio_ap device driver is assigned.
After updating the APCB, if the mdev is in use by a KVM guest, it is
hot plugged into the guest to dynamically provide access to the adapters,
domains and control domains provided via the newly refreshed APCB.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 112 +++++++++++++++---------------
1 file changed, 57 insertions(+), 55 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 080a733f7cd2..47f808122ed2 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -600,10 +600,25 @@ static void vfio_ap_matrix_init(struct ap_config_info *info,
matrix->adm_max = info->apxa ? info->Nd : 15;
}
-static void vfio_ap_mdev_filter_cdoms(struct ap_matrix_mdev *matrix_mdev)
+static void vfio_ap_mdev_update_guest_apcb(struct ap_matrix_mdev *matrix_mdev)
{
+ if (matrix_mdev->kvm)
+ kvm_arch_crypto_set_masks(matrix_mdev->kvm,
+ matrix_mdev->shadow_apcb.apm,
+ matrix_mdev->shadow_apcb.aqm,
+ matrix_mdev->shadow_apcb.adm);
+}
+
+static bool vfio_ap_mdev_filter_cdoms(struct ap_matrix_mdev *matrix_mdev)
+{
+ DECLARE_BITMAP(prev_shadow_adm, AP_DOMAINS);
+
+ bitmap_copy(prev_shadow_adm, matrix_mdev->shadow_apcb.adm, AP_DOMAINS);
bitmap_and(matrix_mdev->shadow_apcb.adm, matrix_mdev->matrix.adm,
(unsigned long *)matrix_dev->info.adm, AP_DOMAINS);
+
+ return !bitmap_equal(prev_shadow_adm, matrix_mdev->shadow_apcb.adm,
+ AP_DOMAINS);
}
/*
@@ -618,17 +633,24 @@ static void vfio_ap_mdev_filter_cdoms(struct ap_matrix_mdev *matrix_mdev)
* driver, its APID will be filtered from the guest's APCB. The matrix
* structure precludes filtering an individual APQN, so its APID will be
* filtered.
+ *
+ * Return: a boolean value indicating whether the KVM guest's APCB was changed
+ * by the filtering or not.
*/
-static void vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
+static bool vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
struct ap_matrix_mdev *matrix_mdev)
{
int ret;
unsigned long apid, apqi, apqn;
+ DECLARE_BITMAP(prev_shadow_apm, AP_DEVICES);
+ DECLARE_BITMAP(prev_shadow_aqm, AP_DOMAINS);
ret = ap_qci(&matrix_dev->info);
if (ret)
- return;
+ return false;
+ bitmap_copy(prev_shadow_apm, matrix_mdev->shadow_apcb.apm, AP_DEVICES);
+ bitmap_copy(prev_shadow_aqm, matrix_mdev->shadow_apcb.aqm, AP_DOMAINS);
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
/*
@@ -660,6 +682,11 @@ static void vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
}
}
}
+
+ return !bitmap_equal(prev_shadow_apm, matrix_mdev->shadow_apcb.apm,
+ AP_DEVICES) ||
+ !bitmap_equal(prev_shadow_aqm, matrix_mdev->shadow_apcb.aqm,
+ AP_DOMAINS);
}
static int vfio_ap_mdev_probe(struct mdev_device *mdev)
@@ -936,17 +963,10 @@ static ssize_t assign_adapter_store(struct device *dev,
int ret;
unsigned long apid;
DECLARE_BITMAP(apm_delta, AP_DEVICES);
-
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
get_update_locks_for_mdev(matrix_mdev);
- /* If the KVM guest is running, disallow assignment of adapter */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &apid);
if (ret)
goto done;
@@ -967,8 +987,11 @@ static ssize_t assign_adapter_store(struct device *dev,
vfio_ap_mdev_link_adapter(matrix_mdev, apid);
memset(apm_delta, 0, sizeof(apm_delta));
set_bit_inv(apid, apm_delta);
- vfio_ap_mdev_filter_matrix(apm_delta,
- matrix_mdev->matrix.aqm, matrix_mdev);
+
+ if (vfio_ap_mdev_filter_matrix(apm_delta,
+ matrix_mdev->matrix.aqm, matrix_mdev))
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
@@ -1016,12 +1039,6 @@ static ssize_t unassign_adapter_store(struct device *dev,
get_update_locks_for_mdev(matrix_mdev);
- /* If the KVM guest is running, disallow unassignment of adapter */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &apid);
if (ret)
goto done;
@@ -1034,8 +1051,10 @@ static ssize_t unassign_adapter_store(struct device *dev,
clear_bit_inv((unsigned long)apid, matrix_mdev->matrix.apm);
vfio_ap_mdev_unlink_adapter(matrix_mdev, apid);
- if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm))
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm)) {
clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
ret = count;
done:
@@ -1092,20 +1111,14 @@ static ssize_t assign_domain_store(struct device *dev,
unsigned long apqi;
DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- unsigned long max_apqi = matrix_mdev->matrix.aqm_max;
get_update_locks_for_mdev(matrix_mdev);
- /* If the KVM guest is running, disallow assignment of domain */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &apqi);
if (ret)
goto done;
- if (apqi > max_apqi) {
+
+ if (apqi > matrix_mdev->matrix.aqm_max) {
ret = -ENODEV;
goto done;
}
@@ -1121,8 +1134,11 @@ static ssize_t assign_domain_store(struct device *dev,
vfio_ap_mdev_link_domain(matrix_mdev, apqi);
memset(aqm_delta, 0, sizeof(aqm_delta));
set_bit_inv(apqi, aqm_delta);
- vfio_ap_mdev_filter_matrix(matrix_mdev->matrix.apm, aqm_delta,
- matrix_mdev);
+
+ if (vfio_ap_mdev_filter_matrix(matrix_mdev->matrix.apm, aqm_delta,
+ matrix_mdev))
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
@@ -1170,12 +1186,6 @@ static ssize_t unassign_domain_store(struct device *dev,
get_update_locks_for_mdev(matrix_mdev);
- /* If the KVM guest is running, disallow unassignment of domain */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &apqi);
if (ret)
goto done;
@@ -1188,8 +1198,10 @@ static ssize_t unassign_domain_store(struct device *dev,
clear_bit_inv((unsigned long)apqi, matrix_mdev->matrix.aqm);
vfio_ap_mdev_unlink_domain(matrix_mdev, apqi);
- if (test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm))
+ if (test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm)) {
clear_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
ret = count;
@@ -1223,12 +1235,6 @@ static ssize_t assign_control_domain_store(struct device *dev,
get_update_locks_for_mdev(matrix_mdev);
- /* If the KVM guest is running, disallow assignment of control domain */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &id);
if (ret)
goto done;
@@ -1244,7 +1250,9 @@ static ssize_t assign_control_domain_store(struct device *dev,
* number of control domains that can be assigned.
*/
set_bit_inv(id, matrix_mdev->matrix.adm);
- vfio_ap_mdev_filter_cdoms(matrix_mdev);
+ if (vfio_ap_mdev_filter_cdoms(matrix_mdev))
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
@@ -1273,28 +1281,24 @@ static ssize_t unassign_control_domain_store(struct device *dev,
int ret;
unsigned long domid;
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
- unsigned long max_domid = matrix_mdev->matrix.adm_max;
get_update_locks_for_mdev(matrix_mdev);
- /* If a KVM guest is running, disallow unassignment of control domain */
- if (matrix_mdev->kvm) {
- ret = -EBUSY;
- goto done;
- }
-
ret = kstrtoul(buf, 0, &domid);
if (ret)
goto done;
- if (domid > max_domid) {
+
+ if (domid > matrix_mdev->matrix.adm_max) {
ret = -ENODEV;
goto done;
}
clear_bit_inv(domid, matrix_mdev->matrix.adm);
- if (test_bit_inv(domid, matrix_mdev->shadow_apcb.adm))
+ if (test_bit_inv(domid, matrix_mdev->shadow_apcb.adm)) {
clear_bit_inv(domid, matrix_mdev->shadow_apcb.adm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
ret = count;
done:
@@ -1427,9 +1431,7 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
kvm_get_kvm(kvm);
matrix_mdev->kvm = kvm;
- kvm_arch_crypto_set_masks(kvm, matrix_mdev->shadow_apcb.apm,
- matrix_mdev->shadow_apcb.aqm,
- matrix_mdev->shadow_apcb.adm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
release_update_locks_for_kvm(kvm);
}
--
2.31.1
Refresh the guest's APCB by filtering the APQNs and control domain numbers
assigned to the matrix mdev.
Filtering of APQNs:
-----------------
APQNs that do not reference an AP queue device bound to the vfio_ap device
driver must be filtered from the APQNs assigned to the matrix mdev before
they can be assigned to the guest's APCB. Given that the APQNs are
configured in the guest's APCB as a matrix of APIDs (adapters) and APQIs
(domains), it is not possible to filter an individual APQN. For example,
suppose the matrix of APQNs is structured as follows:
APIDs
3 4 5
0 (3,0) (4,0) (5,0)
APQIs 1 (3,1) (4,1) (5,1)
2 (3,2) (4,2) (5,2)
Now suppose APQN (4,1) does not reference a queue device bound to the
vfio_ap device driver. If we filter APID 4, the APQNs (4,0), (4,1) and
(4,2) will be removed. Similarly, if we filter domain 1, APQNs (3,1),
(4,1) and (5,1) will be removed.
To resolve this dilemma, the choice was made to filter the APID - in this
case 4 - from the guest's APCB. The reason for this design decision is
because the APID references an AP adapter which is a real hardware device
that can be physically installed, removed, enabled or disabled; whereas, a
domain is a partition within the adapter. It therefore better reflects
reality to remove the APID from the guest's APCB.
Filtering of control domains:
----------------------------
Any control domains that are not assigned to the host's AP configuration
will be filtered from those assigned to the matrix mdev before assigning
them to the guest's APCB.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 104 +++++++++++++++++++++++++++++-
1 file changed, 101 insertions(+), 3 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 9c4a3ad5369a..e53e69a033b0 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -444,6 +444,68 @@ static void vfio_ap_matrix_init(struct ap_config_info *info,
matrix->adm_max = info->apxa ? info->Nd : 15;
}
+static void vfio_ap_mdev_filter_cdoms(struct ap_matrix_mdev *matrix_mdev)
+{
+ bitmap_and(matrix_mdev->shadow_apcb.adm, matrix_mdev->matrix.adm,
+ (unsigned long *)matrix_dev->info.adm, AP_DOMAINS);
+}
+
+/*
+ * vfio_ap_mdev_filter_matrix - filter the APQNs assigned to the matrix mdev
+ * to ensure no queue devices are passed through to
+ * the guest that are not bound to the vfio_ap
+ * device driver.
+ *
+ * @matrix_mdev: the matrix mdev whose matrix is to be filtered.
+ *
+ * Note: If an APQN referencing a queue device that is not bound to the vfio_ap
+ * driver, its APID will be filtered from the guest's APCB. The matrix
+ * structure precludes filtering an individual APQN, so its APID will be
+ * filtered.
+ */
+static void vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
+ struct ap_matrix_mdev *matrix_mdev)
+{
+ int ret;
+ unsigned long apid, apqi, apqn;
+
+ ret = ap_qci(&matrix_dev->info);
+ if (ret)
+ return;
+
+ vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
+
+ /*
+ * Copy the adapters, domains and control domains to the shadow_apcb
+ * from the matrix mdev, but only those that are assigned to the host's
+ * AP configuration.
+ */
+ bitmap_and(matrix_mdev->shadow_apcb.apm, matrix_mdev->matrix.apm,
+ (unsigned long *)matrix_dev->info.apm, AP_DEVICES);
+ bitmap_and(matrix_mdev->shadow_apcb.aqm, matrix_mdev->matrix.aqm,
+ (unsigned long *)matrix_dev->info.aqm, AP_DOMAINS);
+
+ for_each_set_bit_inv(apid, apm, AP_DEVICES) {
+ for_each_set_bit_inv(apqi, aqm, AP_DOMAINS) {
+ /*
+ * If the APQN is not bound to the vfio_ap device
+ * driver, then we can't assign it to the guest's
+ * AP configuration. The AP architecture won't
+ * allow filtering of a single APQN, so let's filter
+ * the APID since an adapter represents a physical
+ * hardware device.
+ */
+ apqn = AP_MKQID(apid, apqi);
+
+ if (!vfio_ap_mdev_get_queue(matrix_mdev, apqn)) {
+ clear_bit_inv(apid,
+ matrix_mdev->shadow_apcb.apm);
+ break;
+ }
+ }
+ }
+}
+
static int vfio_ap_mdev_probe(struct mdev_device *mdev)
{
struct ap_matrix_mdev *matrix_mdev;
@@ -799,6 +861,8 @@ static ssize_t assign_adapter_store(struct device *dev,
{
int ret;
unsigned long apid;
+ DECLARE_BITMAP(apm_delta, AP_DEVICES);
+
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
mutex_lock(&matrix_dev->lock);
@@ -834,6 +898,10 @@ static ssize_t assign_adapter_store(struct device *dev,
goto share_err;
vfio_ap_mdev_link_adapter(matrix_mdev, apid);
+ memset(apm_delta, 0, sizeof(apm_delta));
+ set_bit_inv(apid, apm_delta);
+ vfio_ap_mdev_filter_matrix(apm_delta,
+ matrix_mdev->matrix.aqm, matrix_mdev);
ret = count;
goto done;
@@ -902,6 +970,10 @@ static ssize_t unassign_adapter_store(struct device *dev,
clear_bit_inv((unsigned long)apid, matrix_mdev->matrix.apm);
vfio_ap_mdev_unlink_adapter(matrix_mdev, apid);
+
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm))
+ clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
+
ret = count;
done:
mutex_unlock(&matrix_dev->lock);
@@ -975,6 +1047,7 @@ static ssize_t assign_domain_store(struct device *dev,
{
int ret;
unsigned long apqi;
+ DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
unsigned long max_apqi = matrix_mdev->matrix.aqm_max;
@@ -1005,6 +1078,10 @@ static ssize_t assign_domain_store(struct device *dev,
goto share_err;
vfio_ap_mdev_link_domain(matrix_mdev, apqi);
+ memset(aqm_delta, 0, sizeof(aqm_delta));
+ set_bit_inv(apqi, aqm_delta);
+ vfio_ap_mdev_filter_matrix(matrix_mdev->matrix.apm, aqm_delta,
+ matrix_mdev);
ret = count;
goto done;
@@ -1073,6 +1150,10 @@ static ssize_t unassign_domain_store(struct device *dev,
clear_bit_inv((unsigned long)apqi, matrix_mdev->matrix.aqm);
vfio_ap_mdev_unlink_domain(matrix_mdev, apqi);
+
+ if (test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm))
+ clear_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm);
+
ret = count;
done:
@@ -1126,6 +1207,7 @@ static ssize_t assign_control_domain_store(struct device *dev,
* number of control domains that can be assigned.
*/
set_bit_inv(id, matrix_mdev->matrix.adm);
+ vfio_ap_mdev_filter_cdoms(matrix_mdev);
ret = count;
done:
mutex_unlock(&matrix_dev->lock);
@@ -1173,6 +1255,10 @@ static ssize_t unassign_control_domain_store(struct device *dev,
}
clear_bit_inv(domid, matrix_mdev->matrix.adm);
+
+ if (test_bit_inv(domid, matrix_mdev->shadow_apcb.adm))
+ clear_bit_inv(domid, matrix_mdev->shadow_apcb.adm);
+
ret = count;
done:
mutex_unlock(&matrix_dev->lock);
@@ -1306,8 +1392,6 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
kvm_get_kvm(kvm);
matrix_mdev->kvm = kvm;
- memcpy(&matrix_mdev->shadow_apcb, &matrix_mdev->matrix,
- sizeof(struct ap_matrix));
kvm_arch_crypto_set_masks(kvm, matrix_mdev->shadow_apcb.apm,
matrix_mdev->shadow_apcb.aqm,
matrix_mdev->shadow_apcb.adm);
@@ -1641,6 +1725,7 @@ static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
{
struct vfio_ap_queue *q;
+ DECLARE_BITMAP(apm_delta, AP_DEVICES);
q = kzalloc(sizeof(*q), GFP_KERNEL);
if (!q)
@@ -1649,6 +1734,13 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
q->apqn = to_ap_queue(&apdev->device)->qid;
q->saved_isc = VFIO_AP_ISC_INVALID;
vfio_ap_queue_link_mdev(q);
+ if (q->matrix_mdev) {
+ memset(apm_delta, 0, sizeof(apm_delta));
+ set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
+ vfio_ap_mdev_filter_matrix(apm_delta,
+ q->matrix_mdev->matrix.aqm,
+ q->matrix_mdev);
+ }
dev_set_drvdata(&apdev->device, q);
mutex_unlock(&matrix_dev->lock);
@@ -1657,14 +1749,20 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
{
+ unsigned long apid;
struct vfio_ap_queue *q;
mutex_lock(&matrix_dev->lock);
q = dev_get_drvdata(&apdev->device);
- if (q->matrix_mdev)
+ if (q->matrix_mdev) {
vfio_ap_unlink_queue_fr_mdev(q);
+ apid = AP_QID_CARD(q->apqn);
+ if (test_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm))
+ clear_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm);
+ }
+
vfio_ap_mdev_reset_queue(q, 1);
dev_set_drvdata(&apdev->device, NULL);
kfree(q);
--
2.31.1
The group notifier that handles the VFIO_GROUP_NOTIFY_SET_KVM event must
use the required locks in proper locking order to dynamically update the
guest's APCB. The proper locking order is:
1. matrix_dev->guests_lock: required to use the KVM pointer to
update a KVM guest's APCB.
2. matrix_mdev->kvm->lock: required to update a KVM guest's APCB.
3. matrix_dev->mdevs_lock: required to store or access the data
stored in a struct ap_matrix_mdev instance.
Two macros are introduced to acquire and release the locks in the proper
order. These macros are now used by the group notifier functions.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 56 +++++++++++++++++++++++++------
1 file changed, 46 insertions(+), 10 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 077b8c9c831b..757bbf449b04 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -30,6 +30,47 @@ static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev);
static struct vfio_ap_queue *vfio_ap_find_queue(int apqn);
static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
+/**
+ * get_update_locks_for_kvm: Acquire the locks required to dynamically update a
+ * KVM guest's APCB in the proper order.
+ *
+ * @kvm: a pointer to a struct kvm object containing the KVM guest's APCB.
+ *
+ * The proper locking order is:
+ * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
+ * guest's APCB.
+ * 2. kvm->lock: required to update a guest's APCB
+ * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
+ *
+ * Note: If @kvm is NULL, the KVM lock will not be taken.
+ */
+#define get_update_locks_for_kvm(kvm) ({ \
+ mutex_lock(&matrix_dev->guests_lock); \
+ if (kvm) \
+ mutex_lock(&kvm->lock); \
+ mutex_lock(&matrix_dev->mdevs_lock); \
+})
+
+/**
+ * release_update_locks_for_kvm: Release the locks used to dynamically update a
+ * KVM guest's APCB in the proper order.
+ *
+ * @kvm: a pointer to a struct kvm object containing the KVM guest's APCB.
+ *
+ * The proper unlocking order is:
+ * 1. matrix_dev->mdevs_lock
+ * 2. kvm->lock
+ * 3. matrix_dev->guests_lock
+ *
+ * Note: If @kvm is NULL, the KVM lock will not be released.
+ */
+#define release_update_locks_for_kvm(kvm) ({ \
+ mutex_unlock(&matrix_dev->mdevs_lock); \
+ if (kvm) \
+ mutex_unlock(&kvm->lock); \
+ mutex_unlock(&matrix_dev->guests_lock); \
+})
+
/**
* vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
* hash table of queues assigned to a matrix mdev
@@ -1263,13 +1304,11 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
kvm->arch.crypto.pqap_hook = &matrix_mdev->pqap_hook;
up_write(&kvm->arch.crypto.pqap_hook_rwsem);
- mutex_lock(&kvm->lock);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_kvm(kvm);
list_for_each_entry(m, &matrix_dev->mdev_list, node) {
if (m != matrix_mdev && m->kvm == kvm) {
- mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_kvm(kvm);
return -EPERM;
}
}
@@ -1280,8 +1319,7 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
matrix_mdev->shadow_apcb.aqm,
matrix_mdev->shadow_apcb.adm);
- mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_kvm(kvm);
}
return 0;
@@ -1332,16 +1370,14 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev)
kvm->arch.crypto.pqap_hook = NULL;
up_write(&kvm->arch.crypto.pqap_hook_rwsem);
- mutex_lock(&kvm->lock);
- mutex_lock(&matrix_dev->mdevs_lock);
+ get_update_locks_for_kvm(kvm);
kvm_arch_crypto_clear_masks(kvm);
vfio_ap_mdev_reset_queues(matrix_mdev);
kvm_put_kvm(kvm);
matrix_mdev->kvm = NULL;
- mutex_unlock(&kvm->lock);
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_kvm(kvm);
}
}
--
2.31.1
The APCB is a field within the CRYCB that provides the AP configuration
to a KVM guest. Let's introduce a shadow copy of the KVM guest's APCB and
maintain it for the lifespan of the guest.
The shadow APCB serves the following purposes:
1. The shadow APCB can be maintained even when the mediated device is not
currently in use by a KVM guest. Since the mediated device's AP
configuration is filtered to ensure that no AP queues are passed through
to the KVM guest that are not bound to the vfio_ap device driver or
available to the host, the mediated device's AP configuration may differ
from the guest's. Having a shadow of a guest's APCB allows us to provide
a sysfs interface to view the guest's APCB even if the mediated device
is not currently passed through to a KVM guest. This can aid in
problem determination when the guest is unexpectedly missing AP
resources.
2. If filtering was done in-place for the real APCB, the guest could pick
up a transient state. Doing the filtering on a shadow and transferring
the AP configuration to the real APCB after the guest is started or when
AP resources are assigned to or unassigned from the mediated device, or
when the host configuration changes, the guest's AP configuration will
never be in a transient state.
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Halil Pasic <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 10 ++++++----
drivers/s390/crypto/vfio_ap_private.h | 2 ++
2 files changed, 8 insertions(+), 4 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 9df7ceb50ed1..9c4a3ad5369a 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -463,6 +463,7 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
matrix_mdev->mdev = mdev;
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->matrix);
matrix_mdev->pqap_hook = handle_pqap;
+ vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
hash_init(matrix_mdev->qtable.queues);
mdev_set_drvdata(mdev, matrix_mdev);
mutex_lock(&matrix_dev->lock);
@@ -1305,10 +1306,11 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
kvm_get_kvm(kvm);
matrix_mdev->kvm = kvm;
- kvm_arch_crypto_set_masks(kvm,
- matrix_mdev->matrix.apm,
- matrix_mdev->matrix.aqm,
- matrix_mdev->matrix.adm);
+ memcpy(&matrix_mdev->shadow_apcb, &matrix_mdev->matrix,
+ sizeof(struct ap_matrix));
+ kvm_arch_crypto_set_masks(kvm, matrix_mdev->shadow_apcb.apm,
+ matrix_mdev->shadow_apcb.aqm,
+ matrix_mdev->shadow_apcb.adm);
mutex_unlock(&kvm->lock);
mutex_unlock(&matrix_dev->lock);
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index aea6a8b854b3..fa11a7e91e24 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -91,6 +91,7 @@ struct ap_queue_table {
* @node: allows the ap_matrix_mdev struct to be added to a list
* @matrix: the adapters, usage domains and control domains assigned to the
* mediated matrix device.
+ * @shadow_apcb: the shadow copy of the APCB field of the KVM guest's CRYCB
* @group_notifier: notifier block used for specifying callback function for
* handling the VFIO_GROUP_NOTIFY_SET_KVM event
* @iommu_notifier: notifier block used for specifying callback function for
@@ -105,6 +106,7 @@ struct ap_matrix_mdev {
struct vfio_device vdev;
struct list_head node;
struct ap_matrix matrix;
+ struct ap_matrix shadow_apcb;
struct notifier_block group_notifier;
struct notifier_block iommu_notifier;
struct kvm *kvm;
--
2.31.1
Let's move the probe and remove callbacks into the vfio_ap_ops.c
file to keep all code related to managing queues in a single file. This
way, all functions related to queue management can be removed from the
vfio_ap_private.h header file defining the public interfaces for the
vfio_ap device driver.
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Halil Pasic <[email protected]>
---
drivers/s390/crypto/vfio_ap_drv.c | 59 +--------------------------
drivers/s390/crypto/vfio_ap_ops.c | 31 +++++++++++++-
drivers/s390/crypto/vfio_ap_private.h | 5 ++-
3 files changed, 34 insertions(+), 61 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
index 29ebd54f8919..9a300dd3b6f7 100644
--- a/drivers/s390/crypto/vfio_ap_drv.c
+++ b/drivers/s390/crypto/vfio_ap_drv.c
@@ -104,64 +104,9 @@ static const struct attribute_group vfio_queue_attr_group = {
.attrs = vfio_queue_attrs,
};
-/**
- * vfio_ap_queue_dev_probe: Allocate a vfio_ap_queue structure and associate it
- * with the device as driver_data.
- *
- * @apdev: the AP device being probed
- *
- * Return: returns 0 if the probe succeeded; otherwise, returns an error if
- * storage could not be allocated for a vfio_ap_queue object or the
- * sysfs 'status' attribute could not be created for the queue device.
- */
-static int vfio_ap_queue_dev_probe(struct ap_device *apdev)
-{
- int ret;
- struct vfio_ap_queue *q;
-
- q = kzalloc(sizeof(*q), GFP_KERNEL);
- if (!q)
- return -ENOMEM;
-
- mutex_lock(&matrix_dev->lock);
- dev_set_drvdata(&apdev->device, q);
- q->apqn = to_ap_queue(&apdev->device)->qid;
- q->saved_isc = VFIO_AP_ISC_INVALID;
-
- ret = sysfs_create_group(&apdev->device.kobj, &vfio_queue_attr_group);
- if (ret) {
- dev_set_drvdata(&apdev->device, NULL);
- kfree(q);
- }
-
- mutex_unlock(&matrix_dev->lock);
-
- return ret;
-}
-
-/**
- * vfio_ap_queue_dev_remove: Free the associated vfio_ap_queue structure.
- *
- * @apdev: the AP device being removed
- *
- * Takes the matrix lock to avoid actions on this device while doing the remove.
- */
-static void vfio_ap_queue_dev_remove(struct ap_device *apdev)
-{
- struct vfio_ap_queue *q;
-
- mutex_lock(&matrix_dev->lock);
- sysfs_remove_group(&apdev->device.kobj, &vfio_queue_attr_group);
- q = dev_get_drvdata(&apdev->device);
- vfio_ap_mdev_reset_queue(q, 1);
- dev_set_drvdata(&apdev->device, NULL);
- kfree(q);
- mutex_unlock(&matrix_dev->lock);
-}
-
static struct ap_driver vfio_ap_drv = {
- .probe = vfio_ap_queue_dev_probe,
- .remove = vfio_ap_queue_dev_remove,
+ .probe = vfio_ap_mdev_probe_queue,
+ .remove = vfio_ap_mdev_remove_queue,
.ids = ap_queue_ids,
};
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 2227919fde13..16220157dbe3 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -1314,8 +1314,7 @@ static struct vfio_ap_queue *vfio_ap_find_queue(int apqn)
return q;
}
-int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
- unsigned int retry)
+static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
{
struct ap_queue_status status;
int ret;
@@ -1524,3 +1523,31 @@ void vfio_ap_mdev_unregister(void)
mdev_unregister_device(&matrix_dev->device);
mdev_unregister_driver(&vfio_ap_matrix_driver);
}
+
+int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
+{
+ struct vfio_ap_queue *q;
+
+ q = kzalloc(sizeof(*q), GFP_KERNEL);
+ if (!q)
+ return -ENOMEM;
+ mutex_lock(&matrix_dev->lock);
+ q->apqn = to_ap_queue(&apdev->device)->qid;
+ q->saved_isc = VFIO_AP_ISC_INVALID;
+ dev_set_drvdata(&apdev->device, q);
+ mutex_unlock(&matrix_dev->lock);
+
+ return 0;
+}
+
+void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
+{
+ struct vfio_ap_queue *q;
+
+ mutex_lock(&matrix_dev->lock);
+ q = dev_get_drvdata(&apdev->device);
+ vfio_ap_mdev_reset_queue(q, 1);
+ dev_set_drvdata(&apdev->device, NULL);
+ kfree(q);
+ mutex_unlock(&matrix_dev->lock);
+}
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index 648fcaf8104a..3cade25a1620 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -119,7 +119,8 @@ struct vfio_ap_queue {
int vfio_ap_mdev_register(void);
void vfio_ap_mdev_unregister(void);
-int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
- unsigned int retry);
+
+int vfio_ap_mdev_probe_queue(struct ap_device *queue);
+void vfio_ap_mdev_remove_queue(struct ap_device *queue);
#endif /* _VFIO_AP_PRIVATE_H_ */
--
2.31.1
The callback functions for probing and removing a queue device must take
and release the locks required to perform a dynamic update of a guest's
APCB in the proper order.
The proper order for taking the locks is:
matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
The proper order for releasing the locks is:
matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
A new helper function is introduced to be used by the probe callback to
acquire the required locks. Since the probe callback only has
access to a queue device when it is called, the helper function will find
the ap_matrix_mdev object to which the queue device's APQN is assigned and
return it so the KVM guest to which the mdev is attached can be dynamically
updated.
Note that in order to find the ap_matrix_mdev (matrix_mdev) object, it is
necessary to search the matrix_dev->mdev_list. This presents a
locking order dilemma because the matrix_dev->mdevs_lock can't be taken to
protect against changes to the list while searching for the matrix_mdev to
which a queue device's APQN is assigned. This is due to the fact that the
proper locking order requires that the matrix_dev->mdevs_lock be taken
after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
Consequently, the matrix_dev->guests_lock will be used to protect against
removal of a matrix_mdev object from the list while a queue device is
being probed. This necessitates changes to the mdev probe/remove
callback functions to take the matrix_dev->guests_lock prior to removing
a matrix_mdev object from the list.
A new macro is also introduced to acquire the locks required to dynamically
update the guest's APCB in the proper order when a queue device is
removed.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
1 file changed, 88 insertions(+), 38 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 2219b1069ceb..080a733f7cd2 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -116,6 +116,74 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
mutex_unlock(&matrix_dev->guests_lock); \
})
+/**
+ * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev to which an
+ * APQN is assigned and acquire the
+ * locks required to update the APCB of
+ * the KVM guest to which the mdev is
+ * attached.
+ *
+ * @apqn: the APQN of a queue device.
+ *
+ * The proper locking order is:
+ * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
+ * guest's APCB.
+ * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
+ * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
+ *
+ * Note: If @apqn is not assigned to a matrix_mdev, the matrix_mdev->kvm->lock
+ * will not be taken.
+ *
+ * Return: the ap_matrix_mdev object to which @apqn is assigned or NULL if @apqn
+ * is not assigned to an ap_matrix_mdev.
+ */
+static struct ap_matrix_mdev *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
+{
+ struct ap_matrix_mdev *matrix_mdev;
+
+ mutex_lock(&matrix_dev->guests_lock);
+
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ if (test_bit_inv(AP_QID_CARD(apqn), matrix_mdev->matrix.apm) &&
+ test_bit_inv(AP_QID_QUEUE(apqn), matrix_mdev->matrix.aqm)) {
+ if (matrix_mdev->kvm)
+ mutex_lock(&matrix_mdev->kvm->lock);
+
+ mutex_lock(&matrix_dev->mdevs_lock);
+
+ return matrix_mdev;
+ }
+ }
+
+ mutex_lock(&matrix_dev->mdevs_lock);
+
+ return NULL;
+}
+
+/**
+ * get_update_locks_for_queue: get the locks required to update the APCB of the
+ * KVM guest to which the matrix mdev linked to a
+ * vfio_ap_queue object is attached.
+ *
+ * @queue: a pointer to a vfio_ap_queue object.
+ *
+ * The proper locking order is:
+ * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
+ * guest's APCB.
+ * 2. queue->matrix_mdev->kvm->lock: required to update a guest's APCB
+ * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
+ *
+ * Note: if @queue is not linked to an ap_matrix_mdev object, the KVM lock
+ * will not be taken.
+ */
+#define get_update_locks_for_queue(queue) ({ \
+ struct ap_matrix_mdev *matrix_mdev = q->matrix_mdev; \
+ mutex_lock(&matrix_dev->guests_lock); \
+ if (matrix_mdev && matrix_mdev->kvm) \
+ mutex_lock(&matrix_mdev->kvm->lock); \
+ mutex_lock(&matrix_dev->mdevs_lock); \
+})
+
/**
* vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
* hash table of queues assigned to a matrix mdev
@@ -615,21 +683,18 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
matrix_mdev->pqap_hook = handle_pqap;
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
hash_init(matrix_mdev->qtable.queues);
- mdev_set_drvdata(mdev, matrix_mdev);
- mutex_lock(&matrix_dev->mdevs_lock);
- list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
- mutex_unlock(&matrix_dev->mdevs_lock);
ret = vfio_register_emulated_iommu_dev(&matrix_mdev->vdev);
if (ret)
goto err_list;
+ mdev_set_drvdata(mdev, matrix_mdev);
+ mutex_lock(&matrix_dev->mdevs_lock);
+ list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
+ mutex_unlock(&matrix_dev->mdevs_lock);
dev_set_drvdata(&mdev->dev, matrix_mdev);
return 0;
err_list:
- mutex_lock(&matrix_dev->mdevs_lock);
- list_del(&matrix_mdev->node);
- mutex_unlock(&matrix_dev->mdevs_lock);
vfio_uninit_group_dev(&matrix_mdev->vdev);
kfree(matrix_mdev);
err_dec_available:
@@ -692,11 +757,13 @@ static void vfio_ap_mdev_remove(struct mdev_device *mdev)
vfio_unregister_group_dev(&matrix_mdev->vdev);
+ mutex_lock(&matrix_dev->guests_lock);
mutex_lock(&matrix_dev->mdevs_lock);
vfio_ap_mdev_reset_queues(matrix_mdev);
vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
list_del(&matrix_mdev->node);
mutex_unlock(&matrix_dev->mdevs_lock);
+ mutex_unlock(&matrix_dev->guests_lock);
vfio_uninit_group_dev(&matrix_mdev->vdev);
kfree(matrix_mdev);
atomic_inc(&matrix_dev->available_instances);
@@ -1665,49 +1732,30 @@ void vfio_ap_mdev_unregister(void)
mdev_unregister_driver(&vfio_ap_matrix_driver);
}
-/*
- * vfio_ap_queue_link_mdev
- *
- * @q: The queue to link with the matrix mdev.
- *
- * Links @q with the matrix mdev to which the queue's APQN is assigned.
- */
-static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
-{
- unsigned long apid = AP_QID_CARD(q->apqn);
- unsigned long apqi = AP_QID_QUEUE(q->apqn);
- struct ap_matrix_mdev *matrix_mdev;
-
- list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
- if (test_bit_inv(apid, matrix_mdev->matrix.apm) &&
- test_bit_inv(apqi, matrix_mdev->matrix.aqm)) {
- vfio_ap_mdev_link_queue(matrix_mdev, q);
- break;
- }
- }
-}
-
int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
{
struct vfio_ap_queue *q;
+ struct ap_matrix_mdev *matrix_mdev;
DECLARE_BITMAP(apm_delta, AP_DEVICES);
q = kzalloc(sizeof(*q), GFP_KERNEL);
if (!q)
return -ENOMEM;
- mutex_lock(&matrix_dev->mdevs_lock);
q->apqn = to_ap_queue(&apdev->device)->qid;
q->saved_isc = VFIO_AP_ISC_INVALID;
- vfio_ap_queue_link_mdev(q);
- if (q->matrix_mdev) {
+
+ matrix_mdev = vfio_ap_mdev_get_update_locks_for_apqn(q->apqn);
+
+ if (matrix_mdev) {
+ vfio_ap_mdev_link_queue(matrix_mdev, q);
memset(apm_delta, 0, sizeof(apm_delta));
set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
vfio_ap_mdev_filter_matrix(apm_delta,
- q->matrix_mdev->matrix.aqm,
- q->matrix_mdev);
+ matrix_mdev->matrix.aqm,
+ matrix_mdev);
}
dev_set_drvdata(&apdev->device, q);
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
return 0;
}
@@ -1716,11 +1764,13 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
{
unsigned long apid;
struct vfio_ap_queue *q;
+ struct ap_matrix_mdev *matrix_mdev;
- mutex_lock(&matrix_dev->mdevs_lock);
q = dev_get_drvdata(&apdev->device);
+ get_update_locks_for_queue(q);
+ matrix_mdev = q->matrix_mdev;
- if (q->matrix_mdev) {
+ if (matrix_mdev) {
vfio_ap_unlink_queue_fr_mdev(q);
apid = AP_QID_CARD(q->apqn);
@@ -1731,5 +1781,5 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
vfio_ap_mdev_reset_queue(q, 1);
dev_set_drvdata(&apdev->device, NULL);
kfree(q);
- mutex_unlock(&matrix_dev->mdevs_lock);
+ release_update_locks_for_mdev(matrix_mdev);
}
--
2.31.1
The current implementation does not allow assignment of an AP adapter or
domain to an mdev device if each APQN resulting from the assignment
does not reference an AP queue device that is bound to the vfio_ap device
driver. This patch allows assignment of AP resources to the matrix mdev as
long as the APQNs resulting from the assignment:
1. Are not reserved by the AP BUS for use by the zcrypt device drivers.
2. Are not assigned to another matrix mdev.
The rationale behind this is that the AP architecture does not preclude
assignment of APQNs to an AP configuration profile that are not available
to the system.
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Halil Pasic <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 224 +++++++-----------------------
1 file changed, 53 insertions(+), 171 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index e53e69a033b0..f937f38031f0 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -657,141 +657,48 @@ static struct attribute_group *vfio_ap_mdev_type_groups[] = {
NULL,
};
-struct vfio_ap_queue_reserved {
- unsigned long *apid;
- unsigned long *apqi;
- bool reserved;
-};
+#define MDEV_SHARING_ERR "Userspace may not re-assign queue %02lx.%04lx " \
+ "already assigned to %s"
-/**
- * vfio_ap_has_queue - determines if the AP queue containing the target in @data
- *
- * @dev: an AP queue device
- * @data: a struct vfio_ap_queue_reserved reference
- *
- * Flags whether the AP queue device (@dev) has a queue ID containing the APQN,
- * apid or apqi specified in @data:
- *
- * - If @data contains both an apid and apqi value, then @data will be flagged
- * as reserved if the APID and APQI fields for the AP queue device matches
- *
- * - If @data contains only an apid value, @data will be flagged as
- * reserved if the APID field in the AP queue device matches
- *
- * - If @data contains only an apqi value, @data will be flagged as
- * reserved if the APQI field in the AP queue device matches
- *
- * Return: 0 to indicate the input to function succeeded. Returns -EINVAL if
- * @data does not contain either an apid or apqi.
- */
-static int vfio_ap_has_queue(struct device *dev, void *data)
+static void vfio_ap_mdev_log_sharing_err(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long *apm,
+ unsigned long *aqm)
{
- struct vfio_ap_queue_reserved *qres = data;
- struct ap_queue *ap_queue = to_ap_queue(dev);
- ap_qid_t qid;
- unsigned long id;
-
- if (qres->apid && qres->apqi) {
- qid = AP_MKQID(*qres->apid, *qres->apqi);
- if (qid == ap_queue->qid)
- qres->reserved = true;
- } else if (qres->apid && !qres->apqi) {
- id = AP_QID_CARD(ap_queue->qid);
- if (id == *qres->apid)
- qres->reserved = true;
- } else if (!qres->apid && qres->apqi) {
- id = AP_QID_QUEUE(ap_queue->qid);
- if (id == *qres->apqi)
- qres->reserved = true;
- } else {
- return -EINVAL;
- }
-
- return 0;
-}
-
-/**
- * vfio_ap_verify_queue_reserved - verifies that the AP queue containing
- * @apid or @aqpi is reserved
- *
- * @apid: an AP adapter ID
- * @apqi: an AP queue index
- *
- * Verifies that the AP queue with @apid/@apqi is reserved by the VFIO AP device
- * driver according to the following rules:
- *
- * - If both @apid and @apqi are not NULL, then there must be an AP queue
- * device bound to the vfio_ap driver with the APQN identified by @apid and
- * @apqi
- *
- * - If only @apid is not NULL, then there must be an AP queue device bound
- * to the vfio_ap driver with an APQN containing @apid
- *
- * - If only @apqi is not NULL, then there must be an AP queue device bound
- * to the vfio_ap driver with an APQN containing @apqi
- *
- * Return: 0 if the AP queue is reserved; otherwise, returns -EADDRNOTAVAIL.
- */
-static int vfio_ap_verify_queue_reserved(unsigned long *apid,
- unsigned long *apqi)
-{
- int ret;
- struct vfio_ap_queue_reserved qres;
-
- qres.apid = apid;
- qres.apqi = apqi;
- qres.reserved = false;
-
- ret = driver_for_each_device(&matrix_dev->vfio_ap_drv->driver, NULL,
- &qres, vfio_ap_has_queue);
- if (ret)
- return ret;
-
- if (qres.reserved)
- return 0;
-
- return -EADDRNOTAVAIL;
-}
-
-static int
-vfio_ap_mdev_verify_queues_reserved_for_apid(struct ap_matrix_mdev *matrix_mdev,
- unsigned long apid)
-{
- int ret;
- unsigned long apqi;
- unsigned long nbits = matrix_mdev->matrix.aqm_max + 1;
-
- if (find_first_bit_inv(matrix_mdev->matrix.aqm, nbits) >= nbits)
- return vfio_ap_verify_queue_reserved(&apid, NULL);
-
- for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm, nbits) {
- ret = vfio_ap_verify_queue_reserved(&apid, &apqi);
- if (ret)
- return ret;
- }
+ unsigned long apid, apqi;
+ const struct device *dev = mdev_dev(matrix_mdev->mdev);
+ const char *mdev_name = dev_name(dev);
- return 0;
+ for_each_set_bit_inv(apid, apm, AP_DEVICES)
+ for_each_set_bit_inv(apqi, aqm, AP_DOMAINS)
+ dev_warn(dev, MDEV_SHARING_ERR, apid, apqi, mdev_name);
}
/**
- * vfio_ap_mdev_verify_no_sharing - verifies that the AP matrix is not configured
+ * vfio_ap_mdev_verify_no_sharing - verify APQNs are not shared by matrix mdevs
*
- * @matrix_mdev: the mediated matrix device
+ * @mdev_apm: mask indicating the APIDs of the APQNs to be verified
+ * @mdev_aqm: mask indicating the APQIs of the APQNs to be verified
*
- * Verifies that the APQNs derived from the cross product of the AP adapter IDs
- * and AP queue indexes comprising the AP matrix are not configured for another
+ * Verifies that each APQN derived from the Cartesian product of a bitmap of
+ * AP adapter IDs and AP queue indexes is not configured for any matrix
* mediated device. AP queue sharing is not allowed.
*
- * Return: 0 if the APQNs are not shared; otherwise returns -EADDRINUSE.
+ * Return: 0 if the APQNs are not shared; otherwise return -EADDRINUSE.
*/
-static int vfio_ap_mdev_verify_no_sharing(struct ap_matrix_mdev *matrix_mdev)
+static int vfio_ap_mdev_verify_no_sharing(unsigned long *mdev_apm,
+ unsigned long *mdev_aqm)
{
- struct ap_matrix_mdev *lstdev;
+ struct ap_matrix_mdev *matrix_mdev;
DECLARE_BITMAP(apm, AP_DEVICES);
DECLARE_BITMAP(aqm, AP_DOMAINS);
- list_for_each_entry(lstdev, &matrix_dev->mdev_list, node) {
- if (matrix_mdev == lstdev)
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ /*
+ * If the input apm and aqm are fields of the matrix_mdev
+ * object, then move on to the next matrix_mdev.
+ */
+ if (mdev_apm == matrix_mdev->matrix.apm &&
+ mdev_aqm == matrix_mdev->matrix.aqm)
continue;
memset(apm, 0, sizeof(apm));
@@ -801,20 +708,32 @@ static int vfio_ap_mdev_verify_no_sharing(struct ap_matrix_mdev *matrix_mdev)
* We work on full longs, as we can only exclude the leftover
* bits in non-inverse order. The leftover is all zeros.
*/
- if (!bitmap_and(apm, matrix_mdev->matrix.apm,
- lstdev->matrix.apm, AP_DEVICES))
+ if (!bitmap_and(apm, mdev_apm, matrix_mdev->matrix.apm,
+ AP_DEVICES))
continue;
- if (!bitmap_and(aqm, matrix_mdev->matrix.aqm,
- lstdev->matrix.aqm, AP_DOMAINS))
+ if (!bitmap_and(aqm, mdev_aqm, matrix_mdev->matrix.aqm,
+ AP_DOMAINS))
continue;
+ vfio_ap_mdev_log_sharing_err(matrix_mdev, apm, aqm);
+
return -EADDRINUSE;
}
return 0;
}
+static int vfio_ap_mdev_validate_masks(struct ap_matrix_mdev *matrix_mdev)
+{
+ if (ap_apqn_in_matrix_owned_by_def_drv(matrix_mdev->matrix.apm,
+ matrix_mdev->matrix.aqm))
+ return -EADDRNOTAVAIL;
+
+ return vfio_ap_mdev_verify_no_sharing(matrix_mdev->matrix.apm,
+ matrix_mdev->matrix.aqm);
+}
+
static void vfio_ap_mdev_link_adapter(struct ap_matrix_mdev *matrix_mdev,
unsigned long apid)
{
@@ -882,20 +801,13 @@ static ssize_t assign_adapter_store(struct device *dev,
goto done;
}
- /*
- * Set the bit in the AP mask (APM) corresponding to the AP adapter
- * number (APID). The bits in the mask, from most significant to least
- * significant bit, correspond to APIDs 0-255.
- */
- ret = vfio_ap_mdev_verify_queues_reserved_for_apid(matrix_mdev, apid);
- if (ret)
- goto done;
-
set_bit_inv(apid, matrix_mdev->matrix.apm);
- ret = vfio_ap_mdev_verify_no_sharing(matrix_mdev);
- if (ret)
- goto share_err;
+ ret = vfio_ap_mdev_validate_masks(matrix_mdev);
+ if (ret) {
+ clear_bit_inv(apid, matrix_mdev->matrix.apm);
+ goto done;
+ }
vfio_ap_mdev_link_adapter(matrix_mdev, apid);
memset(apm_delta, 0, sizeof(apm_delta));
@@ -903,10 +815,6 @@ static ssize_t assign_adapter_store(struct device *dev,
vfio_ap_mdev_filter_matrix(apm_delta,
matrix_mdev->matrix.aqm, matrix_mdev);
ret = count;
- goto done;
-
-share_err:
- clear_bit_inv(apid, matrix_mdev->matrix.apm);
done:
mutex_unlock(&matrix_dev->lock);
@@ -981,26 +889,6 @@ static ssize_t unassign_adapter_store(struct device *dev,
}
static DEVICE_ATTR_WO(unassign_adapter);
-static int
-vfio_ap_mdev_verify_queues_reserved_for_apqi(struct ap_matrix_mdev *matrix_mdev,
- unsigned long apqi)
-{
- int ret;
- unsigned long apid;
- unsigned long nbits = matrix_mdev->matrix.apm_max + 1;
-
- if (find_first_bit_inv(matrix_mdev->matrix.apm, nbits) >= nbits)
- return vfio_ap_verify_queue_reserved(NULL, &apqi);
-
- for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, nbits) {
- ret = vfio_ap_verify_queue_reserved(&apid, &apqi);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
static void vfio_ap_mdev_link_domain(struct ap_matrix_mdev *matrix_mdev,
unsigned long apqi)
{
@@ -1067,15 +955,13 @@ static ssize_t assign_domain_store(struct device *dev,
goto done;
}
- ret = vfio_ap_mdev_verify_queues_reserved_for_apqi(matrix_mdev, apqi);
- if (ret)
- goto done;
-
set_bit_inv(apqi, matrix_mdev->matrix.aqm);
- ret = vfio_ap_mdev_verify_no_sharing(matrix_mdev);
- if (ret)
- goto share_err;
+ ret = vfio_ap_mdev_validate_masks(matrix_mdev);
+ if (ret) {
+ clear_bit_inv(apqi, matrix_mdev->matrix.aqm);
+ goto done;
+ }
vfio_ap_mdev_link_domain(matrix_mdev, apqi);
memset(aqm_delta, 0, sizeof(aqm_delta));
@@ -1083,10 +969,6 @@ static ssize_t assign_domain_store(struct device *dev,
vfio_ap_mdev_filter_matrix(matrix_mdev->matrix.apm, aqm_delta,
matrix_mdev);
ret = count;
- goto done;
-
-share_err:
- clear_bit_inv(apqi, matrix_mdev->matrix.aqm);
done:
mutex_unlock(&matrix_dev->lock);
--
2.31.1
This patch implements two new AP driver callbacks:
void (*on_config_changed)(struct ap_config_info *new_config_info,
struct ap_config_info *old_config_info);
void (*on_scan_complete)(struct ap_config_info *new_config_info,
struct ap_config_info *old_config_info);
The on_config_changed callback is invoked at the start of the AP bus scan
function when it determines that the host AP configuration information
has changed since the previous scan.
The vfio_ap device driver registers a callback function for this callback
that performs the following operations:
1. Unplugs the adapters, domains and control domains removed from the
host's AP configuration from the guests to which they are
assigned in a single operation.
2. Stores bitmaps identifying the adapters, domains and control domains
added to the host's AP configuration with the structure representing
the mediated device. When the vfio_ap device driver's probe callback is
subsequently invoked, the probe function will recognize that the
queue is being probed due to a change in the host's AP configuration
and the plugging of the queue into the guest will be bypassed.
The on_scan_complete callback is invoked after the ap bus scan is
completed if the host AP configuration data has changed. The vfio_ap
device driver registers a callback function for this callback that hot
plugs each queue and control domain added to the AP configuration for each
guest using them in a single hot plug operation.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_drv.c | 2 +
drivers/s390/crypto/vfio_ap_ops.c | 270 +++++++++++++++++++++++++-
drivers/s390/crypto/vfio_ap_private.h | 12 ++
3 files changed, 279 insertions(+), 5 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
index 2c3084589347..4d5dda34082f 100644
--- a/drivers/s390/crypto/vfio_ap_drv.c
+++ b/drivers/s390/crypto/vfio_ap_drv.c
@@ -108,6 +108,8 @@ static struct ap_driver vfio_ap_drv = {
.probe = vfio_ap_mdev_probe_queue,
.remove = vfio_ap_mdev_remove_queue,
.in_use = vfio_ap_mdev_resource_in_use,
+ .on_config_changed = vfio_ap_on_cfg_changed,
+ .on_scan_complete = vfio_ap_on_scan_complete,
.ids = ap_queue_ids,
};
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 3e1a7f191c43..083526bdef76 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -641,16 +641,11 @@ static bool vfio_ap_mdev_filter_cdoms(struct ap_matrix_mdev *matrix_mdev)
static bool vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
struct ap_matrix_mdev *matrix_mdev)
{
- int ret;
unsigned long apid, apqi, apqn;
DECLARE_BITMAP(prev_shadow_apm, AP_DEVICES);
DECLARE_BITMAP(prev_shadow_aqm, AP_DOMAINS);
struct vfio_ap_queue *q;
- ret = ap_qci(&matrix_dev->info);
- if (ret)
- return false;
-
bitmap_copy(prev_shadow_apm, matrix_mdev->shadow_apcb.apm, AP_DEVICES);
bitmap_copy(prev_shadow_aqm, matrix_mdev->shadow_apcb.aqm, AP_DOMAINS);
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
@@ -1960,3 +1955,268 @@ int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm)
return ret;
}
+
+/**
+ * vfio_ap_mdev_hot_unplug_cfg - hot unplug the adapters, domains and control
+ * domains that have been removed from the host's
+ * AP configuration from a guest.
+ *
+ * @matrix_mdev: an ap_matrix_mdev object attached to a KVM guest.
+ * @aprem: the adapters that have been removed from the host's AP configuration
+ * @aqrem: the domains that have been removed from the host's AP configuration
+ * @cdrem: the control domains that have been removed from the host's AP
+ * configuration.
+ */
+static void vfio_ap_mdev_hot_unplug_cfg(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long *aprem,
+ unsigned long *aqrem,
+ unsigned long *cdrem)
+{
+ int do_hotplug = 0;
+
+ if (!bitmap_empty(aprem, AP_DEVICES)) {
+ do_hotplug |= bitmap_andnot(matrix_mdev->shadow_apcb.apm,
+ matrix_mdev->shadow_apcb.apm,
+ aprem, AP_DEVICES);
+ }
+
+ if (!bitmap_empty(aqrem, AP_DOMAINS)) {
+ do_hotplug |= bitmap_andnot(matrix_mdev->shadow_apcb.aqm,
+ matrix_mdev->shadow_apcb.aqm,
+ aqrem, AP_DEVICES);
+ }
+
+ if (!bitmap_empty(cdrem, AP_DOMAINS))
+ do_hotplug |= bitmap_andnot(matrix_mdev->shadow_apcb.adm,
+ matrix_mdev->shadow_apcb.adm,
+ cdrem, AP_DOMAINS);
+
+ if (do_hotplug)
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+}
+
+/**
+ * vfio_ap_mdev_cfg_remove - determines which guests are using the adapters,
+ * domains and control domains that have been removed
+ * from the host AP configuration and unplugs them
+ * from those guests.
+ *
+ * @ap_remove: bitmap specifying which adapters have been removed from the host
+ * config.
+ * @aq_remove: bitmap specifying which domains have been removed from the host
+ * config.
+ * @cd_remove: bitmap specifying which control domains have been removed from
+ * the host config.
+ */
+static void vfio_ap_mdev_cfg_remove(unsigned long *ap_remove,
+ unsigned long *aq_remove,
+ unsigned long *cd_remove)
+{
+ struct ap_matrix_mdev *matrix_mdev;
+ DECLARE_BITMAP(aprem, AP_DEVICES);
+ DECLARE_BITMAP(aqrem, AP_DOMAINS);
+ DECLARE_BITMAP(cdrem, AP_DOMAINS);
+ int do_remove = 0;
+
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ if (!matrix_mdev->kvm)
+ continue;
+
+ mutex_lock(&matrix_mdev->kvm->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
+
+ do_remove |= bitmap_and(aprem, ap_remove,
+ matrix_mdev->matrix.apm,
+ AP_DEVICES);
+ do_remove |= bitmap_and(aqrem, aq_remove,
+ matrix_mdev->matrix.aqm,
+ AP_DOMAINS);
+ do_remove |= bitmap_andnot(cdrem, cd_remove,
+ matrix_mdev->matrix.adm,
+ AP_DOMAINS);
+
+ if (do_remove)
+ vfio_ap_mdev_hot_unplug_cfg(matrix_mdev, aprem, aqrem,
+ cdrem);
+
+ mutex_unlock(&matrix_dev->mdevs_lock);
+ mutex_unlock(&matrix_mdev->kvm->lock);
+ }
+}
+
+/**
+ * vfio_ap_mdev_on_cfg_remove - responds to the removal of adapters, domains and
+ * control domains from the host AP configuration
+ * by unplugging them from the guests that are
+ * using them.
+ * @cur_config_info: the current host AP configuration information
+ * @prev_config_info: the previous host AP configuration information
+ */
+static void vfio_ap_mdev_on_cfg_remove(struct ap_config_info *cur_config_info,
+ struct ap_config_info *prev_config_info)
+{
+ int do_remove;
+ DECLARE_BITMAP(aprem, AP_DEVICES);
+ DECLARE_BITMAP(aqrem, AP_DOMAINS);
+ DECLARE_BITMAP(cdrem, AP_DOMAINS);
+
+ do_remove = bitmap_andnot(aprem,
+ (unsigned long *)prev_config_info->apm,
+ (unsigned long *)cur_config_info->apm,
+ AP_DEVICES);
+ do_remove |= bitmap_andnot(aqrem,
+ (unsigned long *)prev_config_info->aqm,
+ (unsigned long *)cur_config_info->aqm,
+ AP_DEVICES);
+ do_remove |= bitmap_andnot(cdrem,
+ (unsigned long *)prev_config_info->adm,
+ (unsigned long *)cur_config_info->adm,
+ AP_DEVICES);
+
+ if (do_remove)
+ vfio_ap_mdev_cfg_remove(aprem, aqrem, cdrem);
+}
+
+/**
+ * vfio_ap_mdev_cfg_add - store bitmaps specifying the adapters, domains and
+ * control domains that have been added to the host's
+ * AP configuration for each matrix mdev to which they
+ * are assigned.
+ *
+ * @apm_add: a bitmap specifying the adapters that have been added to the AP
+ * configuration.
+ * @aqm_add: a bitmap specifying the domains that have been added to the AP
+ * configuration.
+ * @adm_add: a bitmap specifying the control domains that have been added to the
+ * AP configuration.
+ */
+static void vfio_ap_mdev_cfg_add(unsigned long *apm_add, unsigned long *aqm_add,
+ unsigned long *adm_add)
+{
+ struct ap_matrix_mdev *matrix_mdev;
+
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ bitmap_and(matrix_mdev->apm_add,
+ matrix_mdev->matrix.apm, apm_add, AP_DEVICES);
+ bitmap_and(matrix_mdev->aqm_add,
+ matrix_mdev->matrix.aqm, aqm_add, AP_DOMAINS);
+ bitmap_and(matrix_mdev->adm_add,
+ matrix_mdev->matrix.adm, adm_add, AP_DEVICES);
+ }
+}
+
+/**
+ * vfio_ap_mdev_on_cfg_add - responds to the addition of adapters, domains and
+ * control domains to the host AP configuration
+ * by updating the bitmaps that specify what adapters,
+ * domains and control domains have been added so they
+ * can be hot plugged into the guest when the AP bus
+ * scan completes (see vfio_ap_on_scan_complete
+ * function).
+ * @cur_config_info: the current AP configuration information
+ * @prev_config_info: the previous AP configuration information
+ */
+static void vfio_ap_mdev_on_cfg_add(struct ap_config_info *cur_config_info,
+ struct ap_config_info *prev_config_info)
+{
+ bool do_add;
+ DECLARE_BITMAP(apm_add, AP_DEVICES);
+ DECLARE_BITMAP(aqm_add, AP_DOMAINS);
+ DECLARE_BITMAP(adm_add, AP_DOMAINS);
+
+ do_add = bitmap_andnot(apm_add,
+ (unsigned long *)cur_config_info->apm,
+ (unsigned long *)prev_config_info->apm,
+ AP_DEVICES);
+ do_add |= bitmap_andnot(aqm_add,
+ (unsigned long *)cur_config_info->aqm,
+ (unsigned long *)prev_config_info->aqm,
+ AP_DOMAINS);
+ do_add |= bitmap_andnot(adm_add,
+ (unsigned long *)cur_config_info->adm,
+ (unsigned long *)prev_config_info->adm,
+ AP_DOMAINS);
+
+ if (do_add)
+ vfio_ap_mdev_cfg_add(apm_add, aqm_add, adm_add);
+}
+
+/**
+ * vfio_ap_on_cfg_changed - handles notification of changes to the host AP
+ * configuration.
+ *
+ * @cur_cfg_info: the current host AP configuration
+ * @prev_cfg_info: the previous host AP configuration
+ */
+void vfio_ap_on_cfg_changed(struct ap_config_info *cur_cfg_info,
+ struct ap_config_info *prev_cfg_info)
+{
+ mutex_lock(&matrix_dev->guests_lock);
+
+ vfio_ap_mdev_on_cfg_remove(cur_cfg_info, prev_cfg_info);
+ vfio_ap_mdev_on_cfg_add(cur_cfg_info, prev_cfg_info);
+ memcpy(&matrix_dev->info, cur_cfg_info, sizeof(*cur_cfg_info));
+
+ mutex_unlock(&matrix_dev->guests_lock);
+}
+
+static void vfio_ap_mdev_hot_plug_cfg(struct ap_matrix_mdev *matrix_mdev)
+{
+ bool do_hotplug = false;
+ int filter_domains = 0;
+ int filter_adapters = 0;
+ DECLARE_BITMAP(apm, AP_DEVICES);
+ DECLARE_BITMAP(aqm, AP_DOMAINS);
+
+ mutex_lock(&matrix_mdev->kvm->lock);
+ mutex_lock(&matrix_dev->mdevs_lock);
+
+ filter_adapters = bitmap_and(apm, matrix_mdev->matrix.apm,
+ matrix_mdev->apm_add, AP_DEVICES);
+ filter_domains = bitmap_and(aqm, matrix_mdev->matrix.aqm,
+ matrix_mdev->aqm_add, AP_DOMAINS);
+
+ if (filter_adapters && filter_domains)
+ do_hotplug |= vfio_ap_mdev_filter_matrix(apm, aqm, matrix_mdev);
+ else if (filter_adapters)
+ do_hotplug |=
+ vfio_ap_mdev_filter_matrix(apm,
+ matrix_mdev->shadow_apcb.aqm,
+ matrix_mdev);
+ else
+ do_hotplug |=
+ vfio_ap_mdev_filter_matrix(matrix_mdev->shadow_apcb.apm,
+ aqm, matrix_mdev);
+
+ if (bitmap_intersects(matrix_mdev->matrix.adm, matrix_mdev->adm_add,
+ AP_DOMAINS))
+ do_hotplug |= vfio_ap_mdev_filter_cdoms(matrix_mdev);
+
+ if (do_hotplug)
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+
+ mutex_unlock(&matrix_dev->mdevs_lock);
+ mutex_unlock(&matrix_mdev->kvm->lock);
+}
+
+void vfio_ap_on_scan_complete(struct ap_config_info *new_config_info,
+ struct ap_config_info *old_config_info)
+{
+ struct ap_matrix_mdev *matrix_mdev;
+
+ mutex_lock(&matrix_dev->guests_lock);
+
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ if (bitmap_empty(matrix_mdev->apm_add, AP_DEVICES) &&
+ bitmap_empty(matrix_mdev->aqm_add, AP_DOMAINS) &&
+ bitmap_empty(matrix_mdev->adm_add, AP_DOMAINS))
+ continue;
+
+ vfio_ap_mdev_hot_plug_cfg(matrix_mdev);
+ bitmap_clear(matrix_mdev->apm_add, 0, AP_DEVICES);
+ bitmap_clear(matrix_mdev->aqm_add, 0, AP_DOMAINS);
+ bitmap_clear(matrix_mdev->adm_add, 0, AP_DOMAINS);
+ }
+
+ mutex_unlock(&matrix_dev->guests_lock);
+}
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index cbffa0bd01da..5b72e642cd04 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -107,6 +107,10 @@ struct ap_queue_table {
* PQAP(AQIC) instruction.
* @mdev: the mediated device
* @qtable: table of queues (struct vfio_ap_queue) assigned to the mdev
+ * @apm_add: bitmap of APIDs added to the host's AP configuration
+ * @aqm_add: bitmap of APQIs added to the host's AP configuration
+ * @adm_add: bitmap of control domain numbers added to the host's AP
+ * configuration
*/
struct ap_matrix_mdev {
struct vfio_device vdev;
@@ -119,6 +123,9 @@ struct ap_matrix_mdev {
crypto_hook pqap_hook;
struct mdev_device *mdev;
struct ap_queue_table qtable;
+ DECLARE_BITMAP(apm_add, AP_DEVICES);
+ DECLARE_BITMAP(aqm_add, AP_DOMAINS);
+ DECLARE_BITMAP(adm_add, AP_DOMAINS);
};
/**
@@ -149,4 +156,9 @@ void vfio_ap_mdev_remove_queue(struct ap_device *queue);
int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm);
+void vfio_ap_on_cfg_changed(struct ap_config_info *new_config_info,
+ struct ap_config_info *old_config_info);
+void vfio_ap_on_scan_complete(struct ap_config_info *new_config_info,
+ struct ap_config_info *old_config_info);
+
#endif /* _VFIO_AP_PRIVATE_H_ */
--
2.31.1
A new document, Documentation/s390/vfio-ap-locking.rst was added. Make sure
the new document is picked up for the VFIO AP maintainers by using a
wildcard: Documentation/s390/vfio-ap*.
Signed-off-by: Tony Krowiak <[email protected]>
---
MAINTAINERS | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/MAINTAINERS b/MAINTAINERS
index fd768d43e048..c8d8637c184c 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -17239,8 +17239,10 @@ M: Jason Herne <[email protected]>
L: [email protected]
S: Supported
W: http://www.ibm.com/developerworks/linux/linux390/
-F: Documentation/s390/vfio-ap.rst
-F: drivers/s390/crypto/vfio_ap*
+F: Documentation/s390/vfio-ap*
+F: drivers/s390/crypto/vfio_ap_drv.c
+F: drivers/s390/crypto/vfio_ap_ops.c
+F: drivers/s390/crypto/vfio_ap_private.h
S390 VFIO-CCW DRIVER
M: Eric Farman <[email protected]>
--
2.31.1
Update the documentation in vfio-ap.rst to include information about the
AP dynamic configuration support (e.g., hot plug of adapters, domains
and control domains via the matrix mediated device's sysfs assignment
attributes). This patch also makes a few minor tweaks to make corrections
and clarifications.
Signed-off-by: Tony Krowiak <[email protected]>
---
Documentation/s390/vfio-ap.rst | 492 +++++++++++++++++++++++----------
1 file changed, 346 insertions(+), 146 deletions(-)
diff --git a/Documentation/s390/vfio-ap.rst b/Documentation/s390/vfio-ap.rst
index f57ae621f33e..f4b8748ab9a8 100644
--- a/Documentation/s390/vfio-ap.rst
+++ b/Documentation/s390/vfio-ap.rst
@@ -123,27 +123,24 @@ Let's now take a look at how AP instructions executed on a guest are interpreted
by the hardware.
A satellite control block called the Crypto Control Block (CRYCB) is attached to
-our main hardware virtualization control block. The CRYCB contains three fields
-to identify the adapters, usage domains and control domains assigned to the KVM
-guest:
+our main hardware virtualization control block. The CRYCB contains an AP Control
+Block (APCB) that has three fields to identify the adapters, usage domains and
+control domains assigned to the KVM guest:
* The AP Mask (APM) field is a bit mask that identifies the AP adapters assigned
- to the KVM guest. Each bit in the mask, from left to right (i.e. from most
- significant to least significant bit in big endian order), corresponds to
+ to the KVM guest. Each bit in the mask, from left to right, corresponds to
an APID from 0-255. If a bit is set, the corresponding adapter is valid for
use by the KVM guest.
* The AP Queue Mask (AQM) field is a bit mask identifying the AP usage domains
- assigned to the KVM guest. Each bit in the mask, from left to right (i.e. from
- most significant to least significant bit in big endian order), corresponds to
- an AP queue index (APQI) from 0-255. If a bit is set, the corresponding queue
- is valid for use by the KVM guest.
+ assigned to the KVM guest. Each bit in the mask, from left to right,
+ corresponds to an AP queue index (APQI) from 0-255. If a bit is set, the
+ corresponding queue is valid for use by the KVM guest.
* The AP Domain Mask field is a bit mask that identifies the AP control domains
assigned to the KVM guest. The ADM bit mask controls which domains can be
changed by an AP command-request message sent to a usage domain from the
- guest. Each bit in the mask, from left to right (i.e. from most significant to
- least significant bit in big endian order), corresponds to a domain from
+ guest. Each bit in the mask, from left to right, corresponds to a domain from
0-255. If a bit is set, the corresponding domain can be modified by an AP
command-request message sent to a usage domain.
@@ -151,10 +148,10 @@ If you recall from the description of an AP Queue, AP instructions include
an APQN to identify the AP queue to which an AP command-request message is to be
sent (NQAP and PQAP instructions), or from which a command-reply message is to
be received (DQAP instruction). The validity of an APQN is defined by the matrix
-calculated from the APM and AQM; it is the cross product of all assigned adapter
-numbers (APM) with all assigned queue indexes (AQM). For example, if adapters 1
-and 2 and usage domains 5 and 6 are assigned to a guest, the APQNs (1,5), (1,6),
-(2,5) and (2,6) will be valid for the guest.
+calculated from the APM and AQM; it is the Cartesian product of all assigned
+adapter numbers (APM) with all assigned queue indexes (AQM). For example, if
+adapters 1 and 2 and usage domains 5 and 6 are assigned to a guest, the APQNs
+(1,5), (1,6), (2,5) and (2,6) will be valid for the guest.
The APQNs can provide secure key functionality - i.e., a private key is stored
on the adapter card for each of its domains - so each APQN must be assigned to
@@ -192,7 +189,7 @@ The design introduces three new objects:
1. AP matrix device
2. VFIO AP device driver (vfio_ap.ko)
-3. VFIO AP mediated matrix pass-through device
+3. VFIO AP mediated pass-through device
The VFIO AP device driver
-------------------------
@@ -200,12 +197,13 @@ The VFIO AP (vfio_ap) device driver serves the following purposes:
1. Provides the interfaces to secure APQNs for exclusive use of KVM guests.
-2. Sets up the VFIO mediated device interfaces to manage a mediated matrix
+2. Sets up the VFIO mediated device interfaces to manage a vfio_ap mediated
device and creates the sysfs interfaces for assigning adapters, usage
domains, and control domains comprising the matrix for a KVM guest.
-3. Configures the APM, AQM and ADM in the CRYCB referenced by a KVM guest's
- SIE state description to grant the guest access to a matrix of AP devices
+3. Configures the APM, AQM and ADM in the APCB contained in the CRYCB referenced
+ by a KVM guest's SIE state description to grant the guest access to a matrix
+ of AP devices
Reserve APQNs for exclusive use of KVM guests
---------------------------------------------
@@ -235,10 +233,10 @@ reserved::
| | 8 probe | |
+--------^---------+ +--^--^------------+
6 edit | | |
- apmask | +-----------------------------+ | 9 mdev create
+ apmask | +-----------------------------+ | 11 mdev create
aqmask | | 1 modprobe |
+--------+-----+---+ +----------------+-+ +----------------+
- | | | |8 create | mediated |
+ | | | |10 create| mediated |
| admin | | VFIO device core |---------> matrix |
| + | | | device |
+------+-+---------+ +--------^---------+ +--------^-------+
@@ -246,14 +244,14 @@ reserved::
| | 9 create vfio_ap-passthrough | |
| +------------------------------+ |
+-------------------------------------------------------------+
- 10 assign adapter/domain/control domain
+ 12 assign adapter/domain/control domain
The process for reserving an AP queue for use by a KVM guest is:
1. The administrator loads the vfio_ap device driver
2. The vfio-ap driver during its initialization will register a single 'matrix'
device with the device core. This will serve as the parent device for
- all mediated matrix devices used to configure an AP matrix for a guest.
+ all vfio_ap mediated devices used to configure an AP matrix for a guest.
3. The /sys/devices/vfio_ap/matrix device is created by the device core
4. The vfio_ap device driver will register with the AP bus for AP queue devices
of type 10 and higher (CEX4 and newer). The driver will provide the vfio_ap
@@ -269,24 +267,24 @@ The process for reserving an AP queue for use by a KVM guest is:
default zcrypt cex4queue driver.
8. The AP bus probes the vfio_ap device driver to bind the queues reserved for
it.
-9. The administrator creates a passthrough type mediated matrix device to be
+9. The administrator creates a passthrough type vfio_ap mediated device to be
used by a guest
10. The administrator assigns the adapters, usage domains and control domains
to be exclusively used by a guest.
Set up the VFIO mediated device interfaces
------------------------------------------
-The VFIO AP device driver utilizes the common interface of the VFIO mediated
+The VFIO AP device driver utilizes the common interfaces of the VFIO mediated
device core driver to:
-* Register an AP mediated bus driver to add a mediated matrix device to and
+* Register an AP mediated bus driver to add a vfio_ap mediated device to and
remove it from a VFIO group.
-* Create and destroy a mediated matrix device
-* Add a mediated matrix device to and remove it from the AP mediated bus driver
-* Add a mediated matrix device to and remove it from an IOMMU group
+* Create and destroy a vfio_ap mediated device
+* Add a vfio_ap mediated device to and remove it from the AP mediated bus driver
+* Add a vfio_ap mediated device to and remove it from an IOMMU group
The following high-level block diagram shows the main components and interfaces
-of the VFIO AP mediated matrix device driver::
+of the VFIO AP mediated device driver::
+-------------+
| |
@@ -343,7 +341,7 @@ matrix device.
* device_api:
the mediated device type's API
* available_instances:
- the number of mediated matrix passthrough devices
+ the number of vfio_ap mediated passthrough devices
that can be created
* device_api:
specifies the VFIO API
@@ -351,29 +349,37 @@ matrix device.
This attribute group identifies the user-defined sysfs attributes of the
mediated device. When a device is registered with the VFIO mediated device
framework, the sysfs attribute files identified in the 'mdev_attr_groups'
- structure will be created in the mediated matrix device's directory. The
- sysfs attributes for a mediated matrix device are:
+ structure will be created in the vfio_ap mediated device's directory. The
+ sysfs attributes for a vfio_ap mediated device are:
assign_adapter / unassign_adapter:
Write-only attributes for assigning/unassigning an AP adapter to/from the
- mediated matrix device. To assign/unassign an adapter, the APID of the
- adapter is echoed to the respective attribute file.
+ vfio_ap mediated device. To assign/unassign an adapter, the APID of the
+ adapter is echoed into the respective attribute file.
assign_domain / unassign_domain:
Write-only attributes for assigning/unassigning an AP usage domain to/from
- the mediated matrix device. To assign/unassign a domain, the domain
- number of the usage domain is echoed to the respective attribute
+ the vfio_ap mediated device. To assign/unassign a domain, the domain
+ number of the usage domain is echoed into the respective attribute
file.
matrix:
- A read-only file for displaying the APQNs derived from the cross product
- of the adapter and domain numbers assigned to the mediated matrix device.
+ A read-only file for displaying the APQNs derived from the Cartesian
+ product of the adapter and domain numbers assigned to the vfio_ap mediated
+ device.
+ guest_matrix:
+ A read-only file for displaying the APQNs derived from the Cartesian
+ product of the adapter and domain numbers assigned to the APM and AQM
+ fields respectively of the KVM guest's CRYCB. This may differ from the
+ the APQNs assigned to the vfio_ap mediated device if any APQN does not
+ reference a queue device bound to the vfio_ap device driver (i.e., the
+ queue is not in the host's AP configuration).
assign_control_domain / unassign_control_domain:
Write-only attributes for assigning/unassigning an AP control domain
- to/from the mediated matrix device. To assign/unassign a control domain,
- the ID of the domain to be assigned/unassigned is echoed to the respective
- attribute file.
+ to/from the vfio_ap mediated device. To assign/unassign a control domain,
+ the ID of the domain to be assigned/unassigned is echoed into the
+ respective attribute file.
control_domains:
A read-only file for displaying the control domain numbers assigned to the
- mediated matrix device.
+ vfio_ap mediated device.
* functions:
@@ -383,45 +389,75 @@ matrix device.
* Store the reference to the KVM structure for the guest using the mdev
* Store the AP matrix configuration for the adapters, domains, and control
domains assigned via the corresponding sysfs attributes files
+ * Store the AP matrix configuration for the adapters, domains and control
+ domains available to a guest. A guest may not be provided access to APQNs
+ referencing queue devices that do not exist, or are not bound to the
+ vfio_ap device driver.
remove:
- deallocates the mediated matrix device's ap_matrix_mdev structure. This will
- be allowed only if a running guest is not using the mdev.
+ deallocates the vfio_ap mediated device's ap_matrix_mdev structure.
+ This will be allowed only if a running guest is not using the mdev.
* callback interfaces
- open:
+ open_device:
The vfio_ap driver uses this callback to register a
- VFIO_GROUP_NOTIFY_SET_KVM notifier callback function for the mdev matrix
- device. The open is invoked when QEMU connects the VFIO iommu group
- for the mdev matrix device to the MDEV bus. Access to the KVM structure used
- to configure the KVM guest is provided via this callback. The KVM structure,
- is used to configure the guest's access to the AP matrix defined via the
- mediated matrix device's sysfs attribute files.
- release:
+ VFIO_GROUP_NOTIFY_SET_KVM notifier callback function for the matrix mdev
+ devices. The open_device callback is invoked by userspace to connect the
+ VFIO iommu group for the matrix mdev device to the MDEV bus. Access to the
+ KVM structure used to configure the KVM guest is provided via this callback.
+ The KVM structure, is used to configure the guest's access to the AP matrix
+ defined via the vfio_ap mediated device's sysfs attribute files.
+
+ close_device:
unregisters the VFIO_GROUP_NOTIFY_SET_KVM notifier callback function for the
- mdev matrix device and deconfigures the guest's AP matrix.
+ matrix mdev device and deconfigures the guest's AP matrix.
-Configure the APM, AQM and ADM in the CRYCB
--------------------------------------------
-Configuring the AP matrix for a KVM guest will be performed when the
+ ioctl:
+ this callback handles the VFIO_DEVICE_GET_INFO and VFIO_DEVICE_RESET ioctls
+ defined by the vfio framework.
+
+Configure the guest's AP resources
+----------------------------------
+Configuring the AP resources for a KVM guest will be performed when the
VFIO_GROUP_NOTIFY_SET_KVM notifier callback is invoked. The notifier
-function is called when QEMU connects to KVM. The guest's AP matrix is
-configured via it's CRYCB by:
+function is called when userspace connects to KVM. The guest's AP resources are
+configured via it's APCB by:
* Setting the bits in the APM corresponding to the APIDs assigned to the
- mediated matrix device via its 'assign_adapter' interface.
+ vfio_ap mediated device via its 'assign_adapter' interface.
* Setting the bits in the AQM corresponding to the domains assigned to the
- mediated matrix device via its 'assign_domain' interface.
+ vfio_ap mediated device via its 'assign_domain' interface.
* Setting the bits in the ADM corresponding to the domain dIDs assigned to the
- mediated matrix device via its 'assign_control_domains' interface.
+ vfio_ap mediated device via its 'assign_control_domains' interface.
+
+The linux device model precludes passing a device through to a KVM guest that
+is not bound to the device driver facilitating its pass-through. Consequently,
+an APQN that does not reference a queue device bound to the vfio_ap device
+driver will not be assigned to a KVM guest's matrix. The AP architecture,
+however, does not provide a means to filter individual APQNs from the guest's
+matrix, so the adapters, domains and control domains assigned to vfio_ap
+mediated device via its sysfs 'assign_adapter', 'assign_domain' and
+'assign_control_domain' interfaces will be filtered before providing the AP
+configuration to a guest:
+
+* The APIDs of the adapters, the APQIs of the domains and the domain numbers of
+ the control domains assigned to the matrix mdev that are not also assigned to
+ the host's AP configuration will be filtered.
+
+* Each APQN derived from the Cartesian product of the APIDs and APQIs assigned
+ to the vfio_ap mdev is examined and if any one of them does not reference a
+ queue device bound to the vfio_ap device driver, the adapter will not be
+ plugged into the guest (i.e., the bit corresponding to its APID will not be
+ set in the APM of the guest's APCB).
The CPU model features for AP
-----------------------------
-The AP stack relies on the presence of the AP instructions as well as two
-facilities: The AP Facilities Test (APFT) facility; and the AP Query
-Configuration Information (QCI) facility. These features/facilities are made
-available to a KVM guest via the following CPU model features:
+The AP stack relies on the presence of the AP instructions as well as three
+facilities: The AP Facilities Test (APFT) facility; the AP Query
+Configuration Information (QCI) facility; and the AP Queue Interruption Control
+facility. These features/facilities are made available to a KVM guest via the
+following CPU model features:
1. ap: Indicates whether the AP instructions are installed on the guest. This
feature will be enabled by KVM only if the AP instructions are installed
@@ -435,24 +471,28 @@ available to a KVM guest via the following CPU model features:
can be made available to the guest only if it is available on the host (i.e.,
facility bit 12 is set).
+4. apqi: Indicates AP Queue Interruption Control faclity is available on the
+ guest. This facility can be made available to the guest only if it is
+ available on the host (i.e., facility bit 65 is set).
+
Note: If the user chooses to specify a CPU model different than the 'host'
model to QEMU, the CPU model features and facilities need to be turned on
explicitly; for example::
- /usr/bin/qemu-system-s390x ... -cpu z13,ap=on,apqci=on,apft=on
+ /usr/bin/qemu-system-s390x ... -cpu z13,ap=on,apqci=on,apft=on,apqi=on
A guest can be precluded from using AP features/facilities by turning them off
explicitly; for example::
- /usr/bin/qemu-system-s390x ... -cpu host,ap=off,apqci=off,apft=off
+ /usr/bin/qemu-system-s390x ... -cpu host,ap=off,apqci=off,apft=off,apqi=off
Note: If the APFT facility is turned off (apft=off) for the guest, the guest
-will not see any AP devices. The zcrypt device drivers that register for type 10
-and newer AP devices - i.e., the cex4card and cex4queue device drivers - need
-the APFT facility to ascertain the facilities installed on a given AP device. If
-the APFT facility is not installed on the guest, then the probe of device
-drivers will fail since only type 10 and newer devices can be configured for
-guest use.
+will not see any AP devices. The zcrypt device drivers on the guest that
+register for type 10 and newer AP devices - i.e., the cex4card and cex4queue
+device drivers - need the APFT facility to ascertain the facilities installed on
+a given AP device. If the APFT facility is not installed on the guest, then no
+adapter or domain devices will get created by the AP bus running on the
+guest because only type 10 and newer devices can be configured for guest use.
Example
=======
@@ -471,7 +511,7 @@ CARD.DOMAIN TYPE MODE
05.00ab CEX5C CCA-Coproc
06 CEX5A Accelerator
06.0004 CEX5A Accelerator
-06.00ab CEX5C CCA-Coproc
+06.00ab CEX5A Accelerator
=========== ===== ============
Guest2
@@ -479,9 +519,9 @@ Guest2
=========== ===== ============
CARD.DOMAIN TYPE MODE
=========== ===== ============
-05 CEX5A Accelerator
-05.0047 CEX5A Accelerator
-05.00ff CEX5A Accelerator
+05 CEX5C CCA-Coproc
+05.0047 CEX5C CCA-Coproc
+05.00ff CEX5C CCA-Coproc
=========== ===== ============
Guest3
@@ -529,40 +569,56 @@ These are the steps:
2. Secure the AP queues to be used by the three guests so that the host can not
access them. To secure them, there are two sysfs files that specify
- bitmasks marking a subset of the APQN range as 'usable by the default AP
- queue device drivers' or 'not usable by the default device drivers' and thus
- available for use by the vfio_ap device driver'. The location of the sysfs
- files containing the masks are::
+ bitmasks marking a subset of the APQN range as usable only by the default AP
+ queue device drivers. All remaining APQNs are available for use by
+ any other device driver. The vfio_ap device driver is currently the only
+ non-default device driver. The location of the sysfs files containing the
+ masks are::
/sys/bus/ap/apmask
/sys/bus/ap/aqmask
The 'apmask' is a 256-bit mask that identifies a set of AP adapter IDs
- (APID). Each bit in the mask, from left to right (i.e., from most significant
- to least significant bit in big endian order), corresponds to an APID from
- 0-255. If a bit is set, the APID is marked as usable only by the default AP
- queue device drivers; otherwise, the APID is usable by the vfio_ap
- device driver.
+ (APID). Each bit in the mask, from left to right, corresponds to an APID from
+ 0-255. If a bit is set, the APID belongs to the subset of APQNs marked as
+ available only to the default AP queue device drivers.
The 'aqmask' is a 256-bit mask that identifies a set of AP queue indexes
- (APQI). Each bit in the mask, from left to right (i.e., from most significant
- to least significant bit in big endian order), corresponds to an APQI from
- 0-255. If a bit is set, the APQI is marked as usable only by the default AP
- queue device drivers; otherwise, the APQI is usable by the vfio_ap device
- driver.
+ (APQI). Each bit in the mask, from left to right, corresponds to an APQI from
+ 0-255. If a bit is set, the APQI belongs to the subset of APQNs marked as
+ available only to the default AP queue device drivers.
+
+ The Cartesian product of the APIDs corresponding to the bits set in the
+ apmask and the APQIs corresponding to the bits set in the aqmask comprise
+ the subset of APQNs that can be used only by the host default device drivers.
+ All other APQNs are available to the non-default device drivers such as the
+ vfio_ap driver.
+
+ Take, for example, the following masks::
+
+ apmask:
+ 0x7d00000000000000000000000000000000000000000000000000000000000000
- Take, for example, the following mask::
+ aqmask:
+ 0x8000000000000000000000000000000000000000000000000000000000000000
- 0x7dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ The masks indicate:
- It indicates:
+ * Adapters 1, 2, 3, 4, 5, and 7 are available for use by the host default
+ device drivers.
- 1, 2, 3, 4, 5, and 7-255 belong to the default drivers' pool, and 0 and 6
- belong to the vfio_ap device driver's pool.
+ * Domain 0 is available for use by the host default device drivers
+
+ * The subset of APQNs available for use only by the default host device
+ drivers are:
+
+ (1,0), (2,0), (3,0), (4.0), (5,0) and (7,0)
+
+ * All other APQNs are available for use by the non-default device drivers.
The APQN of each AP queue device assigned to the linux host is checked by the
- AP bus against the set of APQNs derived from the cross product of APIDs
- and APQIs marked as usable only by the default AP queue device drivers. If a
+ AP bus against the set of APQNs derived from the Cartesian product of APIDs
+ and APQIs marked as available to the default AP queue device drivers. If a
match is detected, only the default AP queue device drivers will be probed;
otherwise, the vfio_ap device driver will be probed.
@@ -579,8 +635,7 @@ These are the steps:
0x4100000000000000000000000000000000000000000000000000000000000000
- Keep in mind that the mask reads from left to right (i.e., most
- significant to least significant bit in big endian order), so the mask
+ Keep in mind that the mask reads from left to right, so the mask
above identifies device numbers 1 and 7 (01000001).
If the string is longer than the mask, the operation is terminated with
@@ -626,11 +681,22 @@ These are the steps:
default drivers pool: adapter 0-15, domain 1
alternate drivers pool: adapter 16-255, domains 0, 2-255
+ Note ***:
+ Changing a mask such that one or more APQNs will be taken from a vfio_ap
+ mediated device (see below) will fail with an error (EBUSY). A message
+ is logged to the kernel ring buffer which can be viewed with the 'dmesg'
+ command. The output identifies each APQN flagged as 'in use' and identifies
+ the vfio_ap mediated device to which it is assigned; for example:
+
+ Userspace may not re-assign queue 05.0054 already assigned to 62177883-f1bb-47f0-914d-32a22e3a8804
+ Userspace may not re-assign queue 04.0054 already assigned to cef03c3c-903d-4ecc-9a83-40694cb8aee4
+
Securing the APQNs for our example
----------------------------------
To secure the AP queues 05.0004, 05.0047, 05.00ab, 05.00ff, 06.0004, 06.0047,
06.00ab, and 06.00ff for use by the vfio_ap device driver, the corresponding
- APQNs can either be removed from the default masks::
+ APQNs can be removed from the default masks using either of the following
+ commands::
echo -5,-6 > /sys/bus/ap/apmask
@@ -683,7 +749,7 @@ Securing the APQNs for our example
/sys/devices/vfio_ap/matrix/
--- [mdev_supported_types]
- ------ [vfio_ap-passthrough] (passthrough mediated matrix device type)
+ ------ [vfio_ap-passthrough] (passthrough vfio_ap mediated device type)
--------- create
--------- [devices]
@@ -734,6 +800,9 @@ Securing the APQNs for our example
----------------unassign_control_domain
----------------unassign_domain
+ Note *****: The vfio_ap mdevs do not persist across reboots unless the
+ mdevctl tool is used to create and persist them.
+
4. The administrator now needs to configure the matrixes for the mediated
devices $uuid1 (for Guest1), $uuid2 (for Guest2) and $uuid3 (for Guest3).
@@ -755,6 +824,10 @@ Securing the APQNs for our example
cat matrix
+ To display the matrix that is or will be assigned to Guest1::
+
+ cat guest_matrix
+
This is how the matrix is configured for Guest2::
echo 5 > assign_adapter
@@ -774,17 +847,24 @@ Securing the APQNs for our example
higher than the maximum is specified, the operation will terminate with
an error (ENODEV).
- * All APQNs that can be derived from the adapter ID and the IDs of
- the previously assigned domains must be bound to the vfio_ap device
- driver. If no domains have yet been assigned, then there must be at least
- one APQN with the specified APID bound to the vfio_ap driver. If no such
- APQNs are bound to the driver, the operation will terminate with an
- error (EADDRNOTAVAIL).
+ Note: The maximum adapter number can be obtained via the sysfs
+ /sys/bus/ap/ap_max_adapter_id attribute file.
+
+ * Each APQN derived from the Cartesian product of the APID of the adapter
+ being assigned and the APQIs of the domains previously assigned:
- No APQN that can be derived from the adapter ID and the IDs of the
- previously assigned domains can be assigned to another mediated matrix
- device. If an APQN is assigned to another mediated matrix device, the
- operation will terminate with an error (EADDRINUSE).
+ - Must only be available to the vfio_ap device driver as specified in the
+ sysfs /sys/bus/ap/apmask and /sys/bus/ap/aqmask attribute files. If even
+ one APQN is reserved for use by the host device driver, the operation
+ will terminate with an error (EADDRNOTAVAIL).
+
+ - Must NOT be assigned to another vfio_ap mediated device. If even one APQN
+ is assigned to another vfio_ap mediated device, the operation will
+ terminate with an error (EBUSY).
+
+ - Must NOT be assigned while the sysfs /sys/bus/ap/apmask and
+ sys/bus/ap/aqmask attribute files are being edited or the operation may
+ terminate with an error (EBUSY).
In order to successfully assign a domain:
@@ -793,41 +873,50 @@ Securing the APQNs for our example
higher than the maximum is specified, the operation will terminate with
an error (ENODEV).
- * All APQNs that can be derived from the domain ID and the IDs of
- the previously assigned adapters must be bound to the vfio_ap device
- driver. If no domains have yet been assigned, then there must be at least
- one APQN with the specified APQI bound to the vfio_ap driver. If no such
- APQNs are bound to the driver, the operation will terminate with an
- error (EADDRNOTAVAIL).
+ Note: The maximum domain number can be obtained via the sysfs
+ /sys/bus/ap/ap_max_domain_id attribute file.
+
+ * Each APQN derived from the Cartesian product of the APQI of the domain
+ being assigned and the APIDs of the adapters previously assigned:
- No APQN that can be derived from the domain ID and the IDs of the
- previously assigned adapters can be assigned to another mediated matrix
- device. If an APQN is assigned to another mediated matrix device, the
- operation will terminate with an error (EADDRINUSE).
+ - Must only be available to the vfio_ap device driver as specified in the
+ sysfs /sys/bus/ap/apmask and /sys/bus/ap/aqmask attribute files. If even
+ one APQN is reserved for use by the host device driver, the operation
+ will terminate with an error (EADDRNOTAVAIL).
- In order to successfully assign a control domain, the domain number
- specified must represent a value from 0 up to the maximum domain number
- configured for the system. If a control domain number higher than the maximum
- is specified, the operation will terminate with an error (ENODEV).
+ - Must NOT be assigned to another vfio_ap mediated device. If even one APQN
+ is assigned to another vfio_ap mediated device, the operation will
+ terminate with an error (EBUSY).
+
+ - Must NOT be assigned while the sysfs /sys/bus/ap/apmask and
+ sys/bus/ap/aqmask attribute files are being edited or the operation may
+ terminate with an error (EBUSY).
+
+ In order to successfully assign a control domain:
+
+ * The domain number specified must represent a value from 0 up to the maximum
+ domain number configured for the system. If a control domain number higher
+ than the maximum is specified, the operation will terminate with an
+ error (ENODEV).
5. Start Guest1::
- /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on \
+ /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on,apqi=on \
-device vfio-ap,sysfsdev=/sys/devices/vfio_ap/matrix/$uuid1 ...
7. Start Guest2::
- /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on \
+ /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on,apqi=on \
-device vfio-ap,sysfsdev=/sys/devices/vfio_ap/matrix/$uuid2 ...
7. Start Guest3::
- /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on \
+ /usr/bin/qemu-system-s390x ... -cpu host,ap=on,apqci=on,apft=on,apqi=on \
-device vfio-ap,sysfsdev=/sys/devices/vfio_ap/matrix/$uuid3 ...
-When the guest is shut down, the mediated matrix devices may be removed.
+When the guest is shut down, the vfio_ap mediated devices may be removed.
-Using our example again, to remove the mediated matrix device $uuid1::
+Using our example again, to remove the vfio_ap mediated device $uuid1::
/sys/devices/vfio_ap/matrix/
--- [mdev_supported_types]
@@ -840,26 +929,137 @@ Using our example again, to remove the mediated matrix device $uuid1::
echo 1 > remove
-This will remove all of the mdev matrix device's sysfs structures including
-the mdev device itself. To recreate and reconfigure the mdev matrix device,
+This will remove all of the matrix mdev device's sysfs structures including
+the mdev device itself. To recreate and reconfigure the matrix mdev device,
all of the steps starting with step 3 will have to be performed again. Note
-that the remove will fail if a guest using the mdev is still running.
+that the remove will fail if a guest using the vfio_ap mdev is still running.
-It is not necessary to remove an mdev matrix device, but one may want to
+It is not necessary to remove a vfio_ap mdev, but one may want to
remove it if no guest will use it during the remaining lifetime of the linux
-host. If the mdev matrix device is removed, one may want to also reconfigure
+host. If the vfio_ap mdev is removed, one may want to also reconfigure
the pool of adapters and queues reserved for use by the default drivers.
+Hot plug/unplug support:
+================
+An adapter, domain or control domain may be hot plugged into a running KVM
+guest by assigning it to the vfio_ap mediated device being used by the guest if
+the following conditions are met:
+
+* The adapter, domain or control domain must also be assigned to the host's
+ AP configuration.
+
+* Each APQN derived from the Cartesian product comprised of the APID of the
+ adapter being assigned and the APQIs of the domains assigned must reference a
+ queue device bound to the vfio_ap device driver.
+
+* To hot plug a domain, each APQN derived from the Cartesian product
+ comprised of the APQI of the domain being assigned and the APIDs of the
+ adapters assigned must reference a queue device bound to the vfio_ap device
+ driver.
+
+An adapter, domain or control domain may be hot unplugged from a running KVM
+guest by unassigning it from the vfio_ap mediated device being used by the
+guest.
+
+Over-provisioning of AP queues for a KVM guest:
+==============================================
+Over-provisioning is defined herein as the assignment of adapters or domains to
+a vfio_ap mediated device that do not reference AP devices in the host's AP
+configuration. The idea here is that when the adapter or domain becomes
+available, it will be automatically hot-plugged into the KVM guest using
+the vfio_ap mediated device to which it is assigned as long as each new APQN
+resulting from plugging it in references a queue device bound to the vfio_ap
+device driver.
+
Limitations
===========
-* The KVM/kernel interfaces do not provide a way to prevent restoring an APQN
- to the default drivers pool of a queue that is still assigned to a mediated
- device in use by a guest. It is incumbent upon the administrator to
- ensure there is no mediated device in use by a guest to which the APQN is
- assigned lest the host be given access to the private data of the AP queue
- device such as a private key configured specifically for the guest.
+Live guest migration is not supported for guests using AP devices without
+intervention by a system administrator. Before a KVM guest can be migrated,
+the vfio_ap mediated device must be removed. Unfortunately, it can not be
+removed manually (i.e., echo 1 > /sys/devices/vfio_ap/matrix/$UUID/remove) while
+the mdev is in use by a KVM guest. If the guest is being emulated by QEMU,
+its mdev can be hot unplugged from the guest in one of two ways:
+
+1. If the KVM guest was started with libvirt, you can hot unplug the mdev via
+ the following commands:
+
+ virsh detach-device <guestname> <path-to-device-xml>
+
+ For example, to hot unplug mdev 62177883-f1bb-47f0-914d-32a22e3a8804 from
+ the guest named 'my-guest':
+
+ virsh detach-device my-guest ~/config/my-guest-hostdev.xml
+
+ The contents of my-guest-hostdev.xml:
+
+ <hostdev mode='subsystem' type='mdev' managed='no' model='vfio-ap'>
+ <source>
+ <address uuid='62177883-f1bb-47f0-914d-32a22e3a8804'/>
+ </source>
+ </hostdev>
+
+
+ virsh qemu-monitor-command <guest-name> --hmp "device-del <device-id>"
+
+ For example, to hot unplug the vfio_ap mediated device identified on the
+ qemu command line with 'id=hostdev0' from the guest named 'my-guest':
+
+ virsh qemu-monitor-command my-guest --hmp "device_del hostdev0"
+
+2. A vfio_ap mediated device can be hot unplugged by attaching the qemu monitor
+ to the guest and using the following qemu monitor command:
+
+ (QEMU) device-del id=<device-id>
+
+ For example, to hot unplug the vfio_ap mediated device that was specified
+ on the qemu command line with 'id=hostdev0' when the guest was started:
+
+ (QEMU) device-del id=hostdev0
+
+After live migration of the KVM guest completes, an AP configuration can be
+restored to the KVM guest by hot plugging a vfio_ap mediated device on the target
+system into the guest in one of two ways:
+
+1. If the KVM guest was started with libvirt, you can hot plug a matrix mediated
+ device into the guest via the following virsh commands:
+
+ virsh attach-device <guestname> <path-to-device-xml>
+
+ For example, to hot plug mdev 62177883-f1bb-47f0-914d-32a22e3a8804 into
+ the guest named 'my-guest':
+
+ virsh attach-device my-guest ~/config/my-guest-hostdev.xml
+
+ The contents of my-guest-hostdev.xml:
+
+ <hostdev mode='subsystem' type='mdev' managed='no' model='vfio-ap'>
+ <source>
+ <address uuid='62177883-f1bb-47f0-914d-32a22e3a8804'/>
+ </source>
+ </hostdev>
+
+
+ virsh qemu-monitor-command <guest-name> --hmp \
+ "device_add vfio-ap,sysfsdev=<path-to-mdev>,id=<device-id>"
+
+ For example, to hot plug the vfio_ap mediated device
+ 62177883-f1bb-47f0-914d-32a22e3a8804 into the guest named 'my-guest' with
+ device-id hostdev0:
+
+ virsh qemu-monitor-command my-guest --hmp \
+ "device_add vfio-ap,\
+ sysfsdev=/sys/devices/vfio_ap/matrix/62177883-f1bb-47f0-914d-32a22e3a8804,\
+ id=hostdev0"
+
+2. A vfio_ap mediated device can be hot plugged by attaching the qemu monitor
+ to the guest and using the following qemu monitor command:
+
+ (qemu) device_add "vfio-ap,sysfsdev=<path-to-mdev>,id=<device-id>"
-* Dynamically modifying the AP matrix for a running guest (which would amount to
- hot(un)plug of AP devices for the guest) is currently not supported
+ For example, to plug the vfio_ap mediated device
+ 62177883-f1bb-47f0-914d-32a22e3a8804 into the guest with the device-id
+ hostdev0:
-* Live guest migration is not supported for guests using AP devices.
+ (QEMU) device-add "vfio-ap,\
+ sysfsdev=/sys/devices/vfio_ap/matrix/62177883-f1bb-47f0-914d-32a22e3a8804,\
+ id=hostdev0"
--
2.31.1
When an adapter or domain is unassigned from an mdev attached to a KVM
guest, one or more of the guest's queues may get dynamically removed. Since
the removed queues could get re-assigned to another mdev, they need to be
reset. So, when an adapter or domain is unassigned from the mdev, the
queues that are removed from the guest's AP configuration (APCB) will be
reset.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 152 +++++++++++++++++++-------
drivers/s390/crypto/vfio_ap_private.h | 2 +
2 files changed, 114 insertions(+), 40 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index ec5f37d726ec..49ed54dc9e05 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -26,9 +26,10 @@
#define VFIO_AP_MDEV_TYPE_HWVIRT "passthrough"
#define VFIO_AP_MDEV_NAME_HWVIRT "VFIO AP Passthrough Device"
-static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev);
+static int vfio_ap_mdev_reset_queues(struct ap_queue_table *qtable);
static struct vfio_ap_queue *vfio_ap_find_queue(int apqn);
static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
+static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry);
/**
* get_update_locks_for_kvm: Acquire the locks required to dynamically update a
@@ -644,6 +645,7 @@ static bool vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
unsigned long apid, apqi, apqn;
DECLARE_BITMAP(prev_shadow_apm, AP_DEVICES);
DECLARE_BITMAP(prev_shadow_aqm, AP_DOMAINS);
+ struct vfio_ap_queue *q;
ret = ap_qci(&matrix_dev->info);
if (ret)
@@ -674,8 +676,8 @@ static bool vfio_ap_mdev_filter_matrix(unsigned long *apm, unsigned long *aqm,
* hardware device.
*/
apqn = AP_MKQID(apid, apqi);
-
- if (!vfio_ap_mdev_get_queue(matrix_mdev, apqn)) {
+ q = vfio_ap_mdev_get_queue(matrix_mdev, apqn);
+ if (!q || q->reset_rc) {
clear_bit_inv(apid,
matrix_mdev->shadow_apcb.apm);
break;
@@ -756,12 +758,6 @@ static void vfio_ap_unlink_mdev_fr_queue(struct vfio_ap_queue *q)
q->matrix_mdev = NULL;
}
-static void vfio_ap_mdev_unlink_queue(struct vfio_ap_queue *q)
-{
- vfio_ap_unlink_queue_fr_mdev(q);
- vfio_ap_unlink_mdev_fr_queue(q);
-}
-
static void vfio_ap_mdev_unlink_fr_queues(struct ap_matrix_mdev *matrix_mdev)
{
struct vfio_ap_queue *q;
@@ -786,7 +782,7 @@ static void vfio_ap_mdev_remove(struct mdev_device *mdev)
mutex_lock(&matrix_dev->guests_lock);
mutex_lock(&matrix_dev->mdevs_lock);
- vfio_ap_mdev_reset_queues(matrix_mdev);
+ vfio_ap_mdev_reset_queues(&matrix_mdev->qtable);
vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
list_del(&matrix_mdev->node);
mutex_unlock(&matrix_dev->mdevs_lock);
@@ -1000,18 +996,70 @@ static ssize_t assign_adapter_store(struct device *dev,
}
static DEVICE_ATTR_WO(assign_adapter);
+static struct vfio_ap_queue
+*vfio_ap_unlink_apqn_fr_mdev(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apid, unsigned long apqi)
+{
+ struct vfio_ap_queue *q = NULL;
+
+ q = vfio_ap_mdev_get_queue(matrix_mdev, AP_MKQID(apid, apqi));
+ /* If the queue is assigned to the matrix mdev, unlink it. */
+ if (q)
+ vfio_ap_unlink_queue_fr_mdev(q);
+
+ return q;
+}
+
+/**
+ * vfio_ap_mdev_unlink_adapter - unlink all queues associated with unassigned
+ * adapter from the matrix mdev to which the
+ * adapter was assigned.
+ * @matrix_mdev: the matrix mediated device to which the adapter was assigned.
+ * @apid: the APID of the unassigned adapter.
+ * @qtable: table for storing queues associated with unassigned adapter.
+ */
static void vfio_ap_mdev_unlink_adapter(struct ap_matrix_mdev *matrix_mdev,
- unsigned long apid)
+ unsigned long apid,
+ struct ap_queue_table *qtable)
{
unsigned long apqi;
struct vfio_ap_queue *q;
for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm, AP_DOMAINS) {
- q = vfio_ap_mdev_get_queue(matrix_mdev, AP_MKQID(apid, apqi));
+ q = vfio_ap_unlink_apqn_fr_mdev(matrix_mdev, apid, apqi);
+
+ if (q && qtable) {
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm) &&
+ test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm))
+ hash_add(qtable->queues, &q->mdev_qnode,
+ q->apqn);
+ }
+ }
+}
+
+static void vfio_ap_mdev_hot_unplug_adapter(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apid)
+{
+ int loop_cursor;
+ struct vfio_ap_queue *q;
+ struct ap_queue_table *qtable = kzalloc(sizeof(*qtable), GFP_KERNEL);
+
+ hash_init(qtable->queues);
+ vfio_ap_mdev_unlink_adapter(matrix_mdev, apid, qtable);
+
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm)) {
+ clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
+
+ vfio_ap_mdev_reset_queues(qtable);
- if (q)
- vfio_ap_mdev_unlink_queue(q);
+ hash_for_each(qtable->queues, loop_cursor, q, mdev_qnode) {
+ vfio_ap_unlink_mdev_fr_queue(q);
+ hash_del(&q->mdev_qnode);
}
+
+ kfree(qtable);
}
/**
@@ -1049,13 +1097,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
}
clear_bit_inv((unsigned long)apid, matrix_mdev->matrix.apm);
- vfio_ap_mdev_unlink_adapter(matrix_mdev, apid);
-
- if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm)) {
- clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
- vfio_ap_mdev_update_guest_apcb(matrix_mdev);
- }
-
+ vfio_ap_mdev_hot_unplug_adapter(matrix_mdev, apid);
ret = count;
done:
release_update_locks_for_mdev(matrix_mdev);
@@ -1148,19 +1190,49 @@ static ssize_t assign_domain_store(struct device *dev,
static DEVICE_ATTR_WO(assign_domain);
static void vfio_ap_mdev_unlink_domain(struct ap_matrix_mdev *matrix_mdev,
- unsigned long apqi)
+ unsigned long apqi,
+ struct ap_queue_table *qtable)
{
unsigned long apid;
struct vfio_ap_queue *q;
for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, AP_DEVICES) {
- q = vfio_ap_mdev_get_queue(matrix_mdev, AP_MKQID(apid, apqi));
+ q = vfio_ap_unlink_apqn_fr_mdev(matrix_mdev, apid, apqi);
- if (q)
- vfio_ap_mdev_unlink_queue(q);
+ if (q && qtable) {
+ if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm) &&
+ test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm))
+ hash_add(qtable->queues, &q->mdev_qnode,
+ q->apqn);
+ }
}
}
+static void vfio_ap_mdev_hot_unplug_domain(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apqi)
+{
+ int loop_cursor;
+ struct vfio_ap_queue *q;
+ struct ap_queue_table *qtable = kzalloc(sizeof(*qtable), GFP_KERNEL);
+
+ hash_init(qtable->queues);
+ vfio_ap_mdev_unlink_domain(matrix_mdev, apqi, qtable);
+
+ if (test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm)) {
+ clear_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm);
+ vfio_ap_mdev_update_guest_apcb(matrix_mdev);
+ }
+
+ vfio_ap_mdev_reset_queues(qtable);
+
+ hash_for_each(qtable->queues, loop_cursor, q, mdev_qnode) {
+ vfio_ap_unlink_mdev_fr_queue(q);
+ hash_del(&q->mdev_qnode);
+ }
+
+ kfree(qtable);
+}
+
/**
* unassign_domain_store - parses the APQI from @buf and clears the
* corresponding bit in the mediated matrix device's AQM
@@ -1196,13 +1268,7 @@ static ssize_t unassign_domain_store(struct device *dev,
}
clear_bit_inv((unsigned long)apqi, matrix_mdev->matrix.aqm);
- vfio_ap_mdev_unlink_domain(matrix_mdev, apqi);
-
- if (test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm)) {
- clear_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm);
- vfio_ap_mdev_update_guest_apcb(matrix_mdev);
- }
-
+ vfio_ap_mdev_hot_unplug_domain(matrix_mdev, apqi);
ret = count;
done:
@@ -1487,7 +1553,7 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev)
get_update_locks_for_kvm(kvm);
kvm_arch_crypto_clear_masks(kvm);
- vfio_ap_mdev_reset_queues(matrix_mdev);
+ vfio_ap_mdev_reset_queues(&matrix_mdev->qtable);
kvm_put_kvm(kvm);
matrix_mdev->kvm = NULL;
@@ -1539,9 +1605,9 @@ static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
if (!q)
return 0;
-
retry_zapq:
status = ap_zapq(q->apqn);
+ q->reset_rc = status.response_code;
switch (status.response_code) {
case AP_RESPONSE_NORMAL:
ret = 0;
@@ -1556,12 +1622,17 @@ static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
case AP_RESPONSE_Q_NOT_AVAIL:
case AP_RESPONSE_DECONFIGURED:
case AP_RESPONSE_CHECKSTOPPED:
- WARN_ON_ONCE(status.irq_enabled);
+ WARN_ONCE(status.irq_enabled,
+ "PQAP/ZAPQ for %02x.%04x failed with rc=%u while IRQ enabled",
+ AP_QID_CARD(q->apqn), AP_QID_QUEUE(q->apqn),
+ status.response_code);
ret = -EBUSY;
goto free_resources;
default:
/* things are really broken, give up */
- WARN(true, "PQAP/ZAPQ completed with invalid rc (%x)\n",
+ WARN(true,
+ "PQAP/ZAPQ for %02x.%04x failed with invalid rc=%u\n",
+ AP_QID_CARD(q->apqn), AP_QID_QUEUE(q->apqn),
status.response_code);
return -EIO;
}
@@ -1573,7 +1644,8 @@ static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
msleep(20);
status = ap_tapq(q->apqn, NULL);
}
- WARN_ON_ONCE(retry2 <= 0);
+ WARN_ONCE(retry2 <= 0, "unable to verify reset of queue %02x.%04x",
+ AP_QID_CARD(q->apqn), AP_QID_QUEUE(q->apqn));
free_resources:
vfio_ap_free_aqic_resources(q);
@@ -1581,12 +1653,12 @@ static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
return ret;
}
-static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev)
+static int vfio_ap_mdev_reset_queues(struct ap_queue_table *qtable)
{
int ret, loop_cursor, rc = 0;
struct vfio_ap_queue *q;
- hash_for_each(matrix_mdev->qtable.queues, loop_cursor, q, mdev_qnode) {
+ hash_for_each(qtable->queues, loop_cursor, q, mdev_qnode) {
ret = vfio_ap_mdev_reset_queue(q, 1);
/*
* Regardless whether a queue turns out to be busy, or
@@ -1674,7 +1746,7 @@ static ssize_t vfio_ap_mdev_ioctl(struct vfio_device *vdev,
ret = vfio_ap_mdev_get_device_info(arg);
break;
case VFIO_DEVICE_RESET:
- ret = vfio_ap_mdev_reset_queues(matrix_mdev);
+ ret = vfio_ap_mdev_reset_queues(&matrix_mdev->qtable);
break;
default:
ret = -EOPNOTSUPP;
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index ec926f2f2930..6d4ca39f783b 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -129,6 +129,7 @@ struct ap_matrix_mdev {
* @apqn: the APQN of the AP queue device
* @saved_isc: the guest ISC registered with the GIB interface
* @mdev_qnode: allows the vfio_ap_queue struct to be added to a hashtable
+ * @reset_rc: the status response code from the last reset of the queue
*/
struct vfio_ap_queue {
struct ap_matrix_mdev *matrix_mdev;
@@ -137,6 +138,7 @@ struct vfio_ap_queue {
#define VFIO_AP_ISC_INVALID 0xff
unsigned char saved_isc;
struct hlist_node mdev_qnode;
+ unsigned int reset_rc;
};
int vfio_ap_mdev_register(void);
--
2.31.1
Let's create links between each queue device bound to the vfio_ap device
driver and the matrix mdev to which the queue's APQN is assigned. The idea
is to facilitate efficient retrieval of the objects representing the queue
devices and matrix mdevs as well as to verify that a queue assigned to
a matrix mdev is bound to the driver.
The links will be created as follows:
* When the queue device is probed, if its APQN is assigned to a matrix
mdev, the structures representing the queue device and the matrix mdev
will be linked.
* When an adapter or domain is assigned to a matrix mdev, for each new
APQN assigned that references a queue device bound to the vfio_ap
device driver, the structures representing the queue device and the
matrix mdev will be linked.
The links will be removed as follows:
* When the queue device is removed, if its APQN is assigned to a matrix
mdev, the link from the structure representing the matrix mdev to the
structure representing the queue will be removed. Since the storage
allocated for the vfio_ap_queue will be freed, there is no need to
remove the link to the matrix_mdev to which the queue's APQN is
assigned.
* When an adapter or domain is unassigned from a matrix mdev, for each
APQN unassigned that references a queue device bound to the vfio_ap
device driver, the structures representing the queue device and the
matrix mdev will be unlinked.
* When an mdev is removed, the link from any queues assigned to the mdev
to the mdev will be removed.
Signed-off-by: Tony Krowiak <[email protected]>
Reviewed-by: Halil Pasic <[email protected]>
---
drivers/s390/crypto/vfio_ap_ops.c | 191 +++++++++++++++++++++-----
drivers/s390/crypto/vfio_ap_private.h | 14 ++
2 files changed, 168 insertions(+), 37 deletions(-)
diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
index 16220157dbe3..9df7ceb50ed1 100644
--- a/drivers/s390/crypto/vfio_ap_ops.c
+++ b/drivers/s390/crypto/vfio_ap_ops.c
@@ -31,32 +31,27 @@ static struct vfio_ap_queue *vfio_ap_find_queue(int apqn);
static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
/**
- * vfio_ap_get_queue - retrieve a queue with a specific APQN from a list
- * @matrix_mdev: the associated mediated matrix
- * @apqn: The queue APQN
+ * vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
+ * hash table of queues assigned to a matrix mdev
+ * @matrix_mdev: the matrix mdev
+ * @apqn: The APQN of a queue device
*
- * Retrieve a queue with a specific APQN from the list of the
- * devices of the vfio_ap_drv.
- * Verify that the APID and the APQI are set in the matrix.
- *
- * Return: the pointer to the associated vfio_ap_queue
+ * Return: the pointer to the vfio_ap_queue struct representing the queue or
+ * NULL if the queue is not assigned to @matrix_mdev
*/
-static struct vfio_ap_queue *vfio_ap_get_queue(
+static struct vfio_ap_queue *vfio_ap_mdev_get_queue(
struct ap_matrix_mdev *matrix_mdev,
int apqn)
{
struct vfio_ap_queue *q;
- if (!test_bit_inv(AP_QID_CARD(apqn), matrix_mdev->matrix.apm))
- return NULL;
- if (!test_bit_inv(AP_QID_QUEUE(apqn), matrix_mdev->matrix.aqm))
- return NULL;
-
- q = vfio_ap_find_queue(apqn);
- if (q)
- q->matrix_mdev = matrix_mdev;
+ hash_for_each_possible(matrix_mdev->qtable.queues, q, mdev_qnode,
+ apqn) {
+ if (q && q->apqn == apqn)
+ return q;
+ }
- return q;
+ return NULL;
}
/**
@@ -174,7 +169,6 @@ static struct ap_queue_status vfio_ap_irq_disable(struct vfio_ap_queue *q)
status.response_code);
end_free:
vfio_ap_free_aqic_resources(q);
- q->matrix_mdev = NULL;
return status;
}
@@ -419,7 +413,7 @@ static int handle_pqap(struct kvm_vcpu *vcpu)
goto out_unlock;
}
- q = vfio_ap_get_queue(matrix_mdev, apqn);
+ q = vfio_ap_mdev_get_queue(matrix_mdev, apqn);
if (!q) {
VFIO_AP_DBF_WARN("%s: Queue %02x.%04x not bound to the vfio_ap driver\n",
__func__, AP_QID_CARD(apqn),
@@ -469,6 +463,8 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
matrix_mdev->mdev = mdev;
vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->matrix);
matrix_mdev->pqap_hook = handle_pqap;
+ hash_init(matrix_mdev->qtable.queues);
+ mdev_set_drvdata(mdev, matrix_mdev);
mutex_lock(&matrix_dev->lock);
list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
mutex_unlock(&matrix_dev->lock);
@@ -490,6 +486,55 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
return ret;
}
+static void vfio_ap_mdev_link_queue(struct ap_matrix_mdev *matrix_mdev,
+ struct vfio_ap_queue *q)
+{
+ if (q) {
+ q->matrix_mdev = matrix_mdev;
+ hash_add(matrix_mdev->qtable.queues, &q->mdev_qnode, q->apqn);
+ }
+}
+
+static void vfio_ap_mdev_link_apqn(struct ap_matrix_mdev *matrix_mdev, int apqn)
+{
+ struct vfio_ap_queue *q;
+
+ q = vfio_ap_find_queue(apqn);
+ vfio_ap_mdev_link_queue(matrix_mdev, q);
+}
+
+static void vfio_ap_unlink_queue_fr_mdev(struct vfio_ap_queue *q)
+{
+ hash_del(&q->mdev_qnode);
+}
+
+static void vfio_ap_unlink_mdev_fr_queue(struct vfio_ap_queue *q)
+{
+ q->matrix_mdev = NULL;
+}
+
+static void vfio_ap_mdev_unlink_queue(struct vfio_ap_queue *q)
+{
+ vfio_ap_unlink_queue_fr_mdev(q);
+ vfio_ap_unlink_mdev_fr_queue(q);
+}
+
+static void vfio_ap_mdev_unlink_fr_queues(struct ap_matrix_mdev *matrix_mdev)
+{
+ struct vfio_ap_queue *q;
+ unsigned long apid, apqi;
+
+ for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, AP_DEVICES) {
+ for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm,
+ AP_DOMAINS) {
+ q = vfio_ap_mdev_get_queue(matrix_mdev,
+ AP_MKQID(apid, apqi));
+ if (q)
+ q->matrix_mdev = NULL;
+ }
+ }
+}
+
static void vfio_ap_mdev_remove(struct mdev_device *mdev)
{
struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(&mdev->dev);
@@ -498,6 +543,7 @@ static void vfio_ap_mdev_remove(struct mdev_device *mdev)
mutex_lock(&matrix_dev->lock);
vfio_ap_mdev_reset_queues(matrix_mdev);
+ vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
list_del(&matrix_mdev->node);
mutex_unlock(&matrix_dev->lock);
vfio_uninit_group_dev(&matrix_mdev->vdev);
@@ -706,6 +752,16 @@ static int vfio_ap_mdev_verify_no_sharing(struct ap_matrix_mdev *matrix_mdev)
return 0;
}
+static void vfio_ap_mdev_link_adapter(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apid)
+{
+ unsigned long apqi;
+
+ for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm, AP_DOMAINS)
+ vfio_ap_mdev_link_apqn(matrix_mdev,
+ AP_MKQID(apid, apqi));
+}
+
/**
* assign_adapter_store - parses the APID from @buf and sets the
* corresponding bit in the mediated matrix device's APM
@@ -776,6 +832,7 @@ static ssize_t assign_adapter_store(struct device *dev,
if (ret)
goto share_err;
+ vfio_ap_mdev_link_adapter(matrix_mdev, apid);
ret = count;
goto done;
@@ -788,6 +845,20 @@ static ssize_t assign_adapter_store(struct device *dev,
}
static DEVICE_ATTR_WO(assign_adapter);
+static void vfio_ap_mdev_unlink_adapter(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apid)
+{
+ unsigned long apqi;
+ struct vfio_ap_queue *q;
+
+ for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm, AP_DOMAINS) {
+ q = vfio_ap_mdev_get_queue(matrix_mdev, AP_MKQID(apid, apqi));
+
+ if (q)
+ vfio_ap_mdev_unlink_queue(q);
+ }
+}
+
/**
* unassign_adapter_store - parses the APID from @buf and clears the
* corresponding bit in the mediated matrix device's APM
@@ -829,6 +900,7 @@ static ssize_t unassign_adapter_store(struct device *dev,
}
clear_bit_inv((unsigned long)apid, matrix_mdev->matrix.apm);
+ vfio_ap_mdev_unlink_adapter(matrix_mdev, apid);
ret = count;
done:
mutex_unlock(&matrix_dev->lock);
@@ -856,6 +928,16 @@ vfio_ap_mdev_verify_queues_reserved_for_apqi(struct ap_matrix_mdev *matrix_mdev,
return 0;
}
+static void vfio_ap_mdev_link_domain(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apqi)
+{
+ unsigned long apid;
+
+ for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, AP_DEVICES)
+ vfio_ap_mdev_link_apqn(matrix_mdev,
+ AP_MKQID(apid, apqi));
+}
+
/**
* assign_domain_store - parses the APQI from @buf and sets the
* corresponding bit in the mediated matrix device's AQM
@@ -921,6 +1003,7 @@ static ssize_t assign_domain_store(struct device *dev,
if (ret)
goto share_err;
+ vfio_ap_mdev_link_domain(matrix_mdev, apqi);
ret = count;
goto done;
@@ -933,6 +1016,19 @@ static ssize_t assign_domain_store(struct device *dev,
}
static DEVICE_ATTR_WO(assign_domain);
+static void vfio_ap_mdev_unlink_domain(struct ap_matrix_mdev *matrix_mdev,
+ unsigned long apqi)
+{
+ unsigned long apid;
+ struct vfio_ap_queue *q;
+
+ for_each_set_bit_inv(apid, matrix_mdev->matrix.apm, AP_DEVICES) {
+ q = vfio_ap_mdev_get_queue(matrix_mdev, AP_MKQID(apid, apqi));
+
+ if (q)
+ vfio_ap_mdev_unlink_queue(q);
+ }
+}
/**
* unassign_domain_store - parses the APQI from @buf and clears the
@@ -975,6 +1071,7 @@ static ssize_t unassign_domain_store(struct device *dev,
}
clear_bit_inv((unsigned long)apqi, matrix_mdev->matrix.aqm);
+ vfio_ap_mdev_unlink_domain(matrix_mdev, apqi);
ret = count;
done:
@@ -1366,25 +1463,18 @@ static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev)
{
- int ret;
- int rc = 0;
- unsigned long apid, apqi;
+ int ret, loop_cursor, rc = 0;
struct vfio_ap_queue *q;
- for_each_set_bit_inv(apid, matrix_mdev->matrix.apm,
- matrix_mdev->matrix.apm_max + 1) {
- for_each_set_bit_inv(apqi, matrix_mdev->matrix.aqm,
- matrix_mdev->matrix.aqm_max + 1) {
- q = vfio_ap_find_queue(AP_MKQID(apid, apqi));
- ret = vfio_ap_mdev_reset_queue(q, 1);
- /*
- * Regardless whether a queue turns out to be busy, or
- * is not operational, we need to continue resetting
- * the remaining queues.
- */
- if (ret)
- rc = ret;
- }
+ hash_for_each(matrix_mdev->qtable.queues, loop_cursor, q, mdev_qnode) {
+ ret = vfio_ap_mdev_reset_queue(q, 1);
+ /*
+ * Regardless whether a queue turns out to be busy, or
+ * is not operational, we need to continue resetting
+ * the remaining queues.
+ */
+ if (ret)
+ rc = ret;
}
return rc;
@@ -1524,6 +1614,28 @@ void vfio_ap_mdev_unregister(void)
mdev_unregister_driver(&vfio_ap_matrix_driver);
}
+/*
+ * vfio_ap_queue_link_mdev
+ *
+ * @q: The queue to link with the matrix mdev.
+ *
+ * Links @q with the matrix mdev to which the queue's APQN is assigned.
+ */
+static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
+{
+ unsigned long apid = AP_QID_CARD(q->apqn);
+ unsigned long apqi = AP_QID_QUEUE(q->apqn);
+ struct ap_matrix_mdev *matrix_mdev;
+
+ list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
+ if (test_bit_inv(apid, matrix_mdev->matrix.apm) &&
+ test_bit_inv(apqi, matrix_mdev->matrix.aqm)) {
+ vfio_ap_mdev_link_queue(matrix_mdev, q);
+ break;
+ }
+ }
+}
+
int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
{
struct vfio_ap_queue *q;
@@ -1534,6 +1646,7 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
mutex_lock(&matrix_dev->lock);
q->apqn = to_ap_queue(&apdev->device)->qid;
q->saved_isc = VFIO_AP_ISC_INVALID;
+ vfio_ap_queue_link_mdev(q);
dev_set_drvdata(&apdev->device, q);
mutex_unlock(&matrix_dev->lock);
@@ -1546,6 +1659,10 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
mutex_lock(&matrix_dev->lock);
q = dev_get_drvdata(&apdev->device);
+
+ if (q->matrix_mdev)
+ vfio_ap_unlink_queue_fr_mdev(q);
+
vfio_ap_mdev_reset_queue(q, 1);
dev_set_drvdata(&apdev->device, NULL);
kfree(q);
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index 3cade25a1620..aea6a8b854b3 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -19,6 +19,7 @@
#include <linux/mutex.h>
#include <linux/kvm_host.h>
#include <linux/vfio.h>
+#include <linux/hashtable.h>
#include "ap_bus.h"
@@ -74,6 +75,15 @@ struct ap_matrix {
DECLARE_BITMAP(adm, 256);
};
+/**
+ * struct ap_queue_table - a table of queue objects.
+ *
+ * @queues: a hashtable of queues (struct vfio_ap_queue).
+ */
+struct ap_queue_table {
+ DECLARE_HASHTABLE(queues, 8);
+};
+
/**
* struct ap_matrix_mdev - Contains the data associated with a matrix mediated
* device.
@@ -89,6 +99,7 @@ struct ap_matrix {
* @pqap_hook: the function pointer to the interception handler for the
* PQAP(AQIC) instruction.
* @mdev: the mediated device
+ * @qtable: table of queues (struct vfio_ap_queue) assigned to the mdev
*/
struct ap_matrix_mdev {
struct vfio_device vdev;
@@ -99,6 +110,7 @@ struct ap_matrix_mdev {
struct kvm *kvm;
crypto_hook pqap_hook;
struct mdev_device *mdev;
+ struct ap_queue_table qtable;
};
/**
@@ -108,6 +120,7 @@ struct ap_matrix_mdev {
* @saved_pfn: the guest PFN pinned for the guest
* @apqn: the APQN of the AP queue device
* @saved_isc: the guest ISC registered with the GIB interface
+ * @mdev_qnode: allows the vfio_ap_queue struct to be added to a hashtable
*/
struct vfio_ap_queue {
struct ap_matrix_mdev *matrix_mdev;
@@ -115,6 +128,7 @@ struct vfio_ap_queue {
int apqn;
#define VFIO_AP_ISC_INVALID 0xff
unsigned char saved_isc;
+ struct hlist_node mdev_qnode;
};
int vfio_ap_mdev_register(void);
--
2.31.1
The vfio_ap device driver registers for notification when the pointer to
the KVM object for a guest is set. Recall that the KVM lock (kvm->lock)
mutex must be taken outside of the matrix_dev->lock mutex to prevent the
reporting by lockdep of a circular locking dependency (a.k.a., a lockdep
splat):
* see commit 0cc00c8d4050 ("Fix circular lockdep when setting/clearing
crypto masks")
* see commit 86956e70761b ("replace open coded locks for
VFIO_GROUP_NOTIFY_SET_KVM notification")
With the introduction of support for hot plugging/unplugging AP devices
passed through to a KVM guest, a new guests_lock mutex is introduced to
ensure the proper locking order is maintained:
struct ap_matrix_dev {
...
struct mutex guests_lock;
...
}
The matrix_dev->guests_lock controls access to the matrix_mdev instances
that hold the state for AP devices that have been passed through to a
KVM guest. This lock must be held to control access to the KVM pointer
(matrix_mdev->kvm) while the vfio_ap device driver is using it to
plug/unplug AP devices passed through to the KVM guest.
Keep in mind, the proper locking order must be maintained whenever
dynamically updating a KVM guest's APCB to plug/unplug adapters, domains
and control domains:
1. matrix_dev->guests_lock: required to use the KVM pointer - stored in
a struct ap_matrix_mdev instance - to update a KVM guest's APCB
2. matrix_mdev->kvm->lock: required to update a guest's APCB
3. matrix_dev->mdevs_lock: required to access data stored in a
struct ap_matrix_mdev instance.
Signed-off-by: Tony Krowiak <[email protected]>
---
drivers/s390/crypto/vfio_ap_drv.c | 1 +
drivers/s390/crypto/vfio_ap_private.h | 6 ++++++
2 files changed, 7 insertions(+)
diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
index 0a5acd151a9b..c258e5f7fdfc 100644
--- a/drivers/s390/crypto/vfio_ap_drv.c
+++ b/drivers/s390/crypto/vfio_ap_drv.c
@@ -161,6 +161,7 @@ static int vfio_ap_matrix_dev_create(void)
mutex_init(&matrix_dev->mdevs_lock);
INIT_LIST_HEAD(&matrix_dev->mdev_list);
+ mutex_init(&matrix_dev->guests_lock);
dev_set_name(&matrix_dev->device, "%s", VFIO_AP_DEV_NAME);
matrix_dev->device.parent = root_device;
diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
index 5262e02192a4..ec926f2f2930 100644
--- a/drivers/s390/crypto/vfio_ap_private.h
+++ b/drivers/s390/crypto/vfio_ap_private.h
@@ -39,6 +39,11 @@
* single ap_matrix_mdev device. It's quite coarse but we don't
* expect much contention.
* @vfio_ap_drv: the vfio_ap device driver
+ * @guests_lock: mutex for controlling access to a guest that is using AP
+ * devices passed through by the vfio_ap device driver. This lock
+ * will be taken when the AP devices are plugged into or unplugged
+ * from a guest, and when an ap_matrix_mdev device is added to or
+ * removed from @mdev_list or the list is iterated.
*/
struct ap_matrix_dev {
struct device device;
@@ -47,6 +52,7 @@ struct ap_matrix_dev {
struct list_head mdev_list;
struct mutex mdevs_lock;
struct ap_driver *vfio_ap_drv;
+ struct mutex guests_lock;
};
extern struct ap_matrix_dev *matrix_dev;
--
2.31.1
PING!!
On 4/4/22 6:10 PM, Tony Krowiak wrote:
> The current design for AP pass-through does not support making dynamic
> changes to the AP matrix of a running guest resulting in a few
> deficiencies this patch series is intended to mitigate:
>
> 1. Adapters, domains and control domains can not be added to or removed
> from a running guest. In order to modify a guest's AP configuration,
> the guest must be terminated; only then can AP resources be assigned
> to or unassigned from the guest's matrix mdev. The new AP
> configuration becomes available to the guest when it is subsequently
> restarted.
>
> 2. The AP bus's /sys/bus/ap/apmask and /sys/bus/ap/aqmask interfaces can
> be modified by a root user without any restrictions. A change to
> either mask can result in AP queue devices being unbound from the
> vfio_ap device driver and bound to a zcrypt device driver even if a
> guest is using the queues, thus giving the host access to the guest's
> private crypto data and vice versa.
>
> 3. The APQNs derived from the Cartesian product of the APIDs of the
> adapters and APQIs of the domains assigned to a matrix mdev must
> reference an AP queue device bound to the vfio_ap device driver. The
> AP architecture allows assignment of AP resources that are not
> available to the system, so this artificial restriction is not
> compliant with the architecture.
>
> 4. The AP configuration profile can be dynamically changed for the linux
> host after a KVM guest is started. For example, a new domain can be
> dynamically added to the configuration profile via the SE or an HMC
> connected to a DPM enabled lpar. Likewise, AP adapters can be
> dynamically configured (online state) and deconfigured (standby state)
> using the SE, an SCLP command or an HMC connected to a DPM enabled
> lpar. This can result in inadvertent sharing of AP queues between the
> guest and host.
>
> 5. A root user can manually unbind an AP queue device representing a
> queue in use by a KVM guest via the vfio_ap device driver's sysfs
> unbind attribute. In this case, the guest will be using a queue that
> is not bound to the driver which violates the device model.
>
> This patch series introduces the following changes to the current design
> to alleviate the shortcomings described above as well as to implement
> more of the AP architecture:
>
> 1. A root user will be prevented from making edits to the AP bus's
> /sys/bus/ap/apmask or /sys/bus/ap/aqmask if the change would transfer
> ownership of an APQN from the vfio_ap device driver to a zcrypt driver
> while the APQN is assigned to a matrix mdev.
>
> 2. Allow a root user to hot plug/unplug AP adapters, domains and control
> domains for a KVM guest using the matrix mdev via its sysfs
> assign/unassign attributes.
>
> 4. Allow assignment of an AP adapter or domain to a matrix mdev even if
> it results in assignment of an APQN that does not reference an AP
> queue device bound to the vfio_ap device driver, as long as the APQN
> is not reserved for use by the default zcrypt drivers (also known as
> over-provisioning of AP resources). Allowing over-provisioning of AP
> resources better models the architecture which does not preclude
> assigning AP resources that are not yet available in the system. Such
> APQNs, however, will not be assigned to the guest using the matrix
> mdev; only APQNs referencing AP queue devices bound to the vfio_ap
> device driver will actually get assigned to the guest.
>
> 5. Handle dynamic changes to the AP device model.
>
> 1. Rationale for changes to AP bus's apmask/aqmask interfaces:
> ----------------------------------------------------------
> Due to the extremely sensitive nature of cryptographic data, it is
> imperative that great care be taken to ensure that such data is secured.
> Allowing a root user, either inadvertently or maliciously, to configure
> these masks such that a queue is shared between the host and a guest is
> not only avoidable, it is advisable. It was suggested that this scenario
> is better handled in user space with management software, but that does
> not preclude a malicious administrator from using the sysfs interfaces
> to gain access to a guest's crypto data. It was also suggested that this
> scenario could be avoided by taking access to the adapter away from the
> guest and zeroing out the queues prior to the vfio_ap driver releasing the
> device; however, stealing an adapter in use from a guest as a by-product
> of an operation is bad and will likely cause problems for the guest
> unnecessarily. It was decided that the most effective solution with the
> least number of negative side effects is to prevent the situation at the
> source.
>
> 2. Rationale for hot plug/unplug using matrix mdev sysfs interfaces:
> ----------------------------------------------------------------
> Allowing a user to hot plug/unplug AP resources using the matrix mdev
> sysfs interfaces circumvents the need to terminate the guest in order to
> modify its AP configuration. Allowing dynamic configuration makes
> reconfiguring a guest's AP matrix much less disruptive.
>
> 3. Rationale for allowing over-provisioning of AP resources:
> -----------------------------------------------------------
> Allowing assignment of AP resources to a matrix mdev and ultimately to a
> guest better models the AP architecture. The architecture does not
> preclude assignment of unavailable AP resources. If a queue subsequently
> becomes available while a guest using the matrix mdev to which its APQN
> is assigned, the guest will be given access to it. If an APQN
> is dynamically unassigned from the underlying host system, it will
> automatically become unavailable to the guest.
>
> Change log v18-v19:
> ------------------
> * Changed name of vfio_ap_mdev_hotplug_apcb (vfio_ap_ops.c) to
> vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Replace call to kvm_arch_crypto_set_masks in vfio_ap_mdev_set_kvm with
> call to vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Moved changes related to new locking scheme into its own set of
> patches (Suggested by Jason: review of patch 10/18)
>
> * Consolidated some of the lock acquisition code into macros called by the
> functions that update a KVM guest's APCB.
>
> * Refactored vfio_ap_mdev_unlink_adapter() and
> vfio_ap_unlink_apqn_fr_mdev() functions according to Jason's sample
> code. (Suggested by Jason: review of patch 12/18)
>
> * Require callers of the AP bus ap_apqn_in_matrix_owned_by_def_drv and
> ap_owned_by_def_drv - only called by the vfio_ap driver - to take the
> ap_perms_mutex lock. The adapter/domain assignment interfaces will take
> the ap_perms_mutex lock prior to other required locks to maintain a
> proper locking order and avoid circular locking dependencies when the
> vfio_ap device driver's in_use callback is invoked simultaneously with
> the adapter/domain assignment interfaces. (Suggested by Jason)
>
> * Refactored patch 15/18: handle config changed and scan complete
> notification (Suggested by Jason)
>
> * Refactored filtering of the matrix to reduce redundant processing of
> APQNs:
> - Inspect only the new APIDs or APQIs assigned to the matrix mdev or
> added to the host's AP configuration
> - Automatically removing APIDs or APQIs unassigned from the matrix mdev
> or removed from the host's AP configuration.
> (Suggested by Halil)
>
> Tony Krowiak (20):
> s390/vfio-ap: use new AP bus interface to search for queue devices
> s390/vfio-ap: move probe and remove callbacks to vfio_ap_ops.c
> s390/vfio-ap: manage link between queue struct and matrix mdev
> s390/vfio-ap: introduce shadow APCB
> s390/vfio-ap: refresh guest's APCB by filtering AP resources assigned
> to mdev
> s390/vfio-ap: allow assignment of unavailable AP queues to mdev device
> s390/vfio-ap: rename matrix_dev->lock mutex to matrix_dev->mdevs_lock
> s390/vfio-ap: introduce new mutex to control access to the KVM pointer
> s390/vfio-ap: use proper locking order when setting/clearing KVM
> pointer
> s390/vfio-ap: prepare for dynamic update of guest's APCB on
> assign/unassign
> s390/vfio-ap: prepare for dynamic update of guest's APCB on queue
> probe/remove
> s390/vfio-ap: allow hot plug/unplug of AP devices when
> assigned/unassigned
> s390/vfio-ap: hot plug/unplug of AP devices when probed/removed
> s390/vfio-ap: reset queues after adapter/domain unassignment
> s390/vfio-ap: implement in-use callback for vfio_ap driver
> s390/vfio-ap: sysfs attribute to display the guest's matrix
> s390/vfio-ap: handle config changed and scan complete notification
> s390/vfio-ap: update docs to include dynamic config support
> s390/Docs: new doc describing lock usage by the vfio_ap device driver
> MAINTAINERS: pick up all vfio_ap docs for VFIO AP maintainers
>
> Documentation/s390/vfio-ap-locking.rst | 389 +++++++
> Documentation/s390/vfio-ap.rst | 492 ++++++---
> MAINTAINERS | 6 +-
> drivers/s390/crypto/ap_bus.c | 31 +-
> drivers/s390/crypto/vfio_ap_drv.c | 69 +-
> drivers/s390/crypto/vfio_ap_ops.c | 1321 ++++++++++++++++++------
> drivers/s390/crypto/vfio_ap_private.h | 47 +-
> 7 files changed, 1820 insertions(+), 535 deletions(-)
> create mode 100644 Documentation/s390/vfio-ap-locking.rst
>
Hello, anybody home?
On 4/4/22 6:10 PM, Tony Krowiak wrote:
> The current design for AP pass-through does not support making dynamic
> changes to the AP matrix of a running guest resulting in a few
> deficiencies this patch series is intended to mitigate:
>
> 1. Adapters, domains and control domains can not be added to or removed
> from a running guest. In order to modify a guest's AP configuration,
> the guest must be terminated; only then can AP resources be assigned
> to or unassigned from the guest's matrix mdev. The new AP
> configuration becomes available to the guest when it is subsequently
> restarted.
>
> 2. The AP bus's /sys/bus/ap/apmask and /sys/bus/ap/aqmask interfaces can
> be modified by a root user without any restrictions. A change to
> either mask can result in AP queue devices being unbound from the
> vfio_ap device driver and bound to a zcrypt device driver even if a
> guest is using the queues, thus giving the host access to the guest's
> private crypto data and vice versa.
>
> 3. The APQNs derived from the Cartesian product of the APIDs of the
> adapters and APQIs of the domains assigned to a matrix mdev must
> reference an AP queue device bound to the vfio_ap device driver. The
> AP architecture allows assignment of AP resources that are not
> available to the system, so this artificial restriction is not
> compliant with the architecture.
>
> 4. The AP configuration profile can be dynamically changed for the linux
> host after a KVM guest is started. For example, a new domain can be
> dynamically added to the configuration profile via the SE or an HMC
> connected to a DPM enabled lpar. Likewise, AP adapters can be
> dynamically configured (online state) and deconfigured (standby state)
> using the SE, an SCLP command or an HMC connected to a DPM enabled
> lpar. This can result in inadvertent sharing of AP queues between the
> guest and host.
>
> 5. A root user can manually unbind an AP queue device representing a
> queue in use by a KVM guest via the vfio_ap device driver's sysfs
> unbind attribute. In this case, the guest will be using a queue that
> is not bound to the driver which violates the device model.
>
> This patch series introduces the following changes to the current design
> to alleviate the shortcomings described above as well as to implement
> more of the AP architecture:
>
> 1. A root user will be prevented from making edits to the AP bus's
> /sys/bus/ap/apmask or /sys/bus/ap/aqmask if the change would transfer
> ownership of an APQN from the vfio_ap device driver to a zcrypt driver
> while the APQN is assigned to a matrix mdev.
>
> 2. Allow a root user to hot plug/unplug AP adapters, domains and control
> domains for a KVM guest using the matrix mdev via its sysfs
> assign/unassign attributes.
>
> 4. Allow assignment of an AP adapter or domain to a matrix mdev even if
> it results in assignment of an APQN that does not reference an AP
> queue device bound to the vfio_ap device driver, as long as the APQN
> is not reserved for use by the default zcrypt drivers (also known as
> over-provisioning of AP resources). Allowing over-provisioning of AP
> resources better models the architecture which does not preclude
> assigning AP resources that are not yet available in the system. Such
> APQNs, however, will not be assigned to the guest using the matrix
> mdev; only APQNs referencing AP queue devices bound to the vfio_ap
> device driver will actually get assigned to the guest.
>
> 5. Handle dynamic changes to the AP device model.
>
> 1. Rationale for changes to AP bus's apmask/aqmask interfaces:
> ----------------------------------------------------------
> Due to the extremely sensitive nature of cryptographic data, it is
> imperative that great care be taken to ensure that such data is secured.
> Allowing a root user, either inadvertently or maliciously, to configure
> these masks such that a queue is shared between the host and a guest is
> not only avoidable, it is advisable. It was suggested that this scenario
> is better handled in user space with management software, but that does
> not preclude a malicious administrator from using the sysfs interfaces
> to gain access to a guest's crypto data. It was also suggested that this
> scenario could be avoided by taking access to the adapter away from the
> guest and zeroing out the queues prior to the vfio_ap driver releasing the
> device; however, stealing an adapter in use from a guest as a by-product
> of an operation is bad and will likely cause problems for the guest
> unnecessarily. It was decided that the most effective solution with the
> least number of negative side effects is to prevent the situation at the
> source.
>
> 2. Rationale for hot plug/unplug using matrix mdev sysfs interfaces:
> ----------------------------------------------------------------
> Allowing a user to hot plug/unplug AP resources using the matrix mdev
> sysfs interfaces circumvents the need to terminate the guest in order to
> modify its AP configuration. Allowing dynamic configuration makes
> reconfiguring a guest's AP matrix much less disruptive.
>
> 3. Rationale for allowing over-provisioning of AP resources:
> -----------------------------------------------------------
> Allowing assignment of AP resources to a matrix mdev and ultimately to a
> guest better models the AP architecture. The architecture does not
> preclude assignment of unavailable AP resources. If a queue subsequently
> becomes available while a guest using the matrix mdev to which its APQN
> is assigned, the guest will be given access to it. If an APQN
> is dynamically unassigned from the underlying host system, it will
> automatically become unavailable to the guest.
>
> Change log v18-v19:
> ------------------
> * Changed name of vfio_ap_mdev_hotplug_apcb (vfio_ap_ops.c) to
> vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Replace call to kvm_arch_crypto_set_masks in vfio_ap_mdev_set_kvm with
> call to vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Moved changes related to new locking scheme into its own set of
> patches (Suggested by Jason: review of patch 10/18)
>
> * Consolidated some of the lock acquisition code into macros called by the
> functions that update a KVM guest's APCB.
>
> * Refactored vfio_ap_mdev_unlink_adapter() and
> vfio_ap_unlink_apqn_fr_mdev() functions according to Jason's sample
> code. (Suggested by Jason: review of patch 12/18)
>
> * Require callers of the AP bus ap_apqn_in_matrix_owned_by_def_drv and
> ap_owned_by_def_drv - only called by the vfio_ap driver - to take the
> ap_perms_mutex lock. The adapter/domain assignment interfaces will take
> the ap_perms_mutex lock prior to other required locks to maintain a
> proper locking order and avoid circular locking dependencies when the
> vfio_ap device driver's in_use callback is invoked simultaneously with
> the adapter/domain assignment interfaces. (Suggested by Jason)
>
> * Refactored patch 15/18: handle config changed and scan complete
> notification (Suggested by Jason)
>
> * Refactored filtering of the matrix to reduce redundant processing of
> APQNs:
> - Inspect only the new APIDs or APQIs assigned to the matrix mdev or
> added to the host's AP configuration
> - Automatically removing APIDs or APQIs unassigned from the matrix mdev
> or removed from the host's AP configuration.
> (Suggested by Halil)
>
> Tony Krowiak (20):
> s390/vfio-ap: use new AP bus interface to search for queue devices
> s390/vfio-ap: move probe and remove callbacks to vfio_ap_ops.c
> s390/vfio-ap: manage link between queue struct and matrix mdev
> s390/vfio-ap: introduce shadow APCB
> s390/vfio-ap: refresh guest's APCB by filtering AP resources assigned
> to mdev
> s390/vfio-ap: allow assignment of unavailable AP queues to mdev device
> s390/vfio-ap: rename matrix_dev->lock mutex to matrix_dev->mdevs_lock
> s390/vfio-ap: introduce new mutex to control access to the KVM pointer
> s390/vfio-ap: use proper locking order when setting/clearing KVM
> pointer
> s390/vfio-ap: prepare for dynamic update of guest's APCB on
> assign/unassign
> s390/vfio-ap: prepare for dynamic update of guest's APCB on queue
> probe/remove
> s390/vfio-ap: allow hot plug/unplug of AP devices when
> assigned/unassigned
> s390/vfio-ap: hot plug/unplug of AP devices when probed/removed
> s390/vfio-ap: reset queues after adapter/domain unassignment
> s390/vfio-ap: implement in-use callback for vfio_ap driver
> s390/vfio-ap: sysfs attribute to display the guest's matrix
> s390/vfio-ap: handle config changed and scan complete notification
> s390/vfio-ap: update docs to include dynamic config support
> s390/Docs: new doc describing lock usage by the vfio_ap device driver
> MAINTAINERS: pick up all vfio_ap docs for VFIO AP maintainers
>
> Documentation/s390/vfio-ap-locking.rst | 389 +++++++
> Documentation/s390/vfio-ap.rst | 492 ++++++---
> MAINTAINERS | 6 +-
> drivers/s390/crypto/ap_bus.c | 31 +-
> drivers/s390/crypto/vfio_ap_drv.c | 69 +-
> drivers/s390/crypto/vfio_ap_ops.c | 1321 ++++++++++++++++++------
> drivers/s390/crypto/vfio_ap_private.h | 47 +-
> 7 files changed, 1820 insertions(+), 535 deletions(-)
> create mode 100644 Documentation/s390/vfio-ap-locking.rst
>
PING
On 4/4/22 6:10 PM, Tony Krowiak wrote:
> The current design for AP pass-through does not support making dynamic
> changes to the AP matrix of a running guest resulting in a few
> deficiencies this patch series is intended to mitigate:
>
> 1. Adapters, domains and control domains can not be added to or removed
> from a running guest. In order to modify a guest's AP configuration,
> the guest must be terminated; only then can AP resources be assigned
> to or unassigned from the guest's matrix mdev. The new AP
> configuration becomes available to the guest when it is subsequently
> restarted.
>
> 2. The AP bus's /sys/bus/ap/apmask and /sys/bus/ap/aqmask interfaces can
> be modified by a root user without any restrictions. A change to
> either mask can result in AP queue devices being unbound from the
> vfio_ap device driver and bound to a zcrypt device driver even if a
> guest is using the queues, thus giving the host access to the guest's
> private crypto data and vice versa.
>
> 3. The APQNs derived from the Cartesian product of the APIDs of the
> adapters and APQIs of the domains assigned to a matrix mdev must
> reference an AP queue device bound to the vfio_ap device driver. The
> AP architecture allows assignment of AP resources that are not
> available to the system, so this artificial restriction is not
> compliant with the architecture.
>
> 4. The AP configuration profile can be dynamically changed for the linux
> host after a KVM guest is started. For example, a new domain can be
> dynamically added to the configuration profile via the SE or an HMC
> connected to a DPM enabled lpar. Likewise, AP adapters can be
> dynamically configured (online state) and deconfigured (standby state)
> using the SE, an SCLP command or an HMC connected to a DPM enabled
> lpar. This can result in inadvertent sharing of AP queues between the
> guest and host.
>
> 5. A root user can manually unbind an AP queue device representing a
> queue in use by a KVM guest via the vfio_ap device driver's sysfs
> unbind attribute. In this case, the guest will be using a queue that
> is not bound to the driver which violates the device model.
>
> This patch series introduces the following changes to the current design
> to alleviate the shortcomings described above as well as to implement
> more of the AP architecture:
>
> 1. A root user will be prevented from making edits to the AP bus's
> /sys/bus/ap/apmask or /sys/bus/ap/aqmask if the change would transfer
> ownership of an APQN from the vfio_ap device driver to a zcrypt driver
> while the APQN is assigned to a matrix mdev.
>
> 2. Allow a root user to hot plug/unplug AP adapters, domains and control
> domains for a KVM guest using the matrix mdev via its sysfs
> assign/unassign attributes.
>
> 4. Allow assignment of an AP adapter or domain to a matrix mdev even if
> it results in assignment of an APQN that does not reference an AP
> queue device bound to the vfio_ap device driver, as long as the APQN
> is not reserved for use by the default zcrypt drivers (also known as
> over-provisioning of AP resources). Allowing over-provisioning of AP
> resources better models the architecture which does not preclude
> assigning AP resources that are not yet available in the system. Such
> APQNs, however, will not be assigned to the guest using the matrix
> mdev; only APQNs referencing AP queue devices bound to the vfio_ap
> device driver will actually get assigned to the guest.
>
> 5. Handle dynamic changes to the AP device model.
>
> 1. Rationale for changes to AP bus's apmask/aqmask interfaces:
> ----------------------------------------------------------
> Due to the extremely sensitive nature of cryptographic data, it is
> imperative that great care be taken to ensure that such data is secured.
> Allowing a root user, either inadvertently or maliciously, to configure
> these masks such that a queue is shared between the host and a guest is
> not only avoidable, it is advisable. It was suggested that this scenario
> is better handled in user space with management software, but that does
> not preclude a malicious administrator from using the sysfs interfaces
> to gain access to a guest's crypto data. It was also suggested that this
> scenario could be avoided by taking access to the adapter away from the
> guest and zeroing out the queues prior to the vfio_ap driver releasing the
> device; however, stealing an adapter in use from a guest as a by-product
> of an operation is bad and will likely cause problems for the guest
> unnecessarily. It was decided that the most effective solution with the
> least number of negative side effects is to prevent the situation at the
> source.
>
> 2. Rationale for hot plug/unplug using matrix mdev sysfs interfaces:
> ----------------------------------------------------------------
> Allowing a user to hot plug/unplug AP resources using the matrix mdev
> sysfs interfaces circumvents the need to terminate the guest in order to
> modify its AP configuration. Allowing dynamic configuration makes
> reconfiguring a guest's AP matrix much less disruptive.
>
> 3. Rationale for allowing over-provisioning of AP resources:
> -----------------------------------------------------------
> Allowing assignment of AP resources to a matrix mdev and ultimately to a
> guest better models the AP architecture. The architecture does not
> preclude assignment of unavailable AP resources. If a queue subsequently
> becomes available while a guest using the matrix mdev to which its APQN
> is assigned, the guest will be given access to it. If an APQN
> is dynamically unassigned from the underlying host system, it will
> automatically become unavailable to the guest.
>
> Change log v18-v19:
> ------------------
> * Changed name of vfio_ap_mdev_hotplug_apcb (vfio_ap_ops.c) to
> vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Replace call to kvm_arch_crypto_set_masks in vfio_ap_mdev_set_kvm with
> call to vfio_ap_mdev_update_guest_apcb
> (Suggested by Jason: review of patch 10/18)
>
> * Moved changes related to new locking scheme into its own set of
> patches (Suggested by Jason: review of patch 10/18)
>
> * Consolidated some of the lock acquisition code into macros called by the
> functions that update a KVM guest's APCB.
>
> * Refactored vfio_ap_mdev_unlink_adapter() and
> vfio_ap_unlink_apqn_fr_mdev() functions according to Jason's sample
> code. (Suggested by Jason: review of patch 12/18)
>
> * Require callers of the AP bus ap_apqn_in_matrix_owned_by_def_drv and
> ap_owned_by_def_drv - only called by the vfio_ap driver - to take the
> ap_perms_mutex lock. The adapter/domain assignment interfaces will take
> the ap_perms_mutex lock prior to other required locks to maintain a
> proper locking order and avoid circular locking dependencies when the
> vfio_ap device driver's in_use callback is invoked simultaneously with
> the adapter/domain assignment interfaces. (Suggested by Jason)
>
> * Refactored patch 15/18: handle config changed and scan complete
> notification (Suggested by Jason)
>
> * Refactored filtering of the matrix to reduce redundant processing of
> APQNs:
> - Inspect only the new APIDs or APQIs assigned to the matrix mdev or
> added to the host's AP configuration
> - Automatically removing APIDs or APQIs unassigned from the matrix mdev
> or removed from the host's AP configuration.
> (Suggested by Halil)
>
> Tony Krowiak (20):
> s390/vfio-ap: use new AP bus interface to search for queue devices
> s390/vfio-ap: move probe and remove callbacks to vfio_ap_ops.c
> s390/vfio-ap: manage link between queue struct and matrix mdev
> s390/vfio-ap: introduce shadow APCB
> s390/vfio-ap: refresh guest's APCB by filtering AP resources assigned
> to mdev
> s390/vfio-ap: allow assignment of unavailable AP queues to mdev device
> s390/vfio-ap: rename matrix_dev->lock mutex to matrix_dev->mdevs_lock
> s390/vfio-ap: introduce new mutex to control access to the KVM pointer
> s390/vfio-ap: use proper locking order when setting/clearing KVM
> pointer
> s390/vfio-ap: prepare for dynamic update of guest's APCB on
> assign/unassign
> s390/vfio-ap: prepare for dynamic update of guest's APCB on queue
> probe/remove
> s390/vfio-ap: allow hot plug/unplug of AP devices when
> assigned/unassigned
> s390/vfio-ap: hot plug/unplug of AP devices when probed/removed
> s390/vfio-ap: reset queues after adapter/domain unassignment
> s390/vfio-ap: implement in-use callback for vfio_ap driver
> s390/vfio-ap: sysfs attribute to display the guest's matrix
> s390/vfio-ap: handle config changed and scan complete notification
> s390/vfio-ap: update docs to include dynamic config support
> s390/Docs: new doc describing lock usage by the vfio_ap device driver
> MAINTAINERS: pick up all vfio_ap docs for VFIO AP maintainers
>
> Documentation/s390/vfio-ap-locking.rst | 389 +++++++
> Documentation/s390/vfio-ap.rst | 492 ++++++---
> MAINTAINERS | 6 +-
> drivers/s390/crypto/ap_bus.c | 31 +-
> drivers/s390/crypto/vfio_ap_drv.c | 69 +-
> drivers/s390/crypto/vfio_ap_ops.c | 1321 ++++++++++++++++++------
> drivers/s390/crypto/vfio_ap_private.h | 47 +-
> 7 files changed, 1820 insertions(+), 535 deletions(-)
> create mode 100644 Documentation/s390/vfio-ap-locking.rst
>
Thanks for the review
On 5/16/22 1:50 PM, Jason J. Herne wrote:
> Reviewed-by: Jason J. Herne <[email protected]>
On 5/16/22 12:36 PM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> |@@ -1306,8 +1392,6 @@ static int vfio_ap_mdev_set_kvm(struct
>> ap_matrix_mdev *matrix_mdev, kvm_get_kvm(kvm); matrix_mdev->kvm =
>> kvm; - memcpy(&matrix_mdev->shadow_apcb, &matrix_mdev->matrix, -
>> sizeof(struct ap_matrix)); kvm_arch_crypto_set_masks(kvm,
>> matrix_mdev->shadow_apcb.apm, matrix_mdev->shadow_apcb.aqm,
>> matrix_mdev->shadow_apcb.adm);|
>
> This looks like an unrelated change. Does this snippet really belong
> to this patch?
It's kind of hard to tell which snippet you are talking about without
the patch context, but I assume you are referring to the removal of the
memcpy statement in the vfio_ap_mdev_set_kvm() function in which case
this snippet belongs with this patch.
This patch introduces a function that filters the contents of the
matrix_mdev->matrix to ensure that the matrix_mdev->shadow_apcb contains
only queues that are bound to the vfio_ap device driver. The filtering
function is called whenever an adapter, domain or control domain is
assigned or unassigned, so it is no longer necessary to copy the
contents of matrix_mdev->matrix into matrix_mdev->shadow_apcb before
setting the masks in the guest; that will have already been done by the
filter function.
On 5/16/22 13:13, Tony Krowiak wrote:
>
>
> On 5/16/22 12:36 PM, Jason J. Herne wrote:
>> On 4/4/22 18:10, Tony Krowiak wrote:
>>> |@@ -1306,8 +1392,6 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev
>>> *matrix_mdev, kvm_get_kvm(kvm); matrix_mdev->kvm = kvm; -
>>> memcpy(&matrix_mdev->shadow_apcb, &matrix_mdev->matrix, - sizeof(struct ap_matrix));
>>> kvm_arch_crypto_set_masks(kvm, matrix_mdev->shadow_apcb.apm,
>>> matrix_mdev->shadow_apcb.aqm, matrix_mdev->shadow_apcb.adm);|
>>
>> This looks like an unrelated change. Does this snippet really belong to this patch?
>
> It's kind of hard to tell which snippet you are talking about without the patch context,
> but I assume you are referring to the removal of the memcpy statement in the
> vfio_ap_mdev_set_kvm() function in which case this snippet belongs with this patch.
>
> This patch introduces a function that filters the contents of the matrix_mdev->matrix to
> ensure that the matrix_mdev->shadow_apcb contains only queues that are bound to the
> vfio_ap device driver. The filtering function is called whenever an adapter, domain or
> control domain is assigned or unassigned, so it is no longer necessary to copy the
> contents of matrix_mdev->matrix into matrix_mdev->shadow_apcb before setting the masks in
> the guest; that will have already been done by the filter function.
>
>
I was apparently a little overzealous with my trimming. Yes, you are correct. Thanks for
the explanation.
Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> |@@ -1306,8 +1392,6 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
> kvm_get_kvm(kvm); matrix_mdev->kvm = kvm; - memcpy(&matrix_mdev->shadow_apcb,
> &matrix_mdev->matrix, - sizeof(struct ap_matrix)); kvm_arch_crypto_set_masks(kvm,
> matrix_mdev->shadow_apcb.apm, matrix_mdev->shadow_apcb.aqm, matrix_mdev->shadow_apcb.adm);|
This looks like an unrelated change. Does this snippet really belong to this patch?
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The matrix_dev->lock mutex is being renamed to matrix_dev->mdevs_lock to
> better reflect its purpose, which is to control access to the state of the
> mediated devices under the control of the vfio_ap device driver.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_drv.c | 6 +--
> drivers/s390/crypto/vfio_ap_ops.c | 72 ++++++++++++++-------------
> drivers/s390/crypto/vfio_ap_private.h | 4 +-
> 3 files changed, 42 insertions(+), 40 deletions(-)
Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
Thank you for the review.
On 5/17/22 10:02 AM, Jason J. Herne wrote:
> Reviewed-by: Jason J. Herne <[email protected]>
On 5/24/22 10:49 AM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> Let's move the probe and remove callbacks into the vfio_ap_ops.c
>> file to keep all code related to managing queues in a single file. This
>> way, all functions related to queue management can be removed from the
>> vfio_ap_private.h header file defining the public interfaces for the
>> vfio_ap device driver.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> Reviewed-by: Halil Pasic <[email protected]>
>> ---
>> drivers/s390/crypto/vfio_ap_drv.c | 59 +--------------------------
>> drivers/s390/crypto/vfio_ap_ops.c | 31 +++++++++++++-
>> drivers/s390/crypto/vfio_ap_private.h | 5 ++-
>> 3 files changed, 34 insertions(+), 61 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/vfio_ap_drv.c
>> b/drivers/s390/crypto/vfio_ap_drv.c
>> index 29ebd54f8919..9a300dd3b6f7 100644
>> --- a/drivers/s390/crypto/vfio_ap_drv.c
>> +++ b/drivers/s390/crypto/vfio_ap_drv.c
>> @@ -104,64 +104,9 @@ static const struct attribute_group
>> vfio_queue_attr_group = {
>> .attrs = vfio_queue_attrs,
>> };
>> -/**
>> - * vfio_ap_queue_dev_probe: Allocate a vfio_ap_queue structure and
>> associate it
>> - * with the device as driver_data.
>> - *
>> - * @apdev: the AP device being probed
>> - *
>> - * Return: returns 0 if the probe succeeded; otherwise, returns an
>> error if
>> - * storage could not be allocated for a vfio_ap_queue object
>> or the
>> - * sysfs 'status' attribute could not be created for the queue
>> device.
>> - */
>> -static int vfio_ap_queue_dev_probe(struct ap_device *apdev)
>> -{
>> - int ret;
>> - struct vfio_ap_queue *q;
>> -
>> - q = kzalloc(sizeof(*q), GFP_KERNEL);
>> - if (!q)
>> - return -ENOMEM;
>> -
>> - mutex_lock(&matrix_dev->lock);
>> - dev_set_drvdata(&apdev->device, q);
>> - q->apqn = to_ap_queue(&apdev->device)->qid;
>> - q->saved_isc = VFIO_AP_ISC_INVALID;
>> -
>> - ret = sysfs_create_group(&apdev->device.kobj,
>> &vfio_queue_attr_group);
>> - if (ret) {
>> - dev_set_drvdata(&apdev->device, NULL);
>> - kfree(q);
>> - }
>> -
>> - mutex_unlock(&matrix_dev->lock);
>> -
>> - return ret;
>> -}
>> -
>> -/**
>> - * vfio_ap_queue_dev_remove: Free the associated vfio_ap_queue
>> structure.
>> - *
>> - * @apdev: the AP device being removed
>> - *
>> - * Takes the matrix lock to avoid actions on this device while doing
>> the remove.
>> - */
>> -static void vfio_ap_queue_dev_remove(struct ap_device *apdev)
>> -{
>> - struct vfio_ap_queue *q;
>> -
>> - mutex_lock(&matrix_dev->lock);
>> - sysfs_remove_group(&apdev->device.kobj, &vfio_queue_attr_group);
>> - q = dev_get_drvdata(&apdev->device);
>> - vfio_ap_mdev_reset_queue(q, 1);
>> - dev_set_drvdata(&apdev->device, NULL);
>> - kfree(q);
>> - mutex_unlock(&matrix_dev->lock);
>> -}
>> -
>> static struct ap_driver vfio_ap_drv = {
>> - .probe = vfio_ap_queue_dev_probe,
>> - .remove = vfio_ap_queue_dev_remove,
>> + .probe = vfio_ap_mdev_probe_queue,
>> + .remove = vfio_ap_mdev_remove_queue,
>> .ids = ap_queue_ids,
>> };
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 2227919fde13..16220157dbe3 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -1314,8 +1314,7 @@ static struct vfio_ap_queue
>> *vfio_ap_find_queue(int apqn)
>> return q;
>> }
>> -int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
>> - unsigned int retry)
>> +static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
>> unsigned int retry)
>> {
>> struct ap_queue_status status;
>> int ret;
>> @@ -1524,3 +1523,31 @@ void vfio_ap_mdev_unregister(void)
>> mdev_unregister_device(&matrix_dev->device);
>> mdev_unregister_driver(&vfio_ap_matrix_driver);
>> }
>> +
>> +int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
>> +{
>> + struct vfio_ap_queue *q;
>> +
>> + q = kzalloc(sizeof(*q), GFP_KERNEL);
>> + if (!q)
>> + return -ENOMEM;
>> + mutex_lock(&matrix_dev->lock);
>> + q->apqn = to_ap_queue(&apdev->device)->qid;
>> + q->saved_isc = VFIO_AP_ISC_INVALID;
>> + dev_set_drvdata(&apdev->device, q);
>> + mutex_unlock(&matrix_dev->lock);
>> +
>> + return 0;
>> +}
>> +
>> +void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
>> +{
>> + struct vfio_ap_queue *q;
>> +
>> + mutex_lock(&matrix_dev->lock);
>> + q = dev_get_drvdata(&apdev->device);
>> + vfio_ap_mdev_reset_queue(q, 1);
>> + dev_set_drvdata(&apdev->device, NULL);
>> + kfree(q);
>> + mutex_unlock(&matrix_dev->lock);
>> +}
>> diff --git a/drivers/s390/crypto/vfio_ap_private.h
>> b/drivers/s390/crypto/vfio_ap_private.h
>> index 648fcaf8104a..3cade25a1620 100644
>> --- a/drivers/s390/crypto/vfio_ap_private.h
>> +++ b/drivers/s390/crypto/vfio_ap_private.h
>> @@ -119,7 +119,8 @@ struct vfio_ap_queue {
>> int vfio_ap_mdev_register(void);
>> void vfio_ap_mdev_unregister(void);
>> -int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
>> - unsigned int retry);
>> +
>> +int vfio_ap_mdev_probe_queue(struct ap_device *queue);
>> +void vfio_ap_mdev_remove_queue(struct ap_device *queue);
>> #endif /* _VFIO_AP_PRIVATE_H_ */
>
>
> With this commit, you did more than just move the probe/remove
> functions. You also changed their behavior. The call to
> sysfs_create_group has been removed. So the following in vfop_ap_drv.c
> becomes dead code:
>
> vfio_ap_mdev_for_queue
> status_show
> static DEVICE_ATTR_RO(status);
> vfio_queue_attrs
> vfio_queue_attr_group
>
> Is this what you intended? If so, I assume we can live without the
> status attribute?
> If this is the case then you'll want to remove all the dead code.
This was not intended. The status attribute was added via commit
f139862b92cf which
was merged into the KVM last October. I believe it may have been removed
when this
was rebased on the release containing that patch. I'll reinstate that
attribute as it is
necessary. Thanks and good catch.
>
>
On 4/4/22 18:10, Tony Krowiak wrote:
> Let's move the probe and remove callbacks into the vfio_ap_ops.c
> file to keep all code related to managing queues in a single file. This
> way, all functions related to queue management can be removed from the
> vfio_ap_private.h header file defining the public interfaces for the
> vfio_ap device driver.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> Reviewed-by: Halil Pasic <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_drv.c | 59 +--------------------------
> drivers/s390/crypto/vfio_ap_ops.c | 31 +++++++++++++-
> drivers/s390/crypto/vfio_ap_private.h | 5 ++-
> 3 files changed, 34 insertions(+), 61 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
> index 29ebd54f8919..9a300dd3b6f7 100644
> --- a/drivers/s390/crypto/vfio_ap_drv.c
> +++ b/drivers/s390/crypto/vfio_ap_drv.c
> @@ -104,64 +104,9 @@ static const struct attribute_group vfio_queue_attr_group = {
> .attrs = vfio_queue_attrs,
> };
>
> -/**
> - * vfio_ap_queue_dev_probe: Allocate a vfio_ap_queue structure and associate it
> - * with the device as driver_data.
> - *
> - * @apdev: the AP device being probed
> - *
> - * Return: returns 0 if the probe succeeded; otherwise, returns an error if
> - * storage could not be allocated for a vfio_ap_queue object or the
> - * sysfs 'status' attribute could not be created for the queue device.
> - */
> -static int vfio_ap_queue_dev_probe(struct ap_device *apdev)
> -{
> - int ret;
> - struct vfio_ap_queue *q;
> -
> - q = kzalloc(sizeof(*q), GFP_KERNEL);
> - if (!q)
> - return -ENOMEM;
> -
> - mutex_lock(&matrix_dev->lock);
> - dev_set_drvdata(&apdev->device, q);
> - q->apqn = to_ap_queue(&apdev->device)->qid;
> - q->saved_isc = VFIO_AP_ISC_INVALID;
> -
> - ret = sysfs_create_group(&apdev->device.kobj, &vfio_queue_attr_group);
> - if (ret) {
> - dev_set_drvdata(&apdev->device, NULL);
> - kfree(q);
> - }
> -
> - mutex_unlock(&matrix_dev->lock);
> -
> - return ret;
> -}
> -
> -/**
> - * vfio_ap_queue_dev_remove: Free the associated vfio_ap_queue structure.
> - *
> - * @apdev: the AP device being removed
> - *
> - * Takes the matrix lock to avoid actions on this device while doing the remove.
> - */
> -static void vfio_ap_queue_dev_remove(struct ap_device *apdev)
> -{
> - struct vfio_ap_queue *q;
> -
> - mutex_lock(&matrix_dev->lock);
> - sysfs_remove_group(&apdev->device.kobj, &vfio_queue_attr_group);
> - q = dev_get_drvdata(&apdev->device);
> - vfio_ap_mdev_reset_queue(q, 1);
> - dev_set_drvdata(&apdev->device, NULL);
> - kfree(q);
> - mutex_unlock(&matrix_dev->lock);
> -}
> -
> static struct ap_driver vfio_ap_drv = {
> - .probe = vfio_ap_queue_dev_probe,
> - .remove = vfio_ap_queue_dev_remove,
> + .probe = vfio_ap_mdev_probe_queue,
> + .remove = vfio_ap_mdev_remove_queue,
> .ids = ap_queue_ids,
> };
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 2227919fde13..16220157dbe3 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -1314,8 +1314,7 @@ static struct vfio_ap_queue *vfio_ap_find_queue(int apqn)
> return q;
> }
>
> -int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
> - unsigned int retry)
> +static int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q, unsigned int retry)
> {
> struct ap_queue_status status;
> int ret;
> @@ -1524,3 +1523,31 @@ void vfio_ap_mdev_unregister(void)
> mdev_unregister_device(&matrix_dev->device);
> mdev_unregister_driver(&vfio_ap_matrix_driver);
> }
> +
> +int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
> +{
> + struct vfio_ap_queue *q;
> +
> + q = kzalloc(sizeof(*q), GFP_KERNEL);
> + if (!q)
> + return -ENOMEM;
> + mutex_lock(&matrix_dev->lock);
> + q->apqn = to_ap_queue(&apdev->device)->qid;
> + q->saved_isc = VFIO_AP_ISC_INVALID;
> + dev_set_drvdata(&apdev->device, q);
> + mutex_unlock(&matrix_dev->lock);
> +
> + return 0;
> +}
> +
> +void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> +{
> + struct vfio_ap_queue *q;
> +
> + mutex_lock(&matrix_dev->lock);
> + q = dev_get_drvdata(&apdev->device);
> + vfio_ap_mdev_reset_queue(q, 1);
> + dev_set_drvdata(&apdev->device, NULL);
> + kfree(q);
> + mutex_unlock(&matrix_dev->lock);
> +}
> diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
> index 648fcaf8104a..3cade25a1620 100644
> --- a/drivers/s390/crypto/vfio_ap_private.h
> +++ b/drivers/s390/crypto/vfio_ap_private.h
> @@ -119,7 +119,8 @@ struct vfio_ap_queue {
>
> int vfio_ap_mdev_register(void);
> void vfio_ap_mdev_unregister(void);
> -int vfio_ap_mdev_reset_queue(struct vfio_ap_queue *q,
> - unsigned int retry);
> +
> +int vfio_ap_mdev_probe_queue(struct ap_device *queue);
> +void vfio_ap_mdev_remove_queue(struct ap_device *queue);
>
> #endif /* _VFIO_AP_PRIVATE_H_ */
With this commit, you did more than just move the probe/remove functions. You also changed
their behavior. The call to sysfs_create_group has been removed. So the following in
vfop_ap_drv.c becomes dead code:
vfio_ap_mdev_for_queue
status_show
static DEVICE_ATTR_RO(status);
vfio_queue_attrs
vfio_queue_attr_group
Is this what you intended? If so, I assume we can live without the status attribute?
If this is the case then you'll want to remove all the dead code.
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The vfio_ap device driver registers for notification when the pointer to
> the KVM object for a guest is set. Recall that the KVM lock (kvm->lock)
> mutex must be taken outside of the matrix_dev->lock mutex to prevent the
> reporting by lockdep of a circular locking dependency (a.k.a., a lockdep
> splat):
>
> * see commit 0cc00c8d4050 ("Fix circular lockdep when setting/clearing
> crypto masks")
>
> * see commit 86956e70761b ("replace open coded locks for
> VFIO_GROUP_NOTIFY_SET_KVM notification")
>
> With the introduction of support for hot plugging/unplugging AP devices
> passed through to a KVM guest, a new guests_lock mutex is introduced to
> ensure the proper locking order is maintained:
>
> struct ap_matrix_dev {
> ...
> struct mutex guests_lock;
> ...
> }
>
> The matrix_dev->guests_lock controls access to the matrix_mdev instances
> that hold the state for AP devices that have been passed through to a
> KVM guest. This lock must be held to control access to the KVM pointer
> (matrix_mdev->kvm) while the vfio_ap device driver is using it to
> plug/unplug AP devices passed through to the KVM guest.
>
> Keep in mind, the proper locking order must be maintained whenever
> dynamically updating a KVM guest's APCB to plug/unplug adapters, domains
> and control domains:
>
> 1. matrix_dev->guests_lock: required to use the KVM pointer - stored in
> a struct ap_matrix_mdev instance - to update a KVM guest's APCB
>
> 2. matrix_mdev->kvm->lock: required to update a guest's APCB
>
> 3. matrix_dev->mdevs_lock: required to access data stored in a
> struct ap_matrix_mdev instance.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_drv.c | 1 +
> drivers/s390/crypto/vfio_ap_private.h | 6 ++++++
> 2 files changed, 7 insertions(+)
>
> diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
> index 0a5acd151a9b..c258e5f7fdfc 100644
> --- a/drivers/s390/crypto/vfio_ap_drv.c
> +++ b/drivers/s390/crypto/vfio_ap_drv.c
> @@ -161,6 +161,7 @@ static int vfio_ap_matrix_dev_create(void)
>
> mutex_init(&matrix_dev->mdevs_lock);
> INIT_LIST_HEAD(&matrix_dev->mdev_list);
> + mutex_init(&matrix_dev->guests_lock);
>
> dev_set_name(&matrix_dev->device, "%s", VFIO_AP_DEV_NAME);
> matrix_dev->device.parent = root_device;
> diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
> index 5262e02192a4..ec926f2f2930 100644
> --- a/drivers/s390/crypto/vfio_ap_private.h
> +++ b/drivers/s390/crypto/vfio_ap_private.h
> @@ -39,6 +39,11 @@
> * single ap_matrix_mdev device. It's quite coarse but we don't
> * expect much contention.
> * @vfio_ap_drv: the vfio_ap device driver
> + * @guests_lock: mutex for controlling access to a guest that is using AP
> + * devices passed through by the vfio_ap device driver. This lock
> + * will be taken when the AP devices are plugged into or unplugged
> + * from a guest, and when an ap_matrix_mdev device is added to or
> + * removed from @mdev_list or the list is iterated.
> */
> struct ap_matrix_dev {
> struct device device;
> @@ -47,6 +52,7 @@ struct ap_matrix_dev {
> struct list_head mdev_list;
> struct mutex mdevs_lock;
> struct ap_driver *vfio_ap_drv;
> + struct mutex guests_lock;
> };
>
> extern struct ap_matrix_dev *matrix_dev;
In isolation... Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The group notifier that handles the VFIO_GROUP_NOTIFY_SET_KVM event must
> use the required locks in proper locking order to dynamically update the
> guest's APCB. The proper locking order is:
>
> 1. matrix_dev->guests_lock: required to use the KVM pointer to
> update a KVM guest's APCB.
>
> 2. matrix_mdev->kvm->lock: required to update a KVM guest's APCB.
>
> 3. matrix_dev->mdevs_lock: required to store or access the data
> stored in a struct ap_matrix_mdev instance.
>
> Two macros are introduced to acquire and release the locks in the proper
> order. These macros are now used by the group notifier functions.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 56 +++++++++++++++++++++++++------
> 1 file changed, 46 insertions(+), 10 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 077b8c9c831b..757bbf449b04 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -30,6 +30,47 @@ static int vfio_ap_mdev_reset_queues(struct ap_matrix_mdev *matrix_mdev);
> static struct vfio_ap_queue *vfio_ap_find_queue(int apqn);
> static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
>
> +/**
> + * get_update_locks_for_kvm: Acquire the locks required to dynamically update a
> + * KVM guest's APCB in the proper order.
> + *
> + * @kvm: a pointer to a struct kvm object containing the KVM guest's APCB.
> + *
> + * The proper locking order is:
> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
> + * guest's APCB.
> + * 2. kvm->lock: required to update a guest's APCB
> + * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
> + *
> + * Note: If @kvm is NULL, the KVM lock will not be taken.
> + */
> +#define get_update_locks_for_kvm(kvm) ({ \
> + mutex_lock(&matrix_dev->guests_lock); \
> + if (kvm) \
> + mutex_lock(&kvm->lock); \
> + mutex_lock(&matrix_dev->mdevs_lock); \
> +})
> +
> +/**
> + * release_update_locks_for_kvm: Release the locks used to dynamically update a
> + * KVM guest's APCB in the proper order.
> + *
> + * @kvm: a pointer to a struct kvm object containing the KVM guest's APCB.
> + *
> + * The proper unlocking order is:
> + * 1. matrix_dev->mdevs_lock
> + * 2. kvm->lock
> + * 3. matrix_dev->guests_lock
> + *
> + * Note: If @kvm is NULL, the KVM lock will not be released.
> + */
> +#define release_update_locks_for_kvm(kvm) ({ \
> + mutex_unlock(&matrix_dev->mdevs_lock); \
> + if (kvm) \
> + mutex_unlock(&kvm->lock); \
> + mutex_unlock(&matrix_dev->guests_lock); \
> +})
> +
> /**
> * vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
> * hash table of queues assigned to a matrix mdev
> @@ -1263,13 +1304,11 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
> kvm->arch.crypto.pqap_hook = &matrix_mdev->pqap_hook;
> up_write(&kvm->arch.crypto.pqap_hook_rwsem);
>
> - mutex_lock(&kvm->lock);
> - mutex_lock(&matrix_dev->mdevs_lock);
> + get_update_locks_for_kvm(kvm);
>
> list_for_each_entry(m, &matrix_dev->mdev_list, node) {
> if (m != matrix_mdev && m->kvm == kvm) {
> - mutex_unlock(&kvm->lock);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> + release_update_locks_for_kvm(kvm);
> return -EPERM;
> }
> }
> @@ -1280,8 +1319,7 @@ static int vfio_ap_mdev_set_kvm(struct ap_matrix_mdev *matrix_mdev,
> matrix_mdev->shadow_apcb.aqm,
> matrix_mdev->shadow_apcb.adm);
>
> - mutex_unlock(&kvm->lock);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> + release_update_locks_for_kvm(kvm);
> }
>
> return 0;
> @@ -1332,16 +1370,14 @@ static void vfio_ap_mdev_unset_kvm(struct ap_matrix_mdev *matrix_mdev)
> kvm->arch.crypto.pqap_hook = NULL;
> up_write(&kvm->arch.crypto.pqap_hook_rwsem);
>
> - mutex_lock(&kvm->lock);
> - mutex_lock(&matrix_dev->mdevs_lock);
> + get_update_locks_for_kvm(kvm);
>
> kvm_arch_crypto_clear_masks(kvm);
> vfio_ap_mdev_reset_queues(matrix_mdev);
> kvm_put_kvm(kvm);
> matrix_mdev->kvm = NULL;
>
> - mutex_unlock(&kvm->lock);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> + release_update_locks_for_kvm(kvm);
> }
> }
>
In isolation... Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The callback functions for probing and removing a queue device must take
> and release the locks required to perform a dynamic update of a guest's
> APCB in the proper order.
>
> The proper order for taking the locks is:
>
> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>
> The proper order for releasing the locks is:
>
> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>
> A new helper function is introduced to be used by the probe callback to
> acquire the required locks. Since the probe callback only has
> access to a queue device when it is called, the helper function will find
> the ap_matrix_mdev object to which the queue device's APQN is assigned and
> return it so the KVM guest to which the mdev is attached can be dynamically
> updated.
>
> Note that in order to find the ap_matrix_mdev (matrix_mdev) object, it is
> necessary to search the matrix_dev->mdev_list. This presents a
> locking order dilemma because the matrix_dev->mdevs_lock can't be taken to
> protect against changes to the list while searching for the matrix_mdev to
> which a queue device's APQN is assigned. This is due to the fact that the
> proper locking order requires that the matrix_dev->mdevs_lock be taken
> after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
> Consequently, the matrix_dev->guests_lock will be used to protect against
> removal of a matrix_mdev object from the list while a queue device is
> being probed. This necessitates changes to the mdev probe/remove
> callback functions to take the matrix_dev->guests_lock prior to removing
> a matrix_mdev object from the list.
>
> A new macro is also introduced to acquire the locks required to dynamically
> update the guest's APCB in the proper order when a queue device is
> removed.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
> 1 file changed, 88 insertions(+), 38 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 2219b1069ceb..080a733f7cd2 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -116,6 +116,74 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
> mutex_unlock(&matrix_dev->guests_lock); \
> })
>
> +/**
> + * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev to which an
> + * APQN is assigned and acquire the
> + * locks required to update the APCB of
> + * the KVM guest to which the mdev is
> + * attached.
> + *
> + * @apqn: the APQN of a queue device.
> + *
> + * The proper locking order is:
> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
> + * guest's APCB.
> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
> + * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
> + *
> + * Note: If @apqn is not assigned to a matrix_mdev, the matrix_mdev->kvm->lock
> + * will not be taken.
> + *
> + * Return: the ap_matrix_mdev object to which @apqn is assigned or NULL if @apqn
> + * is not assigned to an ap_matrix_mdev.
> + */
> +static struct ap_matrix_mdev *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
> +{
> + struct ap_matrix_mdev *matrix_mdev;
> +
> + mutex_lock(&matrix_dev->guests_lock);
> +
> + list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
> + if (test_bit_inv(AP_QID_CARD(apqn), matrix_mdev->matrix.apm) &&
> + test_bit_inv(AP_QID_QUEUE(apqn), matrix_mdev->matrix.aqm)) {
> + if (matrix_mdev->kvm)
> + mutex_lock(&matrix_mdev->kvm->lock);
> +
> + mutex_lock(&matrix_dev->mdevs_lock);
> +
> + return matrix_mdev;
> + }
> + }
> +
> + mutex_lock(&matrix_dev->mdevs_lock);
> +
> + return NULL;
> +}
> +
> +/**
> + * get_update_locks_for_queue: get the locks required to update the APCB of the
> + * KVM guest to which the matrix mdev linked to a
> + * vfio_ap_queue object is attached.
> + *
> + * @queue: a pointer to a vfio_ap_queue object.
> + *
> + * The proper locking order is:
> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
> + * guest's APCB.
> + * 2. queue->matrix_mdev->kvm->lock: required to update a guest's APCB
> + * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
> + *
> + * Note: if @queue is not linked to an ap_matrix_mdev object, the KVM lock
> + * will not be taken.
> + */
> +#define get_update_locks_for_queue(queue) ({ \
> + struct ap_matrix_mdev *matrix_mdev = q->matrix_mdev; \
> + mutex_lock(&matrix_dev->guests_lock); \
> + if (matrix_mdev && matrix_mdev->kvm) \
> + mutex_lock(&matrix_mdev->kvm->lock); \
> + mutex_lock(&matrix_dev->mdevs_lock); \
> +})
> +
One more comment I forgot to include before:
This macro is far too similar to existing macro, get_update_locks_for_mdev. And it is only
called in one place. Let's remove this and replace the single invocation with:
get_update_locks_for_mdev(q->matrix_mdev);
> /**
> * vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN from a
> * hash table of queues assigned to a matrix mdev
> @@ -615,21 +683,18 @@ static int vfio_ap_mdev_probe(struct mdev_device *mdev)
> matrix_mdev->pqap_hook = handle_pqap;
> vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
> hash_init(matrix_mdev->qtable.queues);
> - mdev_set_drvdata(mdev, matrix_mdev);
> - mutex_lock(&matrix_dev->mdevs_lock);
> - list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
> - mutex_unlock(&matrix_dev->mdevs_lock);
>
> ret = vfio_register_emulated_iommu_dev(&matrix_mdev->vdev);
> if (ret)
> goto err_list;
> + mdev_set_drvdata(mdev, matrix_mdev);
> + mutex_lock(&matrix_dev->mdevs_lock);
> + list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
> + mutex_unlock(&matrix_dev->mdevs_lock);
> dev_set_drvdata(&mdev->dev, matrix_mdev);
> return 0;
>
> err_list:
> - mutex_lock(&matrix_dev->mdevs_lock);
> - list_del(&matrix_mdev->node);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> vfio_uninit_group_dev(&matrix_mdev->vdev);
> kfree(matrix_mdev);
> err_dec_available:
> @@ -692,11 +757,13 @@ static void vfio_ap_mdev_remove(struct mdev_device *mdev)
>
> vfio_unregister_group_dev(&matrix_mdev->vdev);
>
> + mutex_lock(&matrix_dev->guests_lock);
> mutex_lock(&matrix_dev->mdevs_lock);
> vfio_ap_mdev_reset_queues(matrix_mdev);
> vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
> list_del(&matrix_mdev->node);
> mutex_unlock(&matrix_dev->mdevs_lock);
> + mutex_unlock(&matrix_dev->guests_lock);
> vfio_uninit_group_dev(&matrix_mdev->vdev);
> kfree(matrix_mdev);
> atomic_inc(&matrix_dev->available_instances);
> @@ -1665,49 +1732,30 @@ void vfio_ap_mdev_unregister(void)
> mdev_unregister_driver(&vfio_ap_matrix_driver);
> }
>
> -/*
> - * vfio_ap_queue_link_mdev
> - *
> - * @q: The queue to link with the matrix mdev.
> - *
> - * Links @q with the matrix mdev to which the queue's APQN is assigned.
> - */
> -static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
> -{
> - unsigned long apid = AP_QID_CARD(q->apqn);
> - unsigned long apqi = AP_QID_QUEUE(q->apqn);
> - struct ap_matrix_mdev *matrix_mdev;
> -
> - list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
> - if (test_bit_inv(apid, matrix_mdev->matrix.apm) &&
> - test_bit_inv(apqi, matrix_mdev->matrix.aqm)) {
> - vfio_ap_mdev_link_queue(matrix_mdev, q);
> - break;
> - }
> - }
> -}
> -
> int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
> {
> struct vfio_ap_queue *q;
> + struct ap_matrix_mdev *matrix_mdev;
> DECLARE_BITMAP(apm_delta, AP_DEVICES);
>
> q = kzalloc(sizeof(*q), GFP_KERNEL);
> if (!q)
> return -ENOMEM;
> - mutex_lock(&matrix_dev->mdevs_lock);
> q->apqn = to_ap_queue(&apdev->device)->qid;
> q->saved_isc = VFIO_AP_ISC_INVALID;
> - vfio_ap_queue_link_mdev(q);
> - if (q->matrix_mdev) {
> +
> + matrix_mdev = vfio_ap_mdev_get_update_locks_for_apqn(q->apqn);
> +
> + if (matrix_mdev) {
> + vfio_ap_mdev_link_queue(matrix_mdev, q);
> memset(apm_delta, 0, sizeof(apm_delta));
> set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
> vfio_ap_mdev_filter_matrix(apm_delta,
> - q->matrix_mdev->matrix.aqm,
> - q->matrix_mdev);
> + matrix_mdev->matrix.aqm,
> + matrix_mdev);
> }
> dev_set_drvdata(&apdev->device, q);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> + release_update_locks_for_mdev(matrix_mdev);
>
> return 0;
> }
> @@ -1716,11 +1764,13 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> {
> unsigned long apid;
> struct vfio_ap_queue *q;
> + struct ap_matrix_mdev *matrix_mdev;
>
> - mutex_lock(&matrix_dev->mdevs_lock);
> q = dev_get_drvdata(&apdev->device);
> + get_update_locks_for_queue(q);
> + matrix_mdev = q->matrix_mdev;
>
> - if (q->matrix_mdev) {
> + if (matrix_mdev) {
> vfio_ap_unlink_queue_fr_mdev(q);
>
> apid = AP_QID_CARD(q->apqn);
> @@ -1731,5 +1781,5 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> vfio_ap_mdev_reset_queue(q, 1);
> dev_set_drvdata(&apdev->device, NULL);
> kfree(q);
> - mutex_unlock(&matrix_dev->mdevs_lock);
> + release_update_locks_for_mdev(matrix_mdev);
> }
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The functions backing the matrix mdev's sysfs attribute interfaces to
> assign/unassign adapters, domains and control domains must take and
> release the locks required to perform a dynamic update of a guest's APCB
> in the proper order.
>
> The proper order for taking the locks is:
>
> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>
> The proper order for releasing the locks is:
>
> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>
> Two new macros are introduced for this purpose: One to take the locks and
> the other to release the locks. These macros will be used by the
> assignment/unassignment functions to prepare for dynamic update of
> the KVM guest's APCB.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 69 +++++++++++++++++++++++++------
> 1 file changed, 57 insertions(+), 12 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 757bbf449b04..2219b1069ceb 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -71,6 +71,51 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
> mutex_unlock(&matrix_dev->guests_lock); \
> })
>
> +/**
> + * get_update_locks_for_mdev: Acquire the locks required to dynamically update a
> + * KVM guest's APCB in the proper order.
> + *
> + * @matrix_mdev: a pointer to a struct ap_matrix_mdev object containing the AP
> + * configuration data to use to update a KVM guest's APCB.
> + *
> + * The proper locking order is:
> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
> + * guest's APCB.
> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
> + * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
> + *
> + * Note: If @matrix_mdev is NULL or is not attached to a KVM guest, the KVM
> + * lock will not be taken.
> + */
Perhaps the locking order should be documented once at the top of all of the locking
functions instead of in each comment. The current method seems needlessly verbose.
> +#define get_update_locks_for_mdev(matrix_mdev) ({ \
> + mutex_lock(&matrix_dev->guests_lock); \
> + if (matrix_mdev && matrix_mdev->kvm) \
> + mutex_lock(&matrix_mdev->kvm->lock); \
> + mutex_lock(&matrix_dev->mdevs_lock); \
> +})
It does not make sense to reference matrix_dev on the first line of this macro and
then check it for a null value on the next line. If it can be null then the check
needs to come before the usage. If it cannot be null, then we can remove the check.
Same comment for the release macro.
> +/**
> + * release_update_locks_for_mdev: Release the locks used to dynamically update a
> + * KVM guest's APCB in the proper order.
> + *
> + * @matrix_mdev: a pointer to a struct ap_matrix_mdev object containing the AP
> + * configuration data to use to update a KVM guest's APCB.
> + *
> + * The proper unlocking order is:
> + * 1. matrix_dev->mdevs_lock
> + * 2. matrix_mdev->kvm->lock
> + * 3. matrix_dev->guests_lock
> + *
> + * Note: If @matrix_mdev is NULL or is not attached to a KVM guest, the KVM
> + * lock will not be released.
> + */
> +#define release_update_locks_for_mdev(matrix_mdev) ({ \
> + mutex_unlock(&matrix_dev->mdevs_lock); \
> + if (matrix_mdev && matrix_mdev->kvm) \
> + mutex_unlock(&matrix_mdev->kvm->lock); \
> + mutex_unlock(&matrix_dev->guests_lock); \
> +})
> +
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> The callback functions for probing and removing a queue device must take
> and release the locks required to perform a dynamic update of a guest's
> APCB in the proper order.
>
> The proper order for taking the locks is:
>
> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>
> The proper order for releasing the locks is:
>
> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>
> A new helper function is introduced to be used by the probe callback to
> acquire the required locks. Since the probe callback only has
> access to a queue device when it is called, the helper function will find
> the ap_matrix_mdev object to which the queue device's APQN is assigned and
> return it so the KVM guest to which the mdev is attached can be dynamically
> updated.
>
> Note that in order to find the ap_matrix_mdev (matrix_mdev) object, it is
> necessary to search the matrix_dev->mdev_list. This presents a
> locking order dilemma because the matrix_dev->mdevs_lock can't be taken to
> protect against changes to the list while searching for the matrix_mdev to
> which a queue device's APQN is assigned. This is due to the fact that the
> proper locking order requires that the matrix_dev->mdevs_lock be taken
> after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
> Consequently, the matrix_dev->guests_lock will be used to protect against
> removal of a matrix_mdev object from the list while a queue device is
> being probed. This necessitates changes to the mdev probe/remove
> callback functions to take the matrix_dev->guests_lock prior to removing
> a matrix_mdev object from the list.
>
> A new macro is also introduced to acquire the locks required to dynamically
> update the guest's APCB in the proper order when a queue device is
> removed.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
> 1 file changed, 88 insertions(+), 38 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 2219b1069ceb..080a733f7cd2 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -116,6 +116,74 @@ static const struct vfio_device_ops vfio_ap_matrix_dev_ops;
> mutex_unlock(&matrix_dev->guests_lock); \
> })
>
> +/**
> + * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev to which an
> + * APQN is assigned and acquire the
> + * locks required to update the APCB of
> + * the KVM guest to which the mdev is
> + * attached.
> + *
> + * @apqn: the APQN of a queue device.
> + *
> + * The proper locking order is:
> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to update a KVM
> + * guest's APCB.
> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
> + * 3. matrix_dev->mdevs_lock: required to access data stored in a matrix_mdev
> + *
> + * Note: If @apqn is not assigned to a matrix_mdev, the matrix_mdev->kvm->lock
> + * will not be taken.
> + *
> + * Return: the ap_matrix_mdev object to which @apqn is assigned or NULL if @apqn
> + * is not assigned to an ap_matrix_mdev.
> + */
> +static struct ap_matrix_mdev *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
vfio_ap_mdev_get_update_locks_for_apqn is "crazy long".
How about:
get_mdev_for_apqn()
This function is static and the terms mdev and apqn are specific enough that I
don't think it needs to start with vfio_ap. And there is no need to state in
the function name that locks are acquired. That point will be obvious to anyone
reading the prologue or the code.
Aside from that, Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 5/27/22 9:36 AM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> The callback functions for probing and removing a queue device must take
>> and release the locks required to perform a dynamic update of a guest's
>> APCB in the proper order.
>>
>> The proper order for taking the locks is:
>>
>> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>>
>> The proper order for releasing the locks is:
>>
>> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>>
>> A new helper function is introduced to be used by the probe callback to
>> acquire the required locks. Since the probe callback only has
>> access to a queue device when it is called, the helper function will
>> find
>> the ap_matrix_mdev object to which the queue device's APQN is
>> assigned and
>> return it so the KVM guest to which the mdev is attached can be
>> dynamically
>> updated.
>>
>> Note that in order to find the ap_matrix_mdev (matrix_mdev) object,
>> it is
>> necessary to search the matrix_dev->mdev_list. This presents a
>> locking order dilemma because the matrix_dev->mdevs_lock can't be
>> taken to
>> protect against changes to the list while searching for the
>> matrix_mdev to
>> which a queue device's APQN is assigned. This is due to the fact that
>> the
>> proper locking order requires that the matrix_dev->mdevs_lock be taken
>> after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
>> Consequently, the matrix_dev->guests_lock will be used to protect
>> against
>> removal of a matrix_mdev object from the list while a queue device is
>> being probed. This necessitates changes to the mdev probe/remove
>> callback functions to take the matrix_dev->guests_lock prior to removing
>> a matrix_mdev object from the list.
>>
>> A new macro is also introduced to acquire the locks required to
>> dynamically
>> update the guest's APCB in the proper order when a queue device is
>> removed.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
>> 1 file changed, 88 insertions(+), 38 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 2219b1069ceb..080a733f7cd2 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -116,6 +116,74 @@ static const struct vfio_device_ops
>> vfio_ap_matrix_dev_ops;
>> mutex_unlock(&matrix_dev->guests_lock); \
>> })
>> +/**
>> + * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev
>> to which an
>> + * APQN is assigned and acquire the
>> + * locks required to update the APCB of
>> + * the KVM guest to which the mdev is
>> + * attached.
>> + *
>> + * @apqn: the APQN of a queue device.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: If @apqn is not assigned to a matrix_mdev, the
>> matrix_mdev->kvm->lock
>> + * will not be taken.
>> + *
>> + * Return: the ap_matrix_mdev object to which @apqn is assigned or
>> NULL if @apqn
>> + * is not assigned to an ap_matrix_mdev.
>> + */
>> +static struct ap_matrix_mdev
>> *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
>
> vfio_ap_mdev_get_update_locks_for_apqn is "crazy long".
> How about:
> get_mdev_for_apqn()
>
> This function is static and the terms mdev and apqn are specific
> enough that I
> don't think it needs to start with vfio_ap. And there is no need to
> state in
> the function name that locks are acquired. That point will be obvious
> to anyone
> reading the prologue or the code.
The primary purpose of the function is to acquire the locks in the
proper order, so
I think the name should state that purpose. It may be obvious to someone
reading
the prologue or this function, but not so obvious in the context of the
calling function.
Having said that, I will shorten the name to:
get_update_locks_for_apqn
>
> Aside from that, Reviewed-by: Jason J. Herne <[email protected]>
>
On 4/4/22 6:10 PM, Tony Krowiak wrote:
> A new document, Documentation/s390/vfio-ap-locking.rst was added. Make sure
> the new document is picked up for the VFIO AP maintainers by using a
> wildcard: Documentation/s390/vfio-ap*.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> MAINTAINERS | 6 ++++--
> 1 file changed, 4 insertions(+), 2 deletions(-)
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index fd768d43e048..c8d8637c184c 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -17239,8 +17239,10 @@ M: Jason Herne <[email protected]>
> L: [email protected]
> S: Supported
> W: http://www.ibm.com/developerworks/linux/linux390/
> -F: Documentation/s390/vfio-ap.rst
> -F: drivers/s390/crypto/vfio_ap*
> +F: Documentation/s390/vfio-ap*
> +F: drivers/s390/crypto/vfio_ap_drv.c
> +F: drivers/s390/crypto/vfio_ap_ops.c
> +F: drivers/s390/crypto/vfio_ap_private.h
I think this change was a rebase error, the Documentation change makes
sense but you should leave drivers/s390/crypto/vfio_ap* alone, so the
final result looks like:
F: Documentation/s390/vfio-ap*
F: drivers/s390/crypto/vfio_ap*
On 5/27/22 9:18 AM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> The functions backing the matrix mdev's sysfs attribute interfaces to
>> assign/unassign adapters, domains and control domains must take and
>> release the locks required to perform a dynamic update of a guest's APCB
>> in the proper order.
>>
>> The proper order for taking the locks is:
>>
>> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>>
>> The proper order for releasing the locks is:
>>
>> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>>
>> Two new macros are introduced for this purpose: One to take the locks
>> and
>> the other to release the locks. These macros will be used by the
>> assignment/unassignment functions to prepare for dynamic update of
>> the KVM guest's APCB.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> drivers/s390/crypto/vfio_ap_ops.c | 69 +++++++++++++++++++++++++------
>> 1 file changed, 57 insertions(+), 12 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 757bbf449b04..2219b1069ceb 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -71,6 +71,51 @@ static const struct vfio_device_ops
>> vfio_ap_matrix_dev_ops;
>> mutex_unlock(&matrix_dev->guests_lock); \
>> })
>> +/**
>> + * get_update_locks_for_mdev: Acquire the locks required to
>> dynamically update a
>> + * KVM guest's APCB in the proper order.
>> + *
>> + * @matrix_mdev: a pointer to a struct ap_matrix_mdev object
>> containing the AP
>> + * configuration data to use to update a KVM guest's APCB.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: If @matrix_mdev is NULL or is not attached to a KVM guest,
>> the KVM
>> + * lock will not be taken.
>> + */
>
> Perhaps the locking order should be documented once at the top of all
> of the locking
> functions instead of in each comment. The current method seems
> needlessly verbose.
Perhaps, but I surmise this comment was motivated by the fact you are
reviewing the
locking macros/functions en masse. On the other hand, someone debugging
the code
may miss the locking order comments if their debug thread leads them to
a locking
macro/function that does not have said comments. I think the value of
leaving the
comments in place outweighs the value of limiting them as you suggested.
>
>> +#define get_update_locks_for_mdev(matrix_mdev) ({ \
>> + mutex_lock(&matrix_dev->guests_lock); \
>> + if (matrix_mdev && matrix_mdev->kvm) \
>> + mutex_lock(&matrix_mdev->kvm->lock); \
>> + mutex_lock(&matrix_dev->mdevs_lock); \
>> +})
>
> It does not make sense to reference matrix_dev on the first line of
> this macro and
> then check it for a null value on the next line. If it can be null
> then the check
> needs to come before the usage. If it cannot be null, then we can
> remove the check.
> Same comment for the release macro.
You must have misread the code. The second line checks the value of
matrix_mdev
for NULL, not matrix_dev. There are definitely cases where matrix_mdev
can be
passed as NULL.
>
>> +/**
>> + * release_update_locks_for_mdev: Release the locks used to
>> dynamically update a
>> + * KVM guest's APCB in the proper order.
>> + *
>> + * @matrix_mdev: a pointer to a struct ap_matrix_mdev object
>> containing the AP
>> + * configuration data to use to update a KVM guest's APCB.
>> + *
>> + * The proper unlocking order is:
>> + * 1. matrix_dev->mdevs_lock
>> + * 2. matrix_mdev->kvm->lock
>> + * 3. matrix_dev->guests_lock
>> + *
>> + * Note: If @matrix_mdev is NULL or is not attached to a KVM guest,
>> the KVM
>> + * lock will not be released.
>> + */
>> +#define release_update_locks_for_mdev(matrix_mdev) ({ \
>> + mutex_unlock(&matrix_dev->mdevs_lock); \
>> + if (matrix_mdev && matrix_mdev->kvm) \
>> + mutex_unlock(&matrix_mdev->kvm->lock); \
>> + mutex_unlock(&matrix_dev->guests_lock); \
>> +})
>> +
On 5/27/22 9:50 AM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> The callback functions for probing and removing a queue device must take
>> and release the locks required to perform a dynamic update of a guest's
>> APCB in the proper order.
>>
>> The proper order for taking the locks is:
>>
>> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>>
>> The proper order for releasing the locks is:
>>
>> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>>
>> A new helper function is introduced to be used by the probe callback to
>> acquire the required locks. Since the probe callback only has
>> access to a queue device when it is called, the helper function will
>> find
>> the ap_matrix_mdev object to which the queue device's APQN is
>> assigned and
>> return it so the KVM guest to which the mdev is attached can be
>> dynamically
>> updated.
>>
>> Note that in order to find the ap_matrix_mdev (matrix_mdev) object,
>> it is
>> necessary to search the matrix_dev->mdev_list. This presents a
>> locking order dilemma because the matrix_dev->mdevs_lock can't be
>> taken to
>> protect against changes to the list while searching for the
>> matrix_mdev to
>> which a queue device's APQN is assigned. This is due to the fact that
>> the
>> proper locking order requires that the matrix_dev->mdevs_lock be taken
>> after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
>> Consequently, the matrix_dev->guests_lock will be used to protect
>> against
>> removal of a matrix_mdev object from the list while a queue device is
>> being probed. This necessitates changes to the mdev probe/remove
>> callback functions to take the matrix_dev->guests_lock prior to removing
>> a matrix_mdev object from the list.
>>
>> A new macro is also introduced to acquire the locks required to
>> dynamically
>> update the guest's APCB in the proper order when a queue device is
>> removed.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
>> 1 file changed, 88 insertions(+), 38 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 2219b1069ceb..080a733f7cd2 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -116,6 +116,74 @@ static const struct vfio_device_ops
>> vfio_ap_matrix_dev_ops;
>> mutex_unlock(&matrix_dev->guests_lock); \
>> })
>> +/**
>> + * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev
>> to which an
>> + * APQN is assigned and acquire the
>> + * locks required to update the APCB of
>> + * the KVM guest to which the mdev is
>> + * attached.
>> + *
>> + * @apqn: the APQN of a queue device.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: If @apqn is not assigned to a matrix_mdev, the
>> matrix_mdev->kvm->lock
>> + * will not be taken.
>> + *
>> + * Return: the ap_matrix_mdev object to which @apqn is assigned or
>> NULL if @apqn
>> + * is not assigned to an ap_matrix_mdev.
>> + */
>> +static struct ap_matrix_mdev
>> *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
>> +{
>> + struct ap_matrix_mdev *matrix_mdev;
>> +
>> + mutex_lock(&matrix_dev->guests_lock);
>> +
>> + list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
>> + if (test_bit_inv(AP_QID_CARD(apqn), matrix_mdev->matrix.apm) &&
>> + test_bit_inv(AP_QID_QUEUE(apqn),
>> matrix_mdev->matrix.aqm)) {
>> + if (matrix_mdev->kvm)
>> + mutex_lock(&matrix_mdev->kvm->lock);
>> +
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> +
>> + return matrix_mdev;
>> + }
>> + }
>> +
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> +
>> + return NULL;
>> +}
>> +
>> +/**
>> + * get_update_locks_for_queue: get the locks required to update the
>> APCB of the
>> + * KVM guest to which the matrix mdev linked to a
>> + * vfio_ap_queue object is attached.
>> + *
>> + * @queue: a pointer to a vfio_ap_queue object.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. queue->matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: if @queue is not linked to an ap_matrix_mdev object, the
>> KVM lock
>> + * will not be taken.
>> + */
>> +#define get_update_locks_for_queue(queue) ({ \
>> + struct ap_matrix_mdev *matrix_mdev = q->matrix_mdev; \
>> + mutex_lock(&matrix_dev->guests_lock); \
>> + if (matrix_mdev && matrix_mdev->kvm) \
>> + mutex_lock(&matrix_mdev->kvm->lock); \
>> + mutex_lock(&matrix_dev->mdevs_lock); \
>> +})
>> +
>
>
> One more comment I forgot to include before:
> This macro is far too similar to existing macro,
> get_update_locks_for_mdev. And it is only called in one place. Let's
> remove this and replace the single invocation with:
>
> get_update_locks_for_mdev(q->matrix_mdev);
Yikes, I see another flaw in this macro! Either the input parameter
needs to be renamed to 'q' or the q->matrix_mdev needs to be changed to
queue->matrix_mdev. I think I'll go with the former since vfio_ap_queue
is referred to as 'q' everywhere else.
>
>
>> /**
>> * vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN
>> from a
>> * hash table of queues assigned to a matrix mdev
>> @@ -615,21 +683,18 @@ static int vfio_ap_mdev_probe(struct
>> mdev_device *mdev)
>> matrix_mdev->pqap_hook = handle_pqap;
>> vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
>> hash_init(matrix_mdev->qtable.queues);
>> - mdev_set_drvdata(mdev, matrix_mdev);
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> - list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> ret = vfio_register_emulated_iommu_dev(&matrix_mdev->vdev);
>> if (ret)
>> goto err_list;
>> + mdev_set_drvdata(mdev, matrix_mdev);
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> + list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
>> + mutex_unlock(&matrix_dev->mdevs_lock);
>> dev_set_drvdata(&mdev->dev, matrix_mdev);
>> return 0;
>> err_list:
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> - list_del(&matrix_mdev->node);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> vfio_uninit_group_dev(&matrix_mdev->vdev);
>> kfree(matrix_mdev);
>> err_dec_available:
>> @@ -692,11 +757,13 @@ static void vfio_ap_mdev_remove(struct
>> mdev_device *mdev)
>> vfio_unregister_group_dev(&matrix_mdev->vdev);
>> + mutex_lock(&matrix_dev->guests_lock);
>> mutex_lock(&matrix_dev->mdevs_lock);
>> vfio_ap_mdev_reset_queues(matrix_mdev);
>> vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
>> list_del(&matrix_mdev->node);
>> mutex_unlock(&matrix_dev->mdevs_lock);
>> + mutex_unlock(&matrix_dev->guests_lock);
>> vfio_uninit_group_dev(&matrix_mdev->vdev);
>> kfree(matrix_mdev);
>> atomic_inc(&matrix_dev->available_instances);
>> @@ -1665,49 +1732,30 @@ void vfio_ap_mdev_unregister(void)
>> mdev_unregister_driver(&vfio_ap_matrix_driver);
>> }
>> -/*
>> - * vfio_ap_queue_link_mdev
>> - *
>> - * @q: The queue to link with the matrix mdev.
>> - *
>> - * Links @q with the matrix mdev to which the queue's APQN is assigned.
>> - */
>> -static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
>> -{
>> - unsigned long apid = AP_QID_CARD(q->apqn);
>> - unsigned long apqi = AP_QID_QUEUE(q->apqn);
>> - struct ap_matrix_mdev *matrix_mdev;
>> -
>> - list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
>> - if (test_bit_inv(apid, matrix_mdev->matrix.apm) &&
>> - test_bit_inv(apqi, matrix_mdev->matrix.aqm)) {
>> - vfio_ap_mdev_link_queue(matrix_mdev, q);
>> - break;
>> - }
>> - }
>> -}
>> -
>> int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
>> {
>> struct vfio_ap_queue *q;
>> + struct ap_matrix_mdev *matrix_mdev;
>> DECLARE_BITMAP(apm_delta, AP_DEVICES);
>> q = kzalloc(sizeof(*q), GFP_KERNEL);
>> if (!q)
>> return -ENOMEM;
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> q->apqn = to_ap_queue(&apdev->device)->qid;
>> q->saved_isc = VFIO_AP_ISC_INVALID;
>> - vfio_ap_queue_link_mdev(q);
>> - if (q->matrix_mdev) {
>> +
>> + matrix_mdev = vfio_ap_mdev_get_update_locks_for_apqn(q->apqn);
>> +
>> + if (matrix_mdev) {
>> + vfio_ap_mdev_link_queue(matrix_mdev, q);
>> memset(apm_delta, 0, sizeof(apm_delta));
>> set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
>> vfio_ap_mdev_filter_matrix(apm_delta,
>> - q->matrix_mdev->matrix.aqm,
>> - q->matrix_mdev);
>> + matrix_mdev->matrix.aqm,
>> + matrix_mdev);
>> }
>> dev_set_drvdata(&apdev->device, q);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> + release_update_locks_for_mdev(matrix_mdev);
>> return 0;
>> }
>> @@ -1716,11 +1764,13 @@ void vfio_ap_mdev_remove_queue(struct
>> ap_device *apdev)
>> {
>> unsigned long apid;
>> struct vfio_ap_queue *q;
>> + struct ap_matrix_mdev *matrix_mdev;
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> q = dev_get_drvdata(&apdev->device);
>> + get_update_locks_for_queue(q);
>> + matrix_mdev = q->matrix_mdev;
>> - if (q->matrix_mdev) {
>> + if (matrix_mdev) {
>> vfio_ap_unlink_queue_fr_mdev(q);
>> apid = AP_QID_CARD(q->apqn);
>> @@ -1731,5 +1781,5 @@ void vfio_ap_mdev_remove_queue(struct ap_device
>> *apdev)
>> vfio_ap_mdev_reset_queue(q, 1);
>> dev_set_drvdata(&apdev->device, NULL);
>> kfree(q);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> + release_update_locks_for_mdev(matrix_mdev);
>> }
>
>
On 4/4/22 18:10, Tony Krowiak wrote:
> Introduces a new document describing the locks used by the vfio_ap device
> driver and how to use them so as to avoid lockdep reports and deadlock
> situations.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> Documentation/s390/vfio-ap-locking.rst | 389 +++++++++++++++++++++++++
> 1 file changed, 389 insertions(+)
> create mode 100644 Documentation/s390/vfio-ap-locking.rst
>
> diff --git a/Documentation/s390/vfio-ap-locking.rst b/Documentation/s390/vfio-ap-locking.rst
> new file mode 100644
> index 000000000000..ba5db6689f14
> --- /dev/null
> +++ b/Documentation/s390/vfio-ap-locking.rst
> @@ -0,0 +1,389 @@
> +.. SPDX-License-Identifier: GPL-2.0
> +
> +======================
> +VFIO AP Locks Overview
> +======================
> +This document describes the locks that are pertinent to the secure operation
> +of the vfio_ap device driver. Throughout this document, the following variables
> +will be used to denote instances of the structures herein described:
> +
> +struct ap_matrix_dev *matrix_dev;
> +struct ap_matrix_mdev *matrix_mdev;
> +struct kvm *kvm;
> +
> +The Matrix Devices Lock (drivers/s390/crypto/vfio_ap_private.h)
> +--------------------------------------------------------------
> +
> +struct ap_matrix_dev {
> + ...
> + struct list_head mdev_list;
> + struct mutex mdevs_lock;
> + ...
> +}
> +
> +The Matrix Devices Lock (matrix_dev->mdevs_lock) is implemented as a global
> +mutex contained within the single object of struct ap_matrix_dev. This lock
> +controls access to all fields contained within each matrix_mdev
> +(matrix_dev->mdev_list). This lock must be held while reading from, writing to
> +or using the data from a field contained within a matrix_mdev instance
> +representing one of the vfio_ap device driver's mediated devices.
> +
> +The KVM Lock (include/linux/kvm_host.h)
> +---------------------------------------
> +
> +struct kvm {
> + ...
> + struct mutex lock;
> + ...
> +}
> +
> +The KVM Lock (kvm->lock) controls access to the state data for a KVM guest. This
> +lock must be held by the vfio_ap device driver while one or more AP adapters,
> +domains or control domains are being plugged into or unplugged from the guest.
> +
> +The vfio_ap device driver registers a function to be notified when the pointer
> +to the kvm instance has been set. The KVM pointer is passed to the handler by
> +the notifier and is stored in the in the matrix_mdev instance
> +(matrix_mdev->kvm = kvm) containing the state of the mediated device that has
> +been passed through to the KVM guest.
> +
> +The Guests Lock (drivers/s390/crypto/vfio_ap_private.h)
> +-----------------------------------------------------------
> +
> +struct ap_matrix_dev {
> + ...
> + struct list_head mdev_list;
> + struct mutex guests_lock;
> + ...
> +}
> +
> +The Guests Lock (matrix_dev->guests_lock) controls access to the
> +matrix_mdev instances (matrix_dev->mdev_list) that represent mediated devices
> +that hold the state for the mediated devices that have been passed through to a
> +KVM guest. This lock must be held:
> +
> +1. To control access to the KVM pointer (matrix_mdev->kvm) while the vfio_ap
> + device driver is using it to plug/unplug AP devices passed through to the KVM
> + guest.
> +
> +2. To add matrix_mdev instances to or remove them from matrix_dev->mdev_list.
> + This is necessary to ensure the proper locking order when the list is perused
> + to find an ap_matrix_mdev instance for the purpose of plugging/unplugging
> + AP devices passed through to a KVM guest.
> +
> + For example, when a queue device is removed from the vfio_ap device driver,
> + if the adapter is passed through to a KVM guest, it will have to be
> + unplugged. In order to figure out whether the adapter is passed through,
> + the matrix_mdev object to which the queue is assigned will have to be
> + found. The KVM pointer (matrix_mdev->kvm) can then be used to determine if
> + the mediated device is passed through (matrix_mdev->kvm != NULL) and if so,
> + to unplug the adapter.
> +
> +It is not necessary to take the Guests Lock to access the KVM pointer if the
> +pointer is not used to plug/unplug devices passed through to the KVM guest;
> +however, in this case, the Matrix Devices Lock (matrix_dev->mdevs_lock) must be
> +held in order to access the KVM pointer since it set and cleared under the
> +protection of the Matrix Devices Lock. A case in point is the function that
> +handles interception of the PQAP(AQIC) instruction sub-function. This handler
> +needs to access the KVM pointer only for the purposes of setting or clearing IRQ
> +resources, so only the matrix_dev->mdevs_lock needs to be held.
> +
> +The PQAP Hook Lock (arch/s390/include/asm/kvm_host.h)
> +-----------------------------------------------------
> +
> +typedef int (*crypto_hook)(struct kvm_vcpu *vcpu);
> +
> +struct kvm_s390_crypto {
> + ...
> + struct rw_semaphore pqap_hook_rwsem;
> + crypto_hook *pqap_hook;
> + ...
> +};
> +
> +The PQAP Hook Lock is a r/w semaphore that controls access to the function
> +pointer of the handler (*kvm->arch.crypto.pqap_hook) to invoke when the
> +PQAP(AQIC) instruction sub-function is intercepted by the host. The lock must be
> +held in write mode when pqap_hook value is set, and in read mode when the
> +pqap_hook function is called.
Reviewed-by: Jason J. Herne <[email protected]>
R-b for everything above here. Everything below, I've reviewed in less detail and I'm not
sure it really makes sense. Defining a locking order makes sense and it is adequately
described multiple times in vfio_ap_ops.c. The list of operations and the locks they take
can be derived just as easily from the code instead of this document. Also, documents like
this tend to not stay up to date with respect to the code they describe. My vote would be
to drop everything below.
> +Locking Order
> +-------------
> +
> +If the various locks are not taken in the proper order, it could potentially
> +result in a deadlock or lockdep splat. In general the Guests Lock
> +(matrix_dev->guests_lock) must be taken outside of the KVM Lock (kvm->lock)
> +which in turn must be taken outside of the Matrix Devices Lock
> +(matrix_dev->mdevs_lock).
> +
> +The following describes the various operations under which the various locks are
> +taken, the purpose for taking them and the order in which they must be taken.
> +
> +* Operations: Setting or clearing the KVM pointer (matrix_mdev->kvm):
> +
> + 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem):
> +
> + This semaphore must be held in write mode while setting or clearing the
> + reference to the function pointer (kvm->arch.crypt.pqap_hook) to call
> + when the PQAP(AQIC) instruction sub-function is intercepted by the host.
> + The function pointer is set when the KVM pointer is being set and
> + cleared when the KVM pointer is being cleared.
> +
> + 2.Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held while accessing the KVM pointer
> + (matrix_mdev->kvm) to plug/unplug AP devices passed through to the
> + KVM guest
> +
> + 3. KVM Lock (kvm->lock):
> +
> + This mutex must be held while the AP devices passed through to the KVM
> + guest are plugged/unplugged.
> +
> + 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held to prevent access to the matrix_mdev state
> + while writing/reading state values during the operation.
> +
> +* Operations: Assign or unassign an adapter, domain or control domain of a
> + mediated device under the control of the vfio_ap device driver:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held while accessing the KVM pointer
> + (matrix_dev->kvm) to plug/unplug AP devices passed through to the
> + KVM guest as a result of the assignment/unassignment operation.
> + Assignment of an AP device may result in additional queue devices
> + or control domains being plugged into the guest. Similarly, unassignment
> + may result in unplugging queue devices or control domains from the
> + guest
> +
> + 3. KVM Lock (matrix_mdev->kvm->lock):
> +
> + This mutex must be held while the AP devices passed through to the KVM
> + guest are plugged in or unplugged.
> +
> + 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held to prevent access to the matrix_mdev state
> + while writing/reading state values during the operation. For example, to
> + determine which AP devices need to be plugged/unplugged, the lock
> + must be held to prevent other operations from changing the data used
> + to construct the guest's AP configuration.
> +
> +* Operations: Probe or remove an AP queue device:
> +
> + When a queue device is bound to the vfio_ap device driver, the driver's probe
> + callback is invoked. Similarly, when a queue device is unbound from the
> + driver it's remove callback is invoked. The probe and remove functions will
> + take locks in the following order:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held for the duration of this operation.
> +
> + At the time of the operation, the vfio_ap device driver will only have
> + the APQN of the queue being probed or removed, so the
> + matrix_dev->mdevs_list must be perused to locate the matrix_mdev
> + instance to which the queue is assigned. The Guests Lock must be held
> + during this time to prevent the list from being changed while processing
> + the probe/remove.
> +
> + Once the matrix_mdev is found, the operation must determine whether the
> + mediated device is passed through to a guest (matrix_mdev->kvm != NULL),
> + then use the KVM pointer to perform the plug/unplug operation. Here
> + again, the lock must be held to prevent other operations from accessing
> + the KVM pointer for the same purpose.
> +
> + 2. KVM Lock (kvm->lock):
> +
> + This mutex must be held while the AP devices passed through to the KVM
> + guest are plugged in or unplugged to prevent other operations from
> + accessing the guest's state while it is in flux.
> +
> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held to prevent access to the matrix_mdev state
> + while writing/reading state values during the operation, such as the
> + masks used to construct the KVM guest's AP configuration.
> +
> +* Operations: Probe or remove a mediated device:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held while adding the matrix_mdev to the
> + matrix_dev->mdev_list during the probe operation or when removing it
> + from the list during the remove operation. This is to prevent access by
> + other functions that must traverse the list to find a matrix_mdev for
> + the purpose of plugging/unplugging AP devices passed through to a KVM
> + guest (i.e., probe/remove queue callbacks), while the list is being
> + modified.
> +
> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held to prevent access to the matrix_mdev state
> + while writing/reading state values during the probe or remove operations
> + such as initializing the hashtable of queue devices
> + (matrix_mdev->qtable.queues) assigned to the matrix_mdev.
> +
> +* Operation: Handle interception of the PQAP(AQIC) instruction sub-function:
> +
> + 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem)
> +
> + This semaphore must be held in read mode while retrieving the function
> + pointer (kvm->arch.crypto.pqap_hook) and executing the function that
> + handles the interception of the PQAP(AQIC) instruction sub-function by
> + the host.
> +
> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held to prevent access to the matrix_mdev state
> + while writing/reading state values during the execution of the
> + PQAP(AQIC) instruction sub-function interception handler. For example,
> + the handler must iterate over the matrix_mdev->qtable.queues hashtable
> + to find the vfio_ap_queue object representing the queue for which
> + interrupts are being enabled or disabled.
> +
> + Note: It is not necessary to take the Guests Lock (matrix_dev->guests_lock)
> + or the KVM Lock (matrix_mdev->kvm->lock) because the KVM pointer
> + will not be accessed to plug/unplug AP devices passed through to the
> + guest; it will only be used to allocate or free resources for processing
> + interrupts.
> +
> +* Operation: Handle AP configuration changed notification:
> +
> + The vfio_ap device driver registers a callback function to be notified when
> + the AP bus detects that the host's AP configuration has changed. This can
> + occur due to the addition or removal of AP adapters, domains or control
> + domains via an SE or HMC connected to a DPM enabled LPAR. The objective of the
> + handler is to remove the queues no longer accessible via the host in bulk
> + rather than one queue at a time via the driver's queue device remove callback.
> + The locks and the order in which they must be taken by this operation are:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held for the duration of the operation to:
> +
> + * Iterate over the matrix_dev->mdev_list to find each matrix_mdev from
> + which a queue device to be removed is assigned and prevent other
> + operations from modifying the list while processing the affected
> + matrix_mdev instances.
> +
> + * Prevent other operations from acquiring access to the KVM pointer in
> + each affected matrix_mdev instance (matrix_mdev->kvm) for the purpose
> + of plugging/unplugging AP devices passed through to the KVM guest via
> + that instance.
> +
> +2. KVM Lock (kvm->lock):
> +
> + This mutex must be held for each affected matrix_mdev instance while
> + the AP devices passed through to the KVM guest are unplugged to prevent
> + other operations from accessing the guest's state while it is in flux.
> +
> + Note: This lock must be re-acquired for each matrix_mdev instance.
> +
> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
> +
> + This lock must be held for each affected matrix_mdev to prevent access
> + to the matrix_mdev state while writing/reading state values during the
> + operation, such as the masks used to construct the KVM guest's AP
> + configuration.
> +
> + Note: This lock must be re-acquired for each matrix_mdev instance.
> +
> +Operation: Handle AP bus scan complete notification:
> +
> + The vfio_ap device driver registers a callback function to be notified when
> + the AP bus scan completes after detecting the addition or removal of AP
> + adapters, domains or control domains. The objective of the handler is t
> + add the new queues accessible via the host in bulk rather than one queue
> + at a time via the driver's queue device probe callback. The locks and the
> + order in which they must be taken by this operation are:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held for the duration of the operation to:
> +
> + * Iterate over the matrix_dev->mdev_list to find each matrix_mdev to
> + which a queue device added is assigned and prevent other operations
> + from modifying the list while processing each affected matrix_mdev
> + object.
> +
> + * Prevent other operations from acquiring access to the KVM pointer in
> + each affected matrix_mdev instance (matrix_mdev->kvm) for the purpose
> + of plugging/unplugging AP devices passed through to the KVM guest via
> + that instance.
> +
> + 2. KVM Lock (kvm->lock):
> +
> + This mutex must be held for each affected matrix_mdev instance while
> + the AP devices passed through to the KVM guest are plugged in to prevent
> + other operations from accessing the guest's state while it is in flux.
> +
> + Note: This lock must be re-acquired for each matrix_mdev instance.
> +
> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock):
> +
> + This lock must be held for each affected matrix_mdev to prevent access
> + to the matrix_mdev state while writing/reading state values during the
> + operation, such as the masks used to construct the KVM guest's AP
> + configuration.
> +
> + Note: This lock must be re-acquired for each matrix_mdev instance.
> +
> +Operation: Handle resource in use query:
> +
> + The vfio_ap device driver registers a callback function with the AP bus to be
> + called when changes to the bus's sysfs /sys/bus/ap/apmask or
> + /sys/bus/ap/aqmask attributes would result in one or more AP queue devices
> + getting unbound from the vfio_ap device driver to verify none of them are in
> + use by the driver (i.e., assigned to a matrix_mdev instance). If this function
> + is called while an adapter or domain is also being assigned to a mediated
> + device, this could result in a deadlock; for example:
> +
> + 1. A system administrator assigns an adapter to a mediated device under the
> + control of the vfio_ap device driver. The driver will need to first take
> + the matrix_dev->guests_lock to potentially hot plug the adapter into
> + the KVM guest.
> + 2. At the same time, a system administrator sets a bit in the sysfs
> + /sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
> + must:
> + a. Take the ap_perms_mutex lock to update the object storing the values
> + for the /sys/bus/ap/ap_mask attribute.
> + b. Call the vfio_ap device driver's in-use callback to verify that no
> + queues now being reserved for the default zcrypt drivers are
> + in use by the vfio_ap device driver. To do the verification, the in-use
> + callback function takes the matrix_dev->guests_lock, but has to wait
> + because it is already held by the operation in 1 above.
> + 3. The vfio_ap device driver calls an AP bus function to verify that the
> + new queues resulting from the assignment of the adapter in step 1 are
> + not reserved for the default zcrypt device driver. This AP bus function
> + tries to take the ap_perms_mutex lock but gets stuck waiting for the
> + it due to step 2a above.
> +
> + Consequently, we have the following deadlock situation:
> +
> + matrix_dev->guests_lock locked (1)
> + ap_perms_mutex lock locked (2a)
> + Waiting for matrix_dev->lock (2b) which is currently held (1)
> + Waiting for ap_perms_mutex lock (3) which is currently held (2a)
> +
> + To prevent the deadlock scenario, the in_use operation will take the
> + required locks using the mutex_trylock() function and if the lock can not be
> + acquired will terminate and return -EBUSY to indicate the driver is busy
> + processing another request.
> +
> + The locks required to respond to the handle resource in use query and the
> + order in which they must be taken are:
> +
> + 1. Guests Lock (matrix_dev->guests_lock):
> +
> + This mutex must be held for the duration of the operation to iterate over the
> + matrix_dev->mdev_list to determine whether any of the queues to be unbound
> + are assigned to a matrix_mdev instance.
> +
> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock):
> +
> + This mutex must be held for the duration of the operation to ensure that the
> + AP configuration of each matrix_mdev instance does not change while verifying
> + that none of the queue devices to be removed from the vfio_ap driver are
> + assigned to it.
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> Update the documentation in vfio-ap.rst to include information about the
> AP dynamic configuration support (e.g., hot plug of adapters, domains
> and control domains via the matrix mediated device's sysfs assignment
> attributes). This patch also makes a few minor tweaks to make corrections
> and clarifications.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> Documentation/s390/vfio-ap.rst | 492 +++++++++++++++++++++++----------
> 1 file changed, 346 insertions(+), 146 deletions(-)
Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> Let's hot plug an adapter, domain or control domain into the guest when it
> is assigned to a matrix mdev that is attached to a KVM guest. Likewise,
> let's hot unplug an adapter, domain or control domain from the guest when
> it is unassigned from a matrix_mdev that is attached to a KVM guest.
>
> Whenever an assignment or unassignment of an adapter, domain or control
> domain is performed, the APQNs and control domains assigned to the matrix
> mdev will be filtered and assigned to the AP control block
> (APCB) that supplies the AP configuration to the guest so that no
> adapter, domain or control domain that is not in the host's AP
> configuration nor any APQN that does not reference a queue device bound
> to the vfio_ap device driver is assigned.
>
> After updating the APCB, if the mdev is in use by a KVM guest, it is
> hot plugged into the guest to dynamically provide access to the adapters,
> domains and control domains provided via the newly refreshed APCB.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 112 +++++++++++++++---------------
> 1 file changed, 57 insertions(+), 55 deletions(-)
Seems sane.
Reviewed-by: Jason J. Herne <[email protected]>
On 5/27/22 9:50 AM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> The callback functions for probing and removing a queue device must take
>> and release the locks required to perform a dynamic update of a guest's
>> APCB in the proper order.
>>
>> The proper order for taking the locks is:
>>
>> matrix_dev->guests_lock => kvm->lock => matrix_dev->mdevs_lock
>>
>> The proper order for releasing the locks is:
>>
>> matrix_dev->mdevs_lock => kvm->lock => matrix_dev->guests_lock
>>
>> A new helper function is introduced to be used by the probe callback to
>> acquire the required locks. Since the probe callback only has
>> access to a queue device when it is called, the helper function will
>> find
>> the ap_matrix_mdev object to which the queue device's APQN is
>> assigned and
>> return it so the KVM guest to which the mdev is attached can be
>> dynamically
>> updated.
>>
>> Note that in order to find the ap_matrix_mdev (matrix_mdev) object,
>> it is
>> necessary to search the matrix_dev->mdev_list. This presents a
>> locking order dilemma because the matrix_dev->mdevs_lock can't be
>> taken to
>> protect against changes to the list while searching for the
>> matrix_mdev to
>> which a queue device's APQN is assigned. This is due to the fact that
>> the
>> proper locking order requires that the matrix_dev->mdevs_lock be taken
>> after both the matrix_mdev->kvm->lock and the matrix_dev->mdevs_lock.
>> Consequently, the matrix_dev->guests_lock will be used to protect
>> against
>> removal of a matrix_mdev object from the list while a queue device is
>> being probed. This necessitates changes to the mdev probe/remove
>> callback functions to take the matrix_dev->guests_lock prior to removing
>> a matrix_mdev object from the list.
>>
>> A new macro is also introduced to acquire the locks required to
>> dynamically
>> update the guest's APCB in the proper order when a queue device is
>> removed.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> drivers/s390/crypto/vfio_ap_ops.c | 126 +++++++++++++++++++++---------
>> 1 file changed, 88 insertions(+), 38 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 2219b1069ceb..080a733f7cd2 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -116,6 +116,74 @@ static const struct vfio_device_ops
>> vfio_ap_matrix_dev_ops;
>> mutex_unlock(&matrix_dev->guests_lock); \
>> })
>> +/**
>> + * vfio_ap_mdev_get_update_locks_for_apqn: retrieve the matrix mdev
>> to which an
>> + * APQN is assigned and acquire the
>> + * locks required to update the APCB of
>> + * the KVM guest to which the mdev is
>> + * attached.
>> + *
>> + * @apqn: the APQN of a queue device.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: If @apqn is not assigned to a matrix_mdev, the
>> matrix_mdev->kvm->lock
>> + * will not be taken.
>> + *
>> + * Return: the ap_matrix_mdev object to which @apqn is assigned or
>> NULL if @apqn
>> + * is not assigned to an ap_matrix_mdev.
>> + */
>> +static struct ap_matrix_mdev
>> *vfio_ap_mdev_get_update_locks_for_apqn(int apqn)
>> +{
>> + struct ap_matrix_mdev *matrix_mdev;
>> +
>> + mutex_lock(&matrix_dev->guests_lock);
>> +
>> + list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
>> + if (test_bit_inv(AP_QID_CARD(apqn), matrix_mdev->matrix.apm) &&
>> + test_bit_inv(AP_QID_QUEUE(apqn),
>> matrix_mdev->matrix.aqm)) {
>> + if (matrix_mdev->kvm)
>> + mutex_lock(&matrix_mdev->kvm->lock);
>> +
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> +
>> + return matrix_mdev;
>> + }
>> + }
>> +
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> +
>> + return NULL;
>> +}
>> +
>> +/**
>> + * get_update_locks_for_queue: get the locks required to update the
>> APCB of the
>> + * KVM guest to which the matrix mdev linked to a
>> + * vfio_ap_queue object is attached.
>> + *
>> + * @queue: a pointer to a vfio_ap_queue object.
>> + *
>> + * The proper locking order is:
>> + * 1. matrix_dev->guests_lock: required to use the KVM pointer to
>> update a KVM
>> + * guest's APCB.
>> + * 2. queue->matrix_mdev->kvm->lock: required to update a guest's APCB
>> + * 3. matrix_dev->mdevs_lock: required to access data stored in a
>> matrix_mdev
>> + *
>> + * Note: if @queue is not linked to an ap_matrix_mdev object, the
>> KVM lock
>> + * will not be taken.
>> + */
>> +#define get_update_locks_for_queue(queue) ({ \
>> + struct ap_matrix_mdev *matrix_mdev = q->matrix_mdev; \
>> + mutex_lock(&matrix_dev->guests_lock); \
>> + if (matrix_mdev && matrix_mdev->kvm) \
>> + mutex_lock(&matrix_mdev->kvm->lock); \
>> + mutex_lock(&matrix_dev->mdevs_lock); \
>> +})
>> +
>
>
> One more comment I forgot to include before:
> This macro is far too similar to existing macro,
> get_update_locks_for_mdev. And it is only called in one place. Let's
> remove this and replace the single invocation with:
>
> get_update_locks_for_mdev(q->matrix_mdev);
We can't do that, but your comment does point out a flaw in this macro;
namely, we must take the matrix_dev->guests_lock before attempting to
access q->matrix_mdev.
An ap_matrix_mdev can be unlinked from a vfio_ap_queue (and vice versa)
when the queue is removed, but it also can be unlinked when an adapter
or domain is unassigned from an ap_matrix_mdev. In order to ensure that
the q->matrix_mdev is not in the process of being nullified (unlinked),
we must be holding the guests_lock which is also held when an adapter or
domain is unassigned.
>
>
>> /**
>> * vfio_ap_mdev_get_queue - retrieve a queue with a specific APQN
>> from a
>> * hash table of queues assigned to a matrix mdev
>> @@ -615,21 +683,18 @@ static int vfio_ap_mdev_probe(struct
>> mdev_device *mdev)
>> matrix_mdev->pqap_hook = handle_pqap;
>> vfio_ap_matrix_init(&matrix_dev->info, &matrix_mdev->shadow_apcb);
>> hash_init(matrix_mdev->qtable.queues);
>> - mdev_set_drvdata(mdev, matrix_mdev);
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> - list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> ret = vfio_register_emulated_iommu_dev(&matrix_mdev->vdev);
>> if (ret)
>> goto err_list;
>> + mdev_set_drvdata(mdev, matrix_mdev);
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> + list_add(&matrix_mdev->node, &matrix_dev->mdev_list);
>> + mutex_unlock(&matrix_dev->mdevs_lock);
>> dev_set_drvdata(&mdev->dev, matrix_mdev);
>> return 0;
>> err_list:
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> - list_del(&matrix_mdev->node);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> vfio_uninit_group_dev(&matrix_mdev->vdev);
>> kfree(matrix_mdev);
>> err_dec_available:
>> @@ -692,11 +757,13 @@ static void vfio_ap_mdev_remove(struct
>> mdev_device *mdev)
>> vfio_unregister_group_dev(&matrix_mdev->vdev);
>> + mutex_lock(&matrix_dev->guests_lock);
>> mutex_lock(&matrix_dev->mdevs_lock);
>> vfio_ap_mdev_reset_queues(matrix_mdev);
>> vfio_ap_mdev_unlink_fr_queues(matrix_mdev);
>> list_del(&matrix_mdev->node);
>> mutex_unlock(&matrix_dev->mdevs_lock);
>> + mutex_unlock(&matrix_dev->guests_lock);
>> vfio_uninit_group_dev(&matrix_mdev->vdev);
>> kfree(matrix_mdev);
>> atomic_inc(&matrix_dev->available_instances);
>> @@ -1665,49 +1732,30 @@ void vfio_ap_mdev_unregister(void)
>> mdev_unregister_driver(&vfio_ap_matrix_driver);
>> }
>> -/*
>> - * vfio_ap_queue_link_mdev
>> - *
>> - * @q: The queue to link with the matrix mdev.
>> - *
>> - * Links @q with the matrix mdev to which the queue's APQN is assigned.
>> - */
>> -static void vfio_ap_queue_link_mdev(struct vfio_ap_queue *q)
>> -{
>> - unsigned long apid = AP_QID_CARD(q->apqn);
>> - unsigned long apqi = AP_QID_QUEUE(q->apqn);
>> - struct ap_matrix_mdev *matrix_mdev;
>> -
>> - list_for_each_entry(matrix_mdev, &matrix_dev->mdev_list, node) {
>> - if (test_bit_inv(apid, matrix_mdev->matrix.apm) &&
>> - test_bit_inv(apqi, matrix_mdev->matrix.aqm)) {
>> - vfio_ap_mdev_link_queue(matrix_mdev, q);
>> - break;
>> - }
>> - }
>> -}
>> -
>> int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
>> {
>> struct vfio_ap_queue *q;
>> + struct ap_matrix_mdev *matrix_mdev;
>> DECLARE_BITMAP(apm_delta, AP_DEVICES);
>> q = kzalloc(sizeof(*q), GFP_KERNEL);
>> if (!q)
>> return -ENOMEM;
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> q->apqn = to_ap_queue(&apdev->device)->qid;
>> q->saved_isc = VFIO_AP_ISC_INVALID;
>> - vfio_ap_queue_link_mdev(q);
>> - if (q->matrix_mdev) {
>> +
>> + matrix_mdev = vfio_ap_mdev_get_update_locks_for_apqn(q->apqn);
>> +
>> + if (matrix_mdev) {
>> + vfio_ap_mdev_link_queue(matrix_mdev, q);
>> memset(apm_delta, 0, sizeof(apm_delta));
>> set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
>> vfio_ap_mdev_filter_matrix(apm_delta,
>> - q->matrix_mdev->matrix.aqm,
>> - q->matrix_mdev);
>> + matrix_mdev->matrix.aqm,
>> + matrix_mdev);
>> }
>> dev_set_drvdata(&apdev->device, q);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> + release_update_locks_for_mdev(matrix_mdev);
>> return 0;
>> }
>> @@ -1716,11 +1764,13 @@ void vfio_ap_mdev_remove_queue(struct
>> ap_device *apdev)
>> {
>> unsigned long apid;
>> struct vfio_ap_queue *q;
>> + struct ap_matrix_mdev *matrix_mdev;
>> - mutex_lock(&matrix_dev->mdevs_lock);
>> q = dev_get_drvdata(&apdev->device);
>> + get_update_locks_for_queue(q);
>> + matrix_mdev = q->matrix_mdev;
>> - if (q->matrix_mdev) {
>> + if (matrix_mdev) {
>> vfio_ap_unlink_queue_fr_mdev(q);
>> apid = AP_QID_CARD(q->apqn);
>> @@ -1731,5 +1781,5 @@ void vfio_ap_mdev_remove_queue(struct ap_device
>> *apdev)
>> vfio_ap_mdev_reset_queue(q, 1);
>> dev_set_drvdata(&apdev->device, NULL);
>> kfree(q);
>> - mutex_unlock(&matrix_dev->mdevs_lock);
>> + release_update_locks_for_mdev(matrix_mdev);
>> }
>
>
On 4/4/22 18:10, Tony Krowiak wrote:
> When an AP queue device is probed or removed, if the mediated device is
> attached to a KVM guest, the mediated device's adapter, domain and
> control domain bitmaps must be filtered to update the guest's APCB and if
> any changes are detected, the guest's APCB must then be hot plugged into
> the guest to reflect those changes to the guest.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 23 +++++++++++++++++------
> 1 file changed, 17 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 47f808122ed2..ec5f37d726ec 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -1752,9 +1752,11 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
> vfio_ap_mdev_link_queue(matrix_mdev, q);
> memset(apm_delta, 0, sizeof(apm_delta));
> set_bit_inv(AP_QID_CARD(q->apqn), apm_delta);
> - vfio_ap_mdev_filter_matrix(apm_delta,
> - matrix_mdev->matrix.aqm,
> - matrix_mdev);
> +
> + if (vfio_ap_mdev_filter_matrix(apm_delta,
> + matrix_mdev->matrix.aqm,
> + matrix_mdev))
> + vfio_ap_mdev_update_guest_apcb(matrix_mdev);
> }
> dev_set_drvdata(&apdev->device, q);
> release_update_locks_for_mdev(matrix_mdev);
> @@ -1764,7 +1766,7 @@ int vfio_ap_mdev_probe_queue(struct ap_device *apdev)
>
> void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> {
> - unsigned long apid;
> + unsigned long apid, apqi;
> struct vfio_ap_queue *q;
> struct ap_matrix_mdev *matrix_mdev;
>
> @@ -1776,8 +1778,17 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> vfio_ap_unlink_queue_fr_mdev(q);
>
> apid = AP_QID_CARD(q->apqn);
> - if (test_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm))
> - clear_bit_inv(apid, q->matrix_mdev->shadow_apcb.apm);
> + apqi = AP_QID_QUEUE(q->apqn);
> +
> + /*
> + * If the queue is assigned to the guest's APCB, then remove
> + * the adapter's APID from the APCB and hot it into the guest.
> + */
> + if (test_bit_inv(apid, matrix_mdev->shadow_apcb.apm) &&
> + test_bit_inv(apqi, matrix_mdev->shadow_apcb.aqm)) {
> + clear_bit_inv(apid, matrix_mdev->shadow_apcb.apm);
> + vfio_ap_mdev_update_guest_apcb(matrix_mdev);
> + }
> }
>
> vfio_ap_mdev_reset_queue(q, 1);
Also seems sane.
Reviewed-by: Jason J. Herne <[email protected]>
On 4/4/22 18:10, Tony Krowiak wrote:
> When an adapter or domain is unassigned from an mdev attached to a KVM
> guest, one or more of the guest's queues may get dynamically removed. Since
> the removed queues could get re-assigned to another mdev, they need to be
> reset. So, when an adapter or domain is unassigned from the mdev, the
> queues that are removed from the guest's AP configuration (APCB) will be
> reset.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_ops.c | 152 +++++++++++++++++++-------
> drivers/s390/crypto/vfio_ap_private.h | 2 +
> 2 files changed, 114 insertions(+), 40 deletions(-)
Reviewed-by: Jason J. Herne <[email protected]>
On 6/2/22 2:16 PM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> Let's implement the callback to indicate when an APQN
>> is in use by the vfio_ap device driver. The callback is
>> invoked whenever a change to the apmask or aqmask would
>> result in one or more queue devices being removed from the driver. The
>> vfio_ap device driver will indicate a resource is in use
>> if the APQN of any of the queue devices to be removed are assigned to
>> any of the matrix mdevs under the driver's control.
>>
>> There is potential for a deadlock condition between the
>> matrix_dev->guests_lock used to lock the guest during assignment of
>> adapters and domains and the ap_perms_mutex locked by the AP bus when
>> changes are made to the sysfs apmask/aqmask attributes.
>>
>> The AP Perms lock controls access to the objects that store the adapter
>> numbers (ap_perms) and domain numbers (aq_perms) for the sysfs
>> /sys/bus/ap/apmask and /sys/bus/ap/aqmask attributes. These attributes
>> identify which queues are reserved for the zcrypt default device
>> drivers.
>> Before allowing a bit to be removed from either mask, the AP bus must
>> check
>> with the vfio_ap device driver to verify that none of the queues are
>> assigned to any of its mediated devices.
>>
>> The apmask/aqmask attributes can be written or read at any time from
>> userspace, so care must be taken to prevent a deadlock with asynchronous
>> operations that might be taking place in the vfio_ap device driver. For
>> example, consider the following:
>>
>> 1. A system administrator assigns an adapter to a mediated device
>> under the
>> control of the vfio_ap device driver. The driver will need to
>> first take
>> the matrix_dev->guests_lock to potentially hot plug the adapter into
>> the KVM guest.
>> 2. At the same time, a system administrator sets a bit in the sysfs
>> /sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
>> must:
>> a. Take the ap_perms_mutex lock to update the object storing the
>> values
>> for the /sys/bus/ap/ap_mask attribute.
>> b. Call the vfio_ap device driver's in-use callback to verify
>> that the
>> queues now being reserved for the default zcrypt drivers are not
>> assigned to a mediated device owned by the vfio_ap device
>> driver. To
>> do the verification, the in-use callback function takes the
>> matrix_dev->guests_lock, but has to wait because it is already
>> held
>> by the operation in 1 above.
>> 3. The vfio_ap device driver calls an AP bus function to verify that the
>> new queues resulting from the assignment of the adapter in step 1
>> are
>> not reserved for the default zcrypt device driver. This AP bus
>> function
>> tries to take the ap_perms_mutex lock but gets stuck waiting for the
>> waiting for the lock due to step 2a above.
>>
>> Consequently, we have the following deadlock situation:
>>
>> matrix_dev->guests_lock locked (1)
>> ap_perms_mutex lock locked (2a)
>> Waiting for matrix_dev->gusts_lock (2b) which is currently held (1)
>> Waiting for ap_perms_mutex lock (3) which is currently held (2a)
>>
>> To prevent this deadlock scenario, the function called in step 3 will no
>> longer take the ap_perms_mutex lock and require the caller to take the
>> lock. The lock will be the first taken by the adapter/domain assignment
>> functions in the vfio_ap device driver to maintain the proper locking
>> order.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> drivers/s390/crypto/ap_bus.c | 31 ++++++++----
>> drivers/s390/crypto/vfio_ap_drv.c | 1 +
>> drivers/s390/crypto/vfio_ap_ops.c | 68 +++++++++++++++++++++++++++
>> drivers/s390/crypto/vfio_ap_private.h | 2 +
>> 4 files changed, 94 insertions(+), 8 deletions(-)
>>
>> diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
>> index fdf16cb70881..f48552e900a2 100644
>> --- a/drivers/s390/crypto/ap_bus.c
>> +++ b/drivers/s390/crypto/ap_bus.c
>> @@ -817,6 +817,17 @@ static void ap_bus_revise_bindings(void)
>> bus_for_each_dev(&ap_bus_type, NULL, NULL, __ap_revise_reserved);
>> }
>> +/**
>> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether an APQN c
>> is reserved
>> + * for the host drivers or not.
>> + * @card: the APID of the adapter card to check
>> + * @queue: the APQI of the queue to check
>> + *
>> + * Note: the ap_perms_mutex must be locked by the caller of this
>> function.
>> + *
>> + * Return: an int specifying whether the APQN is reserved for the
>> host (1) or
>> + * not (0)
>> + */
>
> Comment's function name does not match real function name. Also APQN
> "c", from
> description does not appear to exist.
No, it definitely does not match and the 'c' is an extraneous typo. I'll
fix both.
>
>
>
>> int ap_owned_by_def_drv(int card, int queue)
>> {
>> int rc = 0;
>> @@ -824,25 +835,31 @@ int ap_owned_by_def_drv(int card, int queue)
>> if (card < 0 || card >= AP_DEVICES || queue < 0 || queue >=
>> AP_DOMAINS)
>> return -EINVAL;
>> - mutex_lock(&ap_perms_mutex);
>> -
>> if (test_bit_inv(card, ap_perms.apm)
>> && test_bit_inv(queue, ap_perms.aqm))
>> rc = 1;
>> - mutex_unlock(&ap_perms_mutex);
>> -
>> return rc;
>> }
>> EXPORT_SYMBOL(ap_owned_by_def_drv);
>> +/**
>> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether every APQN
>> contained in
>> + * a set is reserved for the host drivers
>> + * or not.
>> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to
>> check
>> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to
>> check
>> + *
>> + * Note: the ap_perms_mutex must be locked by the caller of this
>> function.
>> + *
>> + * Return: an int specifying whether each APQN is reserved for the
>> host (1) or
>> + * not (0)
>> + */
>> int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
>> unsigned long *aqm)
>> {
>> int card, queue, rc = 0;
>> - mutex_lock(&ap_perms_mutex);
>> -
>> for (card = 0; !rc && card < AP_DEVICES; card++)
>> if (test_bit_inv(card, apm) &&
>> test_bit_inv(card, ap_perms.apm))
>> @@ -851,8 +868,6 @@ int ap_apqn_in_matrix_owned_by_def_drv(unsigned
>> long *apm,
>> test_bit_inv(queue, ap_perms.aqm))
>> rc = 1;
>> - mutex_unlock(&ap_perms_mutex);
>> -
>> return rc;
>> }
>> EXPORT_SYMBOL(ap_apqn_in_matrix_owned_by_def_drv);
>> diff --git a/drivers/s390/crypto/vfio_ap_drv.c
>> b/drivers/s390/crypto/vfio_ap_drv.c
>> index c258e5f7fdfc..2c3084589347 100644
>> --- a/drivers/s390/crypto/vfio_ap_drv.c
>> +++ b/drivers/s390/crypto/vfio_ap_drv.c
>> @@ -107,6 +107,7 @@ static const struct attribute_group
>> vfio_queue_attr_group = {
>> static struct ap_driver vfio_ap_drv = {
>> .probe = vfio_ap_mdev_probe_queue,
>> .remove = vfio_ap_mdev_remove_queue,
>> + .in_use = vfio_ap_mdev_resource_in_use,
>> .ids = ap_queue_ids,
>> };
>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c
>> b/drivers/s390/crypto/vfio_ap_ops.c
>> index 49ed54dc9e05..3ece2cd9f1e7 100644
>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>> @@ -902,6 +902,21 @@ static int
>> vfio_ap_mdev_verify_no_sharing(unsigned long *mdev_apm,
>> return 0;
>> }
>> +/**
>> + * vfio_ap_mdev_validate_masks - verify that the APQNs assigned to
>> the mdev are
>> + * not reserved for the default zcrypt driver and
>> + * are not assigned to another mdev.
>> + *
>> + * @matrix_mdev: the mdev to which the APQNs being validated are
>> assigned.
>> + *
>> + * Return: One of the following values:
>> + * o the error returned from the
>> ap_apqn_in_matrix_owned_by_def_drv() function,
>> + * most likely -EBUSY indicating the ap_perms_mutex lock is
>> already held.
>> + * o EADDRNOTAVAIL if an APQN assigned to @matrix_mdev is reserved
>> for the
>> + * zcrypt default driver.
>> + * o EADDRINUSE if an APQN assigned to @matrix_mdev is assigned to
>> another mdev
>> + * o A zero indicating validation succeeded.
>> + */
>> static int vfio_ap_mdev_validate_masks(struct ap_matrix_mdev
>> *matrix_mdev)
>> {
>> if (ap_apqn_in_matrix_owned_by_def_drv(matrix_mdev->matrix.apm,
>> @@ -951,6 +966,10 @@ static void vfio_ap_mdev_link_adapter(struct
>> ap_matrix_mdev *matrix_mdev,
>> * An APQN derived from the cross product of the APID being
>> assigned
>> * and the APQIs previously assigned is being used by another
>> mediated
>> * matrix device
>> + *
>> + * 5. -EAGAIN
>> + * A lock required to validate the mdev's AP configuration
>> could not
>> + * be obtained.
>> */
>> static ssize_t assign_adapter_store(struct device *dev,
>> struct device_attribute *attr,
>> @@ -961,6 +980,7 @@ static ssize_t assign_adapter_store(struct device
>> *dev,
>> DECLARE_BITMAP(apm_delta, AP_DEVICES);
>> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>> + mutex_lock(&ap_perms_mutex);
>> get_update_locks_for_mdev(matrix_mdev);
>> ret = kstrtoul(buf, 0, &apid);
>> @@ -991,6 +1011,7 @@ static ssize_t assign_adapter_store(struct
>> device *dev,
>> ret = count;
>> done:
>> release_update_locks_for_mdev(matrix_mdev);
>> + mutex_unlock(&ap_perms_mutex);
>> return ret;
>> }
>> @@ -1144,6 +1165,10 @@ static void vfio_ap_mdev_link_domain(struct
>> ap_matrix_mdev *matrix_mdev,
>> * An APQN derived from the cross product of the APQI being
>> assigned
>> * and the APIDs previously assigned is being used by another
>> mediated
>> * matrix device
>> + *
>> + * 5. -EAGAIN
>> + * The lock required to validate the mdev's AP configuration
>> could not
>> + * be obtained.
>> */
>> static ssize_t assign_domain_store(struct device *dev,
>> struct device_attribute *attr,
>> @@ -1154,6 +1179,7 @@ static ssize_t assign_domain_store(struct
>> device *dev,
>> DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
>> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>> + mutex_lock(&ap_perms_mutex);
>> get_update_locks_for_mdev(matrix_mdev);
>> ret = kstrtoul(buf, 0, &apqi);
>> @@ -1184,6 +1210,7 @@ static ssize_t assign_domain_store(struct
>> device *dev,
>> ret = count;
>> done:
>> release_update_locks_for_mdev(matrix_mdev);
>> + mutex_unlock(&ap_perms_mutex);
>> return ret;
>> }
>> @@ -1868,3 +1895,44 @@ void vfio_ap_mdev_remove_queue(struct
>> ap_device *apdev)
>> kfree(q);
>> release_update_locks_for_mdev(matrix_mdev);
>> }
>> +
>> +/**
>> + * vfio_ap_mdev_resource_in_use: check whether any of a set of APQNs is
>> + * assigned to a mediated device under the control
>> + * of the vfio_ap device driver.
>> + *
>> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to
>> check.
>> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to
>> check.
>> + *
>> + * This function is invoked by the AP bus when changes to the
>> apmask/aqmask
>> + * attributes will result in giving control of the queue devices
>> specified via
>> + * @apm and @aqm to the default zcrypt device driver. Prior to
>> calling this
>> + * function, the AP bus locks the ap_perms_mutex. If this function
>> is called
>> + * while an adapter or domain is being assigned to a mediated
>> device, the
>> + * assignment operations will take the matrix_dev->guests_lock and
>> + * matrix_dev->mdevs_lock then call the
>> ap_apqn_in_matrix_owned_by_def_drv
>> + * function, which also locks the ap_perms_mutex. This could result
>> in a
>> + * deadlock.
>> + *
>> + * To avoid a deadlock, this function will verify that the
>> + * matrix_dev->guests_lock and matrix_dev->mdevs_lock are not
>> currently held and
>> + * will return -EBUSY if the locks can not be obtained.
>
> This part of the comment does not seem to match reality. Unless I'm
> missing
> something? Did you mean to call mutex_trylock? Or is the comment stale?
The comment was written prior to the changes introduced to avoid the locking
dependency (i.e., taking the ap_perms_mutex lock by the assignment functions
which I believe was your suggestion). I shall remove the comment.
>
>> + * Return:
>> + * * -EBUSY if the locks required by this function are already
>> locked.
>> + * * -EADDRINUSE if one or more of the APQNs specified via
>> @apm/@aqm are
>> + * assigned to a mediated device under the control of the vfio_ap
>> + * device driver.
>> + */
>> +int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long
>> *aqm)
>> +{
>> + int ret;
>> +
>> + mutex_lock(&matrix_dev->guests_lock);
>> + mutex_lock(&matrix_dev->mdevs_lock);
>> + ret = vfio_ap_mdev_verify_no_sharing(apm, aqm);
>> + mutex_unlock(&matrix_dev->mdevs_lock);
>> + mutex_unlock(&matrix_dev->guests_lock);
>> +
>> + return ret;
>> +}
>> diff --git a/drivers/s390/crypto/vfio_ap_private.h
>> b/drivers/s390/crypto/vfio_ap_private.h
>> index 6d4ca39f783b..cbffa0bd01da 100644
>> --- a/drivers/s390/crypto/vfio_ap_private.h
>> +++ b/drivers/s390/crypto/vfio_ap_private.h
>> @@ -147,4 +147,6 @@ void vfio_ap_mdev_unregister(void);
>> int vfio_ap_mdev_probe_queue(struct ap_device *queue);
>> void vfio_ap_mdev_remove_queue(struct ap_device *queue);
>> +int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long
>> *aqm);
>> +
>> #endif /* _VFIO_AP_PRIVATE_H_ */
>
>
On 6/2/22 15:19, Tony Krowiak wrote:
>
>
> On 6/2/22 2:16 PM, Jason J. Herne wrote:
>> On 4/4/22 18:10, Tony Krowiak wrote:
>>> Let's implement the callback to indicate when an APQN
>>> is in use by the vfio_ap device driver. The callback is
>>> invoked whenever a change to the apmask or aqmask would
>>> result in one or more queue devices being removed from the driver. The
>>> vfio_ap device driver will indicate a resource is in use
>>> if the APQN of any of the queue devices to be removed are assigned to
>>> any of the matrix mdevs under the driver's control.
>>>
>>> There is potential for a deadlock condition between the
>>> matrix_dev->guests_lock used to lock the guest during assignment of
>>> adapters and domains and the ap_perms_mutex locked by the AP bus when
>>> changes are made to the sysfs apmask/aqmask attributes.
>>>
>>> The AP Perms lock controls access to the objects that store the adapter
>>> numbers (ap_perms) and domain numbers (aq_perms) for the sysfs
>>> /sys/bus/ap/apmask and /sys/bus/ap/aqmask attributes. These attributes
>>> identify which queues are reserved for the zcrypt default device drivers.
>>> Before allowing a bit to be removed from either mask, the AP bus must check
>>> with the vfio_ap device driver to verify that none of the queues are
>>> assigned to any of its mediated devices.
>>>
>>> The apmask/aqmask attributes can be written or read at any time from
>>> userspace, so care must be taken to prevent a deadlock with asynchronous
>>> operations that might be taking place in the vfio_ap device driver. For
>>> example, consider the following:
>>>
>>> 1. A system administrator assigns an adapter to a mediated device under the
>>> control of the vfio_ap device driver. The driver will need to first take
>>> the matrix_dev->guests_lock to potentially hot plug the adapter into
>>> the KVM guest.
>>> 2. At the same time, a system administrator sets a bit in the sysfs
>>> /sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
>>> must:
>>> a. Take the ap_perms_mutex lock to update the object storing the values
>>> for the /sys/bus/ap/ap_mask attribute.
>>> b. Call the vfio_ap device driver's in-use callback to verify that the
>>> queues now being reserved for the default zcrypt drivers are not
>>> assigned to a mediated device owned by the vfio_ap device driver. To
>>> do the verification, the in-use callback function takes the
>>> matrix_dev->guests_lock, but has to wait because it is already held
>>> by the operation in 1 above.
>>> 3. The vfio_ap device driver calls an AP bus function to verify that the
>>> new queues resulting from the assignment of the adapter in step 1 are
>>> not reserved for the default zcrypt device driver. This AP bus function
>>> tries to take the ap_perms_mutex lock but gets stuck waiting for the
>>> waiting for the lock due to step 2a above.
>>>
>>> Consequently, we have the following deadlock situation:
>>>
>>> matrix_dev->guests_lock locked (1)
>>> ap_perms_mutex lock locked (2a)
>>> Waiting for matrix_dev->gusts_lock (2b) which is currently held (1)
>>> Waiting for ap_perms_mutex lock (3) which is currently held (2a)
>>>
>>> To prevent this deadlock scenario, the function called in step 3 will no
>>> longer take the ap_perms_mutex lock and require the caller to take the
>>> lock. The lock will be the first taken by the adapter/domain assignment
>>> functions in the vfio_ap device driver to maintain the proper locking
>>> order.
>>>
>>> Signed-off-by: Tony Krowiak <[email protected]>
>>> ---
>>> drivers/s390/crypto/ap_bus.c | 31 ++++++++----
>>> drivers/s390/crypto/vfio_ap_drv.c | 1 +
>>> drivers/s390/crypto/vfio_ap_ops.c | 68 +++++++++++++++++++++++++++
>>> drivers/s390/crypto/vfio_ap_private.h | 2 +
>>> 4 files changed, 94 insertions(+), 8 deletions(-)
>>>
>>> diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
>>> index fdf16cb70881..f48552e900a2 100644
>>> --- a/drivers/s390/crypto/ap_bus.c
>>> +++ b/drivers/s390/crypto/ap_bus.c
>>> @@ -817,6 +817,17 @@ static void ap_bus_revise_bindings(void)
>>> bus_for_each_dev(&ap_bus_type, NULL, NULL, __ap_revise_reserved);
>>> }
>>> +/**
>>> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether an APQN c is reserved
>>> + * for the host drivers or not.
>>> + * @card: the APID of the adapter card to check
>>> + * @queue: the APQI of the queue to check
>>> + *
>>> + * Note: the ap_perms_mutex must be locked by the caller of this function.
>>> + *
>>> + * Return: an int specifying whether the APQN is reserved for the host (1) or
>>> + * not (0)
>>> + */
>>
>> Comment's function name does not match real function name. Also APQN "c", from
>> description does not appear to exist.
>
> No, it definitely does not match and the 'c' is an extraneous typo. I'll fix both.
>
>>
>>
>>
>>> int ap_owned_by_def_drv(int card, int queue)
>>> {
>>> int rc = 0;
>>> @@ -824,25 +835,31 @@ int ap_owned_by_def_drv(int card, int queue)
>>> if (card < 0 || card >= AP_DEVICES || queue < 0 || queue >= AP_DOMAINS)
>>> return -EINVAL;
>>> - mutex_lock(&ap_perms_mutex);
>>> -
>>> if (test_bit_inv(card, ap_perms.apm)
>>> && test_bit_inv(queue, ap_perms.aqm))
>>> rc = 1;
>>> - mutex_unlock(&ap_perms_mutex);
>>> -
>>> return rc;
>>> }
>>> EXPORT_SYMBOL(ap_owned_by_def_drv);
>>> +/**
>>> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether every APQN contained in
>>> + * a set is reserved for the host drivers
>>> + * or not.
>>> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check
>>> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check
>>> + *
>>> + * Note: the ap_perms_mutex must be locked by the caller of this function.
>>> + *
>>> + * Return: an int specifying whether each APQN is reserved for the host (1) or
>>> + * not (0)
>>> + */
>>> int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
>>> unsigned long *aqm)
>>> {
>>> int card, queue, rc = 0;
>>> - mutex_lock(&ap_perms_mutex);
>>> -
>>> for (card = 0; !rc && card < AP_DEVICES; card++)
>>> if (test_bit_inv(card, apm) &&
>>> test_bit_inv(card, ap_perms.apm))
>>> @@ -851,8 +868,6 @@ int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
>>> test_bit_inv(queue, ap_perms.aqm))
>>> rc = 1;
>>> - mutex_unlock(&ap_perms_mutex);
>>> -
>>> return rc;
>>> }
>>> EXPORT_SYMBOL(ap_apqn_in_matrix_owned_by_def_drv);
>>> diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
>>> index c258e5f7fdfc..2c3084589347 100644
>>> --- a/drivers/s390/crypto/vfio_ap_drv.c
>>> +++ b/drivers/s390/crypto/vfio_ap_drv.c
>>> @@ -107,6 +107,7 @@ static const struct attribute_group vfio_queue_attr_group = {
>>> static struct ap_driver vfio_ap_drv = {
>>> .probe = vfio_ap_mdev_probe_queue,
>>> .remove = vfio_ap_mdev_remove_queue,
>>> + .in_use = vfio_ap_mdev_resource_in_use,
>>> .ids = ap_queue_ids,
>>> };
>>> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
>>> index 49ed54dc9e05..3ece2cd9f1e7 100644
>>> --- a/drivers/s390/crypto/vfio_ap_ops.c
>>> +++ b/drivers/s390/crypto/vfio_ap_ops.c
>>> @@ -902,6 +902,21 @@ static int vfio_ap_mdev_verify_no_sharing(unsigned long *mdev_apm,
>>> return 0;
>>> }
>>> +/**
>>> + * vfio_ap_mdev_validate_masks - verify that the APQNs assigned to the mdev are
>>> + * not reserved for the default zcrypt driver and
>>> + * are not assigned to another mdev.
>>> + *
>>> + * @matrix_mdev: the mdev to which the APQNs being validated are assigned.
>>> + *
>>> + * Return: One of the following values:
>>> + * o the error returned from the ap_apqn_in_matrix_owned_by_def_drv() function,
>>> + * most likely -EBUSY indicating the ap_perms_mutex lock is already held.
>>> + * o EADDRNOTAVAIL if an APQN assigned to @matrix_mdev is reserved for the
>>> + * zcrypt default driver.
>>> + * o EADDRINUSE if an APQN assigned to @matrix_mdev is assigned to another mdev
>>> + * o A zero indicating validation succeeded.
>>> + */
>>> static int vfio_ap_mdev_validate_masks(struct ap_matrix_mdev *matrix_mdev)
>>> {
>>> if (ap_apqn_in_matrix_owned_by_def_drv(matrix_mdev->matrix.apm,
>>> @@ -951,6 +966,10 @@ static void vfio_ap_mdev_link_adapter(struct ap_matrix_mdev
>>> *matrix_mdev,
>>> * An APQN derived from the cross product of the APID being assigned
>>> * and the APQIs previously assigned is being used by another mediated
>>> * matrix device
>>> + *
>>> + * 5. -EAGAIN
>>> + * A lock required to validate the mdev's AP configuration could not
>>> + * be obtained.
>>> */
>>> static ssize_t assign_adapter_store(struct device *dev,
>>> struct device_attribute *attr,
>>> @@ -961,6 +980,7 @@ static ssize_t assign_adapter_store(struct device *dev,
>>> DECLARE_BITMAP(apm_delta, AP_DEVICES);
>>> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>>> + mutex_lock(&ap_perms_mutex);
>>> get_update_locks_for_mdev(matrix_mdev);
>>> ret = kstrtoul(buf, 0, &apid);
>>> @@ -991,6 +1011,7 @@ static ssize_t assign_adapter_store(struct device *dev,
>>> ret = count;
>>> done:
>>> release_update_locks_for_mdev(matrix_mdev);
>>> + mutex_unlock(&ap_perms_mutex);
>>> return ret;
>>> }
>>> @@ -1144,6 +1165,10 @@ static void vfio_ap_mdev_link_domain(struct ap_matrix_mdev
>>> *matrix_mdev,
>>> * An APQN derived from the cross product of the APQI being assigned
>>> * and the APIDs previously assigned is being used by another mediated
>>> * matrix device
>>> + *
>>> + * 5. -EAGAIN
>>> + * The lock required to validate the mdev's AP configuration could not
>>> + * be obtained.
>>> */
>>> static ssize_t assign_domain_store(struct device *dev,
>>> struct device_attribute *attr,
>>> @@ -1154,6 +1179,7 @@ static ssize_t assign_domain_store(struct device *dev,
>>> DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
>>> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>>> + mutex_lock(&ap_perms_mutex);
>>> get_update_locks_for_mdev(matrix_mdev);
>>> ret = kstrtoul(buf, 0, &apqi);
>>> @@ -1184,6 +1210,7 @@ static ssize_t assign_domain_store(struct device *dev,
>>> ret = count;
>>> done:
>>> release_update_locks_for_mdev(matrix_mdev);
>>> + mutex_unlock(&ap_perms_mutex);
>>> return ret;
>>> }
>>> @@ -1868,3 +1895,44 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
>>> kfree(q);
>>> release_update_locks_for_mdev(matrix_mdev);
>>> }
>>> +
>>> +/**
>>> + * vfio_ap_mdev_resource_in_use: check whether any of a set of APQNs is
>>> + * assigned to a mediated device under the control
>>> + * of the vfio_ap device driver.
>>> + *
>>> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check.
>>> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check.
>>> + *
>>> + * This function is invoked by the AP bus when changes to the apmask/aqmask
>>> + * attributes will result in giving control of the queue devices specified via
>>> + * @apm and @aqm to the default zcrypt device driver. Prior to calling this
>>> + * function, the AP bus locks the ap_perms_mutex. If this function is called
>>> + * while an adapter or domain is being assigned to a mediated device, the
>>> + * assignment operations will take the matrix_dev->guests_lock and
>>> + * matrix_dev->mdevs_lock then call the ap_apqn_in_matrix_owned_by_def_drv
>>> + * function, which also locks the ap_perms_mutex. This could result in a
>>> + * deadlock.
>>> + *
>>> + * To avoid a deadlock, this function will verify that the
>>> + * matrix_dev->guests_lock and matrix_dev->mdevs_lock are not currently held and
>>> + * will return -EBUSY if the locks can not be obtained.
>>
>> This part of the comment does not seem to match reality. Unless I'm missing
>> something? Did you mean to call mutex_trylock? Or is the comment stale?
>
> The comment was written prior to the changes introduced to avoid the locking
> dependency (i.e., taking the ap_perms_mutex lock by the assignment functions
> which I believe was your suggestion). I shall remove the comment.
With both changes made...
Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On 5/31/22 3:23 PM, Jason J. Herne wrote:
> On 4/4/22 18:10, Tony Krowiak wrote:
>> Introduces a new document describing the locks used by the vfio_ap
>> device
>> driver and how to use them so as to avoid lockdep reports and deadlock
>> situations.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> Documentation/s390/vfio-ap-locking.rst | 389 +++++++++++++++++++++++++
>> 1 file changed, 389 insertions(+)
>> create mode 100644 Documentation/s390/vfio-ap-locking.rst
>>
>> diff --git a/Documentation/s390/vfio-ap-locking.rst
>> b/Documentation/s390/vfio-ap-locking.rst
>> new file mode 100644
>> index 000000000000..ba5db6689f14
>> --- /dev/null
>> +++ b/Documentation/s390/vfio-ap-locking.rst
>> @@ -0,0 +1,389 @@
>> +.. SPDX-License-Identifier: GPL-2.0
>> +
>> +======================
>> +VFIO AP Locks Overview
>> +======================
>> +This document describes the locks that are pertinent to the secure
>> operation
>> +of the vfio_ap device driver. Throughout this document, the
>> following variables
>> +will be used to denote instances of the structures herein described:
>> +
>> +struct ap_matrix_dev *matrix_dev;
>> +struct ap_matrix_mdev *matrix_mdev;
>> +struct kvm *kvm;
>> +
>> +The Matrix Devices Lock (drivers/s390/crypto/vfio_ap_private.h)
>> +--------------------------------------------------------------
>> +
>> +struct ap_matrix_dev {
>> + ...
>> + struct list_head mdev_list;
>> + struct mutex mdevs_lock;
>> + ...
>> +}
>> +
>> +The Matrix Devices Lock (matrix_dev->mdevs_lock) is implemented as a
>> global
>> +mutex contained within the single object of struct ap_matrix_dev.
>> This lock
>> +controls access to all fields contained within each matrix_mdev
>> +(matrix_dev->mdev_list). This lock must be held while reading from,
>> writing to
>> +or using the data from a field contained within a matrix_mdev instance
>> +representing one of the vfio_ap device driver's mediated devices.
>> +
>> +The KVM Lock (include/linux/kvm_host.h)
>> +---------------------------------------
>> +
>> +struct kvm {
>> + ...
>> + struct mutex lock;
>> + ...
>> +}
>> +
>> +The KVM Lock (kvm->lock) controls access to the state data for a KVM
>> guest. This
>> +lock must be held by the vfio_ap device driver while one or more AP
>> adapters,
>> +domains or control domains are being plugged into or unplugged from
>> the guest.
>> +
>> +The vfio_ap device driver registers a function to be notified when
>> the pointer
>> +to the kvm instance has been set. The KVM pointer is passed to the
>> handler by
>> +the notifier and is stored in the in the matrix_mdev instance
>> +(matrix_mdev->kvm = kvm) containing the state of the mediated device
>> that has
>> +been passed through to the KVM guest.
>> +
>> +The Guests Lock (drivers/s390/crypto/vfio_ap_private.h)
>> +-----------------------------------------------------------
>> +
>> +struct ap_matrix_dev {
>> + ...
>> + struct list_head mdev_list;
>> + struct mutex guests_lock;
>> + ...
>> +}
>> +
>> +The Guests Lock (matrix_dev->guests_lock) controls access to the
>> +matrix_mdev instances (matrix_dev->mdev_list) that represent
>> mediated devices
>> +that hold the state for the mediated devices that have been passed
>> through to a
>> +KVM guest. This lock must be held:
>> +
>> +1. To control access to the KVM pointer (matrix_mdev->kvm) while the
>> vfio_ap
>> + device driver is using it to plug/unplug AP devices passed
>> through to the KVM
>> + guest.
>> +
>> +2. To add matrix_mdev instances to or remove them from
>> matrix_dev->mdev_list.
>> + This is necessary to ensure the proper locking order when the
>> list is perused
>> + to find an ap_matrix_mdev instance for the purpose of
>> plugging/unplugging
>> + AP devices passed through to a KVM guest.
>> +
>> + For example, when a queue device is removed from the vfio_ap
>> device driver,
>> + if the adapter is passed through to a KVM guest, it will have to be
>> + unplugged. In order to figure out whether the adapter is passed
>> through,
>> + the matrix_mdev object to which the queue is assigned will have
>> to be
>> + found. The KVM pointer (matrix_mdev->kvm) can then be used to
>> determine if
>> + the mediated device is passed through (matrix_mdev->kvm != NULL)
>> and if so,
>> + to unplug the adapter.
>> +
>> +It is not necessary to take the Guests Lock to access the KVM
>> pointer if the
>> +pointer is not used to plug/unplug devices passed through to the KVM
>> guest;
>> +however, in this case, the Matrix Devices Lock
>> (matrix_dev->mdevs_lock) must be
>> +held in order to access the KVM pointer since it set and cleared
>> under the
>> +protection of the Matrix Devices Lock. A case in point is the
>> function that
>> +handles interception of the PQAP(AQIC) instruction sub-function.
>> This handler
>> +needs to access the KVM pointer only for the purposes of setting or
>> clearing IRQ
>> +resources, so only the matrix_dev->mdevs_lock needs to be held.
>> +
>> +The PQAP Hook Lock (arch/s390/include/asm/kvm_host.h)
>> +-----------------------------------------------------
>> +
>> +typedef int (*crypto_hook)(struct kvm_vcpu *vcpu);
>> +
>> +struct kvm_s390_crypto {
>> + ...
>> + struct rw_semaphore pqap_hook_rwsem;
>> + crypto_hook *pqap_hook;
>> + ...
>> +};
>> +
>> +The PQAP Hook Lock is a r/w semaphore that controls access to the
>> function
>> +pointer of the handler (*kvm->arch.crypto.pqap_hook) to invoke when the
>> +PQAP(AQIC) instruction sub-function is intercepted by the host. The
>> lock must be
>> +held in write mode when pqap_hook value is set, and in read mode
>> when the
>> +pqap_hook function is called.
>
> Reviewed-by: Jason J. Herne <[email protected]>
>
> R-b for everything above here. Everything below, I've reviewed in less
> detail and I'm not sure it really makes sense. Defining a locking
> order makes sense and it is adequately described multiple times in
> vfio_ap_ops.c. The list of operations and the locks they take can be
> derived just as easily from the code instead of this document. Also,
> documents like this tend to not stay up to date with respect to the
> code they describe. My vote would be to drop everything below.
I agree, it is probably overkill anyway; I'll remove it.
>
>
>
>> +Locking Order
>> +-------------
>> +
>> +If the various locks are not taken in the proper order, it could
>> potentially
>> +result in a deadlock or lockdep splat. In general the Guests Lock
>> +(matrix_dev->guests_lock) must be taken outside of the KVM Lock
>> (kvm->lock)
>> +which in turn must be taken outside of the Matrix Devices Lock
>> +(matrix_dev->mdevs_lock).
>> +
>> +The following describes the various operations under which the
>> various locks are
>> +taken, the purpose for taking them and the order in which they must
>> be taken.
>> +
>> +* Operations: Setting or clearing the KVM pointer (matrix_mdev->kvm):
>> +
>> + 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem):
>> +
>> + This semaphore must be held in write mode while setting or
>> clearing the
>> + reference to the function pointer (kvm->arch.crypt.pqap_hook) to
>> call
>> + when the PQAP(AQIC) instruction sub-function is intercepted by
>> the host.
>> + The function pointer is set when the KVM pointer is being set and
>> + cleared when the KVM pointer is being cleared.
>> +
>> + 2.Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held while accessing the KVM pointer
>> + (matrix_mdev->kvm) to plug/unplug AP devices passed through to the
>> + KVM guest
>> +
>> + 3. KVM Lock (kvm->lock):
>> +
>> + This mutex must be held while the AP devices passed through to
>> the KVM
>> + guest are plugged/unplugged.
>> +
>> + 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held to prevent access to the matrix_mdev state
>> + while writing/reading state values during the operation.
>> +
>> +* Operations: Assign or unassign an adapter, domain or control
>> domain of a
>> + mediated device under the control of the vfio_ap device
>> driver:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held while accessing the KVM pointer
>> + (matrix_dev->kvm) to plug/unplug AP devices passed through to the
>> + KVM guest as a result of the assignment/unassignment operation.
>> + Assignment of an AP device may result in additional queue devices
>> + or control domains being plugged into the guest. Similarly,
>> unassignment
>> + may result in unplugging queue devices or control domains from the
>> + guest
>> +
>> + 3. KVM Lock (matrix_mdev->kvm->lock):
>> +
>> + This mutex must be held while the AP devices passed through to
>> the KVM
>> + guest are plugged in or unplugged.
>> +
>> + 4. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held to prevent access to the matrix_mdev state
>> + while writing/reading state values during the operation. For
>> example, to
>> + determine which AP devices need to be plugged/unplugged, the lock
>> + must be held to prevent other operations from changing the data
>> used
>> + to construct the guest's AP configuration.
>> +
>> +* Operations: Probe or remove an AP queue device:
>> +
>> + When a queue device is bound to the vfio_ap device driver, the
>> driver's probe
>> + callback is invoked. Similarly, when a queue device is unbound
>> from the
>> + driver it's remove callback is invoked. The probe and remove
>> functions will
>> + take locks in the following order:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held for the duration of this operation.
>> +
>> + At the time of the operation, the vfio_ap device driver will
>> only have
>> + the APQN of the queue being probed or removed, so the
>> + matrix_dev->mdevs_list must be perused to locate the matrix_mdev
>> + instance to which the queue is assigned. The Guests Lock must be
>> held
>> + during this time to prevent the list from being changed while
>> processing
>> + the probe/remove.
>> +
>> + Once the matrix_mdev is found, the operation must determine
>> whether the
>> + mediated device is passed through to a guest (matrix_mdev->kvm
>> != NULL),
>> + then use the KVM pointer to perform the plug/unplug operation. Here
>> + again, the lock must be held to prevent other operations from
>> accessing
>> + the KVM pointer for the same purpose.
>> +
>> + 2. KVM Lock (kvm->lock):
>> +
>> + This mutex must be held while the AP devices passed through to
>> the KVM
>> + guest are plugged in or unplugged to prevent other operations from
>> + accessing the guest's state while it is in flux.
>> +
>> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held to prevent access to the matrix_mdev state
>> + while writing/reading state values during the operation, such as
>> the
>> + masks used to construct the KVM guest's AP configuration.
>> +
>> +* Operations: Probe or remove a mediated device:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held while adding the matrix_mdev to the
>> + matrix_dev->mdev_list during the probe operation or when
>> removing it
>> + from the list during the remove operation. This is to prevent
>> access by
>> + other functions that must traverse the list to find a
>> matrix_mdev for
>> + the purpose of plugging/unplugging AP devices passed through to
>> a KVM
>> + guest (i.e., probe/remove queue callbacks), while the list is being
>> + modified.
>> +
>> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held to prevent access to the matrix_mdev state
>> + while writing/reading state values during the probe or remove
>> operations
>> + such as initializing the hashtable of queue devices
>> + (matrix_mdev->qtable.queues) assigned to the matrix_mdev.
>> +
>> +* Operation: Handle interception of the PQAP(AQIC) instruction
>> sub-function:
>> +
>> + 1. PQAP Hook Lock (kvm->arch.crypto.pqap_hook_rwsem)
>> +
>> + This semaphore must be held in read mode while retrieving the
>> function
>> + pointer (kvm->arch.crypto.pqap_hook) and executing the function
>> that
>> + handles the interception of the PQAP(AQIC) instruction
>> sub-function by
>> + the host.
>> +
>> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held to prevent access to the matrix_mdev state
>> + while writing/reading state values during the execution of the
>> + PQAP(AQIC) instruction sub-function interception handler. For
>> example,
>> + the handler must iterate over the matrix_mdev->qtable.queues
>> hashtable
>> + to find the vfio_ap_queue object representing the queue for which
>> + interrupts are being enabled or disabled.
>> +
>> + Note: It is not necessary to take the Guests Lock
>> (matrix_dev->guests_lock)
>> + or the KVM Lock (matrix_mdev->kvm->lock) because the KVM pointer
>> + will not be accessed to plug/unplug AP devices passed through to
>> the
>> + guest; it will only be used to allocate or free resources for
>> processing
>> + interrupts.
>> +
>> +* Operation: Handle AP configuration changed notification:
>> +
>> + The vfio_ap device driver registers a callback function to be
>> notified when
>> + the AP bus detects that the host's AP configuration has changed.
>> This can
>> + occur due to the addition or removal of AP adapters, domains or
>> control
>> + domains via an SE or HMC connected to a DPM enabled LPAR. The
>> objective of the
>> + handler is to remove the queues no longer accessible via the host
>> in bulk
>> + rather than one queue at a time via the driver's queue device
>> remove callback.
>> + The locks and the order in which they must be taken by this
>> operation are:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held for the duration of the operation to:
>> +
>> + * Iterate over the matrix_dev->mdev_list to find each
>> matrix_mdev from
>> + which a queue device to be removed is assigned and prevent other
>> + operations from modifying the list while processing the affected
>> + matrix_mdev instances.
>> +
>> + * Prevent other operations from acquiring access to the KVM
>> pointer in
>> + each affected matrix_mdev instance (matrix_mdev->kvm) for the
>> purpose
>> + of plugging/unplugging AP devices passed through to the KVM
>> guest via
>> + that instance.
>> +
>> +2. KVM Lock (kvm->lock):
>> +
>> + This mutex must be held for each affected matrix_mdev instance
>> while
>> + the AP devices passed through to the KVM guest are unplugged to
>> prevent
>> + other operations from accessing the guest's state while it is in
>> flux.
>> +
>> + Note: This lock must be re-acquired for each matrix_mdev instance.
>> +
>> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock)
>> +
>> + This lock must be held for each affected matrix_mdev to prevent
>> access
>> + to the matrix_mdev state while writing/reading state values
>> during the
>> + operation, such as the masks used to construct the KVM guest's AP
>> + configuration.
>> +
>> + Note: This lock must be re-acquired for each matrix_mdev instance.
>> +
>> +Operation: Handle AP bus scan complete notification:
>> +
>> + The vfio_ap device driver registers a callback function to be
>> notified when
>> + the AP bus scan completes after detecting the addition or removal
>> of AP
>> + adapters, domains or control domains. The objective of the handler
>> is t
>> + add the new queues accessible via the host in bulk rather than one
>> queue
>> + at a time via the driver's queue device probe callback. The locks
>> and the
>> + order in which they must be taken by this operation are:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held for the duration of the operation to:
>> +
>> + * Iterate over the matrix_dev->mdev_list to find each
>> matrix_mdev to
>> + which a queue device added is assigned and prevent other
>> operations
>> + from modifying the list while processing each affected
>> matrix_mdev
>> + object.
>> +
>> + * Prevent other operations from acquiring access to the KVM
>> pointer in
>> + each affected matrix_mdev instance (matrix_mdev->kvm) for the
>> purpose
>> + of plugging/unplugging AP devices passed through to the KVM
>> guest via
>> + that instance.
>> +
>> + 2. KVM Lock (kvm->lock):
>> +
>> + This mutex must be held for each affected matrix_mdev instance
>> while
>> + the AP devices passed through to the KVM guest are plugged in to
>> prevent
>> + other operations from accessing the guest's state while it is in
>> flux.
>> +
>> + Note: This lock must be re-acquired for each matrix_mdev instance.
>> +
>> + 3. Matrix Devices Lock (matrix_dev->mdevs_lock):
>> +
>> + This lock must be held for each affected matrix_mdev to prevent
>> access
>> + to the matrix_mdev state while writing/reading state values
>> during the
>> + operation, such as the masks used to construct the KVM guest's AP
>> + configuration.
>> +
>> + Note: This lock must be re-acquired for each matrix_mdev instance.
>> +
>> +Operation: Handle resource in use query:
>> +
>> + The vfio_ap device driver registers a callback function with the
>> AP bus to be
>> + called when changes to the bus's sysfs /sys/bus/ap/apmask or
>> + /sys/bus/ap/aqmask attributes would result in one or more AP queue
>> devices
>> + getting unbound from the vfio_ap device driver to verify none of
>> them are in
>> + use by the driver (i.e., assigned to a matrix_mdev instance). If
>> this function
>> + is called while an adapter or domain is also being assigned to a
>> mediated
>> + device, this could result in a deadlock; for example:
>> +
>> + 1. A system administrator assigns an adapter to a mediated device
>> under the
>> + control of the vfio_ap device driver. The driver will need to
>> first take
>> + the matrix_dev->guests_lock to potentially hot plug the adapter
>> into
>> + the KVM guest.
>> + 2. At the same time, a system administrator sets a bit in the sysfs
>> + /sys/bus/ap/ap_mask attribute. To complete the operation, the
>> AP bus
>> + must:
>> + a. Take the ap_perms_mutex lock to update the object storing
>> the values
>> + for the /sys/bus/ap/ap_mask attribute.
>> + b. Call the vfio_ap device driver's in-use callback to verify
>> that no
>> + queues now being reserved for the default zcrypt drivers are
>> + in use by the vfio_ap device driver. To do the verification,
>> the in-use
>> + callback function takes the matrix_dev->guests_lock, but has
>> to wait
>> + because it is already held by the operation in 1 above.
>> + 3. The vfio_ap device driver calls an AP bus function to verify
>> that the
>> + new queues resulting from the assignment of the adapter in step
>> 1 are
>> + not reserved for the default zcrypt device driver. This AP bus
>> function
>> + tries to take the ap_perms_mutex lock but gets stuck waiting
>> for the
>> + it due to step 2a above.
>> +
>> + Consequently, we have the following deadlock situation:
>> +
>> + matrix_dev->guests_lock locked (1)
>> + ap_perms_mutex lock locked (2a)
>> + Waiting for matrix_dev->lock (2b) which is currently held (1)
>> + Waiting for ap_perms_mutex lock (3) which is currently held (2a)
>> +
>> + To prevent the deadlock scenario, the in_use operation will take the
>> + required locks using the mutex_trylock() function and if the lock
>> can not be
>> + acquired will terminate and return -EBUSY to indicate the driver
>> is busy
>> + processing another request.
>> +
>> + The locks required to respond to the handle resource in use query
>> and the
>> + order in which they must be taken are:
>> +
>> + 1. Guests Lock (matrix_dev->guests_lock):
>> +
>> + This mutex must be held for the duration of the operation to
>> iterate over the
>> + matrix_dev->mdev_list to determine whether any of the queues to be
>> unbound
>> + are assigned to a matrix_mdev instance.
>> +
>> + 2. Matrix Devices Lock (matrix_dev->mdevs_lock):
>> +
>> + This mutex must be held for the duration of the operation to
>> ensure that the
>> + AP configuration of each matrix_mdev instance does not change
>> while verifying
>> + that none of the queue devices to be removed from the vfio_ap
>> driver are
>> + assigned to it.
>
>
On 5/31/22 2:26 PM, Matthew Rosato wrote:
> On 4/4/22 6:10 PM, Tony Krowiak wrote:
>> A new document, Documentation/s390/vfio-ap-locking.rst was added.
>> Make sure
>> the new document is picked up for the VFIO AP maintainers by using a
>> wildcard: Documentation/s390/vfio-ap*.
>>
>> Signed-off-by: Tony Krowiak <[email protected]>
>> ---
>> MAINTAINERS | 6 ++++--
>> 1 file changed, 4 insertions(+), 2 deletions(-)
>>
>> diff --git a/MAINTAINERS b/MAINTAINERS
>> index fd768d43e048..c8d8637c184c 100644
>> --- a/MAINTAINERS
>> +++ b/MAINTAINERS
>> @@ -17239,8 +17239,10 @@ M: Jason Herne <[email protected]>
>> L: [email protected]
>> S: Supported
>> W: http://www.ibm.com/developerworks/linux/linux390/
>> -F: Documentation/s390/vfio-ap.rst
>> -F: drivers/s390/crypto/vfio_ap*
>> +F: Documentation/s390/vfio-ap*
>> +F: drivers/s390/crypto/vfio_ap_drv.c
>> +F: drivers/s390/crypto/vfio_ap_ops.c
>> +F: drivers/s390/crypto/vfio_ap_private.h
>
> I think this change was a rebase error, the Documentation change makes
> sense but you should leave drivers/s390/crypto/vfio_ap* alone, so the
> final result looks like:
>
> F: Documentation/s390/vfio-ap*
> F: drivers/s390/crypto/vfio_ap*
I presume it happened during a rebase, I've already fixed it.
On 4/4/22 18:10, Tony Krowiak wrote:
> Let's implement the callback to indicate when an APQN
> is in use by the vfio_ap device driver. The callback is
> invoked whenever a change to the apmask or aqmask would
> result in one or more queue devices being removed from the driver. The
> vfio_ap device driver will indicate a resource is in use
> if the APQN of any of the queue devices to be removed are assigned to
> any of the matrix mdevs under the driver's control.
>
> There is potential for a deadlock condition between the
> matrix_dev->guests_lock used to lock the guest during assignment of
> adapters and domains and the ap_perms_mutex locked by the AP bus when
> changes are made to the sysfs apmask/aqmask attributes.
>
> The AP Perms lock controls access to the objects that store the adapter
> numbers (ap_perms) and domain numbers (aq_perms) for the sysfs
> /sys/bus/ap/apmask and /sys/bus/ap/aqmask attributes. These attributes
> identify which queues are reserved for the zcrypt default device drivers.
> Before allowing a bit to be removed from either mask, the AP bus must check
> with the vfio_ap device driver to verify that none of the queues are
> assigned to any of its mediated devices.
>
> The apmask/aqmask attributes can be written or read at any time from
> userspace, so care must be taken to prevent a deadlock with asynchronous
> operations that might be taking place in the vfio_ap device driver. For
> example, consider the following:
>
> 1. A system administrator assigns an adapter to a mediated device under the
> control of the vfio_ap device driver. The driver will need to first take
> the matrix_dev->guests_lock to potentially hot plug the adapter into
> the KVM guest.
> 2. At the same time, a system administrator sets a bit in the sysfs
> /sys/bus/ap/ap_mask attribute. To complete the operation, the AP bus
> must:
> a. Take the ap_perms_mutex lock to update the object storing the values
> for the /sys/bus/ap/ap_mask attribute.
> b. Call the vfio_ap device driver's in-use callback to verify that the
> queues now being reserved for the default zcrypt drivers are not
> assigned to a mediated device owned by the vfio_ap device driver. To
> do the verification, the in-use callback function takes the
> matrix_dev->guests_lock, but has to wait because it is already held
> by the operation in 1 above.
> 3. The vfio_ap device driver calls an AP bus function to verify that the
> new queues resulting from the assignment of the adapter in step 1 are
> not reserved for the default zcrypt device driver. This AP bus function
> tries to take the ap_perms_mutex lock but gets stuck waiting for the
> waiting for the lock due to step 2a above.
>
> Consequently, we have the following deadlock situation:
>
> matrix_dev->guests_lock locked (1)
> ap_perms_mutex lock locked (2a)
> Waiting for matrix_dev->gusts_lock (2b) which is currently held (1)
> Waiting for ap_perms_mutex lock (3) which is currently held (2a)
>
> To prevent this deadlock scenario, the function called in step 3 will no
> longer take the ap_perms_mutex lock and require the caller to take the
> lock. The lock will be the first taken by the adapter/domain assignment
> functions in the vfio_ap device driver to maintain the proper locking
> order.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/ap_bus.c | 31 ++++++++----
> drivers/s390/crypto/vfio_ap_drv.c | 1 +
> drivers/s390/crypto/vfio_ap_ops.c | 68 +++++++++++++++++++++++++++
> drivers/s390/crypto/vfio_ap_private.h | 2 +
> 4 files changed, 94 insertions(+), 8 deletions(-)
>
> diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
> index fdf16cb70881..f48552e900a2 100644
> --- a/drivers/s390/crypto/ap_bus.c
> +++ b/drivers/s390/crypto/ap_bus.c
> @@ -817,6 +817,17 @@ static void ap_bus_revise_bindings(void)
> bus_for_each_dev(&ap_bus_type, NULL, NULL, __ap_revise_reserved);
> }
>
> +/**
> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether an APQN c is reserved
> + * for the host drivers or not.
> + * @card: the APID of the adapter card to check
> + * @queue: the APQI of the queue to check
> + *
> + * Note: the ap_perms_mutex must be locked by the caller of this function.
> + *
> + * Return: an int specifying whether the APQN is reserved for the host (1) or
> + * not (0)
> + */
Comment's function name does not match real function name. Also APQN "c", from
description does not appear to exist.
> int ap_owned_by_def_drv(int card, int queue)
> {
> int rc = 0;
> @@ -824,25 +835,31 @@ int ap_owned_by_def_drv(int card, int queue)
> if (card < 0 || card >= AP_DEVICES || queue < 0 || queue >= AP_DOMAINS)
> return -EINVAL;
>
> - mutex_lock(&ap_perms_mutex);
> -
> if (test_bit_inv(card, ap_perms.apm)
> && test_bit_inv(queue, ap_perms.aqm))
> rc = 1;
>
> - mutex_unlock(&ap_perms_mutex);
> -
> return rc;
> }
> EXPORT_SYMBOL(ap_owned_by_def_drv);
>
> +/**
> + * ap_apqn_in_matrix_owned_by_def_drv: indicates whether every APQN contained in
> + * a set is reserved for the host drivers
> + * or not.
> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check
> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check
> + *
> + * Note: the ap_perms_mutex must be locked by the caller of this function.
> + *
> + * Return: an int specifying whether each APQN is reserved for the host (1) or
> + * not (0)
> + */
> int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
> unsigned long *aqm)
> {
> int card, queue, rc = 0;
>
> - mutex_lock(&ap_perms_mutex);
> -
> for (card = 0; !rc && card < AP_DEVICES; card++)
> if (test_bit_inv(card, apm) &&
> test_bit_inv(card, ap_perms.apm))
> @@ -851,8 +868,6 @@ int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm,
> test_bit_inv(queue, ap_perms.aqm))
> rc = 1;
>
> - mutex_unlock(&ap_perms_mutex);
> -
> return rc;
> }
> EXPORT_SYMBOL(ap_apqn_in_matrix_owned_by_def_drv);
> diff --git a/drivers/s390/crypto/vfio_ap_drv.c b/drivers/s390/crypto/vfio_ap_drv.c
> index c258e5f7fdfc..2c3084589347 100644
> --- a/drivers/s390/crypto/vfio_ap_drv.c
> +++ b/drivers/s390/crypto/vfio_ap_drv.c
> @@ -107,6 +107,7 @@ static const struct attribute_group vfio_queue_attr_group = {
> static struct ap_driver vfio_ap_drv = {
> .probe = vfio_ap_mdev_probe_queue,
> .remove = vfio_ap_mdev_remove_queue,
> + .in_use = vfio_ap_mdev_resource_in_use,
> .ids = ap_queue_ids,
> };
>
> diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_ap_ops.c
> index 49ed54dc9e05..3ece2cd9f1e7 100644
> --- a/drivers/s390/crypto/vfio_ap_ops.c
> +++ b/drivers/s390/crypto/vfio_ap_ops.c
> @@ -902,6 +902,21 @@ static int vfio_ap_mdev_verify_no_sharing(unsigned long *mdev_apm,
> return 0;
> }
>
> +/**
> + * vfio_ap_mdev_validate_masks - verify that the APQNs assigned to the mdev are
> + * not reserved for the default zcrypt driver and
> + * are not assigned to another mdev.
> + *
> + * @matrix_mdev: the mdev to which the APQNs being validated are assigned.
> + *
> + * Return: One of the following values:
> + * o the error returned from the ap_apqn_in_matrix_owned_by_def_drv() function,
> + * most likely -EBUSY indicating the ap_perms_mutex lock is already held.
> + * o EADDRNOTAVAIL if an APQN assigned to @matrix_mdev is reserved for the
> + * zcrypt default driver.
> + * o EADDRINUSE if an APQN assigned to @matrix_mdev is assigned to another mdev
> + * o A zero indicating validation succeeded.
> + */
> static int vfio_ap_mdev_validate_masks(struct ap_matrix_mdev *matrix_mdev)
> {
> if (ap_apqn_in_matrix_owned_by_def_drv(matrix_mdev->matrix.apm,
> @@ -951,6 +966,10 @@ static void vfio_ap_mdev_link_adapter(struct ap_matrix_mdev *matrix_mdev,
> * An APQN derived from the cross product of the APID being assigned
> * and the APQIs previously assigned is being used by another mediated
> * matrix device
> + *
> + * 5. -EAGAIN
> + * A lock required to validate the mdev's AP configuration could not
> + * be obtained.
> */
> static ssize_t assign_adapter_store(struct device *dev,
> struct device_attribute *attr,
> @@ -961,6 +980,7 @@ static ssize_t assign_adapter_store(struct device *dev,
> DECLARE_BITMAP(apm_delta, AP_DEVICES);
> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>
> + mutex_lock(&ap_perms_mutex);
> get_update_locks_for_mdev(matrix_mdev);
>
> ret = kstrtoul(buf, 0, &apid);
> @@ -991,6 +1011,7 @@ static ssize_t assign_adapter_store(struct device *dev,
> ret = count;
> done:
> release_update_locks_for_mdev(matrix_mdev);
> + mutex_unlock(&ap_perms_mutex);
>
> return ret;
> }
> @@ -1144,6 +1165,10 @@ static void vfio_ap_mdev_link_domain(struct ap_matrix_mdev *matrix_mdev,
> * An APQN derived from the cross product of the APQI being assigned
> * and the APIDs previously assigned is being used by another mediated
> * matrix device
> + *
> + * 5. -EAGAIN
> + * The lock required to validate the mdev's AP configuration could not
> + * be obtained.
> */
> static ssize_t assign_domain_store(struct device *dev,
> struct device_attribute *attr,
> @@ -1154,6 +1179,7 @@ static ssize_t assign_domain_store(struct device *dev,
> DECLARE_BITMAP(aqm_delta, AP_DOMAINS);
> struct ap_matrix_mdev *matrix_mdev = dev_get_drvdata(dev);
>
> + mutex_lock(&ap_perms_mutex);
> get_update_locks_for_mdev(matrix_mdev);
>
> ret = kstrtoul(buf, 0, &apqi);
> @@ -1184,6 +1210,7 @@ static ssize_t assign_domain_store(struct device *dev,
> ret = count;
> done:
> release_update_locks_for_mdev(matrix_mdev);
> + mutex_unlock(&ap_perms_mutex);
>
> return ret;
> }
> @@ -1868,3 +1895,44 @@ void vfio_ap_mdev_remove_queue(struct ap_device *apdev)
> kfree(q);
> release_update_locks_for_mdev(matrix_mdev);
> }
> +
> +/**
> + * vfio_ap_mdev_resource_in_use: check whether any of a set of APQNs is
> + * assigned to a mediated device under the control
> + * of the vfio_ap device driver.
> + *
> + * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check.
> + * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check.
> + *
> + * This function is invoked by the AP bus when changes to the apmask/aqmask
> + * attributes will result in giving control of the queue devices specified via
> + * @apm and @aqm to the default zcrypt device driver. Prior to calling this
> + * function, the AP bus locks the ap_perms_mutex. If this function is called
> + * while an adapter or domain is being assigned to a mediated device, the
> + * assignment operations will take the matrix_dev->guests_lock and
> + * matrix_dev->mdevs_lock then call the ap_apqn_in_matrix_owned_by_def_drv
> + * function, which also locks the ap_perms_mutex. This could result in a
> + * deadlock.
> + *
> + * To avoid a deadlock, this function will verify that the
> + * matrix_dev->guests_lock and matrix_dev->mdevs_lock are not currently held and
> + * will return -EBUSY if the locks can not be obtained.
This part of the comment does not seem to match reality. Unless I'm missing
something? Did you mean to call mutex_trylock? Or is the comment stale?
> + * Return:
> + * * -EBUSY if the locks required by this function are already locked.
> + * * -EADDRINUSE if one or more of the APQNs specified via @apm/@aqm are
> + * assigned to a mediated device under the control of the vfio_ap
> + * device driver.
> + */
> +int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm)
> +{
> + int ret;
> +
> + mutex_lock(&matrix_dev->guests_lock);
> + mutex_lock(&matrix_dev->mdevs_lock);
> + ret = vfio_ap_mdev_verify_no_sharing(apm, aqm);
> + mutex_unlock(&matrix_dev->mdevs_lock);
> + mutex_unlock(&matrix_dev->guests_lock);
> +
> + return ret;
> +}
> diff --git a/drivers/s390/crypto/vfio_ap_private.h b/drivers/s390/crypto/vfio_ap_private.h
> index 6d4ca39f783b..cbffa0bd01da 100644
> --- a/drivers/s390/crypto/vfio_ap_private.h
> +++ b/drivers/s390/crypto/vfio_ap_private.h
> @@ -147,4 +147,6 @@ void vfio_ap_mdev_unregister(void);
> int vfio_ap_mdev_probe_queue(struct ap_device *queue);
> void vfio_ap_mdev_remove_queue(struct ap_device *queue);
>
> +int vfio_ap_mdev_resource_in_use(unsigned long *apm, unsigned long *aqm);
> +
> #endif /* _VFIO_AP_PRIVATE_H_ */
--
-- Jason J. Herne ([email protected])
On 4/4/22 18:10, Tony Krowiak wrote:
> This patch implements two new AP driver callbacks:
>
> void (*on_config_changed)(struct ap_config_info *new_config_info,
> struct ap_config_info *old_config_info);
>
> void (*on_scan_complete)(struct ap_config_info *new_config_info,
> struct ap_config_info *old_config_info);
>
> The on_config_changed callback is invoked at the start of the AP bus scan
> function when it determines that the host AP configuration information
> has changed since the previous scan.
>
> The vfio_ap device driver registers a callback function for this callback
> that performs the following operations:
>
> 1. Unplugs the adapters, domains and control domains removed from the
> host's AP configuration from the guests to which they are
> assigned in a single operation.
>
> 2. Stores bitmaps identifying the adapters, domains and control domains
> added to the host's AP configuration with the structure representing
> the mediated device. When the vfio_ap device driver's probe callback is
> subsequently invoked, the probe function will recognize that the
> queue is being probed due to a change in the host's AP configuration
> and the plugging of the queue into the guest will be bypassed.
>
> The on_scan_complete callback is invoked after the ap bus scan is
> completed if the host AP configuration data has changed. The vfio_ap
> device driver registers a callback function for this callback that hot
> plugs each queue and control domain added to the AP configuration for each
> guest using them in a single hot plug operation.
>
> Signed-off-by: Tony Krowiak <[email protected]>
> ---
> drivers/s390/crypto/vfio_ap_drv.c | 2 +
> drivers/s390/crypto/vfio_ap_ops.c | 270 +++++++++++++++++++++++++-
> drivers/s390/crypto/vfio_ap_private.h | 12 ++
> 3 files changed, 279 insertions(+), 5 deletions(-)
>
Reviewed-by: Jason J. Herne <[email protected]>
--
-- Jason J. Herne ([email protected])
On Tue, 31 May 2022 06:44:46 -0400
Tony Krowiak <[email protected]> wrote:
> > vfio_ap_mdev_get_update_locks_for_apqn is "crazy long".
> > How about:
> > get_mdev_for_apqn()
> >
> > This function is static and the terms mdev and apqn are specific
> > enough that I
> > don't think it needs to start with vfio_ap. And there is no need to
> > state in
> > the function name that locks are acquired. That point will be obvious
> > to anyone
> > reading the prologue or the code.
>
> The primary purpose of the function is to acquire the locks in the
> proper order, so
> I think the name should state that purpose. It may be obvious to someone
> reading
> the prologue or this function, but not so obvious in the context of the
> calling function.
I agree with Tony. To me get_mdev_for_apqn() sounds like getting a
reference to a matrix_mdev object (and incrementing its refcount) or
something similar. BTW some more bike shedding: I prefer by_apqn instead
of for_apqn, because the set of locks we need to take is determined _by_
the apqn parameter, but it ain't semantically the set of locks we need
to perform an update operation on the apqn or on the queue associated
with the apqn. No strong opinion though -- I'm no native speaker and
prepositions are difficult for me.
Regards,
Halil
On 6/7/22 8:05 AM, Halil Pasic wrote:
> On Tue, 31 May 2022 06:44:46 -0400
> Tony Krowiak <[email protected]> wrote:
>
>>> vfio_ap_mdev_get_update_locks_for_apqn is "crazy long".
>>> How about:
>>> get_mdev_for_apqn()
>>>
>>> This function is static and the terms mdev and apqn are specific
>>> enough that I
>>> don't think it needs to start with vfio_ap. And there is no need to
>>> state in
>>> the function name that locks are acquired. That point will be obvious
>>> to anyone
>>> reading the prologue or the code.
>> The primary purpose of the function is to acquire the locks in the
>> proper order, so
>> I think the name should state that purpose. It may be obvious to someone
>> reading
>> the prologue or this function, but not so obvious in the context of the
>> calling function.
> I agree with Tony. To me get_mdev_for_apqn() sounds like getting a
> reference to a matrix_mdev object (and incrementing its refcount) or
> something similar. BTW some more bike shedding: I prefer by_apqn instead
> of for_apqn, because the set of locks we need to take is determined _by_
> the apqn parameter, but it ain't semantically the set of locks we need
> to perform an update operation on the apqn or on the queue associated
> with the apqn. No strong opinion though -- I'm no native speaker and
> prepositions are difficult for me.
I am a native speaker and I had to review prepositions. I learned
grammar in elementary school (grades 1-6) and have forgotten
much of the terminology as it relates to sentence structure. Anyway,
I digress. I'm okay with 'by_apqn'.
>
> Regards,
> Halil