Remove DCM test as request_core and phys_alloc are tested elsewhere

Author: Erika Hunhoff

kernel/src/integration_tests.rs

@@ -11,7 +11,7 @@ use crate::ExitReason;
 type MainFn = fn();
 
 #[cfg(feature = "integration-test")]
-const INTEGRATION_TESTS: [(&str, MainFn); 28] = [
+const INTEGRATION_TESTS: [(&str, MainFn); 27] = [
     ("exit", just_exit_ok),
     ("wrgsbase", wrgsbase),
     ("pfault-early", just_exit_fail),
@@ -37,7 +37,6 @@ const INTEGRATION_TESTS: [(&str, MainFn); 28] = [
     ("replica-advance", replica_advance),
     ("gdb", gdb),
     ("vmxnet-smoltcp", vmxnet_smoltcp),
-    ("dcm", dcm),
     ("cxl-read", cxl_read),
     ("cxl-write", cxl_write),
 ];
@@ -764,41 +763,6 @@ fn vmxnet_smoltcp() {
     shutdown(ExitReason::Ok);
 }
 
-/// Test vmxnet3 integrated with smoltcp.s
-#[cfg(all(feature = "integration-test", target_arch = "x86_64"))]
-fn dcm() {
-    use crate::arch::rackscale::client::RPC_CLIENT;
-    use crate::arch::rackscale::processops::allocate_physical::rpc_allocate_physical;
-    use crate::arch::rackscale::processops::core::rpc_request_core;
-    use crate::memory::{paddr_to_kernel_vaddr, PAddr, BASE_PAGE_SIZE};
-    use log::info;
-
-    let pid = 0; // Using dummy pid for now
-    let affinity = 0; // Using dummy affinity for now
-    let frame_size = BASE_PAGE_SIZE as u64; // Using dummy frame_size for now
-    let core_id = 3; // Using dummy core_id for now
-    let entry_point = 4; // Using dummy entry_point for now
-
-    info!("About to send resource requests!");
-    for _ in 0..3 {
-        let mut client = RPC_CLIENT.lock();
-        let (_alloced_frame_size, addr_base) =
-            rpc_allocate_physical(&mut **client, pid, frame_size, affinity).unwrap();
-
-        let vaddr_base = paddr_to_kernel_vaddr(PAddr::from(addr_base)).as_u64();
-        for i in 0..2 {
-            let region = (vaddr_base + i as u64) as *mut u8;
-            unsafe { core::ptr::write(region, 0xb) };
-        }
-
-        // TODO: use the core
-        let _core_ret = rpc_request_core(&mut **client, pid, core_id, entry_point).unwrap();
-    }
-
-    info!("Finished sending resource requests!");
-    shutdown(ExitReason::Ok);
-}
-
 /// Write and test the content on a shared-mem device.
 pub(crate) const BUFFER_CONTENT: u8 = 0xb;
 

kernel/tests/s06_rackscale_tests.rs

@@ -204,116 +204,6 @@ fn rackscale_fs_test(is_shmem: bool) {
     let _ignore = remove_file(SHMEM_PATH);
 }
 
-#[cfg(not(feature = "baremetal"))]
-#[test]
-fn s06_rackscale_shmem_dcm_test() {
-    rackscale_dcm_test(true);
-}
-
-#[cfg(not(feature = "baremetal"))]
-#[test]
-fn s06_rackscale_ethernet_dcm_test() {
-    rackscale_dcm_test(false);
-}
-
-#[cfg(not(feature = "baremetal"))]
-fn rackscale_dcm_test(is_shmem: bool) {
-    use std::fs::remove_file;
-    use std::sync::Arc;
-    use std::thread::sleep;
-    use std::time::Duration;
-
-    // Setup ivshmem file
-    setup_shmem(SHMEM_PATH, SHMEM_SIZE);
-
-    setup_network(2);
-    let timeout = 30_000;
-
-    // Create build for both controller and client
-    let build = Arc::new(
-        BuildArgs::default()
-            .module("init")
-            .user_feature("test-fs")
-            .kernel_feature("shmem")
-            .kernel_feature("ethernet")
-            .kernel_feature("rackscale")
-            .release()
-            .build(),
-    );
-
-    // Run DCM and controller in separate thread
-    let build1 = build.clone();
-    let controller = std::thread::spawn(move || {
-        let controller_cmd = if is_shmem {
-            "mode=controller transport=shmem"
-        } else {
-            "mode=controller transport=ethernet"
-        };
-        let cmdline_controller = RunnerArgs::new_with_build("userspace-smp", &build1)
-            .timeout(timeout)
-            .cmd(controller_cmd)
-            .shmem_size(SHMEM_SIZE as usize)
-            .shmem_path(SHMEM_PATH)
-            .tap("tap0")
-            .no_network_setup()
-            .workers(2)
-            .use_vmxnet3();
-
-        let mut output = String::new();
-        let mut qemu_run = || -> Result<WaitStatus> {
-            let mut dcm = spawn_dcm(1, timeout)?;
-            let mut p = spawn_nrk(&cmdline_controller)?;
-
-            output += p.exp_string("Created DCM UDP socket!")?.as_str();
-            output += p.exp_string("Created DCM RPC client!")?.as_str();
-            output += p.exp_eof()?.as_str();
-
-            dcm.send_control('c')?;
-            p.process.exit()
-        };
-
-        let _ignore = qemu_run();
-    });
-
-    // Run client in separate thead. Wait a bit to make sure DCM and controller started
-    let build2 = build.clone();
-    let client = std::thread::spawn(move || {
-        sleep(Duration::from_millis(5_000));
-        let client_cmd = if is_shmem {
-            "mode=client transport=shmem"
-        } else {
-            "mode=client transport=ethernet"
-        };
-        let cmdline_client = RunnerArgs::new_with_build("dcm", &build2)
-            .timeout(timeout)
-            .cmd(client_cmd)
-            .shmem_size(SHMEM_SIZE as usize)
-            .shmem_path(SHMEM_PATH)
-            .tap("tap2")
-            .no_network_setup()
-            .workers(2)
-            .use_vmxnet3();
-
-        let mut output = String::new();
-        let mut qemu_run = || -> Result<WaitStatus> {
-            let mut p = spawn_nrk(&cmdline_client)?;
-            output += p.exp_string("About to send resource requests")?.as_str();
-            output += p
-                .exp_string("Finished sending resource requests!")?
-                .as_str();
-            output += p.exp_eof()?.as_str();
-            p.process.exit()
-        };
-
-        check_for_successful_exit(&cmdline_client, qemu_run(), output);
-    });
-
-    controller.join().unwrap();
-    client.join().unwrap();
-
-    let _ignore = remove_file(SHMEM_PATH);
-}
-
 #[cfg(not(feature = "baremetal"))]
 #[test]
 fn s06_rackscale_shmem_fs_prop_test() {