//Currently, kmain uses the interrupt stack.
//It might overwrite ATAGs, etc. if care is not used.
//TODO: allocate a stack elsewhere?
void kmain(KMAIN_ARGS) {
get_memory_map();
map_io_area();
bool status = init_console();
if(status) {
init_phys_allocators();
//Drivers must be loaded before any heap allocations
//because driver images are stored at the beginning of the heap.
load_drivers();
interrupt_init();
enable_irqs();
//enable_irq(cpu_timer);
} else {
//To do: error handling.
}
}
bool load_instance(Data* data_p, std::string const& file_p)
{
LOG(INFO) << "Loading Instance inside the data structure : " << file_p;
// VLOG(2) << "Found cookies in DEBUG";
VLOG(1) << "Openning the file";
std::ifstream file_stream_l(file_p);
// get length of file:
file_stream_l.seekg (0, file_stream_l.end);
int length = file_stream_l.tellg();
file_stream_l.seekg (0, file_stream_l.beg);
VLOG(1) << "The length of file is : " << length;
VLOG(1) << "Reading the file";
char * buffer = new char [length];
file_stream_l.read (buffer,length);
if (file_stream_l)
VLOG(1) << "All characters read successfully.";
else
LOG(FATAL) << "Error : only " << file_stream_l.gcount() << " could be read";
file_stream_l.close();
VLOG(1) << "Parsing the file";
rapidxml::xml_document<> doc; // character type defaults to char
doc.parse<0>(buffer); // 0 means default parse flags
VLOG(1) << "Extracting Data";
rapidxml::xml_node<> *root = doc.first_node(); // Node IRP_R_C_I
/** Extraction of the tree ! */
// Unit
rapidxml::xml_node<> *child_l = root->first_node();
check_name(child_l,"unit");
data_p->unit(std::stoi(child_l->value()));
VLOG(1) << "Unit = " << data_p->unit();
// Horizon
child_l = child_l->next_sibling();
check_name(child_l,"horizon");
data_p->horizon(std::stoi(child_l->value()));
VLOG(1) << "Horizon = " << data_p->horizon();
// Time Matrices
child_l = child_l->next_sibling();
check_name(child_l,"timeMatrices");
int size_time_matrices = load_time_matrices(data_p, child_l);
VLOG(1) << "Time Matrix loaded of size = " << size_time_matrices;
// Drivers
child_l = child_l->next_sibling();
check_name(child_l,"drivers");
int num_drivers = load_drivers(data_p, child_l);
VLOG(1) << "Vector of driverd loaded of size = " << num_drivers;
// Trailers
child_l = child_l->next_sibling();
check_name(child_l,"trailers");
int num_trailers = load_trailers(data_p, child_l);
VLOG(1) << "Vector of trailers loaded of size = " << num_trailers;
// Bases
child_l = child_l->next_sibling();
check_name(child_l,"bases");
data_p->bases_index(std::stoi(child_l->first_node()->value()));
VLOG(1) << "bases = " << data_p->bases_index();
// Sources
child_l = child_l->next_sibling();
check_name(child_l,"sources");
int num_sources = load_sources(data_p, child_l);
VLOG(1) << "Vector of sources loaded of size = " << num_sources;
// Customers
child_l = child_l->next_sibling();
check_name(child_l,"customers");
int num_customers = load_customers(data_p, child_l);
VLOG(1) << "Vector of customers loaded of size = " << num_customers;
// Time Matrices
child_l = child_l->next_sibling();
check_name(child_l,"distMatrices");
int size_dist_matrices = load_dist_matrices(data_p, child_l);
VLOG(1) << "Dist Matrix loaded of size = " << size_dist_matrices;
// Clearing memory space
delete[] buffer;
return true;
}
HIDDEN int ibverbs_init(struct ibv_device ***list)
{
const char *sysfs_path;
struct ibv_sysfs_dev *sysfs_dev, *next_dev;
struct ibv_device *device;
int num_devices = 0;
int list_size = 0;
int statically_linked = 0;
int no_driver = 0;
int ret;
*list = NULL;
if (getenv("RDMAV_FORK_SAFE") || getenv("IBV_FORK_SAFE"))
if (ibv_fork_init())
fprintf(stderr, PFX "Warning: fork()-safety requested "
"but init failed\n");
sysfs_path = ibv_get_sysfs_path();
if (!sysfs_path)
return -ENOSYS;
ret = check_abi_version(sysfs_path);
if (ret)
return -ret;
check_memlock_limit();
read_config();
ret = vib_find_sysfs_devs();
if (ret)
return -ret;
for (sysfs_dev = sysfs_dev_list; sysfs_dev; sysfs_dev = sysfs_dev->next) {
device = try_drivers(sysfs_dev);
if (device) {
add_device(device, list, &num_devices, &list_size);
sysfs_dev->have_driver = 1;
} else
no_driver = 1;
}
if (!no_driver)
goto out;
/*
* Check if we can dlopen() ourselves. If this fails,
* libibverbs is probably statically linked into the
* executable, and we should just give up, since trying to
* dlopen() a driver module will fail spectacularly (loading a
* driver .so will bring in dynamic copies of libibverbs and
* libdl to go along with the static copies the executable
* has, which quickly leads to a crash.
*/
{
void *hand = dlopen(NULL, RTLD_NOW);
if (!hand) {
fprintf(stderr, PFX "Warning: dlopen(NULL) failed, "
"assuming static linking.\n");
statically_linked = 1;
goto out;
}
dlclose(hand);
}
load_drivers();
for (sysfs_dev = sysfs_dev_list; sysfs_dev; sysfs_dev = sysfs_dev->next) {
if (sysfs_dev->have_driver)
continue;
device = try_drivers(sysfs_dev);
if (device) {
add_device(device, list, &num_devices, &list_size);
sysfs_dev->have_driver = 1;
}
}
out:
for (sysfs_dev = sysfs_dev_list,
next_dev = sysfs_dev ? sysfs_dev->next : NULL;
sysfs_dev;
sysfs_dev = next_dev, next_dev = sysfs_dev ? sysfs_dev->next : NULL) {
if (!sysfs_dev->have_driver) {
fprintf(stderr, PFX "Warning: no userspace device-specific "
"driver found for %s\n", sysfs_dev->sysfs_path);
if (statically_linked)
fprintf(stderr, " When linking libibverbs statically, "
"driver must be statically linked too.\n");
}
free(sysfs_dev);
}
return num_devices;
}
/* This routine probes libdevinfo for port nodes */
picl_errno_t
probe_libdevinfo(frutree_frunode_t *frup, frutree_device_args_t ** device,
boolean_t load_drv)
{
di_node_t rnode;
picl_errno_t rc;
plist_t list;
if (frup == NULL) {
return (PICL_FAILURE);
}
FRUTREE_DEBUG1(EVENTS, "loading drivers for %s", frup->name);
if (load_drv == B_TRUE) {
if ((rc = load_drivers(frup->fru_path)) != PICL_SUCCESS) {
return (rc);
}
}
FRUTREE_DEBUG1(EVENTS, "done with loading drivers for %s", frup->name);
rnode = di_init(frup->fru_path, DINFOSUBTREE|DINFOMINOR);
if (rnode == DI_NODE_NIL) {
return (PICL_FAILURE);
}
list.first = NULL;
list.last = NULL;
list.n_network = 0;
list.n_serial = 0;
list.n_parallel = 0;
if (di_walk_node(rnode, DI_WALK_CLDFIRST, &list, probe_tree) != 0) {
di_fini(rnode);
free_list(&list);
return (PICL_FAILURE);
}
if (list.n_serial > 0)
if ((rc = assign_geo_addr(&list, SERIAL_PORT)) != PICL_SUCCESS) {
di_fini(rnode);
free_list(&list);
return (rc);
}
if (list.n_network > 0)
if ((rc = assign_geo_addr(&list, NETWORK_PORT)) != PICL_SUCCESS) {
di_fini(rnode);
free_list(&list);
return (rc);
}
if (list.n_parallel > 0)
if ((rc = assign_geo_addr(&list, PARALLEL_PORT)) != PICL_SUCCESS) {
di_fini(rnode);
free_list(&list);
return (rc);
}
if ((rc = create_port_config_info(&list, *device)) != PICL_SUCCESS) {
di_fini(rnode);
free_list(&list);
return (rc);
}
di_fini(rnode);
free_list(&list);
FRUTREE_DEBUG1(EVENTS, "done with probing %s", frup->name);
return (PICL_SUCCESS);
}
int main(int argc, char *argv[]) {
const char *homedir;
parse_arguments(argc, argv);
flowlist=malloc(sizeof(flist_t));
flist_init(flowlist);
clientlist = malloc(sizeof(flist_t));
flist_init(clientlist);
gflist = malloc(sizeof(global_function_list_t));
gflist->fflist=malloc(sizeof(flist_t));
flist_init(gflist->fflist);
gflist->lock = 0;
homedir = getenv("HOME");
if (homedir == NULL) {
fputs("Environment variable HOME not set. Giving up.\n", stderr);
exit( 1);
}
mapid_conf = printf_string( CONFDIR"/"CONF_FILE );
printf("using %s\n", mapid_conf);
log_level = get_log_level(mapid_conf); // get log level from mapi.conf
if (log_to_syslog) // logging to syslog is enabled
open_syslog(log_level, "MAPID");
log_to_file = set_logging_to_file(mapid_conf, &log_fd_info, &log_fd_debug); // support for logging to file
if (log_to_syslog == 0 && log_to_file == 0)
log_level = LOGGING_DISABLED;
if (log_to_syslog == 0)
printf("logging to syslog: disabled\n");
else
printf("logging to syslog: enabled - LogLevel: %d\n", log_level);
if (log_to_file) {
daemon_started(log_fd_info, "MAPID", daemonize, 0);
daemon_started(log_fd_debug, "MAPID", daemonize, 0);
}
if (log_to_syslog)
log_message(
"MAPID was started %s%s",
daemonize ? " ( is running as daemon )" : "");
drvlist = load_drivers();
if (drvlist == NULL) {
DEBUG_CMD(Debug_Message("ERROR: No MAPI drivers found"));
exit(EXIT_FAILURE);
}
// Grab some signals so we can mapid_shutdown gracefully
signal(SIGTERM, mapid_shutdown);
signal(SIGQUIT, mapid_shutdown);
signal(SIGINT, mapid_shutdown);
if (daemonize)
continue_as_daemon();
mapidcom();
mapid_shutdown(0);
// wait for shutdown to finish
// espenb TODO: use pthread_cond_wait (or similar) instead
while (running_shutdown != 2)
usleep(10000);
return 0;
}
