errval_t start_networking(coreid_t core, struct module_info* driver,
char* record)
{
assert(driver != NULL);
errval_t err = SYS_ERR_OK;
if (is_started(driver)) {
return KALUGA_ERR_DRIVER_ALREADY_STARTED;
}
if (!is_auto_driver(driver)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
struct module_info* netd = find_module("netd");
if (netd == NULL || !is_auto_driver(netd)) {
KALUGA_DEBUG("netd not found or not declared as auto.");
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
struct module_info* ngd_mng = find_module("NGD_mng");
if (ngd_mng == NULL || !is_auto_driver(ngd_mng)) {
KALUGA_DEBUG("NGD_mng not found or not declared as auto.");
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
err = spawn_program(core, driver->path, driver->argv + 1, environ, 0,
&driver->did);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", driver->path);
return err;
}
// XXX: Manually add cardname (overwrite first (auto) argument)
// +Weird convention, e1000n binary but cardname=e1000
char* cardname =
strcmp(driver->binary, "e1000n") == 0 ? "e1000" : driver->binary;
size_t name_len = strlen("cardname=") + strlen(cardname) + 1;
char* card_argument = malloc(name_len);
sprintf(card_argument, "cardname=%s", cardname);
printf("############# starting network with argiments %s\n", card_argument);
// Spawn netd and ngd_mng
netd->argv[0] = card_argument;
err = spawn_program(core, netd->path, netd->argv, environ, 0, &netd->did);
ngd_mng->argv[0] = card_argument;
err = spawn_program(core, ngd_mng->path, ngd_mng->argv, environ, 0,
&ngd_mng->did);
free(card_argument);
return err;
}
errval_t default_start_function(coreid_t where,
struct module_info* mi,
char* record)
{
assert(mi != NULL);
errval_t err = SYS_ERR_OK;
coreid_t core;
/*
* XXX: there may be more device using this driver, so starting it a second time
* may be needed.
*/
if (!can_start(mi)) {
return KALUGA_ERR_DRIVER_ALREADY_STARTED;
}
core = where + get_core_id_offset(mi);
if (!is_auto_driver(mi)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
// Construct additional command line arguments containing pci-id.
// We need one extra entry for the new argument.
uint64_t vendor_id, device_id, bus, dev, fun;
char **argv = mi->argv;
bool cleanup = false;
err = oct_read(record, "_ { bus: %d, device: %d, function: %d, vendor: %d, device_id: %d }",
&bus, &dev, &fun, &vendor_id, &device_id);
if (err_is_ok(err)) {
// We assume that we're starting a device if the query above succeeds
// and therefore append the pci vendor and device id to the argument
// list.
argv = malloc((mi->argc+1) * sizeof(char *));
memcpy(argv, mi->argv, mi->argc * sizeof(char *));
char *pci_id = malloc(26);
// Make sure pci vendor and device id fit into our argument
assert(vendor_id < 0x9999 && device_id < 0x9999);
snprintf(pci_id, 26, "%04"PRIx64":%04"PRIx64":%04"PRIx64":%04"
PRIx64":%04"PRIx64, vendor_id, device_id, bus, dev, fun);
argv[mi->argc] = pci_id;
argv[mi->argc+1] = NULL;
cleanup = true;
}
err = spawn_program(core, mi->path, argv,
environ, 0, get_did_ptr(mi));
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", mi->path);
}
if (cleanup) {
// alloc'd string is the last of our array
free(argv[mi->argc]);
free(argv);
}
return err;
}
errval_t default_start_function(coreid_t where, struct module_info* mi,
char* record)
{
assert(mi != NULL);
errval_t err = SYS_ERR_OK;
if (is_started(mi)) {
return KALUGA_ERR_DRIVER_ALREADY_STARTED;
}
if (!is_auto_driver(mi)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
// Construct additional command line arguments containing pci-id.
// We need one extra entry for the new argument.
uint64_t vendor_id, device_id;
char **argv = mi->argv;
bool cleanup = false;
err = oct_read(record, "_ { vendor: %d, device_id: %d }",
&vendor_id, &device_id);
if (err_is_ok(err)) {
// We assume that we're starting a device if the query above succeeds
// and therefore append the pci vendor and device id to the argument
// list.
argv = malloc((mi->argc+1) * sizeof(char *));
memcpy(argv, mi->argv, mi->argc * sizeof(char *));
char *pci_id = malloc(10);
// Make sure pci vendor and device id fit into our argument
assert(vendor_id < 0x9999 && device_id < 0x9999);
snprintf(pci_id, 10, "%04"PRIx64":%04"PRIx64, vendor_id, device_id);
argv[mi->argc] = pci_id;
mi->argc += 1;
argv[mi->argc] = NULL;
cleanup = true;
}
err = spawn_program(where, mi->path, argv,
environ, 0, &mi->did);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", mi->path);
}
if (cleanup) {
// alloc'd string is the last of our array
free(argv[mi->argc-1]);
free(argv);
}
return err;
}
errval_t start_networking(coreid_t core,
struct module_info* driver,
char* record)
{
assert(driver != NULL);
errval_t err = SYS_ERR_OK;
uint64_t vendor_id, device_id, bus, dev, fun;
/* check if we are using the supplied pci address of eth0 */
if (eth0.bus != 0xff || eth0.device != 0xff || eth0.function != 0xff) {
err = oct_read(record, "_ { bus: %d, device: %d, function: %d, vendor: %d, device_id: %d }",
&bus, &dev, &fun, &vendor_id, &device_id);
assert(err_is_ok(err));
if ((eth0.bus != (uint8_t)bus)
| (eth0.device != (uint8_t)dev)
| (eth0.function != (uint8_t)fun)) {
KALUGA_DEBUG("start_networking: skipping card %" PRIu64 ":% "PRIu64 ":% "
PRIu64"\n", bus, dev, fun);
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
}
if (is_started(driver)) {
return KALUGA_ERR_DRIVER_ALREADY_STARTED;
}
if (!is_auto_driver(driver)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
struct module_info* netd = find_module("netd");
if (netd == NULL || !is_auto_driver(netd)) {
KALUGA_DEBUG("netd not found or not declared as auto.");
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
struct module_info* ngd_mng = find_module("NGD_mng");
if (ngd_mng == NULL || !is_auto_driver(ngd_mng)) {
KALUGA_DEBUG("NGD_mng not found or not declared as auto.");
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
err = default_start_function(core, driver, record);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", driver->path);
return err;
}
// XXX: Manually add cardname (overwrite first (auto) argument)
// +Weird convention, e1000n binary but cardname=e1000
char* cardname = strcmp(driver->binary, "e1000n") == 0 ? "e1000" : driver->binary;
size_t name_len = strlen("cardname=") + strlen(cardname) + 1;
char* card_argument = malloc(name_len);
sprintf(card_argument, "cardname=%s", cardname);
printf("############# starting network with arguments %s\n", card_argument);
// Spawn netd and ngd_mng
netd->argv[0] = card_argument;
err = spawn_program(core, netd->path, netd->argv, environ, 0, get_did_ptr(netd));
ngd_mng->argv[0] = card_argument;
err = spawn_program(core, ngd_mng->path, ngd_mng->argv, environ, 0,
get_did_ptr(ngd_mng));
free(card_argument);
return err;
}
errval_t start_boot_driver(coreid_t where, struct module_info* mi,
char* record)
{
assert(mi != NULL);
errval_t err = SYS_ERR_OK;
if (!is_auto_driver(mi)) {
return KALUGA_ERR_DRIVER_NOT_AUTO;
}
// Construct additional command line arguments containing pci-id.
// We need one extra entry for the new argument.
uint64_t barrelfish_id, apic_id, cpu_type;
char **argv = mi->argv;
bool cleanup = false;
char barrelfish_id_s[10];
size_t argc = mi->argc;
KALUGA_DEBUG("Starting corectrl for %s\n", record);
err = oct_read(record, "_ { apic_id: %d, barrelfish_id: %d, type: %d }",
&apic_id, &barrelfish_id, &cpu_type);
if (err_is_ok(err)) {
skb_add_fact("corename(%"PRIu64", %s, apic(%"PRIu64")).",
barrelfish_id, cpu_type_to_archstr(cpu_type), apic_id);
if (barrelfish_id == my_core_id) {
return SYS_ERR_OK;
}
argv = malloc((argc+5) * sizeof(char *));
memcpy(argv, mi->argv, argc * sizeof(char *));
snprintf(barrelfish_id_s, 10, "%"PRIu64"", barrelfish_id);
argv[argc] = "boot";
argc += 1;
argv[argc] = barrelfish_id_s;
argc += 1;
// Copy kernel args over to new core
struct module_info* cpu_module = find_module("cpu");
if (cpu_module != NULL && strlen(cpu_module->args) > 1) {
KALUGA_DEBUG("%s:%s:%d: Boot with cpu arg %s and barrelfish_id_s=%s\n",
__FILE__, __FUNCTION__, __LINE__, cpu_module->args, barrelfish_id_s);
argv[argc] = "-a";
argc += 1;
argv[argc] = cpu_module->args;
argc += 1;
}
argv[argc] = NULL;
cleanup = true;
}
else {
DEBUG_ERR(err, "Malformed CPU record?");
return err;
}
struct capref task_cap_kernel;
task_cap_kernel.cnode = cnode_task;
task_cap_kernel.slot = TASKCN_SLOT_KERNELCAP;
#ifdef KALUGA_SERVICE_DEBUG
struct capability info;
err = debug_cap_identify(task_cap_kernel, &info);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "Can not identify the capability.");
}
char buffer[1024];
debug_print_cap(buffer, 1024, &info);
KALUGA_DEBUG("%s:%d: capability=%s\n", __FILE__, __LINE__, buffer);
#endif
struct capref inheritcn_cap;
err = alloc_inheritcn_with_caps(&inheritcn_cap,
NULL_CAP, NULL_CAP, task_cap_kernel);
if (err_is_fail(err)) {
DEBUG_ERR(err, "alloc_inheritcn_with_caps failed.");
}
err = spawn_program_with_caps(where, mi->path, argv,
environ, inheritcn_cap,
NULL_CAP, SPAWN_FLAGS_NEW_DOMAIN,
&mi->did[0]);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Spawning %s failed.", mi->path);
}
if (cleanup) {
free(argv);
}
return err;
}
