feat: import @hargonix hardware diff

README.md

@@ -7,71 +7,47 @@ efficiently develop Rust clients and servers running on top of a highly
 configurable, secure and performant OS. Rust services and clients can
 communicate without adaptation with C++ server and clients from L4Re.
 
-Suggestions, criticism and everything else is welcome, contact me on IRC as
-Moomoc in the Mozilla, Freenode or OFTC network.
-
 L4Re Setup
 ----------
 
 This is better explained in [RL4Re's README](EADME.l4re), but in short you need
-(GNU) make, gcc, libgcc, bison and flex. Execute `make setup` and `make -j4`
+(GNU) make, gcc, libgcc, bison and flex. Execute `make setup` and `make -j8`
 afterwards. If compilation aborts with "failed to build l4linux", you
 successfully build everything except l4linux which isn't required.
 
 This L4Re snapshot needs to reside in a path without any spaces, thanks to Makes
 inability to treat those appropriately. Enter the L4Re source tree root and type
-`make ssetup` to choose the build target. Then type make, followed by half a
+`make setup` to choose the build target. Then type make, followed by half a
 dozen tea breaks.
 
-Now you need to configure the object directory for your build. Open a new file
-called `obj/l4/amd64/conf/Makeconf.local` and specify the object directory; substitute
-amd64 through the chosen architecture. Assuming you are
-on `x86_64` (AKA amd64) and the source tree is below `/home/user/l4re`, the
-content might look like this:
-
-    OBJ_BASE=/home/USER/rustl4re/obj/l4/amd64
-
 Rust Compilation
 ----------------
 
 Rust doesn't ship binary versions of the cross-compiled `std` crate. There is
 also a minor deficiency in passing linker arguments containing spaces, so you
 need a slightly patched Rust compiler yourself. Grab the source from
-<https://github.com/humenda/rust> and follow these steps:
+<https://github.com/hargonix/rust/tree/l4re_fix> (this is in the process of getting upstreamed)
+and follow these steps:
 
 -   Create a file `config.toml` in the repository root with this content:
-
-    ````
-    [llvm]
-    optimize = true
-    [build]
-    build = "x86_64-unknown-linux-gnu"    # defaults to your host platform
-    target = ["x86_64-unknown-l4re-uclibc"] # defaults to just the build triple
-    docs = false
-    [install]
-    prefix = '/your/preferred/path'
-    [rust]
-    optimize = true
-    use-jemalloc = false
-    backtrace = false
-
-    You should adjust both prefix and potentially the `build =`-line, if you
-    don't use Linux on a `x86_64` machine.
--   For building Rust with std:
-
-    $ python3 x.py --host=x86_64-unknown-linux-gnu --target=x86_64-unknown-l4re-uclibc
-
+```
+changelog-seen = 2
+[build]
+build = "x86_64-unknown-linux-gnu"
+# We need both linux and l4re because we have build.rs scripts in our libraries
+target = ["x86_64-unknown-l4re-uclibc", "x86_64-unknown-linux-gnu"]
+docs = false
+extended = true
+[install]
+prefix = '/your/prefix/path'
+[rust]
+optimize = true
+jemalloc = false
+backtrace = false
+```
+- `$ python3 x.py build && python3 x.py install`
+- `$ rustup toolchain link l4re /your/prefix/path`
+- `$ rustup default l4re`
 
 Then you can proceed to building the L4Re source tree, see the linked
 instructions above or with hacking, see below.
-
-Branch setup
-------------
-
-The branch `upstream` contains the original L4Re snapshot. The patches to the
-build system BID are in `bid_changes` which is rebased on upstream if a new
-version comes out. `master` is based on bid_changes and contains all the library
-implementation of `l4rust` and a few sample applications, see `pkg/l4rust` and `pkg/oxisamples`. 
-
-The branch `bench` contains some hackish benchmarking applications. These are
-are not guaranteed to run in all environments, patches welcome.

src/l4/conf/modules.list

@@ -213,3 +213,13 @@ module[arch=arm64,fname=linux]            https://l4re.org/download/Linux-kernel
 module[arch=arm,fname=ramdisk-arm.rd]     https://os.inf.tu-dresden.de/~adam/dl/ramdisks/ramdisk-armv7.rd
 module[arch=arm64,fname=ramdisk-arm64.rd] https://os.inf.tu-dresden.de/~adam/dl/ramdisks/ramdisk-armv8-64.rd
 # TODO: Add x86 and MIPS
+
+entry verix
+kernel fiasco -serial_esc -esc
+roottask moe rom/verix.ned
+module l4re
+module ned
+module verix
+module verix.ned
+module nic.vbus
+module io

src/l4/conf/nic.vbus

@@ -0,0 +1,10 @@
+Io.add_vbusses
+{
+  nic = Io.Vi.System_bus(function ()
+    Property.num_msis = 20;
+    PCI0 = Io.Vi.PCI_bus(function ()
+      pci_nic = wrap(Io.system_bus():match("PCI/VEN_8086&DEV_10fb"));
+    end);
+  end);
+};
+

src/l4/conf/verix.ned

@@ -0,0 +1,42 @@
+package.path = "rom/?.lua";
+
+local L4 = require "L4";
+local l = L4.default_loader;
+
+local busses = {
+  nic = 1,
+}
+
+local io_caps = {
+  sigma0 = L4.cast(L4.Proto.Factory, L4.Env.sigma0):create(L4.Proto.Sigma0);
+  icu    = L4.Env.icu;
+  iommu = L4.Env.iommu;
+};
+
+local files = "";
+
+for k, v in pairs(busses) do
+  local c = l:new_channel();
+  busses[k] = c
+  io_caps[k] = c:svr();
+  files = files .. " rom/" .. k .. ".vbus";
+end
+
+l:start({
+  log = { "io", "red" },
+  caps = io_caps
+}, "rom/io " .. "-vvvvv" .. files);
+
+
+l:start(
+  {
+    log = { "verix", "blue" },
+    caps =
+      {
+        vbus = busses.nic,
+        jdb = L4.Env.jdb,
+      },
+  },
+  "rom/verix"
+);
+

src/l4/pkg/io/libvbus/include/vbus_interfaces.h

@@ -28,15 +28,15 @@
  * the type of the device, i.e. from the point of view of the client
  * a device is defined by the kinds of sub-interfaces it supports.
  */
-enum l4vbus_iface_type_t {
+typedef enum {
   L4VBUS_INTERFACE_ICU = 0,
   L4VBUS_INTERFACE_GPIO,
   L4VBUS_INTERFACE_PCI,
   L4VBUS_INTERFACE_PCIDEV,
   L4VBUS_INTERFACE_PM,
   L4VBUS_INTERFACE_BUS,
   L4VBUS_INTERFACE_GENERIC = 0x20
-};
+} l4vbus_iface_type_t;
 
 
 enum {

src/l4/pkg/l4rust/l4-rust/cap.rs

@@ -95,6 +95,12 @@ impl<T: Interface + IfaceInit> Cap<T> {
 }
 
 impl<T: Interface> Cap<T> {
+    pub fn from_raw(val : T) -> Cap<T> {
+        Cap {
+            interface: val
+        }
+    }
+
     pub fn cast<U: Interface + IfaceInit>(self) -> Cap<U> {
         Cap {
             interface: U::new(self.raw()),

src/l4/pkg/l4rust/l4-rust/ipc/mod.rs

@@ -25,11 +25,12 @@ pub use self::types::*;
 pub use syscall::*;
 
 use core::{convert::From, mem::transmute};
-use l4_sys::{l4_msgtag_flags::*, l4_msgtag_t, msgtag};
+use l4_sys::{l4_msgtag_flags::*, l4_msgtag_t, l4_timeout_t, l4_ipc_error, msgtag};
 use num_traits::FromPrimitive;
 
 use crate::error::{Error, Result};
 use crate::types::{Mword, Protocol, UMword};
+use crate::utcb::Utcb;
 
 use l4_sys;
 
@@ -186,11 +187,17 @@ impl MsgTag {
     }
 
     #[inline]
-    pub fn raw(self) -> l4_msgtag_t {
+    pub fn raw(&self) -> l4_msgtag_t {
         ::l4_sys::l4_msgtag_t {
             raw: self.raw as i64,
         }
     }
+
+    #[inline]
+    pub fn has_ipc_error(&self) -> bool {
+        let err = unsafe { l4_ipc_error(self.raw(), Utcb::current().raw) };
+        err != 0
+    }
 }
 
 impl From<l4_msgtag_t> for MsgTag {

src/l4/pkg/l4rust/l4-sys-rust/Control

@@ -1,3 +1,3 @@
 provides: l4-sys-rust
-requires: l4sys libpthread libl4re-wrapper
+requires: l4sys libpthread libl4re-wrapper libio libio-vbus
 Maintainer: [email protected]

src/l4/pkg/l4rust/l4-sys-rust/Makefile

@@ -5,5 +5,5 @@ TARGET  		= libl4_sys-rust.rlib
 SRC_RS   		= lib.rs
 
 DEPENDS_PKGS    = l4sys
-REQUIRES_LIBS   = l4sys libl4re-wrapper
+REQUIRES_LIBS   = l4sys libl4re-wrapper libio libio-vbus
 include $(L4DIR)/mk/lib.mk

src/l4/pkg/l4rust/l4-sys-rust/bindgen.h

@@ -8,9 +8,15 @@
 #include <l4/re/c/util/cap_alloc.h>
 #include <l4/re/env.h>
 #include <pthread-l4.h>
+#include <l4/vbus/vbus.h>
+#include <l4/vbus/vbus_pci.h>
+#include <l4/sys/icu.h>
+#include <l4/sys/irq.h>
 
 // custom wrapper to make inlined C functions visible
 #include <l4/l4rust/ipc.h>
 #include <l4/l4rust/env.h>
 #include <l4/l4rust/scheduler.h>
-
+#include <l4/l4rust/icu.h>
+#include <l4/l4rust/irq.h>
+#include <l4/l4rust/fpage.h>

src/l4/pkg/l4rust/l4-sys-rust/build.rs

@@ -11,7 +11,9 @@ fn main() {
         .blocklist_type("strtod")
         .blocklist_type("max_align_t")
         .blocklist_file(".*/stdlib.h")
-        .ctypes_prefix("core::ffi");
+        .ctypes_prefix("core::ffi")
+        .blocklist_type("l4_addr_t")
+        .ctypes_prefix("::libc");
     if let Ok(include_dirs) = ::std::env::var("L4_INCLUDE_DIRS") {
         for item in include_dirs.split(" ") {
             bindings = bindings.clang_arg(item);

src/l4/pkg/l4rust/l4re-rust/Cargo.toml

@@ -15,5 +15,12 @@ path = "../l4-rust"
 # ToDo: make this conditional
 default-features = false
 
+[dependencies.l4_sys]
+path = "../l4-sys-rust"
+
 [dependencies.l4_derive]
 path = "../l4_derive-rust"
+
+[dependencies.bitflags]
+version = "1.0"
+default-features = false

src/l4/pkg/l4rust/l4re-rust/bindgen.h

@@ -3,6 +3,10 @@
 #include <l4/re/c/mem_alloc.h>
 #include <l4/re/c/rm.h>
 #include <l4/re/c/util/cap_alloc.h>
+#include <l4/re/c/dma_space.h>
 #include <l4/re/protocols.h>
+#include <l4/io/io.h>
+#include <l4/io/types.h>
 #include <l4/l4rust/env.h>
 #include <l4/l4rust/mem.h>
+#include <l4/l4rust/vbus.h>

src/l4/pkg/l4rust/l4re-rust/cap.rs

@@ -1,13 +1,13 @@
 use core::ops::{Deref, DerefMut};
 
 use l4::{
-    cap::{Cap, IfaceInit},
+    cap::{Cap, IfaceInit, Interface},
     error::{Error, Result},
 };
 
 use crate::sys;
 
-pub struct OwnedCap<T: IfaceInit>(Cap<T>);
+pub struct OwnedCap<T: Interface>(pub(crate) Cap<T>);
 
 impl<T: IfaceInit> OwnedCap<T> {
     /// Allocate new capability slot
@@ -32,20 +32,20 @@ impl<T: IfaceInit> OwnedCap<T> {
     }
 }
 
-impl<T: IfaceInit> Deref for OwnedCap<T> {
+impl<T: Interface> Deref for OwnedCap<T> {
     type Target = Cap<T>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl<T: IfaceInit> DerefMut for OwnedCap<T> {
+impl<T: Interface> DerefMut for OwnedCap<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
-impl<T: IfaceInit> Drop for OwnedCap<T> {
+impl<T: Interface> Drop for OwnedCap<T> {
     fn drop(&mut self) {
         unsafe {
             // free allocated capability index