README

mirage-vnetif -- Virtual network interface and software switch for Mirage

Provides the moduleVnetif which can be used as a replacement for the regularNetif implementation in Xen and Unix. Stacks built usingVnetif are connected to a software switch that allows the stacks to communicate as if they were connected to the same LAN.

An example of a unikernel that communicates with itself overVnetif can be seenhere. An iperf-like performance test is availablehere. The examples can be compiled for Unix and Xen and do not need access to a real network interface.

Install

opam install mirage-vnetif

Getting started

First, construct a TCP/IP stack based onvnetif:

  module S = struct    module B = Basic_backend.Make    module V = Vnetif.Make(B)    module E = Ethif.Make(V)    module I = Ipv4.Make(E)(Clock)(OS.Time)    module U = Udp.Make(I)    module T = Tcp.Flow.Make(I)(OS.Time)(Clock)(Random)    module S = Tcpip_stack_direct.Make(C)(OS.Time)(Random)(V)(E)(I)(U)(T)    include S  end

Since we don't have the mirage-tool to help us we have to construct the stack manually. This code would usually be generated inmain.ml bymirage configure --xen/unix.

let or_error name fn t =    fn t    >>= function        | `Error e -> fail (Failure ("Error starting " ^ name))        | `Ok t -> return t let create_stack c backend ip netmask gw =    or_error "backend" S.V.connect backend >>= fun netif ->    or_error "ethif" S.E.connect netif >>= fun ethif ->    or_error "ipv4" S.I.connect ethif >>= fun ipv4 ->    or_error "udpv4" S.U.connect ipv4 >>= fun udpv4 ->    or_error "tcpv4" S.T.connect ipv4 >>= fun tcpv4 ->    let config = {        Mirage_types_lwt.name = "stack";        Mirage_types_lwt.console = c;         Mirage_types_lwt.interface = netif;        Mirage_types_lwt.mode = `IPv4 (ip, netmask, gw);    } in    or_error "stack" (S.connect config ethif ipv4 udpv4) tcpv4

We can now create multiple stacks that talk over the same backend.Basic_backend.create accepts two optional parameters:

• use_async_readers makes thewrite calls non-blocking. This is necessary to use Vnetif with the Mirage TCP/IP stack.

• yield specifies the yield function to use in non-blocking mode. In a unikernel this is typicallyOS.Time.sleep 0.0, but in a Unix processLwt_main.yield () can be used instead.

let () =    (* create async backend with OS.Time.sleep 0.0 as yield *)    let backend = Basic_backend.create ~use_async_readers:true         ~yield:(fun() -> OS.Time.sleep 0.0 ) () in    let netmask = Ipaddr.V4.of_string_exn "255.255.255.0"  in    let gw = Ipaddr.V4.of_string_exn "10.0.0.1" in    let server_ip = Ipaddr.V4.of_string_exn "10.0.0.100" in    create_stack c backend server_ip netmask [gw] >>= fun server_stack ->    let client_ip = Ipaddr.V4.of_string_exn "10.0.0.101" in    create_stack c backend server_ip netmask [gw] >>= fun client_stack ->

The stacks can now be used as regular Mirage TCP/IP stacks, e.g.:

S.listen_tcpv4 server_stack ~port:80 (fun f -> ...);S.listen s1

Build examples

mirage configure --xen/--unixmake

1. logs
2. duration
3. macaddr
4. ipaddr>= "3.0.0"
5. cstruct>= "6.0.0"
6. mirage-net>= "3.0.0"
7. lwt
8. dune>= "1.9"
9. ocaml>= "4.08.0"

None

1. arp>= "2.3.1"
2. arp-mirage
3. capnp-rpc-mirage
4. mirage-vnetif-stack>= "0.6.2"
5. tcpip< "4.0.0" | = "5.0.1" | >= "8.1.0"
6. vpnkit

1. result< "1.5"