Zoxc

Remote procedure calls in Avery

Introduction

Avery's RPCs are based on capabilities. A capability is a reference to an object which the process has previously received. If you do not have a capability to an object, you cannot communicate with it.

You can do asynchronous calls to objects. These in calls, arguments and return values can contain both bytes and capabilities. If you send a capability to another process it gains access to it.

Objects belong to an event loop (a kernel object) and all messages sent to it is queued there.

Capability system

This is a sketch of a capability system which utilised data and operations in kernel mode.

There are 2 kernel objects used to support the capability system, Vat and Call. Cap is a global identifier of a capability consisting of a Vat reference and a vat defined number.

Messages

enum Message {

Start Date: 2014-07-22
RFC PR #: (leave this empty)
Rust Issue #: (leave this empty)

Summary

This adds the ability to have macros in type signatures.

Motivation

Start Date: 2014-07-21
RFC PR #: (leave this empty)
Rust Issue #: (leave this empty)

Summary

This adds the ability to refer to fields of types and use them later on with objects of that type. The FieldOffset<Obj, Field> type is added which refers to fields of type Field in the object Obj. The offsetof Type.field syntax is defined to construct instances of FieldOffset<Type, the type of field>.

	; ModuleID = '../../../../output-func.ll'
	source_filename = "rustc_mir.anxkd8ga-cgu.7"
	target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-pc-windows-msvc"

	; Function Attrs: nounwind uwtable
	define hidden fastcc void @_ZN5alloc5slice5merge17hae3c4424e1deafb6E([0 x i32]* nonnull align 4 %0, i64 %1, i64 %2, i32* %3) {
	%5 = shl i64 %2, 2
	%6 = bitcast i32* %3 to i8*
	%7 = bitcast i32* undef to i8*

	use std::cell::RefCell;
	use std::collections::HashSet;

	// This is the mapping of types in this model to types in rustc:
	// model => rustc
	// TyS<'a> => TyS<'tcx>
	// Ty<'a> => Ty<'tcx>
	// Arena => DroplessArena
	// Interner<'cx> => CtxtInterner<'tcx>
	// Ctxt<'a, 'gcx, 'lcx> => TyCtxt<'a, 'gcx, 'tcx>


	// A function pointer and some data to pass to the callback
	pub struct Callback<R> {
	pointer: fn (R, *const ()),
	data: *const (),
	}

	// This is the trait implemented for generators
	pub trait Future {
	type Return;

	All code is shared between processes. Processes can not read or write to the code segment.

	The global code segment is 2 TB. It is split into 1MB blocks, giving 2M blocks in total.

	A module is a executable or shared library.

	Each process has an bitmap where each bit represents a block of code of the code segment.
	With 1 bit per block means the size of the array is 256KB.
	If a bit is 0, the process does not have access to the block in the code segment.

	; ModuleID = 'bugpoint-reduced-simplified.bc'
	target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-unknown-linux-gnu"

	; Function Attrs: noreturn
	declare void @fail()

	declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...)

	define void @test() {

	; ModuleID = 'nicer.ll'
	target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-unknown-linux-gnu"

	define i8 @test({ i8*, i64 } %arg, i64 %arg1) unnamed_addr {
	"the block":
	%tmp = extractvalue { i8*, i64 } %arg, 1
	%tmp2 = icmp ugt i64 %tmp, %arg1
	br i1 %tmp2, label %exit, label %cond.i