Implement Goldfish RTC

The system date after boot is not synchronized with the host's wall
clock, resulting in incorrect timestamps shown by commands such as date.
When the system has the hwclock utility, it cannot function because
the /dev/rtc? device file is missing. In addition, programs might rely
on RTC alarm events for wake-up operations, which require access to
/dev/rtc? device file.

This commit implements an RTC device using the Goldfish RTC model,
chosen for its simplicity and native support in the Linux kernel.

By adding RTC support, the following capabilities are enabled:
- System boot-up synchronization: The RTC driver initializes the
  system time from the at boot, ensuring the guestOS starts with an
  accurate and synchronized timestamp.
- Wakeup events: The RTC can generate alarm interrupts to wake up the
  process.
- The date command, hwclock utility, and alarm configuration via ioctl
  (see the rtc(4) man page) are now functional.
- Provide accurate timestamps for filesystem operations such as when
  writing or modifying files on a virtio block device.

The #605 hardcoded vblk_mmio_base_hi to 0x41, which limits adding new
subnodes (e.g., RTC) under the SoC node. This value should instead be
dynamically set during load_dtb(). Another limitation is in the
next_addr probing logic, which currently uses subnode's name + 7. This
assumes a fixed-length name and fails for variable-length names (e.g.,
rtc@4100000, should be name + 4). The fix is to locate the '@' character
in the subnode name and use its position + 1 as the offset.
Additionally, when no virtio block device is specified,
virtio_mmio_base_hi will default to 0. In this case, use vblk_cnt for
condition checking during MMIO handling to avoid incorrect behavior.

Author: ChinYikMing

src/common.h

@@ -29,7 +29,7 @@
 
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
 
-#define MASK(n) (~((~0U << (n))))
+#define MASK(n) (~((~0UL << (n))))
 
 #if defined(_MSC_VER)
 #include <intrin.h>

src/devices/minimal.dts

@@ -66,14 +66,21 @@
             clock-frequency = <5000000>; /* the baudrate divisor is ignored */
         };
 
+        rtc0: rtc@4100000 {
+            compatible = "google,goldfish-rtc";
+            reg = <0x4100000 0x1000>;
+            interrupts = <2>;
+            interrupt-parent = <&plic0>;
+        };
+
         /*
          * Virtio block example subnode
          * The actual subnode are generated dynamically depends on the CLI -x vblk option
          */
-        /*blk0: virtio@4100000 {
+        /*blk0: virtio@4200000 {
             compatible = "virtio,mmio";
-            reg = <0x4100000 0x200>;
-            interrupts = <2>;
+            reg = <0x4200000 0x200>;
+            interrupts = <3>;
         };*/
     };
 };

src/devices/rtc.c

@@ -0,0 +1,120 @@
+/*
+ * rv32emu is freely redistributable under the MIT License. See the file
+ * "LICENSE" for information on usage and redistribution of this file.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "rtc.h"
+
+static uint64_t now_nsec;
+
+uint64_t get_now_nsec(rtc_t *rtc)
+{
+    /* TODO:
+     * - detects timezone and use the correct UTC offset
+     * - a new CLI option should be added to main.c to let user to select
+     *   [UTC] or [UTC + offset](localtime) time. E.g., -x rtc:utc or -x
+     *   rtc:localtime
+     */
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return (uint64_t) (ts.tv_sec * 1e9) + ts.tv_nsec + rtc->clock_offset;
+}
+
+uint32_t rtc_read(rtc_t *rtc, uint32_t addr)
+{
+    uint32_t rtc_read_val = 0;
+
+    switch (addr) {
+    case RTC_TIME_LOW:
+        now_nsec = get_now_nsec(rtc);
+        rtc->time_low = (uint32_t) (now_nsec & MASK(32));
+        rtc_read_val = rtc->time_low;
+        break;
+    case RTC_TIME_HIGH:
+        /* reuse the now_nsec when reading RTC_TIME_LOW */
+        rtc->time_high = (uint32_t) (now_nsec >> 32);
+        rtc_read_val = rtc->time_high;
+        break;
+    case RTC_ALARM_LOW:
+        rtc_read_val = rtc->alarm_low;
+        break;
+    case RTC_ALARM_HIGH:
+        rtc_read_val = rtc->alarm_high;
+        break;
+    case RTC_ALARM_STATUS:
+        rtc_read_val = rtc->alarm_status;
+        break;
+    default:
+        rv_log_error("Unsupported RTC read operation, 0x%x", addr);
+        break;
+    }
+
+    return rtc_read_val;
+}
+
+void rtc_write(rtc_t *rtc, uint32_t addr, uint32_t value)
+{
+    switch (addr) {
+    case RTC_TIME_LOW:
+        now_nsec = get_now_nsec(rtc);
+        rtc->clock_offset += (uint64_t) (value) - (now_nsec & MASK(32));
+        break;
+    case RTC_TIME_HIGH:
+        /* reuse the now_nsec when writing RTC_TIME_LOW */
+        rtc->clock_offset += ((uint64_t) (value) << 32) -
+                             (now_nsec & ((uint64_t) (MASK(32)) << 32));
+        break;
+    case RTC_ALARM_LOW:
+        rtc->alarm_low = value;
+        break;
+    case RTC_ALARM_HIGH:
+        rtc->alarm_high = value;
+        break;
+    case RTC_IRQ_ENABLED:
+        rtc->irq_enabled = value;
+        break;
+    case RTC_CLEAR_ALARM:
+        rtc->clear_alarm = value;
+        break;
+    case RTC_CLEAR_INTERRUPT:
+        rtc->clear_interrupt = value;
+        rtc->interrupt_status = 0;
+        break;
+    default:
+        rv_log_error("Unsupported RTC write operation, 0x%x", addr);
+        break;
+    }
+    return;
+}
+
+rtc_t *rtc_new()
+{
+    rtc_t *rtc = calloc(1, sizeof(rtc_t));
+    assert(rtc);
+
+    /*
+     * The rtc->time_low/high values can be updated through the RTC_SET_TIME
+     * ioctl operation. Therefore, they should be initialized to match the
+     * host OS time during initialization.
+     */
+    now_nsec = get_now_nsec(rtc);
+    rtc->time_low = (uint32_t) (now_nsec & MASK(32));
+    rtc->time_high = (uint32_t) (now_nsec >> 32);
+
+    return rtc;
+}
+
+void rtc_delete(rtc_t *rtc)
+{
+    free(rtc);
+}

src/devices/rtc.h

@@ -0,0 +1,58 @@
+/*
+ * rv32emu is freely redistributable under the MIT License. See the file
+ * "LICENSE" for information on usage and redistribution of this file.
+ */
+
+#pragma once
+
+/* Check: https://github.com/torvalds/linux/blob/v6.1/drivers/rtc/rtc-goldfish.c
+ */
+
+/* Google Goldfish RTC MMIO registers */
+#define RTC_REG_LIST                   \
+    _(TIME_LOW, 0x00)        /* R/W */ \
+    _(TIME_HIGH, 0x04)       /* R/W */ \
+    _(ALARM_LOW, 0x08)       /* R/W */ \
+    _(ALARM_HIGH, 0x0c)      /* R/W */ \
+    _(IRQ_ENABLED, 0x10)     /* W */   \
+    _(CLEAR_ALARM, 0x14)     /* W */   \
+    _(ALARM_STATUS, 0x18)    /* R */   \
+    _(CLEAR_INTERRUPT, 0x1c) /* W */
+
+enum {
+#define _(reg, addr) RTC_##reg = addr,
+    RTC_REG_LIST
+#undef _
+};
+
+typedef struct {
+    uint32_t time_low;
+    uint32_t time_high;
+    uint32_t alarm_low;
+    uint32_t alarm_high;
+    uint32_t irq_enabled;
+    uint32_t clear_alarm;
+    uint32_t alarm_status;
+    uint32_t clear_interrupt;
+
+    /* Ensure the clock always progresses so RTC_SET_TIME ioctl can set any
+     * arbitrary time */
+    uint64_t clock_offset;
+
+    uint32_t interrupt_status;
+} rtc_t;
+
+#define IRQ_RTC_SHIFT 2
+#define IRQ_RTC_BIT (1 << IRQ_RTC_SHIFT)
+
+#define RTC_ALARM_FIRE(rtc, now_nsec) \
+    rtc->irq_enabled &&               \
+        (now_nsec) >= ((((uint64_t) rtc->alarm_high) << 32) | rtc->alarm_low)
+
+uint32_t rtc_read(rtc_t *rtc, uint32_t addr);
+
+void rtc_write(rtc_t *rtc, uint32_t addr, uint32_t value);
+
+rtc_t *rtc_new();
+
+void rtc_delete(rtc_t *rtc);

src/emulate.c

@@ -370,6 +370,8 @@ static bool has_loops = false;
 
 #if RV32_HAS(SYSTEM) && !RV32_HAS(ELF_LOADER)
 extern void emu_update_uart_interrupts(riscv_t *rv);
+extern void emu_update_rtc_interrupts(riscv_t *rv);
+extern uint64_t get_now_nsec(rtc_t *rtc);
 static uint32_t peripheral_update_ctr = 64;
 #endif
 
@@ -1015,6 +1017,13 @@ static void rv_check_interrupt(riscv_t *rv)
         u8250_check_ready(PRIV(rv)->uart);
         if (PRIV(rv)->uart->in_ready)
             emu_update_uart_interrupts(rv);
+
+        uint64_t now_nsec = get_now_nsec(PRIV(rv)->rtc);
+        if (RTC_ALARM_FIRE(PRIV(rv)->rtc, now_nsec)) {
+            PRIV(rv)->rtc->alarm_status = 1;
+            PRIV(rv)->rtc->interrupt_status = 1;
+            emu_update_rtc_interrupts(rv);
+        }
     }
 
     if (rv->timer > attr->timer)

src/riscv.c

@@ -350,7 +350,10 @@ static void load_dtb(char **ram_loc, vm_attr_t *attr)
             const char *name = fdt_get_name(dtb_buf, subnode, NULL);
             assert(name);
 
-            uint32_t addr = strtoul(name + 7, NULL, 16);
+            char *at_pos = strchr(name, '@');
+            assert(at_pos);
+
+            uint32_t addr = strtoul(at_pos + 1, NULL, 16);
             if (addr == next_addr)
                 next_addr = addr + addr_offset;
 
@@ -365,6 +368,10 @@ static void load_dtb(char **ram_loc, vm_attr_t *attr)
         /* set IRQ for virtio block, see devices/virtio.h */
         attr->vblk_irq_base = next_irq;
 
+        /* set the VBLK MMIO valid range */
+        attr->vblk_mmio_base_hi = next_addr >> 20;
+        attr->vblk_mmio_max_hi = attr->vblk_mmio_base_hi + attr->vblk_cnt;
+
         /* adding new virtio block nodes */
         for (int i = 0; i < attr->vblk_cnt; i++) {
             uint32_t new_addr = next_addr + i * addr_offset;
@@ -665,9 +672,8 @@ riscv_t *rv_create(riscv_user_t rv_attr)
     attr->uart->in_fd = attr->fd_stdin;
     attr->uart->out_fd = attr->fd_stdout;
 
-    /* setup virtio-blk */
-    attr->vblk_mmio_base_hi = 0x41;
-    attr->vblk_mmio_max_hi = attr->vblk_mmio_base_hi + attr->vblk_cnt;
+    /* setup rtc */
+    attr->rtc = rtc_new();
 
     attr->vblk = malloc(sizeof(virtio_blk_state_t *) * attr->vblk_cnt);
     assert(attr->vblk);
@@ -848,6 +854,7 @@ void rv_delete(riscv_t *rv)
 #if RV32_HAS(SYSTEM) && !RV32_HAS(ELF_LOADER)
     u8250_delete(attr->uart);
     plic_delete(attr->plic);
+    rtc_delete(attr->rtc);
     /* sync device, cleanup inside the callee */
     rv_fsync_device();
 #endif

src/riscv.h

@@ -15,6 +15,7 @@
 
 #if RV32_HAS(SYSTEM)
 #include "devices/plic.h"
+#include "devices/rtc.h"
 #include "devices/uart.h"
 #include "devices/virtio.h"
 #endif /* RV32_HAS(SYSTEM) */
@@ -483,6 +484,9 @@ typedef struct {
     /* plic object */
     plic_t *plic;
 
+    /* rtc object */
+    rtc_t *rtc;
+
     /* virtio-blk device */
     uint32_t **disk;
     virtio_blk_state_t **vblk;

src/system.c

@@ -30,6 +30,16 @@ void emu_update_vblk_interrupts(riscv_t *rv)
         plic_update_interrupts(attr->plic);
     }
 }
+
+void emu_update_rtc_interrupts(riscv_t *rv)
+{
+    vm_attr_t *attr = PRIV(rv);
+    if (attr->rtc->interrupt_status)
+        attr->plic->active |= IRQ_RTC_BIT;
+    else
+        attr->plic->active &= ~IRQ_RTC_BIT;
+    plic_update_interrupts(attr->plic);
+}
 #endif
 
 static bool ppn_is_valid(riscv_t *rv, uint32_t ppn)