tools/kvm/virtio/rng.c

   1 #include "kvm/virtio-rng.h"
   2
   3 #include "kvm/virtio-pci-dev.h"
   4
   5 #include "kvm/virtio.h"
   6 #include "kvm/util.h"
   7 #include "kvm/kvm.h"
   8 #include "kvm/threadpool.h"
   9 #include "kvm/guest_compat.h"
  10 #include "kvm/virtio-pci.h"
  11
  12 #include <linux/virtio_ring.h>
  13 #include <linux/virtio_rng.h>
  14
  15 #include <linux/list.h>
  16 #include <fcntl.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <pthread.h>
  20 #include <linux/kernel.h>
  21
  22 #define NUM_VIRT_QUEUES         1
  23 #define VIRTIO_RNG_QUEUE_SIZE   128
  24
  25 struct rng_dev_job {
  26         struct virt_queue       *vq;
  27         struct rng_dev          *rdev;
  28         struct thread_pool__job job_id;
  29 };
  30
  31 struct rng_dev {
  32         struct list_head        list;
  33         struct virtio_pci       vpci;
  34
  35         int                     fd;
  36         int                     compat_id;
  37
  38         /* virtio queue */
  39         struct virt_queue       vqs[NUM_VIRT_QUEUES];
  40         struct rng_dev_job      jobs[NUM_VIRT_QUEUES];
  41 };
  42
  43 static LIST_HEAD(rdevs);
  44
  45 static void set_config(struct kvm *kvm, void *dev, u8 data, u32 offset)
  46 {
  47         /* Unused */
  48 }
  49
  50 static u8 get_config(struct kvm *kvm, void *dev, u32 offset)
  51 {
  52         /* Unused */
  53         return 0;
  54 }
  55
  56 static u32 get_host_features(struct kvm *kvm, void *dev)
  57 {
  58         /* Unused */
  59         return 0;
  60 }
  61
  62 static void set_guest_features(struct kvm *kvm, void *dev, u32 features)
  63 {
  64         /* Unused */
  65 }
  66
  67 static bool virtio_rng_do_io_request(struct kvm *kvm, struct rng_dev *rdev, struct virt_queue *queue)
  68 {
  69         struct iovec iov[VIRTIO_RNG_QUEUE_SIZE];
  70         unsigned int len = 0;
  71         u16 out, in, head;
  72
  73         head            = virt_queue__get_iov(queue, iov, &out, &in, kvm);
  74         len             = readv(rdev->fd, iov, in);
  75
  76         virt_queue__set_used_elem(queue, head, len);
  77
  78         return true;
  79 }
  80
  81 static void virtio_rng_do_io(struct kvm *kvm, void *param)
  82 {
  83         struct rng_dev_job *job = param;
  84         struct virt_queue *vq = job->vq;
  85         struct rng_dev *rdev = job->rdev;
  86
  87         while (virt_queue__available(vq))
  88                 virtio_rng_do_io_request(kvm, rdev, vq);
  89
  90         virtio_pci__signal_vq(kvm, &rdev->vpci, vq - rdev->vqs);
  91 }
  92
  93 static int init_vq(struct kvm *kvm, void *dev, u32 vq, u32 pfn)
  94 {
  95         struct rng_dev *rdev = dev;
  96         struct virt_queue *queue;
  97         struct rng_dev_job *job;
  98         void *p;
  99
 100         compat__remove_message(rdev->compat_id);
 101
 102         queue                   = &rdev->vqs[vq];
 103         queue->pfn              = pfn;
 104         p                       = guest_pfn_to_host(kvm, queue->pfn);
 105
 106         job = &rdev->jobs[vq];
 107
 108         vring_init(&queue->vring, VIRTIO_RNG_QUEUE_SIZE, p, VIRTIO_PCI_VRING_ALIGN);
 109
 110         *job            = (struct rng_dev_job) {
 111                 .vq             = queue,
 112                 .rdev           = rdev,
 113         };
 114
 115         thread_pool__init_job(&job->job_id, kvm, virtio_rng_do_io, job);
 116
 117         return 0;
 118 }
 119
 120 static int notify_vq(struct kvm *kvm, void *dev, u32 vq)
 121 {
 122         struct rng_dev *rdev = dev;
 123
 124         thread_pool__do_job(&rdev->jobs[vq].job_id);
 125
 126         return 0;
 127 }
 128
 129 static int get_pfn_vq(struct kvm *kvm, void *dev, u32 vq)
 130 {
 131         struct rng_dev *rdev = dev;
 132
 133         return rdev->vqs[vq].pfn;
 134 }
 135
 136 static int get_size_vq(struct kvm *kvm, void *dev, u32 vq)
 137 {
 138         return VIRTIO_RNG_QUEUE_SIZE;
 139 }
 140
 141 void virtio_rng__init(struct kvm *kvm)
 142 {
 143         struct rng_dev *rdev;
 144
 145         rdev = malloc(sizeof(*rdev));
 146         if (rdev == NULL)
 147                 return;
 148
 149         rdev->fd = open("/dev/urandom", O_RDONLY);
 150         if (rdev->fd < 0)
 151                 die("Failed initializing RNG");
 152
 153         virtio_pci__init(kvm, &rdev->vpci, rdev, PCI_DEVICE_ID_VIRTIO_RNG, VIRTIO_ID_RNG);
 154         rdev->vpci.ops = (struct virtio_pci_ops) {
 155                 .set_config             = set_config,
 156                 .get_config             = get_config,
 157                 .get_host_features      = get_host_features,
 158                 .set_guest_features     = set_guest_features,
 159                 .init_vq                = init_vq,
 160                 .notify_vq              = notify_vq,
 161                 .get_pfn_vq             = get_pfn_vq,
 162                 .get_size_vq            = get_size_vq,
 163         };
 164
 165         list_add_tail(&rdev->list, &rdevs);
 166
 167         rdev->compat_id = compat__add_message("virtio-rng device was not detected",
 168                                                 "While you have requested a virtio-rng device, "
 169                                                 "the guest kernel didn't seem to detect it.\n"
 170                                                 "Please make sure that the kernel was compiled"
 171                                                 "with CONFIG_HW_RANDOM_VIRTIO.");
 172 }
 173
 174 void virtio_rng__delete_all(struct kvm *kvm)
 175 {
 176         while (!list_empty(&rdevs)) {
 177                 struct rng_dev *rdev;
 178
 179                 rdev = list_first_entry(&rdevs, struct rng_dev, list);
 180                 list_del(&rdev->list);
 181                 free(rdev);
 182         }
 183 }