WIP

Author: Grarak

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "vitaGL"]
 	path = vitaGL
 	url = https://github.com/Rinnegatamante/vitaGL.git
+[submodule "kubridge"]
+	path = kubridge
+	url = https://github.com/bythos14/kubridge.git

Cargo.lock

@@ -32,6 +32,7 @@ affinity = "0.1.2"
 [build-dependencies]
 bindgen = "0.70.0"
 cc = "1.0.100"
+cmake = "0.1"
 
 [target.armv7-sony-vita-newlibeabihf.dependencies]
 vitasdk-sys = { version = "0.3.2", features = [

Cargo.toml

@@ -25,47 +25,82 @@ fn main() {
     let vitasdk_include_path = vitasdk_path.join("arm-vita-eabi").join("include");
     let vitasdk_lib_path = vitasdk_path.join("arm-vita-eabi").join("lib");
 
-    let bindings_file = out_path.join("imgui_bindings.rs");
-
-    const IMGUI_HEADERS: [&str; 3] = ["imgui.h", "imgui_internal.h", "imgui_impl_vitagl.h"];
-    let mut bindings = bindgen::Builder::default()
-        .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
-        .clang_args(["-x", "c++"])
-        .clang_args(["-std=c++17"])
-        .clang_args(["-target", "armv7a-none-eabihf"])
-        .formatter(Formatter::Prettyplease);
-    for header in IMGUI_HEADERS {
-        let header_path = vitasdk_include_path.join(header);
-        println!("cargo:rerun-if-changed={header_path:?}");
-        bindings = bindings.header(header_path.to_str().unwrap());
+    let kubridge_path = PathBuf::from("kubridge");
+
+    {
+        let bindings_file = out_path.join("imgui_bindings.rs");
+
+        const IMGUI_HEADERS: [&str; 3] = ["imgui.h", "imgui_internal.h", "imgui_impl_vitagl.h"];
+        let mut bindings = bindgen::Builder::default()
+            .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
+            .clang_args(["-x", "c++"])
+            .clang_args(["-std=c++17"])
+            .clang_args(["-target", "armv7a-none-eabihf"])
+            .formatter(Formatter::Prettyplease);
+        for header in IMGUI_HEADERS {
+            let header_path = vitasdk_include_path.join(header);
+            println!("cargo:rerun-if-changed={header_path:?}");
+            bindings = bindings.header(header_path.to_str().unwrap());
+        }
+        bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
+
+        println!("cargo:rustc-link-search=native={vitasdk_lib_path:?}");
+        println!("cargo:rustc-link-lib=static=imgui");
+    }
+
+    {
+        let bindings_file = out_path.join("kubridge_bindings.rs");
+
+        const KUBRIDGE_HEADERS: [&str; 1] = ["kubridge.h"];
+        let mut bindings = bindgen::Builder::default()
+            .clang_args(["-I", vitasdk_include_path.to_str().unwrap()])
+            .clang_args(["-I", kubridge_path.to_str().unwrap()])
+            .clang_args(["-x", "c++"])
+            .clang_args(["-std=c++17"])
+            .clang_args(["-target", "armv7a-none-eabihf"])
+            .formatter(Formatter::Prettyplease);
+        for header in KUBRIDGE_HEADERS {
+            let header_path = kubridge_path.join(header);
+            println!("cargo:rerun-if-changed={header_path:?}");
+            bindings = bindings.header(header_path.to_str().unwrap());
+        }
+        bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
+    }
+
+    {
+        let vita_gl_path = PathBuf::from("vitaGL");
+        let vita_gl_lib_path = vita_gl_path.join("libvitaGL.a");
+        let vita_gl_lib_new_path = vita_gl_path.join("libvitaGL_dsvita.a");
+
+        Command::new("make")
+            .current_dir("vitaGL")
+            .args(["-j", &num_jobs])
+            .envs([
+                ("HAVE_UNFLIPPED_FBOS", "1"),
+                ("NO_TEX_COMBINER", "1"),
+                ("NO_DEBUG", "1"),
+                ("SHADER_COMPILER_SPEEDHACK", "1"),
+                ("MATH_SPEEDHACK", "1"),
+                ("HAVE_SHADER_CACHE", "1"),
+                // ("HAVE_SHARK_LOG", "1"),
+                // ("LOG_ERRORS", "1"),
+                // ("HAVE_RAZOR", "1"),
+            ])
+            .status()
+            .unwrap();
+
+        fs::rename(vita_gl_lib_path, vita_gl_lib_new_path).unwrap();
+        println!("cargo:rustc-link-search=native={}", fs::canonicalize(vita_gl_path).unwrap().to_str().unwrap());
+        println!("cargo:rustc-link-lib=static=vitaGL_dsvita");
+    }
+
+    {
+        let kubridge_dst_path = cmake::Config::new(&kubridge_path).build_target("libkubridge_stub.a").build().join("build");
+        let kubridge_lib_path = kubridge_dst_path.join("libkubridge_stub.a");
+        let kubridge_lib_new_path = kubridge_dst_path.join("libkubridge_stub_dsvita.a");
+        fs::rename(kubridge_lib_path, kubridge_lib_new_path).unwrap();
+
+        println!("cargo:rustc-link-search=native={}", fs::canonicalize(kubridge_dst_path).unwrap().to_str().unwrap());
+        println!("cargo:rustc-link-lib=static=kubridge_stub_dsvita");
     }
-    bindings.rust_target(bindgen::RustTarget::Nightly).generate().unwrap().write_to_file(bindings_file).unwrap();
-
-    println!("cargo:rustc-link-search=native={vitasdk_lib_path:?}");
-    println!("cargo:rustc-link-lib=static=imgui");
-
-    let vita_gl_path = PathBuf::from("vitaGL");
-    let vita_gl_lib_path = vita_gl_path.join("libvitaGL.a");
-    let vita_gl_lib_new_path = vita_gl_path.join("libvitaGL_dsvita.a");
-
-    Command::new("make")
-        .current_dir("vitaGL")
-        .args(["-j", &num_jobs])
-        .envs([
-            ("HAVE_UNFLIPPED_FBOS", "1"),
-            ("NO_TEX_COMBINER", "1"),
-            ("NO_DEBUG", "1"),
-            ("SHADER_COMPILER_SPEEDHACK", "1"),
-            ("MATH_SPEEDHACK", "1"),
-            ("HAVE_SHADER_CACHE", "1"),
-            // ("HAVE_SHARK_LOG", "1"),
-            // ("LOG_ERRORS", "1"),
-            // ("HAVE_RAZOR", "1"),
-        ])
-        .status()
-        .unwrap();
-
-    fs::rename(vita_gl_lib_path, vita_gl_lib_new_path).unwrap();
-    println!("cargo:rustc-link-search=native={}", fs::canonicalize(vita_gl_path).unwrap().to_str().unwrap());
-    println!("cargo:rustc-link-lib=static=vitaGL_dsvita");
 }

build.rs

@@ -1,3 +1,5 @@
+use crate::core::memory::vram;
+
 pub const INSTRUCTION_TCM_OFFSET: u32 = 0x00000000;
 pub const INSTRUCTION_TCM_MIRROR_OFFSET: u32 = 0x01000000;
 pub const INSTRUCTION_TCM_SIZE: u32 = 32 * 1024;
@@ -34,3 +36,54 @@ pub const ARM9_BIOS_OFFSET: u32 = 0xFFFF0000;
 pub const ARM9_BIOS_SIZE: u32 = 32 * 1024;
 pub const ARM7_BIOS_OFFSET: u32 = 0x00000000;
 pub const ARM7_BIOS_SIZE: u32 = 16 * 1024;
+
+pub const TOTAL_MEM_SIZE: u32 = INSTRUCTION_TCM_SIZE
+    + DATA_TCM_SIZE
+    + MAIN_MEMORY_SIZE
+    + SHARED_WRAM_SIZE
+    + ARM7_WRAM_SIZE
+    + WIFI_RAM_SIZE
+    + vram::TOTAL_SIZE as u32
+    + GBA_ROM_SIZE
+    + GBA_RAM_SIZE
+    + ARM9_BIOS_SIZE
+    + ARM7_BIOS_SIZE;
+
+pub struct MemRegion {
+    start: u32,
+    end: u32,
+    size: u32,
+    allow_write: bool,
+}
+
+impl MemRegion {
+    pub const fn new(start: u32, end: u32, size: u32, allow_write: bool) -> Self {
+        MemRegion { start, end, size, allow_write }
+    }
+}
+
+pub const VIRTUAL_MEM_REGIONS_ARM9: [MemRegion; 11] = [
+    MemRegion::new(INSTRUCTION_TCM_OFFSET, MAIN_MEMORY_OFFSET, INSTRUCTION_TCM_SIZE, true),
+    MemRegion::new(0, 0, DATA_TCM_SIZE, true),
+    MemRegion::new(MAIN_MEMORY_OFFSET, SHARED_WRAM_OFFSET, MAIN_MEMORY_SIZE, true),
+    MemRegion::new(0, 0, SHARED_WRAM_SIZE, true),
+    MemRegion::new(IO_PORTS_OFFSET, STANDARD_PALETTES_OFFSET, 0, true),
+    MemRegion::new(STANDARD_PALETTES_OFFSET, VRAM_OFFSET, 0, true),
+    MemRegion::new(0, 0, vram::TOTAL_SIZE as u32, true),
+    MemRegion::new(OAM_OFFSET, GBA_ROM_OFFSET, 0, true),
+    MemRegion::new(GBA_ROM_OFFSET, GBA_RAM_OFFSET, GBA_ROM_SIZE, false),
+    MemRegion::new(0, 0, GBA_RAM_SIZE, true),
+    MemRegion::new(0xF0000000, 0x10000000, ARM9_BIOS_SIZE, false),
+];
+
+pub const VIRTUAL_MEM_REGIONS_ARM7: [MemRegion; 8] = [
+    MemRegion::new(ARM7_BIOS_OFFSET, MAIN_MEMORY_OFFSET, ARM7_BIOS_SIZE, true),
+    MemRegion::new(MAIN_MEMORY_OFFSET, SHARED_WRAM_OFFSET, MAIN_MEMORY_SIZE, true),
+    MemRegion::new(0, 0, SHARED_WRAM_SIZE, true),
+    MemRegion::new(ARM7_WRAM_OFFSET, IO_PORTS_OFFSET, ARM7_WRAM_SIZE, true),
+    MemRegion::new(IO_PORTS_OFFSET, WIFI_IO_OFFSET, 0, true),
+    MemRegion::new(WIFI_IO_OFFSET, STANDARD_PALETTES_OFFSET, WIFI_RAM_SIZE, true),
+    MemRegion::new(0, 0, vram::TOTAL_SIZE as u32, true),
+    MemRegion::new(GBA_ROM_OFFSET, GBA_RAM_OFFSET, GBA_ROM_SIZE, false),
+    MemRegion::new(0, 0, GBA_RAM_SIZE, true),
+];

kubridge

@@ -1,33 +1,29 @@
+use libc::*;
 use std::io::{Error, ErrorKind};
 use std::ops::{Deref, DerefMut};
-use std::ptr::null_mut;
-use std::{io, slice};
+use std::{io, ptr, slice};
 
 pub struct Mmap {
-    ptr: *mut libc::c_void,
+    ptr: *mut u8,
     size: usize,
 }
 
 impl Mmap {
-    pub fn rw(_: &str, size: usize) -> io::Result<Self> {
-        Mmap::new(libc::PROT_READ | libc::PROT_WRITE, size)
-    }
-
-    pub fn executable(_: &str, size: usize) -> io::Result<Self> {
-        Mmap::new(libc::PROT_READ | libc::PROT_WRITE | libc::PROT_EXEC, size)
+    pub fn executable(_: impl AsRef<str>, size: usize) -> io::Result<Self> {
+        Mmap::new(PROT_READ | PROT_WRITE | PROT_EXEC, size)
     }
 
     fn new(prot: i32, size: usize) -> io::Result<Self> {
-        let ptr = unsafe { libc::mmap(null_mut(), size as _, prot, libc::MAP_ANON | libc::MAP_PRIVATE, -1, 0) };
-        if ptr != libc::MAP_FAILED {
-            Ok(Mmap { ptr, size })
+        let ptr = unsafe { mmap(ptr::null_mut(), size as _, prot, libc::MAP_ANON | libc::MAP_PRIVATE, -1, 0) };
+        if ptr != MAP_FAILED {
+            Ok(Mmap { ptr: ptr as _, size })
         } else {
             Err(Error::from(ErrorKind::AddrNotAvailable))
         }
     }
 
     pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.ptr as _
+        self.ptr
     }
 
     pub fn as_ptr(&self) -> *const u8 {
@@ -41,7 +37,7 @@ impl Mmap {
 
 impl Drop for Mmap {
     fn drop(&mut self) {
-        unsafe { libc::munmap(self.ptr, self.size as _) };
+        unsafe { munmap(self.ptr as _, self.size as _) };
     }
 }
 
@@ -70,3 +66,97 @@ impl AsMut<[u8]> for Mmap {
         self.deref_mut()
     }
 }
+
+pub struct ShmMem(i32);
+
+impl ShmMem {
+    pub fn new(_: impl AsRef<str>, size: usize) -> io::Result<Self> {
+        let fd = unsafe { shm_open("dsvita_mem\0".as_ptr() as _, O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE) };
+        unsafe { shm_unlink("dsvita_mem\0".as_ptr() as _) };
+        if fd >= 0 {
+            if unsafe { ftruncate(fd, size as _) == 0 } {
+                Ok(ShmMem(fd))
+            } else {
+                unsafe { close(fd) };
+                Err(Error::from(ErrorKind::AddrNotAvailable))
+            }
+        } else {
+            Err(Error::from(ErrorKind::AddrNotAvailable))
+        }
+    }
+}
+
+impl Drop for ShmMem {
+    fn drop(&mut self) {
+        unsafe { close(self.0) };
+    }
+}
+
+pub struct VirtualMem {
+    ptr: *mut u8,
+    size: usize,
+}
+
+impl VirtualMem {
+    pub fn new(virtual_size: usize) -> io::Result<Self> {
+        let ptr = unsafe { mmap(ptr::null_mut(), virtual_size as _, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0) };
+        if ptr == MAP_FAILED {
+            Err(Error::from(ErrorKind::AddrNotAvailable))
+        } else {
+            Ok(VirtualMem { ptr: ptr as _, size: virtual_size })
+        }
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.ptr
+    }
+
+    pub fn as_ptr(&self) -> *const u8 {
+        self.ptr as _
+    }
+
+    pub fn len(&self) -> usize {
+        self.size as _
+    }
+
+    pub fn create_mapping(&mut self, shm_mem: &ShmMem, offset: usize, size: usize, start_addr: usize, end_addr: usize) -> io::Result<()> {
+        for addr_offset in (start_addr..end_addr).step_by(size) {
+            if unsafe { mmap(self.ptr.add(addr_offset) as _, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, shm_mem.0, offset as _) } == MAP_FAILED {
+                return Err(Error::from(ErrorKind::AddrNotAvailable));
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Drop for VirtualMem {
+    fn drop(&mut self) {
+        unsafe { munmap(self.ptr as _, self.size) };
+    }
+}
+
+impl Deref for VirtualMem {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { slice::from_raw_parts(self.as_ptr(), self.len()) }
+    }
+}
+
+impl DerefMut for VirtualMem {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len()) }
+    }
+}
+
+impl AsRef<[u8]> for VirtualMem {
+    fn as_ref(&self) -> &[u8] {
+        self.deref()
+    }
+}
+
+impl AsMut<[u8]> for VirtualMem {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.deref_mut()
+    }
+}