ivshmem interrupts working

Author: hunhoffe

Cargo.lock

@@ -23,7 +23,7 @@ vmxnet3 = { path = "../lib/vmxnet3" }
 bootloader_shared = { path = "../lib/bootloader_shared" }
 x86 = { version = "0.52", features = ["unstable"] }
 klogger = "0.0.16"
-driverkit = "0.21"
+driverkit = { git = "https://github.com/hunhoffe/rust-driverkit.git", branch = "msix" }
 spin = "0.9.1"
 elfloader = "0.14"
 slabmalloc = "0.10"
@@ -123,3 +123,5 @@ cause-gpfault-early = []
 cause-double-fault = []
 # test-timer: print something on a timer interrupt.
 test-timer = []
+# test-shmem: print something on a shmem interrupt.
+test-shmem = []

kernel/Cargo.toml

@@ -407,16 +407,11 @@ def run_qemu(args):
                           'isa-debug-exit,iobase=0xf4,iosize=0x04']
 
     if args.qemu_ivshmem:
-        if not args.qemu_shmem_path:
-            print("Provide path to the shared memory file.")
-            sys.exit(errno.EINVAL)
-
+        qemu_default_args += ['-device', 'ivshmem-doorbell,vectors=2,chardev=id']
         qemu_default_args += [
-            '-object',
-            'memory-backend-file,size={}M,mem-path={},share=on,id=HMB'.format(
-                args.qemu_ivshmem, args.qemu_shmem_path)
+            '-chardev',
+            'socket,path={},id=id'.format(args.qemu_shmem_path)
         ]
-        qemu_default_args += ['-device', 'ivshmem-plain,memdev=HMB']
 
     # Enable networking:
     mac, tap = NETWORK_CONFIG[args.tap]['mac'], args.tap

kernel/run.py

@@ -60,6 +60,9 @@ use super::memory::{PAddr, VAddr, BASE_PAGE_SIZE, KERNEL_BASE};
 use super::process::{Ring0Resumer, Ring3Process, Ring3Resumer};
 use super::{debug, gdb, timer};
 
+// TODO(hunhoffe): probably not the right place for this but transport/shmem isn't always included.
+pub(crate) const SHMEM_VECTOR: u8 = 249;
+
 /// The x2APIC driver of the current core.
 #[thread_local]
 pub(crate) static LOCAL_APIC: RefCell<X2APICDriver> = RefCell::new(X2APICDriver::new());
@@ -180,8 +183,11 @@ impl Default for IdtTable {
         idt_set!(table.0, 46, isr_handler46, 0);
         idt_set!(table.0, 47, isr_handler47, 0);
 
-        idt_set!(table.0, TLB_WORK_PENDING as usize, isr_handler251, 0);
+        // shmem interrupt
+        idt_set!(table.0, SHMEM_VECTOR as usize, isr_handler249, 0);
+
         idt_set!(table.0, MLNR_GC_INIT as usize, isr_handler250, 0);
+        idt_set!(table.0, TLB_WORK_PENDING as usize, isr_handler251, 0);
         idt_set!(table.0, apic::TSC_TIMER_VECTOR as usize, isr_handler252, 0);
 
         table
@@ -230,9 +236,8 @@ impl IdtTable {
         idt_set!(table.0, SIMD_FLOATING_POINT_VECTOR, isr_handler_early19, 0);
         idt_set!(table.0, VIRTUALIZATION_VECTOR, isr_handler_early20, 0);
 
-        idt_set!(table.0, TLB_WORK_PENDING as usize, isr_handler_early251, 0);
-
         idt_set!(table.0, MLNR_GC_INIT as usize, isr_handler_early250, 0);
+        idt_set!(table.0, TLB_WORK_PENDING as usize, isr_handler_early251, 0);
         idt_set!(
             table.0,
             apic::TSC_TIMER_VECTOR as usize,
@@ -491,7 +496,7 @@ unsafe fn timer_handler(_a: &ExceptionArguments) {
     #[cfg(feature = "test-timer")]
     {
         // Don't change this print stmt. without changing
-        // `s01_timer` in integration-tests.rs:
+        // `s01_timer` in tests/s01_kernel_low_tests.rs:
         sprintln!("Got a timer interrupt");
         debug::shutdown(ExitReason::Ok);
     }
@@ -544,6 +549,30 @@ unsafe fn timer_handler(_a: &ExceptionArguments) {
     }
 }
 
+/// Handler for the shmem interrupt.
+///
+/// We currently use it to check for work from the controller
+/// or other nodes in the rackscale architecture.
+unsafe fn shmem_handler(_a: &ExceptionArguments) {
+    #[cfg(feature = "test-shmem")]
+    {
+        // Don't change this print stmt. without changing
+        // `s03_ivshmem_interrupt` in tests/s03_kernel_high_tests.rs:
+        sprintln!("Got a shmem interrupt");
+        debug::shutdown(ExitReason::Ok);
+    }
+
+    if super::process::has_executor() {
+        // Return immediately
+        let kcb = get_kcb();
+        let r = kcb_iret_handle(kcb);
+        r.resume()
+    } else {
+        // Go to scheduler instead
+        crate::scheduler::schedule()
+    }
+}
+
 /// Handler for a general protection exception.
 ///
 /// TODO: Right now we terminate kernel.
@@ -681,8 +710,8 @@ pub extern "C" fn handle_generic_exception(a: ExceptionArguments) -> ! {
         // If we have an active process we should do scheduler activations:
         // TODO(scheduling): do proper masking based on some VCPU mask
         // TODO(scheduling): Currently don't deliver interrupts to process not currently running
-        if a.vector > 30 && a.vector < 250 && a.vector != debug::GDB_REMOTE_IRQ_VECTOR.into() {
-            trace!("handle_generic_exception {:?}", a);
+        if a.vector > 30 && a.vector < 249 && a.vector != debug::GDB_REMOTE_IRQ_VECTOR.into() {
+            log::info!("handle_generic_exception {:?}", a);
 
             let mut pborrow = super::process::CURRENT_EXECUTOR.borrow_mut();
             let p = pborrow.as_mut().unwrap();
@@ -760,6 +789,8 @@ pub extern "C" fn handle_generic_exception(a: ExceptionArguments) -> ! {
             }
         } else if a.vector == apic::TSC_TIMER_VECTOR.into() {
             timer_handler(&a);
+        } else if a.vector == SHMEM_VECTOR.into() {
+            shmem_handler(&a);
         }
 
         unhandled_irq(&a);

kernel/src/arch/x86_64/irq.rs

@@ -229,6 +229,9 @@ isr_handler 45
 isr_handler 46
 isr_handler 47
 
+/* qemu shmem interrupt, may (or may not) be used */
+isr_handler 249
+
 /* The MLNR gc interrupt */
 isr_handler 250
 /* TLB work-queue trigger IPI */

kernel/src/arch/x86_64/isr.S

@@ -15,7 +15,7 @@ use crate::arch::rackscale::processops::request_core::request_core_work;
 use crate::cmdline::Transport;
 use crate::error::KError;
 use crate::fs::NrLock;
-use crate::transport::shmem::SHMEM_REGION;
+use crate::transport::shmem::SHMEM_DEVICE;
 
 /// A handle to an RPC client
 ///
@@ -28,7 +28,7 @@ pub(crate) static ref RPC_CLIENT: Arc<Mutex<Box<Client>>> =
         .map_or(false, |c| c.transport == Transport::Ethernet)
     {
         // To support alloc_phys, client needs shared memory to be mapped
-        lazy_static::initialize(&SHMEM_REGION);
+        lazy_static::initialize(&SHMEM_DEVICE);
 
         Arc::new(Mutex::new(
             crate::transport::ethernet::init_ethernet_rpc(

kernel/src/arch/x86_64/rackscale/client.rs

@@ -19,7 +19,7 @@ use crate::fs::fd::FileDescriptor;
 use crate::memory::backends::PhysicalPageProvider;
 use crate::memory::{Frame, PAddr, BASE_PAGE_SIZE};
 use crate::nrproc::NrProcess;
-use crate::transport::shmem::SHMEM_REGION;
+use crate::transport::shmem::SHMEM_DEVICE;
 
 use super::super::dcm::resource_alloc::dcm_resource_alloc;
 use super::super::dcm::DCM_INTERFACE;
@@ -68,9 +68,9 @@ pub(crate) fn rpc_allocate_physical(
             debug!(
                 "AllocatePhysical() mapping base from {:x?} to {:x?}",
                 frame_base,
-                frame_base + SHMEM_REGION.base_addr
+                frame_base + SHMEM_DEVICE.mem_addr
             );
-            let frame_base = frame_base + SHMEM_REGION.base_addr;
+            let frame_base = frame_base + SHMEM_DEVICE.mem_addr;
             let frame = Frame::new(PAddr::from(frame_base), size as usize, affinity as usize);
             let fid = NrProcess::<Ring3Process>::allocate_frame_to_process(pid, frame)?;
 

kernel/src/arch/x86_64/rackscale/processops/allocate_physical.rs

@@ -23,7 +23,6 @@ use crate::arch::process::current_pid;
 use crate::arch::process::Ring3Process;
 use crate::arch::rackscale::client::{get_frame_as, FRAME_MAP};
 use crate::arch::rackscale::controller::{get_local_pid, SHMEM_MANAGERS};
-use crate::transport::shmem::SHMEM_REGION;
 
 #[derive(Debug)]
 pub(crate) struct ReleasePhysicalReq {

kernel/src/arch/x86_64/rackscale/processops/release_physical.rs

@@ -11,7 +11,7 @@ use crate::ExitReason;
 type MainFn = fn();
 
 #[cfg(feature = "integration-test")]
-const INTEGRATION_TESTS: [(&str, MainFn); 27] = [
+const INTEGRATION_TESTS: [(&str, MainFn); 29] = [
     ("exit", just_exit_ok),
     ("wrgsbase", wrgsbase),
     ("pfault-early", just_exit_fail),
@@ -39,6 +39,8 @@ const INTEGRATION_TESTS: [(&str, MainFn); 27] = [
     ("vmxnet-smoltcp", vmxnet_smoltcp),
     ("cxl-read", cxl_read),
     ("cxl-write", cxl_write),
+    ("shmem-interruptor", shmem_interruptor),
+    ("shmem-interruptee", shmem_interruptee),
 ];
 
 #[cfg(feature = "integration-test")]
@@ -770,11 +772,12 @@ pub(crate) const BUFFER_CONTENT: u8 = 0xb;
 #[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
 pub(crate) fn cxl_write() {
     use crate::memory::KERNEL_BASE;
-    use crate::transport::shmem::init_shmem_device;
+    use crate::transport::shmem::SHMEM_DEVICE;
 
-    let (base_paddr, size) = init_shmem_device().expect("Can't init shmem device");
-    for i in 0..size {
-        let region = (base_paddr + KERNEL_BASE + i as u64) as *mut u8;
+    lazy_static::initialize(&SHMEM_DEVICE);
+
+    for i in 0..SHMEM_DEVICE.mem_size {
+        let region = (SHMEM_DEVICE.mem_addr + KERNEL_BASE + i as u64) as *mut u8;
         unsafe { core::ptr::write(region, BUFFER_CONTENT) };
     }
 
@@ -785,18 +788,63 @@ pub(crate) fn cxl_write() {
 #[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
 pub(crate) fn cxl_read() {
     use crate::memory::KERNEL_BASE;
-    use crate::transport::shmem::init_shmem_device;
+    use crate::transport::shmem::SHMEM_DEVICE;
+
+    lazy_static::initialize(&SHMEM_DEVICE);
 
-    let (base_paddr, size) = init_shmem_device().expect("Can't init shmem device");
-    for i in 0..size {
-        let region = (base_paddr + KERNEL_BASE + i as u64) as *mut u8;
+    for i in 0..SHMEM_DEVICE.mem_size {
+        let region = (SHMEM_DEVICE.mem_addr + KERNEL_BASE + i as u64) as *mut u8;
         let read = unsafe { core::ptr::read(region) };
         assert_eq!(read, BUFFER_CONTENT);
     }
 
     shutdown(ExitReason::Ok);
 }
 
+/// Test cxl device in the kernel.
+#[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
+pub(crate) fn shmem_interruptor() {
+    use crate::transport::shmem::SHMEM_DEVICE;
+
+    lazy_static::initialize(&SHMEM_DEVICE);
+    {
+        // The ivshmem server allocates IDs consecutively, so we'll assume interruptee is
+        // current_id - 1
+        log::info!(
+            "Sending shmem interrupt to: {:?} on vector {:?}",
+            SHMEM_DEVICE.id - 1,
+            1
+        );
+        SHMEM_DEVICE.set_doorbell(1, SHMEM_DEVICE.id - 1);
+    }
+    shutdown(ExitReason::Ok);
+}
+
+/// Test cxl device in the kernel.
+#[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
+pub(crate) fn shmem_interruptee() {
+    use core::hint::spin_loop;
+    use core::time::Duration;
+
+    use crate::arch::irq::SHMEM_VECTOR;
+    use crate::transport::shmem::SHMEM_DEVICE;
+
+    lazy_static::initialize(&SHMEM_DEVICE);
+
+    SHMEM_DEVICE.enable_msix_vector(0, 0, SHMEM_VECTOR);
+    SHMEM_DEVICE.enable_msix_vector(1, 0, SHMEM_VECTOR);
+
+    let start = rawtime::Instant::now();
+    crate::arch::irq::enable();
+    while start.elapsed() < Duration::from_secs(60) {
+        spin_loop();
+    }
+    crate::arch::irq::disable();
+    let _done = start.elapsed().as_nanos();
+
+    shutdown(ExitReason::Ok);
+}
+
 /// Test shootdown facilities in the kernel.
 #[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
 fn shootdown_simple() {