Implement virtio-rng device

This commit introduces the VirtIO entropy device (also know as virtio-rng in
QEMU and the Linux kernel) to resolve the blocking issue of arc4random_buf()
[1] caused by insufficient entropy for /dev/random.

According to the man page (`man 7 random`):

The kernel random-number generator relies on entropy gathered from device
drivers and other sources of environmental noise to seed a cryptographically
secure pseudorandom number generator (CSPRNG).

Interface Pool: /dev/random
Pool: Blocking pool
Blocking behavior: If entropy too low, blocks until there is enough entropy
Behavior when pool is not yet ready: Blocks until enough entropy gathered

Quaoted from https://en.wikipedia.org/wiki//dev/random

With Linux kernel 3.16 and newer, the kernel itself mixes data from hardware
random number generators into /dev/random on a sliding scale based on the
definable entropy estimation quality of the HWRNG. This means that no userspace
daemon, such as rngd from rng-tools, is needed to do that job. With Linux
kernel 3.17+, the VirtIO RNG was modified to have a default quality defined
above 0, and as such, is currently the only HWRNG mixed into /dev/random by
default.

[1] https://elixir.bootlin.com/glibc/glibc-2.36/source/stdlib/arc4random.c

Close #68.

Author: shengwen-tw

Makefile

@@ -31,6 +31,13 @@ ifeq ($(call has, VIRTIOBLK), 1)
     endif
 endif
 
+# virtio-rng
+ENABLE_VIRTIORNG ?= 1
+$(call set-feature, VIRTIORNG)
+ifeq ($(call has, VIRTIORNG), 1)
+    OBJS_EXTRA += virtio-rng.o
+endif
+
 NETDEV ?= tap
 # virtio-net
 ENABLE_VIRTIONET ?= 1

device.h

@@ -172,6 +172,52 @@ void virtio_blk_write(hart_t *vm,
 uint32_t *virtio_blk_init(virtio_blk_state_t *vblk, char *disk_file);
 #endif /* SEMU_HAS(VIRTIOBLK) */
 
+/* VirtIO-RNG */
+
+#if SEMU_HAS(VIRTIORNG)
+
+#define IRQ_VRNG 4
+#define IRQ_VRNG_BIT (1 << IRQ_VRNG)
+
+typedef struct {
+    uint32_t QueueNum;
+    uint32_t QueueDesc;
+    uint32_t QueueAvail;
+    uint32_t QueueUsed;
+    uint16_t last_avail;
+    bool ready;
+} virtio_rng_queue_t;
+
+typedef struct {
+    /* feature negotiation */
+    uint32_t DeviceFeaturesSel;
+    uint32_t DriverFeatures;
+    uint32_t DriverFeaturesSel;
+    /* queue config */
+    uint32_t QueueSel;
+    virtio_rng_queue_t queues[1];
+    /* status */
+    uint32_t Status;
+    uint32_t InterruptStatus;
+    /* supplied by environment */
+    uint32_t *ram;
+} virtio_rng_state_t;
+
+void virtio_rng_read(hart_t *vm,
+                     virtio_rng_state_t *rng,
+                     uint32_t addr,
+                     uint8_t width,
+                     uint32_t *value);
+
+void virtio_rng_write(hart_t *vm,
+                      virtio_rng_state_t *vrng,
+                      uint32_t addr,
+                      uint8_t width,
+                      uint32_t value);
+
+void virtio_rng_init(void);
+#endif /* SEMU_HAS(VIRTIORNG) */
+
 /* ACLINT MTIMER */
 typedef struct {
     /* A MTIMER device has two separate base addresses: one for the MTIME
@@ -272,6 +318,9 @@ typedef struct {
 #endif
 #if SEMU_HAS(VIRTIOBLK)
     virtio_blk_state_t vblk;
+#endif
+#if SEMU_HAS(VIRTIORNG)
+    virtio_rng_state_t vrng;
 #endif
     /* ACLINT */
     mtimer_state_t mtimer;

main.c

@@ -72,6 +72,18 @@ static void emu_update_vblk_interrupts(vm_t *vm)
 }
 #endif
 
+#if SEMU_HAS(VIRTIORNG)
+static void emu_update_vrng_interrupts(vm_t *vm)
+{
+    emu_state_t *data = PRIV(vm->hart[0]);
+    if (data->vrng.InterruptStatus)
+        data->plic.active |= IRQ_VRNG_BIT;
+    else
+        data->plic.active &= ~IRQ_VRNG_BIT;
+    plic_update_interrupts(vm, &data->plic);
+}
+#endif
+
 static void emu_update_timer_interrupt(hart_t *hart)
 {
     emu_state_t *data = PRIV(hart);
@@ -137,6 +149,12 @@ static void mem_load(hart_t *hart,
             aclint_sswi_read(hart, &data->sswi, addr & 0xFFFFF, width, value);
             aclint_sswi_update_interrupts(hart, &data->sswi);
             return;
+#if SEMU_HAS(VIRTIORNG)
+        case 0x46: /* virtio-rng */
+            virtio_rng_read(hart, &data->vrng, addr & 0xFFFFF, width, value);
+            emu_update_vrng_interrupts(hart->vm);
+            return;
+#endif
         }
     }
     vm_set_exception(hart, RV_EXC_LOAD_FAULT, hart->exc_val);
@@ -191,6 +209,12 @@ static void mem_store(hart_t *hart,
             aclint_sswi_write(hart, &data->sswi, addr & 0xFFFFF, width, value);
             aclint_sswi_update_interrupts(hart, &data->sswi);
             return;
+#if SEMU_HAS(VIRTIORNG)
+        case 0x46: /* virtio-rng */
+            virtio_rng_write(hart, &data->vrng, addr & 0xFFFFF, width, value);
+            emu_update_vrng_interrupts(hart->vm);
+            return;
+#endif
         }
     }
     vm_set_exception(hart, RV_EXC_STORE_FAULT, hart->exc_val);
@@ -617,6 +641,10 @@ static int semu_start(int argc, char **argv)
 #if SEMU_HAS(VIRTIOBLK)
     emu.vblk.ram = emu.ram;
     emu.disk = virtio_blk_init(&(emu.vblk), disk_file);
+#endif
+#if SEMU_HAS(VIRTIORNG)
+    emu.vrng.ram = emu.ram;
+    virtio_rng_init();
 #endif
     /* Set up ACLINT */
     semu_timer_init(&emu.mtimer.mtime, CLOCK_FREQ);

minimal.dts

@@ -63,5 +63,13 @@
             interrupts = <3>;
         };
 #endif
+
+#if SEMU_FEATURE_VIRTIORNG
+        rng0: virtio@4600000 {
+            compatible = "virtio,mmio";
+            reg = <0x4600000 0x200>;
+            interrupts = <4>;
+        };
+#endif
     };
 };