System Calls and Interprocess Communication

Interprocess communication (IPC) is presumably initiated by a syscall operation.

According to the course materials, there is only one meaningful system call (invoke_object):

Microkernel-based Operating Systems - Introduction

(See page 24 in the above.)

Instances of syscall

In L4Re, syscall operations appear to occur in the following place:

• pkg/l4re-core/l4sys/include/ARCH-mips/L4API-l4f/ipc.h

In this file, the l4_ipc function employs registers as follows:

• s0 = caller UTCB
• s1 = destination object | invocation flags
• s2 = timeout
• s3 = send descriptor -> receive descriptor (tag)
• s4 = send label -> receive label

Related Specifications

In the L4 X.2 (MIPS64) and V2/MIPS specifications, the IPC description appears to employ registers differently, with s0...s7 corresponding to virtual message registers. Here, some details of V2/MIPS are omitted:

Here, the X.2 register usage for a0 and a1 has been interpreted and hopefully translated correctly to some common terminology. See Kernel for more details regarding Fiasco.OC.

Other Instances

There are also syscall operations in other places within the following location:

• pkg/l4re-core/uclibc/lib/contrib/uclibc

Within this location, the following files appear interesting:

• pkg/l4re-core/uclibc/lib/contrib/uclibc/libc/sysdeps/linux/mips/bits/syscalls.h
• pkg/l4re-core/uclibc/lib/contrib/uclibc/libc/sysdeps/linux/mips/syscall.S

However, it doesn't seem clear if they are actually used, especially in the light of the assertion about system call usage.

The following file seems to list symbols provided by uclibc for L4:

• pkg/l4re-core/uclibc/lib/uclibc/ARCH-all/include/bits/l4-libc-symbols.h

l4_ipc

l4_ipc is wrapped by a family of other functions:

• l4_ipc_call
• l4_ipc_reply_and_wait
• l4_ipc_send_and_wait
• l4_ipc_send
• l4_ipc_wait
• l4_ipc_receive

A simple example of IPC is provided by l4_usleep and l4_sleep:

• pkg/l4re-core/l4util/lib/src/sleep.c

The l4_sleep function just calls l4_ipc_receive with a timeout. Similarly, the l4_usleep function calls l4_ipc_sleep whose definition is provided elsewhere:

• pkg/l4re-core/l4sys/include/ipc.h

l4_ipc_sleep then calls l4_ipc_receive with a timeout.

Such functions are exposed by C library functions such as usleep:

• pkg/l4re-core/libc_backends/lib/l4re/lib/usleep.c

So, such C library functions call into the l4-prefixed functions which in turn ultimately call the l4_ipc function.

Kernel

IPC syscalls enter the kernel in the following place:

• kernel/fiasco/src/kern/mips/exception.S

Specifically, the syscall entry point is involved. It invokes the sys_ipc_wrapper function, which is found here:

• kernel/fiasco/src/kern/syscalls.cpp

This function dereferences the object reference (capability), and on the object supporting the appropriate interface (Kobject_iface), the invoke method is called:

• kernel/fiasco/src/kern/kobject_helper.cpp

The portion of the saved registers referencing s0 is reinterpreted as a Syscall_frame instance:

• kernel/fiasco/src/kern/mips/entry_frame-mips.cpp

Thus, an abstraction for the s0...s4 registers is employed, being presented to invoke and used in an invocation of a kinvoke method. For IPCs this is presumably supported in the Ipc_gate_ctl class:

• kernel/fiasco/src/kern/ipc_gate.cpp

Thus resulting in an invocation of kobject_invoke and, within this, commit_result:

• kernel/fiasco/src/kern/kobject.cpp
• kernel/fiasco/src/kern/kobject_iface.cpp

With a L4_msg_tag instance being created and returned:

• kernel/fiasco/src/abi/l4_types.cpp

Back in the invoke method, this new tag is set in the Syscall_frame instance.

Protocols

pkg/l4re-core/l4sys/include/types.h

Dispatch

There presumably has to be the registration of a kernel object to accept IPC calls. A reference to such an object - a capability - must be presented to any caller. Then, any IPC call, directed via the capability, will be conveyed by the kernel mechanisms and presented to the recipient.

pkg/l4re-core/l4sys/include/factory.h