Getting Started with Genode

[Sid Agrawal]

Hi Genodians,
I am a graduate student at the University of British Columbia with
their Systopia
Lab <http://systopia.cs.ubc.ca/>. My research area is operating systems,
and I would like to use Genode(with seL4) as the OS platform for
demonstrating my research ideas. As with starting with a new platform I
have run into some hurdles. At the end I have given a summary of my
research project, which is still in a nascent stage.


   - *Running the hello_tutorial*: the hello_tutorial job on qemu does not
   finish to completing and times out. Below are my steps on ubuntu 20.04.1. I
   am using the Genode development container
   <https://genodians.org/skalk/2020-09-29-docker-devel>, so the tools
   should not an issue. I also tried it outside the container.

git clone git://github.com/genodelabs/genode.git
cd genode
tool/ports/prepare_port sel4
tool/ports/prepare_port grub2
tool/create_builddir x86_64

cd x86_64/build/
# Change build/x86_64/etc/build.conf.
# Change kernel to sel4 and add hello_tutorial
diff etc/build.conf.old etc/build.conf

20c20

< #KERNEL ?= nova

---

> KERNEL ?= sel4

85a86

> REPOSITORIES += $(GENODE_DIR)/repos/hello_tutorial

make
make hello
make run/hello # This times out as shown below.

[init -> hello_server] creating root component [0m [0m
[init -> hello_client] upgrading quota donation for PD session (0
bytes, 4 caps)
[0m [0m
[init] child "hello_server" requests resources: cap_quota=3 [0m [0m
[init] child "hello_client" requests resources: ram_quota=0, cap_quota=4
[0m [0m
Error: Test execution timed out



Any comments on what I am doing wrong would be very helpful. Secondly, what
would be the best way to go about debugging an issue like this.


   - Summary of my research project
   <https://sid-agrawal.ca/index.html#research-projects> on building "General
   Purpose Isolation Mechanisms".

After sixty years of operating system evolution, we continue to find new
and different isolation mechanisms: threads, processes, containers, virtual
machines, lightweight contexts. Even applications provide isolation
mechanisms: a JVM is a user-level process that provides isolation units
whose API is Java bytecodes; some browsers offer units of isolation between
each browser tab.

We ask whether we really need to have N different isolation mechanisms or,
instead, we could develop a framework in which all these different
mechanisms represent points on a continuum. If we could do that, then
perhaps A) we could implement such a unified framework, and B) the
framework might allow us to discover new and useful isolation mechanisms
(that could be created seamlessly rather than requiring an entirely new
implementation).

The project has three main goals:


   - Develop a theoretical model or framework to unify existing isolation
      mechanisms.
      - Identify novel points in the model that are useful.
      - Implement the model in seL4.

The Fig below shows how different access and isolation levels of memory can
be used to construct different types of PD. The points along the Y-axis are
building blocks of memory isolation. The points on the X-axis are different
types of PD. A given PD can be constructed using different building
blocks, which
are represented as circles that intersect one or more blocks. Mapping these
concepts to Genode,

This is an evolving model, as we are still investigating:


   - If the "Security and Performance Guarantees" across any two types of
      PD can be compared.
      - Should there be more building blocks on the Y-axis
      - What novel types of PD can we come up by combining the different
      building blocks

[image: image]


I am excited about building my project with Genode, the composability in
its architecture make it well suited as platform to show unconventional OS
ideas.

Best,
Sid
sid-agrawal.ca
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.genode.org/pipermail/users/attachments/20210922/343f70e8/attachment.html>