lekkit/rvvm

The RISC-V Virtual Machine

rvvm's Issues

Asking for vnc support

Right now we have sdl and x11 supports, but maybe RVVM is run on a server with no screen,and both x11 and sdl is diffcult to stream through internet.And vnc support is also useful for me to add display support in archriscv-term(as I just need to add vnc module to archriscv-term).I have just tried Xvnc , but it`s too complex and has much performance cost.

Add Haiku host support

I am an author of Haiku operating system RISC-V support and I am grad to see there are some interest in Haiku by RVVM developers.

Test FreeBSD, HaikuOS (FreeBSD generic kernel boots but i have no idea how to mount rootfs, too lazy to look at Haiku)

Some time ago I experimented in running Haiku in RVVM and got some results. First I made RVVM running on Haiku (patch is here). And then I try to adapt Haiku so it can run as guest in RVVM. Result can be seen in screenshot. It is not trivial to adapt Haiku guest for RVVM because Haiku ATA and PS/2 drivers code is very x86-centered, so patches are not yet upstreamed.

Haiku is booted in RVVM by commad like this:

rvvm -mem 512M -res 800x600 --rv64 \
-image haiku-minimum.image \
haiku_loader.riscv

haiku_loader.riscv is Haiku boot loader for bare metal RISC-V virtual machines (TinyEMU and QEmu are currently fully supported). It is responsible for loading kernel, boot drivers, configuration and some hardware information.

In this issue I only ask about Haiku host support, I think guest support should be done on Haiku side.

Asking for support of /dev/fb0 (or /dev/graphics/fb0) directly

In some embedded linux platforms, both sdl and x11 just doest exist. Maybe a support of /dev/fb0` can help to run rvvm on these platforms. We can also handle the keyboard, mouse or touchscreen events directly. Maybe this feature can also be used in some BSDs and can reduce the performance cost of SDL or X11.( And also, remove these depends, which will definitely help us in porting RVVM to SONY walkmans and some other platforms with limited gui libs)

CPU Core Framework

I would like to improve the JIT performance. I wonder whether there are CPU core testing cases in RVVM?

Falling back to VMA file mapping on NetBSD

I have tried rvvm on sdf.(The environment is netbsd 9.3)
It worked well ,but I got the warnings:

WARN: Falling back to VMA file mapping                                                                                               
WARN: Falling back to VMA file mapping                                                                                              
WARN: Falling back to VMA file mapping                                                                                               
WARN: Falling back to VMA file mapping

Is that a bug of RVVM or limition of netbsd?

i2c-hid: Linux guest hangs on input spam at boot stage

Converted issue; See #126 (comment)

Older issue

Steps to reproduce

• Have a very slow guest (rvvm_set_opt(machine, RVVM_OPT_MAX_CPU_CENT, 1) or immediately call hid_keyboard_release())
• Some key presses will be lost when typing
• Same possibly applies to hid_mouse

Investigation

• Press/release API calls just mark/unmark a bit in pressed keys bitmask, then mark that input is available on HID device
• Guest reads input report, which enumerates pressed keys - if release() happens before this, no pressed keys are reported

Suggested fix

My initial idea is to have two key bitmasks: keys_report and keys_pressed.

• On hid_keyboard_press(), a bit is set in both bitmasks;
• On hid_keyboard_release(), a bit is cleared only in keys_pressed bitmask.
• When guest is reading input report, a key should be reported as pressed if it's bit is set in either bitmasks.
• Then, if the bit is actually cleared in keys_pressed, then that means we now should replay a key release event, so input_avail() should be called. Finally, the bit in keys_report is cleared.

The problem is, input_avail() locking causes recursive deadlock inside i2c-hid when calling from read_report handler.
This needs further investigation - I see there is some queueing mechanism available inside i2c-hid, so maybe we can actually queue input reports instead, but haven't read into that code much yet.

@X547 perhaps you can point me in the right direction? I am wondering if HID reports should be just queued as packets and not call back into the device read_report handler, this would also allow copy-paste into hid_keyboard beyond just fixing this issue.

In the mean time I'll be polishing network code for a new stable release, and will be back to this issue soon

tap_linux: Bad checksums with RTL8169, broken by default

The issue

• Newer emulated RTL8169 NIC doesn't provide working network with tap_linux backend and a Linux guest

Problem investigation

• Older OpenCores Ethernet NIC didn't support checksum offload; The guest would compute proper TCP/IP checksum in software
• Newer (and default) Realtek RTL8169 NIC supports checksum offload, which is turned on by default; The guest (rightfully so) doesn't compute the checksum in transmitted packets and just gives them to NIC like that
• The RVVM TAP API receives the TX packet, at which point it's either parsed by tap_user which doesn't care about checksums, or it is passed to TUN/TAP Linux interface via tap_linux
• Finally, the TUN/TAP Linux interface doesn't have means of "checksum offload"; It simply drops those packets since the checksum is bad and leaves no option to compute the checksum by the kernel, or better offload it to the host NIC and omit any overhead from software checksumming at all

Workarounds

• Disable TX checksum offload in the guest via ethtool -K enp1s0 tx off

Possible proper fixes

• Find a way to ask the host TUN/TAP device for TX checksum offload; No piece of documentation has a clue on that, it could be simply a limitation on Linux side...
• Implement software TX checksumming in tap_linux implementation; Slightly complicated and carries some overhead

If anyone has an advice on proper TUN/TAP TX checksum offload, it would be nice to point out here. Otherwise it should fallback to (arguably, more ugly) approach of working around the system interface limitations, or simply deprecate the TUN/TAP backend when tap_user is at more usable state.

Fix typo in the README file

There will be "and" instead of "or" in the License section of the README file as the repository is dual-licensed.

It will be GPL 3.0 and MPL 2.0

Kindly assign me this issue.

rtl8169: Kernel panic on FreeBSD 14 when loading if_re kernel module

Steps to reproduce

• Use this guest image: https://download.freebsd.org/snapshots/VM-IMAGES/14.0-STABLE/riscv64/20240314/FreeBSD-14.0-STABLE-riscv-riscv64-20240314-91c1c36102a6-266971.raw.xz
• Login with root:root
• Run # kldload if_re
• Kernel panic

Panic backtrace

root@freebsd:~ # kldload if_re
re0: <RealTek 8169/8169S/8169SB(L)/8110S/8110SB(L) Gigabit Ethernet> mem 0x40000000-0x400000ff irq 7 at device 1.0 on pci0
re0: Chip rev. 0x00800000
re0: MAC rev. 0x00000000
   t[0]: 0x0000000000000201
   t[1]: 0xffffffc06440b35c
   t[2]: 0xffffffffa3ce9d4f
   t[3]: 0xffffffc000400e76
   t[4]: 0x000000000c938ce0
   t[5]: 0xffffffc045368200
   t[6]: 0xffffffc045368200
   s[0]: 0xffffffc045368270
   s[1]: 0x0000000000008802
   s[2]: 0xffffffd001c64e00
   s[3]: 0xffffffc0453682a8
   s[4]: 0xffffffd0021c6810
   s[5]: 0xffffffc045368348
   s[6]: 0xffffffffffffffff
   s[7]: 0xffffffc0009b18d8
   s[8]: 0xffffffc0007f5cc2
   s[9]: 0xffffffc05afea130
  s[10]: 0xffffffc00071c230
  s[11]: 0x0000000000000801
   a[0]: 0xffffffd001c6f800
   a[1]: 0xffffffc0453682a8
   a[2]: 0x0000000000000000
   a[3]: 0x00000000c0306938
   a[4]: 0xffffffd0021c6820
   a[5]: 0x0000000000000020
   a[6]: 0x0000000000000020
   a[7]: 0x0000000000000800
     ra: 0xffffffc000400f7a
     sp: 0xffffffc045368240
     gp: 0xffffffc0007f4fa0
     tp: 0xffffffc0009c4600
   sepc: 0x0000000000000000
sstatus: 0x0000000a00000120
stval  : 0x0000000000000000
panic: Fatal page fault at 0: 0
cpuid = 0
time = 1710864605
KDB: stack backtrace:
#0 0xffffffc00034110a at kdb_backtrace+0x4a
#1 0xffffffc0002fc03a at vpanic+0x116
#2 0xffffffc0002fbf20 at panic+0x26
#3 0xffffffc0005ac980 at page_fault_handler+0x21a
#4 0xffffffc0005ac0a4 at do_trap_supervisor+0x56
#5 0xffffffc00059c934 at cpu_exception_handler_supervisor+0x74
#6 0xffffffc0003f8256 at if_ioctl+0xa
#7 0xffffffc0004b4dc6 at dump_iface+0x130
#8 0xffffffc0004b4742 at rtnl_handle_ifevent+0x7c
#9 0xffffffc0004b4a40 at rtnl_handle_ifattach+0x48
#10 0xffffffc0003f1f2a at if_attach_internal+0x36c
#11 0xffffffc0003f1bb2 at if_attach+0xe
#12 0xffffffc0003fc58c at ether_ifattach+0x34
#13 0xffffffc06440694a at .Lpcrel_hi96+0x48
#14 0xffffffc000331d26 at device_attach+0x368
#15 0xffffffc0003319a2 at device_probe_and_attach+0x3e
#16 0xffffffc00012e82a at pci_driver_added+0x102
#17 0xffffffc00032f736 at devclass_driver_added+0x34
Uptime: 47s

Workarounds

• Downgrading to FreeBSD 13.3
• Or not using networking at all

Add RVVM to RISC-V Ecosystem Landscape page

I see TinyEMU "Design Tools+Compilers" section, so RVVM should fit too.

https://github.com/riscv-admin/riscv-landscape

Port to libretro for fun

Hello I make a quick libretro port of RVVM here:
https://github.com/iyzsong/rvvm-libretro

With a modified ns16550a device to use libvterm (fb is disabled for now) for terminal output.
I think this can be useful to play some text games in RetroArch...

Is there some interest to merge a libretro port? Thank you!

Rewrite it in rust

This project need some enhancements. You know that.

Shutdown notification to guest on window close

Currently closing RVVM window cause instant shutdown that give no chance to gratefully shutdown guest and may cause data loss.

Integration with libvirt in the future?

Hi! Nice work! I am running RISC-V Ubuntu 22.04 on my home server through libvirt/qemu and SSH into it through forwarded ports for developing JIT compiler for RISC-V. But build times on QEMU are just super slow. So I am asking if libvirt integration would be possible in the future so setting up and managing the VM can be done through Cockpit UI or virt-manager

Asking for RVVM as a ELF loader

I am currently modifying the RVVM as a elf loader. I am now struggling with a problem that I don't know how to execute a program on the machine. I've noticed that the bincopy in the elf_load is to read the elf file and map into the machine's memory, but does RVVM has the feature of running a program or I should modify RVVM. Besides, should I create a userspace to run the elf file, because I see that there is no userspace in RVVM or I misunderstand it.
Any hint is good, I have think for this problem for a while.

Needs DOOM demo

I'm not even half kidding. :-)

Instruction how to run Linux

Are there any recommended Linux disk images and firmware sets that are confirmed to work? I tried your kernels from this comment, but after switching to NVMe it do not boot anymore.

Haiku OS guest support

Milestones, progress

• Out-of-tree Haiku boots using M-mode haiku_loader under RVVM with ATA drive
• Nightly Haiku EFI boots through U-Boot with NVMe (Unstable framebuffer, app_server crashes, NVMe in polling mode)
• Input devices with upstream Haiku drivers support (See #58)
• Network card with upstream Haiku drivers support (RTL8169, but need stable tap_user first)
• Verify other utility devices (RTC, syscon) work. Are goldfish or DS1742 RTCs supported in Haiku?
• Fix NVMe IRQ loss with Haiku EFI (Doesn't happen in QEMU)
• Fix Haiku EFI bootloader crashing with new U-Boot efifb (Somehow works now, weird fluke?...)
• Fix Haiku EFI bootloader crashing in SMP (Doesn't happen in QEMU)
• NVMe support in M-Mode haiku_loader
• Fix display server crashing upon late userspace init in Haiku EFI (Unrelated to RVVM?)

[Haiku host] Freeze on shutdown

RVVM freeze when shutting down guest with window close button or request from guest OS.

Host OS: Haiku x86_64.

Discussion for new ISA extensions

This issue is a place for discussions about newer unprivileged ISA extensions

Each extension should be evaluated for following qualities:

• Mandatory for a known usecase
• Benefit for guest (Better performance or more features)
• Benefit for advanced user (Better debugging capabilities inside/outside the guest, testing guest compliance)
• Ease of implementation
• Emulation performance
• JITability (If new extension is too complicated for JIT, yet guest will use it instead of usual JITed ALU ops, this might cause a performance hit)
• Conformance tests available (Implementing extensions without standardized testing suite is very error-prone)
• Compiler support

Extensible list of ratified ISA extensions beyond rv64imafdc

Bitmanip family

Zba - Bitmanip address generation

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Moderate
• Emulation performance
• JITability (May fallback to ALU lowering without significant perf hit)
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Zbb - Bitmanip basic bit-manipulation

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Moderate
• Emulation performance
• JITability (May fallback to ALU lowering without significant perf hit)
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Zbc - Bitmanip carry-less multiplication

• Mandatory for a known usecase
• Benefit for guest: Unknown
• Benefit for user (Testing guest compliance)
• Ease of implementation
• Emulation performance
• JITability: Unknown
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Zbs - Bitmanip single-bit instructions

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Moderate
• Emulation performance
• JITability (May fallback to ALU lowering without significant perf hit)
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Floating-point family

Q - 128-bit IEEE754 floating point

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Significant complexity
• Emulation performance
• JITability
• Tests available
• Compiler support

Zfh - 16-bit IEEE754 floating point, Zfhmin - bfloat16

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Significant complexity
• Emulation performance
• JITability
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Zfa - Additional floating-point instructions

• Mandatory for a known usecase
• Benefit for guest: Unknown
• Benefit for user (Testing guest compliance)
• Ease of implementation: Relatively easy
• Emulation performance
• JITability
• Tests available
• Compiler support

Vector family

V - Vector Operations

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Extremely complex
• Emulation performance: Unknown, might be fast enough with big vector sizes
• JITability: Likely none
• Tests available
• Compiler support

K - Vector Cryptography

• Mandatory for a known usecase
• Benefit for guest: Unknown (But things like OpenSSL are likely to use it if they aren't already)
• Benefit for user (Testing guest compliance)
• Ease of implementation: Very complex
• Emulation performance: Unknown, might be fast enough with big vector sizes
• JITability: Likely none
• Tests available
• Compiler support

Memory/atomics related extensions

Zawrs - Wait on memory reservation (Almost like a hint)

• Mandatory for a known usecase
• Benefit for guest (Linux spinlock optimization merged into 6.9)
• Benefit for user (Testing guest compliance)
• Ease of implementation: Relatively easy, might actually implement as a pause on some hosts
• Emulation performance: Unlikely to have significant impact
• JITability: Not needed
• Tests available
• Compiler support (Usable in assembly)

Zacas - Compare and Swap

• Mandatory for a known usecase
• Benefit for guest: Unknown
• Benefit for user (Testing guest compliance)
• Ease of implementation: Easy
• Emulation performance: Unlikely to have significant impact
• JITability: Probably not needed
• Tests available
• Compiler support

Zicbom, Zicboz - Cache management (flush, invalidate, prefetch, zero cache block)

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Relatively easy
• Emulation performance: Unlikely to have significant impact
• JITability: Probably not needed
• Tests available (https://github.com/LekKit/riscv-tests)
• Compiler support

Hints

Zihintpause - Pause hint

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user
• Ease of implementation: Easy
• Emulation performance: Unlikely to have significant impact
• JITability
• Tests not needed
• Compiler support

Extra

Zicond - Integer Conditional operations

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Relatively easy
• Emulation performance
• JITability
• Tests available
• Compiler support

Zcb - Code size reduction extension

• Mandatory for a known usecase
• Benefit for guest
• Benefit for user (Testing guest compliance)
• Ease of implementation: Moderate
• Emulation performance
• JITability
• Tests available
• Compiler support

Online demo: kernel panic

[    8.477060] /dev/root: Can't open blockdev
[    8.570120] VFS: Cannot open root device "nvme0n1" or unknown-block(0,0): error -6
[    8.740940] Please append a correct "root=" boot option; here are the available partitions:
[    8.914860] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)
[    9.073880] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0) ]---

Mac OS X: Guest hangs when allocating >=2G of RAM

The issue

• Few people reported RVVM guests hanging on Mac OS (OpenSBI doesn't start, UART is empty), on both M1 and older x86 ones.
• The same setup works on any other system 👀
• It was quickly determined that when they remove some of their arguments, it starts working.
• The culpit is setting -mem to 2G or higher.

Now, there is only one place which is directly affected by -mem and it's riscv_init_ram(), which allocates guest memory using either mmap() or calloc() (depending on the target), and enables KSM/hugepages where available.
The same hang scenario happens with either implementations on OS X, which are also used on Linux, Windows, FreeBSD and the problem doesn't happen there... So, same code, same APIs, different results. This already starts to be confusing.

The RAM size is later passed to the guest inside the FDT, and current debugging efforts show that it starts to work when we lie about RAM size being smaller than it actually is. To be continued...

Asking for more serial ports

(sorry for my broken english...)
I made a project of a emulator on android ,which runs archlinux riscv on android using RVVM.The project is archriscv-term.The problem is that there is only one tty available.Could you add more serial ports? You may bind them to some sockets so that I can connect them using socat.

Asking for support for splited disk images

It's a bit difficult for users (include me) to use a large disk image (for example, 512G) in RVVM on a net-based filesystem(nfs, rclone FUSE, etc.) or a filesystem with limited file size(fat32).
It causes trouble for users on vps with low disk space and embedded device(like the MP3 I'm currently porting RVVM to).
Maybe we can support it with the ability to use all files listed in a config file as a whole drive.
For example,
File: archriscv.list

/data/arhcriscv.img.chunk.0
/data/archriscv.img.chunk.1
/data/archriscv.img.chunk.2
...

And the user can run RVVM with rvvm -image_list archriscv.list ... to run the machine just like using rvvm -image archriscv.img ...

Sorry for my poor English :D

Userland emulation, API

RVVM is usable as a generic CPU execution engine, not just as a complete machine.
This suggests for working userspace emulation, which runs RISC-V code inside a host process, directly accesses it's memory and defers syscall execution to the host kernel.
For convenience, it's also great to expose an API for that, there is a working project that already needs that (https://github.com/X547/UserlandVM), which uses RVVM for HaikuOS RISC-V userland emulation.

Progress tracking:

• Decide on the initial userland API draft (See #55 for discussion on that)
• Implement the Userland API
• Test regressions with rebased UserlandVM as a primary API user
• Test RVJIT cache tracking
• Von Neumann RVJIT cache for userland
• Signal handling
• Upstream ELF loader
• Linux process stack setup
• Simple system call shims
• Full Linux syscall emulation

Discussions & suggestions are welcome.

Disk error on NetBSD

I have just got this error:

WARN: Possible deadlock at src/devices/nvme.c@346                                                 
WARN: The lock was previously held at src/devices/nvme.c@330
WARN: Version: RVVM v0.6-unknown                                                                  
WARN: Attempting to recover execution...                                                           
* * * * * * *                                                                                                                                                                                      WARN: Possible deadlock at src/devices/nvme.c@346                                                 
* WARN: The lock was previously held at src/devices/nvme.c@330
WARN: Version: RVVM v0.6-unknown
WARN: Attempting to recover execution...
 * * * * * * *

Is that a bug of RVVM or SDF?
P.S. The time of the files on SDF is inaccurate.That might be the problem(?)
Is it possible to disable the lock by the user?

Unixbench on ubuntu 23.10 Double-Precision Whetstone slow than Qemu

I run the unixbench on RVMM and Qemu on Ubuntu 23.10

The test environment

EM780 mini pc, linux Ubuntu 23.10

RVVM: master branch: @21433cca22d63a748b3c6d0b1cfbcb10c307badf
Qemu: ubuntu apt install qemu

RVMM:

release.linux.x86_64/rvvm_x86_64 -mem 8G -smp 8 -nogui fw_jump.bin -k u-boot.bin -i ubuntu-23.10-preinstalled-server-riscv64.img -jitcache 1G

`------------------------------------------------------------------------
Benchmark Run: Sun Feb 04 2024 02:45:51 - 03:13:50
0 CPUs in system; running 1 parallel copy of tests

Dhrystone 2 using register variables 10744333.0 lps (10.0 s, 7 samples)
Double-Precision Whetstone 464.9 MWIPS (10.0 s, 7 samples)
Execl Throughput 276.0 lps (29.9 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 101814.3 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 26649.3 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 308874.0 KBps (30.0 s, 2 samples)
Pipe Throughput 143627.2 lps (10.0 s, 7 samples)
Pipe-based Context Switching 5810.2 lps (10.0 s, 7 samples)
Process Creation 308.9 lps (30.0 s, 2 samples)
Shell Scripts (1 concurrent) 751.1 lpm (60.1 s, 2 samples)
Shell Scripts (8 concurrent) 318.5 lpm (60.1 s, 2 samples)
System Call Overhead 325415.9 lps (10.0 s, 7 samples)

System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 10744333.0 920.7
Double-Precision Whetstone 55.0 464.9 84.5
Execl Throughput 43.0 276.0 64.2
File Copy 1024 bufsize 2000 maxblocks 3960.0 101814.3 257.1
File Copy 256 bufsize 500 maxblocks 1655.0 26649.3 161.0
File Copy 4096 bufsize 8000 maxblocks 5800.0 308874.0 532.5
Pipe Throughput 12440.0 143627.2 115.5
Pipe-based Context Switching 4000.0 5810.2 14.5
Process Creation 126.0 308.9 24.5
Shell Scripts (1 concurrent) 42.4 751.1 177.1
Shell Scripts (8 concurrent) 6.0 318.5 530.9
System Call Overhead 15000.0 325415.9 216.9
========
System Benchmarks Index Score 145.8
`
Qemu

qemu-system-riscv64 -machine virt -nographic -m 8192 -smp 8 -bios /usr/lib/riscv64-linux-gnu/opensbi/generic/fw_jump.bin -kernel /usr/lib/u-boot/qemu-riscv64_smode/uboot.elf -device virtio-net-device,netdev=eth0 -netdev user,id=eth0 -device virtio-rng-pci -drive file=ubuntu-23.10-preinstalled-server-riscv64.img,format=raw,if=virtio

`------------------------------------------------------------------------
Benchmark Run: Sun Feb 04 2024 03:19:31 - 03:47:57
0 CPUs in system; running 1 parallel copy of tests

Dhrystone 2 using register variables 5036880.1 lps (10.1 s, 7 samples)
Double-Precision Whetstone 924.7 MWIPS (10.3 s, 7 samples)
Execl Throughput 56.5 lps (29.7 s, 2 samples)
File Copy 1024 bufsize 2000 maxblocks 21528.0 KBps (30.0 s, 2 samples)
File Copy 256 bufsize 500 maxblocks 5470.1 KBps (30.0 s, 2 samples)
File Copy 4096 bufsize 8000 maxblocks 77479.0 KBps (30.0 s, 2 samples)
Pipe Throughput 31337.4 lps (10.1 s, 7 samples)
Pipe-based Context Switching 6855.0 lps (10.1 s, 7 samples)
Process Creation 371.8 lps (30.1 s, 2 samples)
Shell Scripts (1 concurrent) 258.7 lpm (60.2 s, 2 samples)
Shell Scripts (8 concurrent) 109.6 lpm (60.2 s, 2 samples)
System Call Overhead 208745.2 lps (10.1 s, 7 samples)

System Benchmarks Index Values BASELINE RESULT INDEX
Dhrystone 2 using register variables 116700.0 5036880.1 431.6
Double-Precision Whetstone 55.0 924.7 168.1
Execl Throughput 43.0 56.5 13.1
File Copy 1024 bufsize 2000 maxblocks 3960.0 21528.0 54.4
File Copy 256 bufsize 500 maxblocks 1655.0 5470.1 33.1
File Copy 4096 bufsize 8000 maxblocks 5800.0 77479.0 133.6
Pipe Throughput 12440.0 31337.4 25.2
Pipe-based Context Switching 4000.0 6855.0 17.1
Process Creation 126.0 371.8 29.5
Shell Scripts (1 concurrent) 42.4 258.7 61.0
Shell Scripts (8 concurrent) 6.0 109.6 182.6
System Call Overhead 15000.0 208745.2 139.2
========
System Benchmarks Index Score 63.8
`

Double-Precision Whetstone is slow than Qemu twice.
Others result is faster. it is good for replace Qemu.

RV32 U-Mode JIT is nonconformant and slow on ctx switch

The issue

• Running riscv32 userland with riscv64 kernel is broken

Steps to reproduce

• Use those firmware/kernel/rootfs: rv32_umode.zip
• Run rvvm fw_jump.bin -k linux_6.8 -i rootfs_rv32.ext2 -nojit
• The userland will crash almost immediately with random unhandled pagefaults inside the kernel or segfaults in userspace

Investigation

• RV32 U-mode RVJIT is most likely broken. It doesn't sign-extend the dirty 32-bit registers upon spilling them into hart ctx. So just disable it for now and fix later.
• Interpreter properly sign-extends writes into rv32 registers to full 64-bit register by intermediate cast to sxlen_t:
  

  RVVM/src/riscv_cpu.h

  Line 422 in 9929fdd

  static forceinline void riscv_write_reg(rvvm_hart_t* vm, regid_t reg, sxlen_t data)

• Interpreter load/stores are computing effective virtual address as xlen_t which is unsigned 32-bit in rv32. It's okay for bare or SV32 MMU, but apparently rv32 U-mode uses an SV39/48 MMU so the upper VA half is not properly sign-extended. Either riscv_mmu should manually sign-extend rv32 addresses on SV39, or switch to sxlen_t addresses in interpreter and making Bare/SV32 modes work with this.
• The CSR subsystem is likely broken. Applying a 32-bit CSR mask when running in rv32 mode allows to see buildroot MOTD, but most other userspace parts are still crashing.

librvvm: Dynamic unloading doesn't deinit

The issue

• When using shared librvvm, unloading it leaves some global state initialized
• This may cause segfaults from thread workers kept running, leaks, etc

Steps to reproduce

• Run Retroarch with libretro port of RVVM (See #96), I.e. load the lib
• Do some IO workloads, causing thread workers to run
• Click close content, which unloads the shared lib
• Segfault

Investigation

• Global data is deinitialized via use of atexit(), which is fine for standalone VM but not for a lib

Workarounds

• Omitting unloading the lib
• Waiting for a while after VM destruction so that thread workers exit

Suggested fix

• Implement rvvm_at_deinit() callbacks instead of atexit()
• Expose rvvm_deinit() API that is called before unloading the lib
• Perhaps mark it with GNU attributes for automatic deinit

Hibernate / resume (and discussing other ideas)

A neat feature that would probably be easier here than a real VM would be dumping memory and state to a hibernate file and allowing the VM to be resumed from that file. Would enable hot migrate of VMs, sleep/wake, etc.

Asking for SDL debug output support

Currently I'm porting RVVM to a sony walkman nw-zx300. I closed all processes using /dev/graphics/fb0 and it's possible to use cat to write to /dev/graphics/fb0 now. However, RVVM just didn't worked and I got a blank black screen. It seems to be a problem of SDL, not the kernel or framebuffer device since the picture on the screen was wiped out, so I wanted to see the SDL's output. It seems that RVVM's --verbose option didn't print the debug output given by SDL, will we add it later?

Dynamic allocation / ballooning memory?

Another obvious idea: implement support for minimum and maximum memory and dynamic allocation / ballooning.

Absolute positioned input device support

Currently RVVM support only relative-positioned PS/2 mouse emulation that require pointer capture. It is annoying and limiting because it do not work properly on touchscreens and tablets with digital pen. TinyEMU and QEmu supports absolute positioned pointer.

It can be implemented with i2c HID or USB HID.

tap_user usability tracking

( Sorry for my poor english)
The QEMU has a feature to bind the guest`s port to the host\s port.Will RVVM support it later?It\s impossible to support x11 or SDL on android,so the vnc is the only choice.It`s important to make it possible to connect to the guest using the network port.

Remove RISC-V foundation official branding

Unless you're a special member of the the RISC-V foundation, you're not allowed to use the organization's trademark to advertise your projects (which includes logo and branding).

Just giving you a heads-up in case you were not aware.

Controlling iteration speed of the machine

Hi, is it possible to control the event loop, looking through the public API I did not see a feature like that, is it a feature being considered ?

Failed to build openSBI.

Hi, I have built risc-v linux toolchain, linux kernel, and uBoot, and try to build openSBI.
After generate fw_jump.bin in opensbi/build/platform/generic/firmware
./rvvm_riscv fw_jump.bin -kernel linux_Image -image rootfs.img -rv64 -mem 2G -smp 2 -res 1280x720
It will loop forever, like this

Is this problem is caused by openSBI or RVMM and how can I successfully execute RVMM?

many thanks!

Test cases

Hi, I am attempting to improve the JIT engine. So it would be really great if you can provide test cases for the RVVM.
I saw in the makefile that riscv-tests.tar.gz was used. I tried to compile my own one from https://github.com/riscv-software-src/riscv-tests. But my RVVM was not taking any of the input and just stuck.

rtl8169: fail to read MAC address on FreeBSD-originated drivers

Following patch is needed to make it working on Haiku:

diff --git a/src/add-ons/kernel/drivers/network/ether/rtl81xx/dev/re/if_re.c b/src/add-ons/kernel/drivers/network/ether/rtl81xx/dev/re/if_re.c
index cf327932cd7..5bd4ee548a7 100644
--- a/src/add-ons/kernel/drivers/network/ether/rtl81xx/dev/re/if_re.c
+++ b/src/add-ons/kernel/drivers/network/ether/rtl81xx/dev/re/if_re.c
@@ -1564,7 +1564,7 @@ re_attach(device_t dev)
 	CSR_WRITE_1(sc, sc->rl_cfg5, cfg);
 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
 
-	if ((sc->rl_flags & RL_FLAG_PAR) != 0) {
+	if (true || (sc->rl_flags & RL_FLAG_PAR) != 0) {
 		/*
 		 * XXX Should have a better way to extract station
 		 * address from EEPROM.

RVVM probably incorrectly declare network card model that don't match implemented MAC address access method.

Virtual Terminal as UART backend

Hello I'd like to add VT support to RVVM.

Exact requirements

I think it should:

• compatible with TERM=xterm, with a good score from vttest, https://www.invisible-island.net/vttest/
• takeover fb_window for input/output, a keyboard shortcut can be used to switch between VT and original mode
• support UTF-8, has built-in font for ASCII, can load external font file for CJK etc.
• maybe color support, so compatible with TERM=xterm-256color
• maybe bold and itatic support, with seperated font files

Suggested solution

My current plan are:

• use libvterm for VT emulation, can be switch out later..

• support pcbasic / hex font format,
  pre-made (.hex) fonts: https://github.com/robhagemans/pcbasic/tree/master/pcbasic/data/fonts
  tools: https://github.com/robhagemans/monobit

• implement a chardev VT backend, with fb_window takeover and switch logic

Expected results and side effects

The showcase can be TERM=xterm-mono emacs -nw running in OpenBSD editing UTF-8 text, via RetroArch...

How does this sound?

Online demo: Input/SDL/other problems

• Buttons HID_KEY_MINUS and HID_KEY_EQUAL aren't reported, even tho native SDL build works fine
• Any way to lazy load the FS image? Downloading entire rootfs at page load seems wasteful. Tried using synchronous XHR, but it seems overly complicated and not supported well in Emscripten.
• No way to use touch keyboard on Android, etc. Needs help from JS side.
• Host cursor is visible (Minor nuisance for proper cursor integration)
• When in fullscreen, input isn't working at all
• Temporary mouse/keyboard lockups (Perhaps I2C HID related?)

It's not a bug, I just wanted to know how to use an Ubuntu image because everything I tried didn't work

Hello, I'm trying to use an Ubuntu image but it didn't work even in img. I don't know if I'm converting the file correctly, I wanted an explanation on how to use Ubuntu

Implement IMSIC and APLIC according to AIA spec

RISC-V Advanced Interrupt Architecture (AIA) specification: https://github.com/riscv/riscv-aia/releases/download/1.0/riscv-interrupts-1.0.pdf.

Reference code (QEmu):

• https://github.com/qemu/qemu/blob/master/include/hw/intc/riscv_imsic.h
• https://github.com/qemu/qemu/blob/master/hw/intc/riscv_imsic.c
• https://github.com/qemu/qemu/blob/master/include/hw/intc/riscv_aplic.h
• https://github.com/qemu/qemu/blob/master/hw/intc/riscv_aplic.c

PLIC interrupts stop working after some time

Tested on Haiku host and guest, no SMP guest.

PS/2 mouse received interrupts and data log:

altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 0)
AlteraPs2::HandleInterrupt
 ff 03 00
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 0)
AlteraPs2::HandleInterrupt
 ff 0d 00
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 0)
AlteraPs2::HandleInterrupt
 ff 08 00
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 0)
AlteraPs2::HandleInterrupt
 00 0b 00
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 0)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
altps2_interrupt_unlocked(irq_enabled: 1, irq_pending: 1)
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1
WARN: Overflow in ringbuf 0x11318aadabd0! size=1024, consumed=1024, len=1