static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "export failed");
}
// construct name
char namebuf[32];
size_t len = snprintf(namebuf, sizeof(namebuf), "%s.%d", SERVICE_BASENAME,
my_core_id);
assert(len < sizeof(namebuf));
namebuf[sizeof(namebuf) - 1] = '\0';
// register this iref with the name service
err = nameservice_register(namebuf, iref);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nameservice_register failed");
}
#if !defined(USE_KALUGA_DVM) || defined(__arm__) || defined(__scc__) || defined(__k1om__)
// let the master know we are ready
err = nsb_register_n(my_core_id, SERVICE_BASENAME);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nsb_register_n failed");
}
// wait for boot to finish
err = nsb_wait(ALL_SPAWNDS_UP);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "failed ns barrier wait for %s", ALL_SPAWNDS_UP);
}
// debug_printf("got \"%s\", continuing\n", ALL_SPAWNDS_UP);
#endif
}
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;
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
size_t size = 0;
char *service_name = NULL;
char *driver_name = (char *) st;
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "Exporting basic interface failed.\n");
}
// build service name as driver_name.SERVICE_SUFFIX
size = snprintf(NULL, 0, "%s.%s", driver_name, SERVICE_SUFFIX);
service_name = (char *) malloc(size + 1);
if (service_name == NULL) {
USER_PANIC("Error allocating memory.");
}
snprintf(service_name, size + 1, "%s.%s", driver_name, SERVICE_SUFFIX);
SERIAL_DEBUG("About to register basic interface '%s' at nameservice.\n",
service_name);
// register basic serial driver service at nameservice
err = nameservice_register(service_name, iref);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "Registering basic interface at "
"nameserver failed.");
}
free(service_name);
}
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));
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
struct descq_endpoint_state* q = (struct descq_endpoint_state*) st;
err = nameservice_register(q->name, iref);
assert(err_is_ok(err));
q->exp_done = true;
// state is only function pointers
DESCQ_DEBUG("Control interface exported (%s)\n", q->name);
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "export failed");
}
err = nameservice_register(service_name, iref);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nameservice_register failed");
}
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "export failed");
}
// register this iref with the name service
err = nameservice_register("server", iref);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nameservice_register failed");
}
}
static void export_cb(void *st, errval_t err, iref_t iref2)
{
if (err_is_fail(err)) {
DEBUG_ERR(err, "export failed");
abort();
}
// register this iref with the name service
err = nameservice_register("multihop_server", iref2);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
abort();
}
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "export failed");
}
printf("bfscope: exported at iref %"PRIuIREF"\n", iref);
// register this iref with the name service
err = nameservice_register("bfscope", iref);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nameservice_register failed");
}
}
static void export_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
DEBUG_ERR(err, "export failed");
abort();
}
printf("xcorecapserv: service exported at iref %"PRIuIREF"\n", iref);
fflush(stdout);
// register this iref with the name service
err = nameservice_register(my_service_name, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
abort();
}
}
errval_t dma_service_init(struct xeon_phi *phi)
{
errval_t err;
XDMA_DEBUG("Initializing DMA service\n");
struct waitset *ws = get_default_waitset();
err = xeon_phi_dma_export(phi,
svc_export_cb,
svc_connect_cb,
ws,
IDC_EXPORT_FLAGS_DEFAULT);
if (err_is_fail(err)) {
return err;
}
XDMAV_DEBUG("Waiting for export...\n");
while (svc_state == XPM_SVC_STATE_EXPORTING) {
messages_wait_and_handle_next();
}
if (svc_state == XPM_SVC_STATE_EXPORT_FAIL) {
return FLOUNDER_ERR_BIND;
}
svc_state = XPM_SVC_STATE_NS_REGISTERING;
char buf[50];
#ifdef __k1om__
snprintf(buf, 50, "%s.%u", XEON_PHI_DMA_SERVICE_NAME, 0);
#else
snprintf(buf, 50, "%s.%u", XEON_PHI_DMA_SERVICE_NAME, phi->id);
#endif
XDMA_DEBUG("Registering iref [%u] with name [%s]\n", dma_iref, buf);
err = nameservice_register(buf, dma_iref);
if (err_is_fail(err)) {
svc_state = XPM_SVC_STATE_NS_REGISTER_FAIL;
return err;
}
svc_state = XPM_SVC_STATE_RUNNING;
return SYS_ERR_OK;
}
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;
}
static void export_ether_cb(void *st, errval_t err, iref_t iref)
{
if (err_is_fail(err)) {
DEBUG_ERR(err, "service [%s] export failed", exported_queue_name);
abort();
}
// ETHERSRV_DEBUG
printf("service [%s] exported at iref %"PRIu32"\n", exported_queue_name,
(uint32_t)iref);
// register this iref with the name service
err = nameservice_register(exported_queue_name, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed for [%s]",
exported_queue_name);
abort();
}
}
static void _listening(void *st, errval_t err, iref_t iref)
{
assert(err_is_ok(err));
/* printf("%s: listening\n", my_name); */
/* Register the service with the nameserver */
char serv[100];
snprintf(serv, sizeof(serv), "%s%d", my_name, my_core_id);
err = nameservice_register(serv, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
abort();
}
/* printf("%s: registered '%s'\n", my_name, serv); */
assert(!request_done);
request_done = true;
}
static void run_server(struct mem_thc_service_binding_t *sv)
{
mem_service_msg_t msg;
bool loop = true;
// this is the bitmap of messages we are interested in receiving
struct mem_service_selector selector = {
.allocate = 1,
.available = 1,
.free = 1,
.steal = 1,
};
while (loop) {
// receive any message
sv->recv_any(sv, &msg, selector);
// dispatch it
switch(msg.msg) {
case mem_allocate:
percore_allocate_handler(sv, msg.args.allocate.in.bits,
msg.args.allocate.in.minbase,
msg.args.allocate.in.maxlimit);
break;
case mem_steal:
percore_steal_handler(sv, msg.args.allocate.in.bits,
msg.args.allocate.in.minbase,
msg.args.allocate.in.maxlimit);
break;
case mem_available:
mem_available_handler(sv);
break;
case mem_free_monitor:
percore_free_handler(sv, msg.args.free.in.mem_cap);
break;
default:
debug_printf("unexpected message: %d\n", msg.msg);
loop = false;
break;
}
}
}
errval_t percore_mem_serv(coreid_t core, coreid_t *cores,
int len_cores, memsize_t ram)
{
errval_t err;
struct waitset *ws = get_default_waitset();
// Init the memory allocator
err = initialize_percore_mem_serv(core, cores, len_cores, ram);
if (err_is_fail(err)) {
DEBUG_ERR(err, "initializing percore mem_serv");
return err;
}
struct mem_thc_export_info e_info;
struct mem_thc_service_binding_t *sv;
struct mem_binding *b;
iref_t iref;
char service_name[NAME_LEN];
snprintf(service_name, NAME_LEN, "%s.%d", MEMSERV_DIST, core);
// err = mem_thc_export(&e_info, service_name, ws,
err = mem_thc_export(&e_info, NULL, ws,
IDC_EXPORT_FLAGS_DEFAULT,
&iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "exporting percore mem interface");
return err;
}
struct monitor_binding *mb = get_monitor_binding();
err = mb->tx_vtbl. set_mem_iref_request(mb, NOP_CONT, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "setting monitor's percore mem_serv iref");
return err;
}
// explicitly tell spawnd to use us
err = set_local_spawnd_memserv(core);
if (err_is_fail(err)) {
DEBUG_ERR(err, "setting spawnd.%d's local memserv", core);
return err;
}
// register only after spawnd's local memserv has been set
err = nameservice_register(service_name, iref);
if (err_is_fail(err)) {
DEBUG_ERR(err, "nameservice_register failed");
return err;
}
// let the master know we are ready
err = nsb_register_n(core, MEMSERV_DIST);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "nsb_register_n failed");
}
do {
while (true) {
mem_thc_accept(&e_info, &b);
if (err_is_fail(err)) {
DEBUG_ERR(err, "thc accept failed");
continue;
}
sv = malloc(sizeof(struct mem_thc_service_binding_t));
if (sv == NULL) {
DEBUG_ERR(LIB_ERR_MALLOC_FAIL, "allocating thc service binding");
continue;
}
err = mem_thc_init_service(sv, b, b);
if (err_is_fail(err)) {
DEBUG_ERR(err, "thc init failed");
continue;
}
async run_server(sv);
}
} finish;
// should never reach here
return SYS_ERR_OK;
}
