/**
* \brief Called when the "client" connects to "server"
*
* Make the connection a "server" connection, free unnecessary state.
* Send init msg to the dispatcher that spanned this dispatcher.
*/
static void client_connected(void *st, errval_t err,
struct interdisp_binding *b)
{
struct remote_core_state *state = (struct remote_core_state*)st;
struct domain_state *domain_state = get_domain_state();
if(err_is_fail(err)) {
DEBUG_ERR(err, "binding to interdisp service");
abort();
}
/* Set it on the domain library state */
b->rx_vtbl = interdisp_vtbl;
domain_state->b[state->cnt] = b;
// Send it our core id
err = b->tx_vtbl.span_eager_connect(b, NOP_CONT, disp_get_core_id());
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "sending span_eager_connect");
}
// Connect to next active dispatcher
do {
state->cnt++;
if(state->cnt == disp_get_core_id()) {
state->cnt++;
}
} while(allirefs[state->cnt] == NULL_IREF && state->cnt < MAX_CPUS);
if(state->cnt < MAX_CPUS) {
err = interdisp_bind(allirefs[state->cnt], client_connected,
state, &domain_state->interdisp_ws,
IDC_BIND_FLAGS_DEFAULT);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "Binding to inter-dispatcher service");
}
} else {
struct interdisp_binding *sb = domain_state->b[state->core_id];
/* Send initialized msg to the dispatcher that spanned us */
errval_t err2 = sb->tx_vtbl.
dispatcher_initialized(sb, NOP_CONT,
(uintptr_t)state->span_domain_state);
if (err_is_fail(err2)) {
DEBUG_ERR(err, "failed to send initalized msg");
abort();
}
state->initialized = true;
}
}
static void client_connected(void *st, errval_t err, struct rcce_binding *b)
{
struct rcce_state *cs = st;
assert(err_is_ok(err));
/* printf("%s: Am connected to client\n", my_name); */
b->rx_vtbl = rcce_vtbl;
b->st = cs;
// Create a Frame Capability
size_t allocated_size;
struct capref shared_mem;
#ifdef __scc__
ram_set_affinity(SHARED_MEM_MIN + (PERCORE_MEM_SIZE * disp_get_core_id()),
SHARED_MEM_MIN + (PERCORE_MEM_SIZE * (disp_get_core_id() + 1)));
#endif
errval_t r = frame_alloc(&shared_mem, BULK_SIZE * 2, &allocated_size);
assert(err_is_ok(r));
#ifdef __scc__
ram_set_affinity(0, 0);
#endif
// Map the frame in local memory
void *pool;
r = vspace_map_one_frame_attr(&pool, allocated_size, shared_mem,
BULK_PAGE_MAP, NULL, NULL);
assert(pool != NULL);
assert(err_is_ok(r));
assert(allocated_size >= BULK_SIZE * 2);
// Init sender
err = bulk_init(pool, BULK_SIZE, BLOCK_SIZE, &cs->bt);
assert(err_is_ok(err));
// Init receiver
err = bulk_slave_init(pool + BULK_SIZE, BULK_SIZE, &cs->btr);
assert(err_is_ok(err));
barrier_binding_init(b);
barray[cs->index] = b;
err = barray[cs->index]->tx_vtbl.init_request(barray[cs->index],
NOP_CONT, my_core_id, bsp_id,
(uint64_t)(uintptr_t)cs,
shared_mem);
assert(err_is_ok(err));
}
/** Work-stealing loop for workers */
static int worker_run (void * data) {
struct worker_args * args = (struct worker_args*) data;
int id = args->id;
errval_t err = thread_detach(thread_self());
assert(err_is_ok(err));
free(args);
workers[id].worker_thr = thread_self();
workers[id].id = id;
workers[id].core_id = disp_get_core_id();
struct generic_task_desc * _tweed_top_ = NULL;
thread_set_tls( &(workers[id]));
trace_init_disp();
num_dispatchers += 1;
// start trying to steal work
int steal_id = (id+1) % num_workers;
while(!do_quit) {
int success = steal(_tweed_top_, &workers[steal_id]);
if (!success) {
// try next worker
steal_id = (steal_id+1) % num_workers;
}
}
exit(0);
return 0;
}
static void dispatcher_initialized_handler(void *arg)
{
struct span_domain_state *span_domain_state = arg;
#if 0
struct domain_state *domain_state = get_domain_state();
// XXX: Tell currently active interdisp-threads to handle default waitset
for(int i = 0; i < MAX_CPUS; i++) {
struct interdisp_binding *b = domain_state->b[i];
if(disp_get_core_id() != i &&
span_domain_state->core_id != i && b != NULL) {
errval_t err = b->tx_vtbl.span_slave_done(b, NOP_CONT);
assert(err_is_ok(err));
}
}
#endif
/* Upcall into the domain_new_dispatcher callback if registered */
if (span_domain_state->callback) {
span_domain_state->callback(span_domain_state->callback_arg, SYS_ERR_OK);
}
free(span_domain_state);
}
int main(int argc, char **argv)
{
//this is the bootstrap copy of the domain
if (strcmp(argv[argc - 1], "SpAwNeD") != 0) {
bsp_datagatherer = true;
} else {
bsp_datagatherer = false;
}
core_id = disp_get_core_id();
skb_client_connect();
#ifdef SPAWN_YOUR_SELF
if (bsp_datagatherer) {
spawnmyself();
}
#endif
//gather different types of data
//run cpuid
gather_cpuid_data(core_id);
//get the number of running cores and their APIC IDs from the monitor
if (bsp_datagatherer) {
gather_nr_running_cores(get_monitor_binding());
} else {
nr_cores_done = true;
}
//adding the numer of cores is the last operation performed by the datagatherer.
//therefore the domain can exit after this. process events as long as the number
//of cores has not yet been added to the SKB.
struct waitset *ws = get_default_waitset();
while (!nr_cores_done) {
errval_t err = event_dispatch(ws);
if (err_is_fail(err)) {
DEBUG_ERR(err, "in event_dispatch");
break;
}
}
skb_add_fact("datagatherer_done.");
if (bsp_datagatherer) {
int length = nr_of_running_cores + 1;
while (length != nr_of_running_cores) {
skb_execute_query("findall(X, datagatherer_done, L),length(L,Len),write(Len).");
skb_read_output("%d", &length);
thread_yield();
}
errval_t err = nameservice_register("datagatherer_done", 0);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
}
}
return 0;
}
/**
* Figure out the best NIC card to connect and initialize library network stack.
*/
bool lwip_init_auto_ex(struct waitset * opt_waitset,
struct thread_mutex * opt_mutex)
{
char *card_name = NULL;
uint64_t default_queueid = 0;
/* Figure out the best NIC card that can be used */
/* FIXME: hardcoding the NIC card right now, will do smarter detection
in future. */
#ifndef __scc__
#ifdef CONFIG_QEMU_NETWORK
card_name = "rtl8029";
#else
// FIXME: also check for e10k
// FIXME: get this from kaluga
card_name = "e1000";
//card_name = "e10k";
//card_name = "vmkitmon_eth";
#endif // CONFIG_QEMU_NETWORK
#else
static char cid[100];
snprintf(cid, sizeof(cid), "eMAC2_%u", disp_get_core_id());
card_name = cid;
#endif // __scc__
return lwip_init_ex(card_name, default_queueid, opt_waitset, opt_mutex);
} // end function: lwip_init_auto_ex
int main(int argc, const char *argv[])
{
errval_t err;
printf("Spawnd up.\n");
vfs_init();
my_core_id = disp_get_core_id();
// read in the bootmodules file so that we know what to start
get_bootmodules();
// construct sane inital environment
init_environ();
err = start_service();
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "failed to start spawnd service loop");
}
messages_handler_loop();
}
void spawn_arrakis_domains(void)
{
struct spawn_info si;
size_t bmpos = 0;
errval_t err;
int r;
coreid_t my_coreid = disp_get_core_id();
while (true) {
r = prepare_spawn(&bmpos, &si);
if (r == 0) {
return;
} else if (r == -1) {
DEBUG_ERR(STARTD_ERR_BOOTMODULES,
"failed to read bootmodules entry");
}
/* Only spawn special arrakis modules */
if (si.argc >= 2 && strcmp(si.argv[1], "arrakis") == 0) {
coreid_t coreid;
int extra_args;
// get core id
if (si.argc >= 3 && strncmp(si.argv[2], "core=", 5) == 0) {
char *p = strchr(si.argv[2], '=');
assert(p != NULL);
coreid = strtol(p + 1, NULL, 10);
extra_args = 2;
} else {
coreid = my_coreid;
extra_args = 1;
}
// discard 'dist-serv' and 'core=x' argument
for (int i = 1; i <= si.argc - extra_args; i++) {
si.argv[i] = si.argv[i+extra_args];
}
si.argc--;
debug_printf("starting arrakis domain %s on core %d\n", si.name, coreid);
domainid_t new_domain;
err = spawn_arrakis_program(coreid, si.name, si.argv, environ,
NULL_CAP, NULL_CAP, 0, &new_domain);
if (err_is_fail(err)) {
DEBUG_ERR(err, "spawn of %s failed", si.name);
continue;
}
}
free(si.cmdargs);
free(si.name);
}
}
errval_t domain_thread_create_on_varstack(coreid_t core_id,
thread_func_t start_func,
void *arg, size_t stacksize,
struct thread **newthread)
{
if (disp_get_core_id() == core_id) {
struct thread *th = NULL;
if (stacksize == 0) {
th = thread_create(start_func, arg);
} else {
th = thread_create_varstack(start_func, arg, stacksize);
}
if (th != NULL) {
if (newthread) {
*newthread = th;
}
return SYS_ERR_OK;
} else {
return LIB_ERR_THREAD_CREATE;
}
} else {
struct domain_state *domain_state = get_domain_state();
errval_t err;
if (domain_state->b[core_id] == NULL) {
return LIB_ERR_NO_SPANNED_DISP;
}
struct interdisp_binding *b = domain_state->b[core_id];
struct create_thread_req *req = malloc(sizeof(*req));
req->reply_received = false;
// use special waitset to make sure loop exits properly.
struct waitset ws, *old_ws = b->waitset;
waitset_init(&ws);
b->change_waitset(b, &ws);
err = b->tx_vtbl.create_thread_request(b, NOP_CONT,
(genvaddr_t)(uintptr_t)start_func,
(genvaddr_t)(uintptr_t)arg,
stacksize,
(genvaddr_t)(lvaddr_t)req);
if (err_is_fail(err)) {
return err;
}
while (!req->reply_received) {
event_dispatch(&ws);
}
if (newthread) {
*newthread = req->thread;
}
free(req);
b->change_waitset(b, old_ws);
return SYS_ERR_OK;
}
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
assert(err_is_ok(err));
char name[256];
snprintf(name, 256, "replay_slave.%u", disp_get_core_id());
msg("%s:%s() :: === registering %s\n", __FILE__, __FUNCTION__, name);
err = nameservice_register(name, iref);
assert(err_is_ok(err));
}
errval_t sys_debug_print_timeslice(void)
{
uint64_t val;
errval_t err = sys_debug_timeslice_counter_read(&val);
if (err_is_ok(err)) {
printf("core %d: kernel_now = %" PRIu64 "\n", disp_get_core_id(), val);
}
return err;
}
errval_t sys_debug_print_context_counter(void)
{
uint64_t val;
errval_t err = sys_debug_context_counter_read(&val);
if (err_is_ok(err)) {
printf("core %d: csc = %" PRIu64 "\n", disp_get_core_id(), val);
}
return err;
}
static int mutextest(int arg)
{
for(int i = 0; i < 100000; i++) {
thread_mutex_lock(&print_mutex);
printf("%"PRIuCOREID": test_thread %d\n", disp_get_core_id(), i);
thread_mutex_unlock(&print_mutex);
}
return 0;
}
static void join_thread_request(struct interdisp_binding *b,
genvaddr_t taddr, genvaddr_t req)
{
struct thread *thread = (struct thread *)(lvaddr_t)taddr;
assert(thread->coreid == disp_get_core_id());
int retval = 0;
errval_t err = thread_join(thread, &retval);
err = b->tx_vtbl.join_thread_reply(b, NOP_CONT, err, retval, req);
assert(err_is_ok(err));
}
/**
* \brief Runs enabled on the remote core to initialize the dispatcher
*/
static int remote_core_init_enabled(void *arg)
{
errval_t err;
struct remote_core_state *remote_core_state =
(struct remote_core_state*)arg;
/* construct a temporary spawn param to supply the morecore alignment */
struct spawn_domain_params params;
memset(¶ms, 0, sizeof(params));
params.pagesize = remote_core_state->pagesize;
/* Initialize the barrelfish library */
err = barrelfish_init_onthread(¶ms);
if (err_is_fail(err)) {
DEBUG_ERR(err, "barrelfish_init_onthread failed");
abort();
return -1;
}
// Connect to all dispatchers eagerly
remote_core_state->cnt = 0;
while(allirefs[remote_core_state->cnt] == NULL_IREF && remote_core_state->cnt < MAX_CPUS) {
remote_core_state->cnt++;
if(remote_core_state->cnt == disp_get_core_id()) {
remote_core_state->cnt++;
}
}
// Don't move before barrelfish_init_onthread()
struct domain_state *st = get_domain_state();
if(remote_core_state->cnt != MAX_CPUS) {
err = interdisp_bind(allirefs[remote_core_state->cnt], client_connected,
remote_core_state, &st->interdisp_ws,
IDC_BIND_FLAGS_DEFAULT);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "Failure binding to inter-dispatcher service");
}
}
while(!remote_core_state->initialized) {
event_dispatch(get_default_waitset());
}
/* Free unnecessary state */
free(remote_core_state);
/* XXX: create a thread that will handle the default waitset */
st->default_waitset_handler = thread_create(span_slave_thread, NULL);
assert(st->default_waitset_handler != NULL);
return interdisp_msg_handler(&st->interdisp_ws);
}
int main(int argc, char *argv[])
{
coreid_t mycore = disp_get_core_id();
debug_printf("This is mem_bench_3\n");
if (argc < 2) {
return run_worker(mycore);
} else {
return run_master(mycore, argc, argv);
}
}
int main(int argc, char *argv[])
{
errval_t err;
coreid_t mycore = disp_get_core_id();
debug_printf("This is mem_bench\n");
if (argc >= 2) {
assert(mycore == 0);
int num_cores = strtol(argv[1], NULL, 10);
debug_printf("spawning on %d cores\n", num_cores);
err = init_tracing();
if (err_is_fail(err)) {
DEBUG_ERR(err, "initialising tracing");
return EXIT_FAILURE;
}
prepare_dump();
start_tracing();
char *path = argv[0];
argv[1] = NULL;
for (int i = 1; i <= num_cores; i++) {
err = spawn_program(i, path, argv, NULL, 0, NULL);
if (err_is_fail(err)) {
DEBUG_ERR(err, "failed spawn %d", i);
return EXIT_FAILURE;
}
debug_printf("spawned on core %d\n", i);
}
//start_tracing();
run_benchmark_0(mycore);
ns_barrier_master(1, num_cores, "mem_bench");
debug_printf("all benchmarks completed\n");
stop_tracing();
// dump_trace();
} else {
run_benchmark(mycore);
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
errval_t err;
/* Set my core id */
my_core_id = disp_get_core_id();
strcpy(my_name, argv[0]);
printf("entered\n");
bench_init();
printf("bench_init done\n");
if (argc == 1) { /* server */
/*
1. spawn domain,
2. setup a server,
3. wait for client to connect,
4. run experiment
*/
char *xargv[] = { my_name, "dummy", "dummy", "dummy", NULL };
err = spawn_program(1, my_name, xargv, NULL, SPAWN_FLAGS_DEFAULT, NULL);
assert(err_is_ok(err));
/* Setup a server */
err = bench_export(NULL, export_cb, connect_cb, get_default_waitset(),
IDC_BIND_FLAGS_DEFAULT);
assert(err_is_ok(err));
} else {
/* Connect to the server */
printf("ns lookup\n");
err = nameservice_blocking_lookup("multihop_server", &iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_blocking_lookup failed");
abort();
}
printf("bench_bind\n");
// bind a first time for signaling
err = bench_bind(iref, bind_signal_cb, NULL, get_default_waitset(),
IDC_BIND_FLAGS_DEFAULT);
if (err_is_fail(err)) {
DEBUG_ERR(err, "bind failed");
abort();
}
}
messages_handler_loop();
return 0;
}
static void wakeup_thread_request(struct interdisp_binding *b,
genvaddr_t taddr)
{
coreid_t core_id = disp_get_core_id();
struct thread *wakeup = (struct thread *)(uintptr_t)taddr;
dispatcher_handle_t handle = disp_disable();
struct dispatcher_generic *disp_gen = get_dispatcher_generic(handle);
/* assert_disabled(wakeup->disp == handle); */
assert_disabled(wakeup->coreid == core_id);
wakeup->disp = handle;
thread_enqueue(wakeup, &disp_gen->runq);
disp_enable(handle);
}
int bartest1(int arg)
{
uint64_t count = 0;
char msg[128];
for(int i=0; i<1<<20; i++) {
BARRIER(barrier, NPROC);
count++;
}
// Take address of count to prevent optimisation
sprintf(msg, "%"PRIuCOREID": Count %"PRIx64" %p\n", disp_get_core_id(), count, &count);
sys_print(msg, strlen(msg));
return 0;
}
/**
* \brief Called when domain gets a interdisp service.
* It will set it on the domain_state.
*/
static void server_listening(void *st, errval_t err, iref_t iref)
{
if(err_is_fail(err)) {
DEBUG_ERR(err, "interdisp service export");
abort();
}
struct domain_state *domain_state = get_domain_state();
domain_state->iref = iref;
// Also set in the global array
allirefs[disp_get_core_id()] = iref;
domain_state->conditional = true;
}
int main(int argc, char *argv[])
{
errval_t err;
if (argc != 2) {
printf("Usage %s: <Num additional threads>\n", argv[0]);
exit(-1);
}
//printf("main running on %d\n", disp_get_core_id());
int cores = strtol(argv[1], NULL, 10) + 1;
NPROC = cores -1;
BARINIT(barrier, NPROC);
uint64_t before = rdtsc();
times[0] = before;
trace_event(TRACE_SUBSYS_BENCH, TRACE_EVENT_BENCH_PCBENCH, 1);
for (int i = 1; i < cores; i++) {
err = domain_new_dispatcher(i + disp_get_core_id(),
domain_spanned_callback,
(void*)(uintptr_t)i);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "domain_new_dispatcher failed");
}
}
while (ndispatchers < cores) {
thread_yield();
}
uint64_t finish = rdtsc();
trace_event(TRACE_SUBSYS_BENCH, TRACE_EVENT_BENCH_PCBENCH, 0);
//sys_print("\nDone\n", 6);
printf("spantest: Done in %"PRIu64" cycles\n", finish-before);
//trace_dump();
for(int i = 1; i < cores; i++) {
err = domain_thread_create_on(i, remote, NULL);
assert(err_is_ok(err));
}
messages_handler_loop();
return 0;
}
void
revoke_mark__rx(struct intermon_binding *b,
intermon_caprep_t caprep,
genvaddr_t st)
{
DEBUG_CAPOPS("%s\n", __FUNCTION__);
errval_t err;
struct intermon_state *inter_st = (struct intermon_state*)b->st;
struct revoke_slave_st *rvk_st;
err = calloce(1, sizeof(*rvk_st), &rvk_st);
PANIC_IF_ERR(err, "allocating revoke slave state");
rvk_st->from = inter_st->core_id;
rvk_st->st = st;
caprep_to_capability(&caprep, &rvk_st->rawcap);
if (!slaves_head) {
assert(!slaves_tail);
slaves_head = slaves_tail = rvk_st;
}
else {
assert(slaves_tail);
assert(!slaves_tail->next);
slaves_tail->next = rvk_st;
slaves_tail = rvk_st;
}
// pause any ongoing "delete stepping" as mark phases on other nodes need
// to delete all foreign copies before we can delete locally owned caps
delete_steps_pause();
// XXX: this invocation could create a scheduling hole that could be
// problematic in RT systems and should probably be done in a loop.
err = monitor_revoke_mark_relations(&rvk_st->rawcap);
if (err_no(err) == SYS_ERR_CAP_NOT_FOUND) {
// found no copies or descendants of capability on this core,
// do nothing. -SG
DEBUG_CAPOPS("no copies on core %d\n", disp_get_core_id());
} else if (err_is_fail(err)) {
USER_PANIC_ERR(err, "marking revoke");
}
rvk_st->im_qn.cont = revoke_ready__send;
err = capsend_target(rvk_st->from, (struct msg_queue_elem*)rvk_st);
PANIC_IF_ERR(err, "enqueing revoke_ready");
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
DEBUG_ERR(err, "export failed");
abort();
}
// register this iref with the name service
char my_service_name[128];
get_service_name(my_service_name, 128, disp_get_core_id());
err = nameservice_register(my_service_name, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
abort();
}
exported = true;
}
int main(int argc, const char *argv[])
{
errval_t err;
printf("Spawnd up.\n");
vfs_init();
my_core_id = disp_get_core_id();
#if 0
debug_printf("spawnd invoked on core %d as:", my_core_id);
for (int i = 0; i < argc; i++) {
printf(" %s", argv[i]);
}
printf("\n");
#endif
// read in the bootmodules file so that we know what to start
get_bootmodules();
// construct sane inital environment
init_environ();
if (argc >= 2 && strcmp(argv[1],"boot") == 0) {
debug_printf("we're bsp. start other cores.\n");
// if we're the BSP, bring up the other cores
is_bsp_core = true;
#if defined(USE_KALUGA_DVM) && (!defined(__arm__) && !defined(__scc__) &&!defined(__k1om__))
err = start_service();
#else
bsp_bootup(gbootmodules, argc, argv);
#endif
} else {
// otherwise offer the spawn service
err = start_service();
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "failed to start spawnd service loop");
}
}
messages_handler_loop();
}
int inctest4(int arg)
{
uint64_t lcount = 0;
char msg[128];
for(int i=0; i<1<<20; i++) {
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
}
sprintf(msg, "%"PRIuCOREID": Count %"PRIx64" %p\n", disp_get_core_id(), lcount, &lcount);
sys_print(msg, strlen(msg));
return 0;
}
/** Start the main task */
static int main_worker (int id,
int(*main_func)(struct generic_task_desc *,void*),
void * main_args) {
workers[id].worker_thr = thread_self();
workers[id].id = id;
workers[id].core_id = disp_get_core_id();
struct generic_task_desc * _tweed_top_ = NULL;
thread_set_tls(&(workers[id]));
int ret = main_func(_tweed_top_, main_args);
// signal exit to other workers
do_quit = 1;
return ret;
}
errval_t domain_thread_join(struct thread *thread, int *retval)
{
coreid_t core_id = thread->coreid;
if (disp_get_core_id() == core_id) {
return thread_join(thread, retval);
} else {
struct domain_state *domain_state = get_domain_state();
errval_t err;
if (domain_state->b[core_id] == NULL) {
return LIB_ERR_NO_SPANNED_DISP;
}
struct interdisp_binding *b = domain_state->b[core_id];
struct join_thread_req *req = malloc(sizeof(*req));
req->reply_received = false;
// use special waitset to make sure loop exits properly.
struct waitset ws, *old_ws = b->waitset;
waitset_init(&ws);
b->change_waitset(b, &ws);
err = b->tx_vtbl.join_thread_request(b, NOP_CONT,
(genvaddr_t)(lvaddr_t)thread,
(genvaddr_t)(lvaddr_t)req);
if (err_is_fail(err)) {
return err;
}
while (!req->reply_received) {
event_dispatch(&ws);
}
// change waitset back
b->change_waitset(b, old_ws);
if (retval) {
*retval = req->retval;
}
err = req->err;
free(req);
return err;
}
}
errval_t domain_thread_create_on_varstack(coreid_t core_id,
thread_func_t start_func,
void *arg, size_t stacksize)
{
if (disp_get_core_id() == core_id) {
struct thread *th = NULL;
if (stacksize == 0) {
th = thread_create(start_func, arg);
} else {
th = thread_create_varstack(start_func, arg, stacksize);
}
if (th != NULL) {
return SYS_ERR_OK;
} else {
return LIB_ERR_THREAD_CREATE;
}
} else {
struct domain_state *domain_state = get_domain_state();
errval_t err;
if (domain_state->b[core_id] == NULL) {
return LIB_ERR_NO_SPANNED_DISP;
}
struct interdisp_binding *b = domain_state->b[core_id];
err = b->tx_vtbl.create_thread(b, NOP_CONT,
(genvaddr_t)(uintptr_t)start_func,
(genvaddr_t)(uintptr_t)arg,
stacksize);
if (err_is_fail(err)) {
return err;
}
return SYS_ERR_OK;
}
}
static void remaining_lwip_initialization(char *card_name, uint64_t queueid)
{
nb = netbench_alloc("app", RECORDED_EVENTS_COUNT);
//asq: connect to the NIC driver, before doing anything else
idc_connect_to_driver(card_name, queueid);
DEBUGPRINTPS("Connected to driver [%s]\n", card_name);
stats_init();
sys_init();
DEBUGPRINTPS("remaining_lwip_init: allocating pbuf memory\n");
#ifdef CONFIG_QEMU_NETWORK
printf("#### Networking with small amount of memory #####\n");
#endif // CONFIG_QEMU_NETWORK
printf("#### [%u:%"PRIuDOMAINID":%s] [%s] [%d] MEM_SIZE[%d], "
"PBUF_POOL_SIZE[%d], MEMP_MAX[%d], RECEIVE_BUFFERS[%d] qid[%"PRIu64"]####\n",
disp_get_core_id(), disp_get_domain_id(), disp_name(),
MEM_CONF_LOC, is_ctl, MEM_SIZE, PBUF_POOL_SIZE, MEMP_MAX,
RECEIVE_BUFFERS, queueid);
memp_init(); // 0'st buffer
DEBUGPRINTPS("remaining_lwip_init: allocating memory for sending\n");
mem_init(); // 1'th buffer
DEBUGPRINTPS("remaining_lwip_init: done with memroy allocation\n");
DEBUGPRINTPS("LWIP: lwip_starting\n");
netif_init();
#if LWIP_SOCKET
lwip_socket_init();
#endif /* LWIP_SOCKET */
ip_init();
DEBUGPRINTPS("r_lwip_init: done ip_init\n");
#if LWIP_ARP
etharp_init();
#endif /* LWIP_ARP */
#if LWIP_RAW
raw_init();
#endif /* LWIP_RAW */
#if LWIP_UDP
udp_init();
DEBUGPRINTPS("r_lwip_init: done udp_init\n");
#endif /* LWIP_UDP */
#if LWIP_TCP
tcp_init();
DEBUGPRINTPS("r_lwip_init: done tcp_init\n");
#endif /* LWIP_TCP */
#if LWIP_SNMP
snmp_init();
DEBUGPRINTPS("r_lwip_init: done snmp_init\n");
#endif /* LWIP_SNMP */
#if LWIP_AUTOIP
autoip_init();
DEBUGPRINTPS("r_lwip_init: done autoip_init\n");
#endif /* LWIP_AUTOIP */
#if LWIP_IGMP
igmp_init();
DEBUGPRINTPS("r_lwip_init: done igmp_init\n");
#endif /* LWIP_IGMP */
DEBUGPRINTPS("r_lwip_init: done2 igmp_init\n");
#if LWIP_DNS
DEBUGPRINTPS("r_lwip_init: starting DNS_init\n");
dns_init();
DEBUGPRINTPS("r_lwip_init: done DNS_init\n");
#endif /* LWIP_DNS */
DEBUGPRINTPS("LWIP: lwip_started\n");
}
