2019-05-23 16:14:39 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-05-31 03:09:44 +07:00
|
|
|
/*
|
|
|
|
* Randomness driver for virtio
|
|
|
|
* Copyright (C) 2007, 2008 Rusty Russell IBM Corporation
|
|
|
|
*/
|
2009-12-01 14:26:33 +07:00
|
|
|
|
2008-05-31 03:09:44 +07:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/hw_random.h>
|
|
|
|
#include <linux/scatterlist.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/virtio.h>
|
|
|
|
#include <linux/virtio_rng.h>
|
2011-07-04 00:35:48 +07:00
|
|
|
#include <linux/module.h>
|
2020-04-07 07:37:55 +07:00
|
|
|
#include <linux/slab.h>
|
2008-05-31 03:09:44 +07:00
|
|
|
|
2014-05-16 09:12:43 +07:00
|
|
|
static DEFINE_IDA(rng_index_ida);
|
2014-05-14 08:03:46 +07:00
|
|
|
|
|
|
|
struct virtrng_info {
|
|
|
|
struct hwrng hwrng;
|
|
|
|
struct virtqueue *vq;
|
|
|
|
struct completion have_data;
|
2014-05-16 09:12:43 +07:00
|
|
|
char name[25];
|
2014-07-27 05:03:01 +07:00
|
|
|
unsigned int data_avail;
|
2014-05-16 09:12:43 +07:00
|
|
|
int index;
|
2014-07-27 05:03:01 +07:00
|
|
|
bool busy;
|
virtio: rng: delay hwrng_register() till driver is ready
Instead of calling hwrng_register() in the probe routing, call it in the
scan routine. This ensures that when hwrng_register() is successful,
and it requests a few random bytes to seed the kernel's pool at init,
we're ready to service that request.
This will also enable us to remove the workaround added previously to
check whether probe was completed, and only then ask for data from the
host. The revert follows in the next commit.
There's a slight behaviour change here on unsuccessful hwrng_register().
Previously, when hwrng_register() failed, the probe() routine would
fail, and the vqs would be torn down, and driver would be marked not
initialized. Now, the vqs will remain initialized, driver would be
marked initialized as well, but won't be available in the list of RNGs
available to hwrng core. To fix the failures, the procedure remains the
same, i.e. unload and re-load the module, and hope things succeed the
next time around.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2014-07-27 05:04:01 +07:00
|
|
|
bool hwrng_register_done;
|
2014-09-11 19:51:53 +07:00
|
|
|
bool hwrng_removed;
|
2014-05-14 08:03:46 +07:00
|
|
|
};
|
2008-05-31 03:09:44 +07:00
|
|
|
|
|
|
|
static void random_recv_done(struct virtqueue *vq)
|
|
|
|
{
|
2014-05-14 08:03:46 +07:00
|
|
|
struct virtrng_info *vi = vq->vdev->priv;
|
|
|
|
|
2009-04-23 14:12:59 +07:00
|
|
|
/* We can get spurious callbacks, e.g. shared IRQs + virtio_pci. */
|
2014-05-14 08:03:46 +07:00
|
|
|
if (!virtqueue_get_buf(vi->vq, &vi->data_avail))
|
2009-04-23 14:12:59 +07:00
|
|
|
return;
|
2008-05-31 03:09:44 +07:00
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
complete(&vi->have_data);
|
2008-05-31 03:09:44 +07:00
|
|
|
}
|
|
|
|
|
2009-12-01 14:26:33 +07:00
|
|
|
/* The host will fill any buffer we give it with sweet, sweet randomness. */
|
2014-05-14 08:03:46 +07:00
|
|
|
static void register_buffer(struct virtrng_info *vi, u8 *buf, size_t size)
|
2008-05-31 03:09:44 +07:00
|
|
|
{
|
|
|
|
struct scatterlist sg;
|
|
|
|
|
2009-12-01 14:26:33 +07:00
|
|
|
sg_init_one(&sg, buf, size);
|
|
|
|
|
2008-05-31 03:09:44 +07:00
|
|
|
/* There should always be room for one buffer. */
|
2014-05-14 08:03:46 +07:00
|
|
|
virtqueue_add_inbuf(vi->vq, &sg, 1, buf, GFP_KERNEL);
|
2009-12-01 14:26:33 +07:00
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
virtqueue_kick(vi->vq);
|
2008-05-31 03:09:44 +07:00
|
|
|
}
|
|
|
|
|
2009-12-01 14:26:33 +07:00
|
|
|
static int virtio_read(struct hwrng *rng, void *buf, size_t size, bool wait)
|
2008-05-31 03:09:44 +07:00
|
|
|
{
|
2012-05-28 13:48:40 +07:00
|
|
|
int ret;
|
2014-05-14 08:03:46 +07:00
|
|
|
struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
|
2008-05-31 03:09:44 +07:00
|
|
|
|
2014-09-11 19:51:53 +07:00
|
|
|
if (vi->hwrng_removed)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
if (!vi->busy) {
|
|
|
|
vi->busy = true;
|
2019-01-08 05:36:11 +07:00
|
|
|
reinit_completion(&vi->have_data);
|
2014-05-14 08:03:46 +07:00
|
|
|
register_buffer(vi, buf, size);
|
2009-12-01 14:26:33 +07:00
|
|
|
}
|
|
|
|
|
2008-05-31 03:09:44 +07:00
|
|
|
if (!wait)
|
|
|
|
return 0;
|
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
ret = wait_for_completion_killable(&vi->have_data);
|
2012-05-28 13:48:40 +07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2009-06-13 11:16:39 +07:00
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
vi->busy = false;
|
2009-06-13 11:16:39 +07:00
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
return vi->data_avail;
|
2008-05-31 03:09:44 +07:00
|
|
|
}
|
|
|
|
|
2009-12-01 14:26:33 +07:00
|
|
|
static void virtio_cleanup(struct hwrng *rng)
|
2008-05-31 03:09:44 +07:00
|
|
|
{
|
2014-05-14 08:03:46 +07:00
|
|
|
struct virtrng_info *vi = (struct virtrng_info *)rng->priv;
|
2009-12-01 14:26:33 +07:00
|
|
|
|
2014-05-14 08:03:46 +07:00
|
|
|
if (vi->busy)
|
|
|
|
wait_for_completion(&vi->have_data);
|
|
|
|
}
|
2008-05-31 03:09:44 +07:00
|
|
|
|
2012-05-28 13:48:42 +07:00
|
|
|
static int probe_common(struct virtio_device *vdev)
|
2008-05-31 03:09:44 +07:00
|
|
|
{
|
2014-05-16 09:12:43 +07:00
|
|
|
int err, index;
|
2014-05-14 08:03:46 +07:00
|
|
|
struct virtrng_info *vi = NULL;
|
|
|
|
|
2014-05-16 09:11:57 +07:00
|
|
|
vi = kzalloc(sizeof(struct virtrng_info), GFP_KERNEL);
|
2014-05-16 09:12:43 +07:00
|
|
|
if (!vi)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
vi->index = index = ida_simple_get(&rng_index_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (index < 0) {
|
2014-10-15 06:52:33 +07:00
|
|
|
err = index;
|
|
|
|
goto err_ida;
|
2014-05-16 09:12:43 +07:00
|
|
|
}
|
|
|
|
sprintf(vi->name, "virtio_rng.%d", index);
|
2014-05-14 08:03:46 +07:00
|
|
|
init_completion(&vi->have_data);
|
|
|
|
|
2014-05-16 09:12:43 +07:00
|
|
|
vi->hwrng = (struct hwrng) {
|
|
|
|
.read = virtio_read,
|
|
|
|
.cleanup = virtio_cleanup,
|
|
|
|
.priv = (unsigned long)vi,
|
|
|
|
.name = vi->name,
|
2014-08-12 01:35:41 +07:00
|
|
|
.quality = 1000,
|
2014-05-16 09:12:43 +07:00
|
|
|
};
|
2014-05-14 08:03:46 +07:00
|
|
|
vdev->priv = vi;
|
2008-05-31 03:09:44 +07:00
|
|
|
|
|
|
|
/* We expect a single virtqueue. */
|
2014-05-14 08:03:46 +07:00
|
|
|
vi->vq = virtio_find_single_vq(vdev, random_recv_done, "input");
|
|
|
|
if (IS_ERR(vi->vq)) {
|
|
|
|
err = PTR_ERR(vi->vq);
|
2014-10-15 06:52:33 +07:00
|
|
|
goto err_find;
|
2013-03-08 07:30:18 +07:00
|
|
|
}
|
2008-05-31 03:09:44 +07:00
|
|
|
|
|
|
|
return 0;
|
2014-10-15 06:52:33 +07:00
|
|
|
|
|
|
|
err_find:
|
|
|
|
ida_simple_remove(&rng_index_ida, index);
|
|
|
|
err_ida:
|
|
|
|
kfree(vi);
|
|
|
|
return err;
|
2008-05-31 03:09:44 +07:00
|
|
|
}
|
|
|
|
|
2012-05-28 13:48:42 +07:00
|
|
|
static void remove_common(struct virtio_device *vdev)
|
2008-05-31 03:09:44 +07:00
|
|
|
{
|
2014-05-14 08:03:46 +07:00
|
|
|
struct virtrng_info *vi = vdev->priv;
|
virtio: rng: delay hwrng_register() till driver is ready
Instead of calling hwrng_register() in the probe routing, call it in the
scan routine. This ensures that when hwrng_register() is successful,
and it requests a few random bytes to seed the kernel's pool at init,
we're ready to service that request.
This will also enable us to remove the workaround added previously to
check whether probe was completed, and only then ask for data from the
host. The revert follows in the next commit.
There's a slight behaviour change here on unsuccessful hwrng_register().
Previously, when hwrng_register() failed, the probe() routine would
fail, and the vqs would be torn down, and driver would be marked not
initialized. Now, the vqs will remain initialized, driver would be
marked initialized as well, but won't be available in the list of RNGs
available to hwrng core. To fix the failures, the procedure remains the
same, i.e. unload and re-load the module, and hope things succeed the
next time around.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2014-07-27 05:04:01 +07:00
|
|
|
|
2014-09-11 19:51:53 +07:00
|
|
|
vi->hwrng_removed = true;
|
2014-09-11 19:50:39 +07:00
|
|
|
vi->data_avail = 0;
|
|
|
|
complete(&vi->have_data);
|
2008-05-31 03:09:44 +07:00
|
|
|
vdev->config->reset(vdev);
|
2014-05-14 08:03:46 +07:00
|
|
|
vi->busy = false;
|
virtio: rng: delay hwrng_register() till driver is ready
Instead of calling hwrng_register() in the probe routing, call it in the
scan routine. This ensures that when hwrng_register() is successful,
and it requests a few random bytes to seed the kernel's pool at init,
we're ready to service that request.
This will also enable us to remove the workaround added previously to
check whether probe was completed, and only then ask for data from the
host. The revert follows in the next commit.
There's a slight behaviour change here on unsuccessful hwrng_register().
Previously, when hwrng_register() failed, the probe() routine would
fail, and the vqs would be torn down, and driver would be marked not
initialized. Now, the vqs will remain initialized, driver would be
marked initialized as well, but won't be available in the list of RNGs
available to hwrng core. To fix the failures, the procedure remains the
same, i.e. unload and re-load the module, and hope things succeed the
next time around.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2014-07-27 05:04:01 +07:00
|
|
|
if (vi->hwrng_register_done)
|
|
|
|
hwrng_unregister(&vi->hwrng);
|
2009-06-13 11:16:36 +07:00
|
|
|
vdev->config->del_vqs(vdev);
|
2014-05-16 09:12:43 +07:00
|
|
|
ida_simple_remove(&rng_index_ida, vi->index);
|
2014-05-14 08:03:46 +07:00
|
|
|
kfree(vi);
|
2008-05-31 03:09:44 +07:00
|
|
|
}
|
|
|
|
|
2012-05-28 13:48:42 +07:00
|
|
|
static int virtrng_probe(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
return probe_common(vdev);
|
|
|
|
}
|
|
|
|
|
2012-11-20 01:26:26 +07:00
|
|
|
static void virtrng_remove(struct virtio_device *vdev)
|
2012-05-28 13:48:42 +07:00
|
|
|
{
|
|
|
|
remove_common(vdev);
|
|
|
|
}
|
|
|
|
|
virtio: rng: delay hwrng_register() till driver is ready
Instead of calling hwrng_register() in the probe routing, call it in the
scan routine. This ensures that when hwrng_register() is successful,
and it requests a few random bytes to seed the kernel's pool at init,
we're ready to service that request.
This will also enable us to remove the workaround added previously to
check whether probe was completed, and only then ask for data from the
host. The revert follows in the next commit.
There's a slight behaviour change here on unsuccessful hwrng_register().
Previously, when hwrng_register() failed, the probe() routine would
fail, and the vqs would be torn down, and driver would be marked not
initialized. Now, the vqs will remain initialized, driver would be
marked initialized as well, but won't be available in the list of RNGs
available to hwrng core. To fix the failures, the procedure remains the
same, i.e. unload and re-load the module, and hope things succeed the
next time around.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2014-07-27 05:04:01 +07:00
|
|
|
static void virtrng_scan(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct virtrng_info *vi = vdev->priv;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = hwrng_register(&vi->hwrng);
|
|
|
|
if (!err)
|
|
|
|
vi->hwrng_register_done = true;
|
|
|
|
}
|
|
|
|
|
2013-09-17 06:55:23 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-05-28 13:48:43 +07:00
|
|
|
static int virtrng_freeze(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
remove_common(vdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int virtrng_restore(struct virtio_device *vdev)
|
|
|
|
{
|
2017-11-03 16:57:21 +07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = probe_common(vdev);
|
|
|
|
if (!err) {
|
|
|
|
struct virtrng_info *vi = vdev->priv;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set hwrng_removed to ensure that virtio_read()
|
|
|
|
* does not block waiting for data before the
|
|
|
|
* registration is complete.
|
|
|
|
*/
|
|
|
|
vi->hwrng_removed = true;
|
|
|
|
err = hwrng_register(&vi->hwrng);
|
|
|
|
if (!err) {
|
|
|
|
vi->hwrng_register_done = true;
|
|
|
|
vi->hwrng_removed = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
2012-05-28 13:48:43 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-05-31 03:09:44 +07:00
|
|
|
static struct virtio_device_id id_table[] = {
|
|
|
|
{ VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
|
|
|
|
{ 0 },
|
|
|
|
};
|
|
|
|
|
2010-01-16 08:01:26 +07:00
|
|
|
static struct virtio_driver virtio_rng_driver = {
|
2008-05-31 03:09:44 +07:00
|
|
|
.driver.name = KBUILD_MODNAME,
|
|
|
|
.driver.owner = THIS_MODULE,
|
|
|
|
.id_table = id_table,
|
|
|
|
.probe = virtrng_probe,
|
2012-12-22 06:12:08 +07:00
|
|
|
.remove = virtrng_remove,
|
virtio: rng: delay hwrng_register() till driver is ready
Instead of calling hwrng_register() in the probe routing, call it in the
scan routine. This ensures that when hwrng_register() is successful,
and it requests a few random bytes to seed the kernel's pool at init,
we're ready to service that request.
This will also enable us to remove the workaround added previously to
check whether probe was completed, and only then ask for data from the
host. The revert follows in the next commit.
There's a slight behaviour change here on unsuccessful hwrng_register().
Previously, when hwrng_register() failed, the probe() routine would
fail, and the vqs would be torn down, and driver would be marked not
initialized. Now, the vqs will remain initialized, driver would be
marked initialized as well, but won't be available in the list of RNGs
available to hwrng core. To fix the failures, the procedure remains the
same, i.e. unload and re-load the module, and hope things succeed the
next time around.
Signed-off-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2014-07-27 05:04:01 +07:00
|
|
|
.scan = virtrng_scan,
|
2013-09-17 06:55:23 +07:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-05-28 13:48:43 +07:00
|
|
|
.freeze = virtrng_freeze,
|
|
|
|
.restore = virtrng_restore,
|
|
|
|
#endif
|
2008-05-31 03:09:44 +07:00
|
|
|
};
|
|
|
|
|
2013-02-13 13:29:28 +07:00
|
|
|
module_virtio_driver(virtio_rng_driver);
|
2008-05-31 03:09:44 +07:00
|
|
|
MODULE_DEVICE_TABLE(virtio, id_table);
|
|
|
|
MODULE_DESCRIPTION("Virtio random number driver");
|
|
|
|
MODULE_LICENSE("GPL");
|