int main(int arc, char *argv[])
{
dispatcher_t *dispatcher;
database_t *db;
char *socket;
bool debug;
char *uri;
int timeout, threads;
library_init(NULL);
if (!lib->plugins->load(lib->plugins, NULL,
lib->settings->get_str(lib->settings, "medsrv.load", PLUGINS)))
{
return 1;
}
socket = lib->settings->get_str(lib->settings, "medsrv.socket", NULL);
debug = lib->settings->get_bool(lib->settings, "medsrv.debug", FALSE);
timeout = lib->settings->get_time(lib->settings, "medsrv.timeout", 900);
threads = lib->settings->get_int(lib->settings, "medsrv.threads", 5);
uri = lib->settings->get_str(lib->settings, "medsrv.database", NULL);
if (uri == NULL)
{
fprintf(stderr, "database URI medsrv.database not defined.\n");
return 1;
}
db = lib->db->create(lib->db, uri);
if (db == NULL)
{
fprintf(stderr, "opening database failed.\n");
return 1;
}
dispatcher = dispatcher_create(socket, debug, timeout,
(context_constructor_t)user_create, db);
dispatcher->add_filter(dispatcher,
(filter_constructor_t)auth_filter_create, db);
dispatcher->add_controller(dispatcher,
(controller_constructor_t)user_controller_create, db);
dispatcher->add_controller(dispatcher,
(controller_constructor_t)peer_controller_create, db);
dispatcher->run(dispatcher, threads);
dispatcher->waitsignal(dispatcher);
dispatcher->destroy(dispatcher);
db->destroy(db);
library_deinit();
return 0;
}
/**
* \brief Setup an initial cspace
*
* Create an initial cspace layout
*/
static errval_t spawn_setup_cspace(struct spawninfo *si)
{
errval_t err;
struct capref t1;
/* Create root CNode */
err = cnode_create(&si->rootcn_cap, &si->rootcn, DEFAULT_CNODE_SLOTS, NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_ROOTCN);
}
/* Create taskcn */
err = cnode_create(&si->taskcn_cap, &si->taskcn, DEFAULT_CNODE_SLOTS, NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_TASKCN);
}
// Mint into rootcn setting the guard
t1.cnode = si->rootcn;
t1.slot = ROOTCN_SLOT_TASKCN;
err = cap_mint(t1, si->taskcn_cap, 0,
GUARD_REMAINDER(2 * DEFAULT_CNODE_BITS));
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_MINT_TASKCN);
}
/* Create slot_alloc_cnode */
t1.cnode = si->rootcn;
t1.slot = ROOTCN_SLOT_SLOT_ALLOC0;
err = cnode_create_raw(t1, NULL, (1<<SLOT_ALLOC_CNODE_BITS), NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_SLOTALLOC_CNODE);
}
t1.cnode = si->rootcn;
t1.slot = ROOTCN_SLOT_SLOT_ALLOC1;
err = cnode_create_raw(t1, NULL, (1<<SLOT_ALLOC_CNODE_BITS), NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_SLOTALLOC_CNODE);
}
t1.cnode = si->rootcn;
t1.slot = ROOTCN_SLOT_SLOT_ALLOC2;
err = cnode_create_raw(t1, NULL, (1<<SLOT_ALLOC_CNODE_BITS), NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_SLOTALLOC_CNODE);
}
// Create DCB
si->dcb.cnode = si->taskcn;
si->dcb.slot = TASKCN_SLOT_DISPATCHER;
err = dispatcher_create(si->dcb);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_DISPATCHER);
}
// Give domain endpoint to itself (in taskcn)
struct capref selfep = {
.cnode = si->taskcn,
.slot = TASKCN_SLOT_SELFEP,
};
err = cap_retype(selfep, si->dcb, ObjType_EndPoint, 0);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_SELFEP);
}
// Map root CNode (in taskcn)
t1.cnode = si->taskcn;
t1.slot = TASKCN_SLOT_ROOTCN;
err = cap_mint(t1, si->rootcn_cap, 0, 0);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_MINT_ROOTCN);
}
#ifdef TRACING_EXISTS
// Set up tracing for the child
err = trace_setup_child(si->taskcn, si->handle);
if (err_is_fail(err)) {
printf("Warning: error setting up tracing for child domain\n");
// SYS_DEBUG(err, ...);
}
#endif
// XXX: copy over argspg?
memset(&si->argspg, 0, sizeof(si->argspg));
/* Fill up basecn */
struct capref basecn_cap;
struct cnoderef basecn;
// Create basecn in rootcn
basecn_cap.cnode = si->rootcn;
basecn_cap.slot = ROOTCN_SLOT_BASE_PAGE_CN;
err = cnode_create_raw(basecn_cap, &basecn, DEFAULT_CNODE_SLOTS, NULL);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_CNODE_CREATE);
}
// Place the ram caps
for (uint8_t i = 0; i < DEFAULT_CNODE_SLOTS; i++) {
struct capref base = {
.cnode = basecn,
.slot = i
};
struct capref ram;
err = ram_alloc(&ram, BASE_PAGE_BITS);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_RAM_ALLOC);
}
err = cap_copy(base, ram);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_CAP_COPY);
}
err = cap_destroy(ram);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_CAP_DESTROY);
}
}
return SYS_ERR_OK;
}
static errval_t spawn_setup_vspace(struct spawninfo *si)
{
errval_t err;
/* Create pagecn */
si->pagecn_cap = (struct capref){.cnode = si->rootcn, .slot = ROOTCN_SLOT_PAGECN};
err = cnode_create_raw(si->pagecn_cap, &si->pagecn, PAGE_CNODE_SLOTS, NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_PAGECN);
}
/* Init pagecn's slot allocator */
// XXX: satisfy a peculiarity of the single_slot_alloc_init_raw API
size_t bufsize = SINGLE_SLOT_ALLOC_BUFLEN(PAGE_CNODE_SLOTS);
void *buf = malloc(bufsize);
assert(buf != NULL);
err = single_slot_alloc_init_raw(&si->pagecn_slot_alloc, si->pagecn_cap,
si->pagecn, PAGE_CNODE_SLOTS,
buf, bufsize);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
}
// Create root of pagetable
err = si->pagecn_slot_alloc.a.alloc(&si->pagecn_slot_alloc.a, &si->vtree);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_SLOT_ALLOC);
}
// top-level table should always live in slot 0 of pagecn
assert(si->vtree.slot == 0);
switch(si->cpu_type) {
case CPU_X86_64:
case CPU_K1OM:
err = vnode_create(si->vtree, ObjType_VNode_x86_64_pml4);
break;
case CPU_X86_32:
case CPU_SCC:
#ifdef CONFIG_PAE
err = vnode_create(si->vtree, ObjType_VNode_x86_32_pdpt);
#else
err = vnode_create(si->vtree, ObjType_VNode_x86_32_pdir);
#endif
break;
case CPU_ARM5:
case CPU_ARM7:
err = vnode_create(si->vtree, ObjType_VNode_ARM_l1);
break;
default:
assert(!"Other architecture");
return err_push(err, SPAWN_ERR_UNKNOWN_TARGET_ARCH);
}
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_CREATE_VNODE);
}
err = spawn_vspace_init(si, si->vtree, si->cpu_type);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_VSPACE_INIT);
}
return SYS_ERR_OK;
}
#if 0
/**
* \brief Lookup and map an image
*/
static errval_t spawn_map(const char *name, struct bootinfo *bi,
lvaddr_t *binary, size_t *binary_size)
{
errval_t err;
/* Get the module from the multiboot */
struct mem_region *module = multiboot_find_module(bi, name);
if (module == NULL) {
return SPAWN_ERR_FIND_MODULE;
}
/* Map the image */
err = spawn_map_module(module, binary_size, binary, NULL);
if (err_is_fail(err)) {
return err_push(err, SPAWN_ERR_MAP_MODULE);
}
return SYS_ERR_OK;
}
