GitLab

Documentation in Documentation/lcd-domains/...

Loading, mapping, and running a module is working correctly, using
all of the capability code that interposes on each operation (mapping,
freeing pages, etc.).

cptr allocation and indexing into cspaces is working correctly.

IPC testing and debugging is coming next.

Builds, but not fully tested. Good tests for capability subsystem, some tests
for kliblcd.

Non-isolated kernel threads can "enter" the lcd system by doing
klcd_enter / klcd_exit. They can create other lcd's, set them up, etc. They
use the same interface that regular lcd's will use, so such code could be
moved to an lcd, as we had planned. Will document this in Documentation folder
tomorrow ( == today ).

Capability system does checks now when a capability is deleted/revoked: for
example, if it's for a page, the microkernel checks if the page is mapped, and
unmaps it. If the last capability goes away, the page is freed. Documentation
is in Documentation/lcd-domains/cap.txt.

IPC code is in place, but not tested yet (pray for me).

Debug is taking some time. Sometimes requires a power cycle which adds an
extra 5 - 10 minutes. Build is slow the first time after reboot. Give me a user
level program and I'll debug it in 30 seconds! argc

Main arch-independent files:

    include/lcd-domains/kliblcd.h, types.h

       This is what non-isolated kernel code should include to use the
       kliblcd interface to the microkernel.

    virt/lcd-domains/main.c, kliblcd.c, cap.c, ipc.c, internal.h

       The microkernel, broken up into pieces.

    virt/lcd-domains/tests/

       The tests, in progress.

Some old files are still hanging around in virt/lcd-domains and will be
incorprated/cleaned up soon.

I couldn't squash over the merge from the decomposition branch, so there's a
bunch of junk commits coming over. (I should've just copied Muktesh's files.)

Conflicts:
	drivers/Kconfig
	drivers/lcd-cspace/test.h
	include/lcd-domains/cap.h
	include/lcd-prototype/lcd.h
	include/lcd/console.h
	include/lcd/elfnote.h
	include/linux/init_task.h
	include/linux/module.h
	include/linux/sched.h
	virt/lcd-domains/cap.c
	virt/lcd-domains/ipc.c
	virt/lcd-domains/lcd-cspace-tests2.c
Resolved-by: Vikram Narayanan <vikram186@gmail.com>

In line with more recent design discussions, we now have (limited)
support for running multiple threads inside an lcd.

Each thread will have its own hardware vm, but share a guest
physical address space and cspace.

It's limited for now because threads cannot handle interrupts/exceptions
internally in the lcd. This will require a per-thread TSS (much like
Linux's per-core TSS/interrupt stack). I removed the gdt/idt/tss for
now (Cf. with Dune, they don't use gdt/idt/tss) and will tackle that later
after finishing more important stuff.

I have only tested the code for running one hardware vm inside an lcd. Some
code is missing proper locking for the future when we have multiple threads
inside an lcd. I'm leaving this for now.

The microkernel uses a simple bitmap for guest physical page allocation.

Removed blob loading - code is set up for running modules exclusively.

See the headers and Documentation/lcd-domains for more info.

I put a flag at the top of files that are not currently in use, and will
probably be deleted/incorporated later.

Updated code. Removed gdt/tss/idt for now. Added doc directory
and some initial doc.