int main(int argc, char *argv[])
{
int i, ret;
if (argc > 1) num_units = atoi(argv[1]);
assert(num_units >= 0);
/* Initialize */
ABT_test_init(argc, argv);
/* Create schedulers and ESs */
init_global_data();
create_scheds_and_xstreams();
/* Create work units */
create_work_units();
/* Join ESs */
for (i = 1; i < g_data.num_scheds; i++) {
ret = ABT_xstream_join(g_data.xstreams[i]);
ABT_TEST_ERROR(ret, "ABT_xstream_join");
}
free_scheds_and_xstreams();
/* Finalize */
ret = ABT_test_finalize(0);
fini_global_data();
return ret;
}
void khotkeys_init()
{
// I hope this works
KGlobal::locale()->insertCatalogue("khotkeys");
// CHECKME hack
assert(owner == NULL);
owner = new QObject;
init_global_data(false, owner);
}
KHotKeysModule::KHotKeysModule(const QCString &obj) : KDEDModule(obj)
{
for(int i = 0; i < 5; ++i)
{
if(kapp->dcopClient()->isApplicationRegistered("khotkeys"))
{
QByteArray data, replyData;
QCString reply;
// wait for it to finish
kapp->dcopClient()->call("khotkeys*", "khotkeys", "quit()", data, reply, replyData);
sleep(1);
}
}
client.registerAs("khotkeys", false); // extra dcop connection (like if it was an app)
init_global_data(true, this); // grab keys
// CHECKME triggery a dalsi vytvaret az tady za inicializaci
actions_root = NULL;
reread_configuration();
}
/* Daemon init sequence */
static void
start_check(void)
{
/* Initialize sub-system */
if (ipvs_start() != IPVS_SUCCESS) {
stop_check(KEEPALIVED_EXIT_FATAL);
return;
}
init_checkers_queue();
#ifdef _WITH_VRRP_
init_interface_queue();
kernel_netlink_init();
#endif
/* Parse configuration file */
global_data = alloc_global_data();
check_data = alloc_check_data();
if (!check_data)
stop_check(KEEPALIVED_EXIT_FATAL);
init_data(conf_file, check_init_keywords);
init_global_data(global_data);
/* Post initializations */
#ifdef _MEM_CHECK_
log_message(LOG_INFO, "Configuration is using : %zu Bytes", mem_allocated);
#endif
/* Remove any entries left over from previous invocation */
if (!reload && global_data->lvs_flush)
ipvs_flush_cmd();
#ifdef _WITH_SNMP_CHECKER_
if (!reload && global_data->enable_snmp_checker)
check_snmp_agent_init(global_data->snmp_socket);
#endif
/* SSL load static data & initialize common ctx context */
if (!init_ssl_ctx())
stop_check(KEEPALIVED_EXIT_FATAL);
/* fill 'vsg' members of the virtual_server_t structure.
* We must do that after parsing config, because
* vs and vsg declarations may appear in any order
*/
link_vsg_to_vs();
/* Set the process priority and non swappable if configured */
if (global_data->checker_process_priority)
set_process_priority(global_data->checker_process_priority);
if (global_data->checker_no_swap)
set_process_dont_swap(4096); /* guess a stack size to reserve */
/* Processing differential configuration parsing */
if (reload)
clear_diff_services();
/* Initialize IPVS topology */
if (!init_services())
stop_check(KEEPALIVED_EXIT_FATAL);
/* Dump configuration */
if (__test_bit(DUMP_CONF_BIT, &debug)) {
dump_global_data(global_data);
dump_check_data(check_data);
}
#ifdef _WITH_VRRP_
/* Initialize linkbeat */
init_interface_linkbeat();
#endif
/* Register checkers thread */
register_checkers_thread();
}
/* Daemon init sequence */
static void
start_vrrp(void)
{
/* Initialize sub-system */
init_interface_queue();
kernel_netlink_init();
gratuitous_arp_init();
ndisc_init();
/* Parse configuration file */
global_data = alloc_global_data();
vrrp_data = alloc_vrrp_data();
init_data(conf_file, vrrp_init_keywords);
if (!vrrp_data) {
stop_vrrp();
return;
}
init_global_data(global_data);
#ifdef _WITH_SNMP_
if (!reload && (global_data->enable_snmp_keepalived || global_data->enable_snmp_rfc)) {
vrrp_snmp_agent_init(global_data->snmp_socket);
#ifdef _WITH_SNMP_RFC_
vrrp_start_time = timer_now();
#endif
}
#endif
#ifdef _WITH_LVS_
if (vrrp_ipvs_needed()) {
/* Initialize ipvs related */
if (ipvs_start() != IPVS_SUCCESS) {
stop_vrrp();
return;
}
}
#endif
if (reload) {
clear_diff_saddresses();
clear_diff_srules();
clear_diff_sroutes();
clear_diff_vrrp();
clear_diff_script();
}
/* Complete VRRP initialization */
if (!vrrp_complete_init()) {
if (vrrp_ipvs_needed()) {
stop_vrrp();
}
return;
}
#ifdef _HAVE_LIBIPTC_
iptables_init();
#endif
/* Post initializations */
#ifdef _DEBUG_
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
#endif
/* Set static entries */
netlink_iplist(vrrp_data->static_addresses, IPADDRESS_ADD);
netlink_rulelist(vrrp_data->static_rules, IPRULE_ADD);
netlink_rtlist(vrrp_data->static_routes, IPROUTE_ADD);
/* Dump configuration */
if (__test_bit(DUMP_CONF_BIT, &debug)) {
dump_global_data(global_data);
dump_vrrp_data(vrrp_data);
}
/* Initialize linkbeat */
init_interface_linkbeat();
/* Init & start the VRRP packet dispatcher */
thread_add_event(master, vrrp_dispatcher_init, NULL,
VRRP_DISPATCHER);
}
/* Daemon init sequence */
static void
start_check(void)
{
/* Initialize sub-system */
if (ipvs_start() != IPVS_SUCCESS) {
stop_check();
return;
}
init_checkers_queue();
#ifdef _WITH_VRRP_
init_interface_queue();
kernel_netlink_init();
#endif
#ifdef _WITH_SNMP_
if (!reload && snmp)
check_snmp_agent_init(snmp_socket);
#endif
/* Parse configuration file */
global_data = alloc_global_data();
check_data = alloc_check_data();
init_data(conf_file, check_init_keywords);
if (!check_data) {
stop_check();
return;
}
init_global_data(global_data);
/* Post initializations */
#ifdef _DEBUG_
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
#endif
/* SSL load static data & initialize common ctx context */
if (!init_ssl_ctx()) {
stop_check();
return;
}
/* fill 'vsg' members of the virtual_server_t structure.
* We must do that after parsing config, because
* vs and vsg declarations may appear in any order
*/
link_vsg_to_vs();
/* Processing differential configuration parsing */
if (reload)
clear_diff_services();
/* Initialize IPVS topology */
if (!init_services()) {
stop_check();
return;
}
/* Dump configuration */
if (__test_bit(DUMP_CONF_BIT, &debug)) {
dump_global_data(global_data);
dump_check_data(check_data);
}
#ifdef _WITH_VRRP_
/* Initialize linkbeat */
init_interface_linkbeat();
#endif
/* Register checkers thread */
register_checkers_thread();
}
/* Daemon init sequence */
static void
start_vrrp(void)
{
/* Initialize sub-system */
init_interface_queue();
kernel_netlink_init();
gratuitous_arp_init();
ndisc_init();
global_data = alloc_global_data();
#ifdef _HAVE_LIBIPTC_
iptables_init();
#endif
/* Parse configuration file */
vrrp_data = alloc_vrrp_data();
init_data(conf_file, vrrp_init_keywords);
if (!vrrp_data) {
stop_vrrp();
return;
}
init_global_data(global_data);
/* Set the process priority and non swappable if configured */
if (global_data->vrrp_process_priority)
set_process_priority(global_data->vrrp_process_priority);
if (global_data->vrrp_no_swap)
set_process_dont_swap(4096); /* guess a stack size to reserve */
#ifdef _WITH_SNMP_
if (!reload && (global_data->enable_snmp_keepalived || global_data->enable_snmp_rfcv2 || global_data->enable_snmp_rfcv3)) {
vrrp_snmp_agent_init(global_data->snmp_socket);
#ifdef _WITH_SNMP_RFC_
vrrp_start_time = timer_now();
#endif
}
#endif
#ifdef _WITH_LVS_
if (vrrp_ipvs_needed()) {
/* Initialize ipvs related */
if (ipvs_start() != IPVS_SUCCESS) {
stop_vrrp();
return;
}
#ifdef _HAVE_IPVS_SYNCD_
/* If we are managing the sync daemon, then stop any
* instances of it that may have been running if
* we terminated abnormally */
ipvs_syncd_cmd(IPVS_STOPDAEMON, NULL, IPVS_MASTER, 0, true);
ipvs_syncd_cmd(IPVS_STOPDAEMON, NULL, IPVS_BACKUP, 0, true);
#endif
}
#endif
if (reload) {
clear_diff_saddresses();
#ifdef _HAVE_FIB_ROUTING_
clear_diff_srules();
clear_diff_sroutes();
#endif
clear_diff_vrrp();
clear_diff_script();
}
else {
/* Clear leftover static entries */
netlink_iplist(vrrp_data->static_addresses, IPADDRESS_DEL);
#ifdef _HAVE_FIB_ROUTING_
netlink_rtlist(vrrp_data->static_routes, IPROUTE_DEL);
netlink_error_ignore = ENOENT;
netlink_rulelist(vrrp_data->static_rules, IPRULE_DEL, true);
netlink_error_ignore = 0;
#endif
}
/* Complete VRRP initialization */
if (!vrrp_complete_init()) {
if (vrrp_ipvs_needed()) {
stop_vrrp();
}
return;
}
#ifdef _HAVE_LIBIPTC_
iptables_startup();
#endif
/* Post initializations */
#ifdef _DEBUG_
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
#endif
/* Set static entries */
netlink_iplist(vrrp_data->static_addresses, IPADDRESS_ADD);
#ifdef _HAVE_FIB_ROUTING_
netlink_rtlist(vrrp_data->static_routes, IPROUTE_ADD);
netlink_rulelist(vrrp_data->static_rules, IPRULE_ADD, false);
#endif
/* Dump configuration */
if (__test_bit(DUMP_CONF_BIT, &debug)) {
list ifl;
dump_global_data(global_data);
dump_vrrp_data(vrrp_data);
ifl = get_if_list();
if (!LIST_ISEMPTY(ifl))
dump_list(ifl);
}
/* Initialize linkbeat */
init_interface_linkbeat();
/* Init & start the VRRP packet dispatcher */
thread_add_event(master, vrrp_dispatcher_init, NULL,
VRRP_DISPATCHER);
}
int main(int argc, char **argv)
{
int c, i, retval;
int option = LOG_NDELAY;
pid_t pid, sid;
size_t argv0_len, procname_len, max_procname_len;
progname = argv[0];
shm_common_init();
while (1) {
int option_index = 0;
int curind = optind;
c = getopt_long (argc, argv, "hI:sFf:i:S",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'F':
foreground++;
break;
case 'I':
rtapi_instance = atoi(optarg);
break;
case 'R':
hal_thread_stack_size = atoi(optarg);
break;
case 'i':
instance_name = optarg;
break;
case 'f':
if ((flavor = flavor_byname(optarg)) == NULL) {
fprintf(stderr, "no such flavor: '%s' -- valid flavors are:\n", optarg);
flavor_ptr f = flavors;
while (f->name) {
fprintf(stderr, "\t%s\n", f->name);
f++;
}
exit(1);
}
break;
case 'u':
usr_msglevel = atoi(optarg);
break;
case 'r':
rt_msglevel = atoi(optarg);
break;
case 'H':
halsize = atoi(optarg);
break;
case 'S':
use_shmdrv++;
break;
case 's':
log_stderr++;
option |= LOG_PERROR;
break;
case '?':
if (optopt) fprintf(stderr, "bad short opt '%c'\n", optopt);
else fprintf(stderr, "bad long opt \"%s\"\n", argv[curind]);
exit(1);
break;
default:
usage(argc, argv);
exit(0);
}
}
// sanity
if (getuid() == 0) {
fprintf(stderr, "%s: FATAL - will not run as root\n", progname);
exit(EXIT_FAILURE);
}
if (geteuid() == 0) {
fprintf(stderr, "%s: FATAL - will not run as setuid root\n", progname);
exit(EXIT_FAILURE);
}
if (flavor == NULL)
flavor = default_flavor();
if (flavor == NULL) {
fprintf(stderr, "%s: FATAL - failed to detect thread flavor\n", progname);
exit(EXIT_FAILURE);
}
// can we actually run what's being suggested?
if (!flavor_and_kernel_compatible(flavor)) {
fprintf(stderr, "%s: FATAL - cant run the %s flavor on this kernel\n",
progname, flavor->name);
exit(EXIT_FAILURE);
}
// catch installation error: user not in xenomai group
if (flavor->id == RTAPI_XENOMAI_ID) {
int retval = user_in_xenomai_group();
switch (retval) {
case 1: // yes
break;
case 0:
fprintf(stderr, "this user is not member of group xenomai\n");
fprintf(stderr, "please 'sudo adduser <username> xenomai',"
" logout and login again\n");
exit(EXIT_FAILURE);
default:
fprintf(stderr, "cannot determine if this user "
"is a member of group xenomai: %s\n",
strerror(-retval));
exit(EXIT_FAILURE);
}
}
// do we need the shmdrv module?
if (((flavor->flags & FLAVOR_KERNEL_BUILD) ||
use_shmdrv) &&
!shmdrv_available()) {
fprintf(stderr, "%s: FATAL - %s requires the shmdrv module loaded\n",
progname, use_shmdrv ? "--shmdrv" : flavor->name);
exit(EXIT_FAILURE);
}
// the global segment every entity in HAL/RTAPI land attaches to
if ((retval = create_global_segment()) != 1) // must be a new shm segment
exit(retval);
// good to go
if (!foreground) {
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
if (pid > 0) {
exit(EXIT_SUCCESS);
}
umask(0);
sid = setsid();
if (sid < 0) {
exit(EXIT_FAILURE);
}
#if 0
if ((chdir("/")) < 0) {
exit(EXIT_FAILURE);
}
#endif
}
snprintf(proctitle, sizeof(proctitle), "msgd:%d",rtapi_instance);
openlog_async(proctitle, option , SYSLOG_FACILITY);
// set new process name
argv0_len = strlen(argv[0]);
procname_len = strlen(proctitle);
max_procname_len = (argv0_len > procname_len) ? (procname_len) : (argv0_len);
strncpy(argv[0], proctitle, max_procname_len);
memset(&argv[0][max_procname_len], '\0', argv0_len - max_procname_len);
for (i = 1; i < argc; i++)
memset(argv[i], '\0', strlen(argv[i]));
// this is the single place in all of linuxCNC where the global segment
// gets initialized - no reinitialization from elsewhere
init_global_data(global_data, flavor->id, rtapi_instance,
halsize, rt_msglevel, usr_msglevel,
instance_name,hal_thread_stack_size);
syslog_async(LOG_INFO,
"startup instance=%s pid=%d flavor=%s "
"rtlevel=%d usrlevel=%d halsize=%d shm=%s gcc=%s version=%s",
global_data->instance_name, getpid(),
flavor->name,
global_data->rt_msg_level,
global_data->user_msg_level,
global_data->hal_size,
shmdrv_loaded ? "shmdrv" : "Posix",
__VERSION__,
GIT_VERSION);
syslog_async(LOG_INFO,"configured: %s sha=%s", CONFIG_DATE, GIT_CONFIG_SHA);
syslog_async(LOG_INFO,"built: %s %s sha=%s", __DATE__, __TIME__, GIT_BUILD_SHA);
if (strcmp(GIT_CONFIG_SHA,GIT_BUILD_SHA))
syslog_async(LOG_WARNING, "WARNING: git SHA's for configure and build do not match!");
if ((global_data->rtapi_msgd_pid != 0) &&
kill(global_data->rtapi_msgd_pid, 0) == 0) {
fprintf(stderr,"%s: another rtapi_msgd is already running (pid %d), exiting\n",
progname, global_data->rtapi_msgd_pid);
exit(EXIT_FAILURE);
} else {
global_data->rtapi_msgd_pid = getpid();
}
close(STDIN_FILENO);
close(STDOUT_FILENO);
if (!log_stderr)
close(STDERR_FILENO);
message_thread();
// signal received - check if rtapi_app running, and shut it down
cleanup_actions();
closelog_async();
exit(exit_code);
}
/* Daemon init sequence */
static void
start_vrrp(void)
{
/* Initialize sub-system */
init_interface_queue();
kernel_netlink_init();
gratuitous_arp_init();
ndisc_init();
#ifdef _WITH_SNMP_
if (!reload && snmp)
vrrp_snmp_agent_init();
#endif
/* Parse configuration file */
global_data = alloc_global_data();
vrrp_data = alloc_vrrp_data();
alloc_vrrp_buffer();
init_data(conf_file, vrrp_init_keywords);
if (!vrrp_data) {
stop_vrrp();
return;
}
init_global_data(global_data);
#ifdef _WITH_LVS_
if (vrrp_ipvs_needed()) {
/* Initialize ipvs related */
if (ipvs_start() != IPVS_SUCCESS) {
stop_vrrp();
return;
}
}
#endif
if (reload) {
clear_diff_saddresses();
clear_diff_sroutes();
clear_diff_vrrp();
clear_diff_script();
}
/* Complete VRRP initialization */
if (!vrrp_complete_init()) {
if (vrrp_ipvs_needed()) {
stop_vrrp();
}
return;
}
/* Post initializations */
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
/* Set static entries */
netlink_iplist(vrrp_data->static_addresses, IPADDRESS_ADD, NULL);
netlink_rtlist(vrrp_data->static_routes, IPROUTE_ADD);
/* Dump configuration */
if (debug & 4) {
dump_global_data(global_data);
dump_vrrp_data(vrrp_data);
}
/* Initialize linkbeat */
init_interface_linkbeat();
/* Init & start the VRRP packet dispatcher */
thread_add_event(master, vrrp_dispatcher_init, NULL,
VRRP_DISPATCHER);
}
/* Daemon init sequence */
static void
start_check(void)
{
/* Initialize sub-system */
if (ipvs_start() != IPVS_SUCCESS) {
stop_check();
return;
}
init_checkers_queue();
#ifdef _WITH_VRRP_
init_interface_queue();
kernel_netlink_init();
#endif
#ifdef _WITH_SNMP_
if (!reload && snmp)
check_snmp_agent_init();
#endif
/* Parse configuration file */
global_data = alloc_global_data();
check_data = alloc_check_data();
init_data(conf_file, check_init_keywords);
if (!check_data) {
stop_check();
return;
}
init_global_data(global_data);
/* Post initializations */
log_message(LOG_INFO, "Configuration is using : %lu Bytes", mem_allocated);
/* SSL load static data & initialize common ctx context */
if (!init_ssl_ctx()) {
stop_check();
return;
}
/* Processing differential configuration parsing */
if (reload) {
clear_diff_services();
copy_srv_states();
}
/* Initialize IPVS topology */
if (!init_services()) {
stop_check();
return;
}
/* Dump configuration */
if (debug & 4) {
dump_global_data(global_data);
dump_check_data(check_data);
}
#ifdef _WITH_VRRP_
/* Initialize linkbeat */
init_interface_linkbeat();
#endif
/* Register checkers thread */
register_checkers_thread();
}
int main(dword_t mb_magic, struct multiboot_info *mbi)
{
CORBA_Environment env = idl4_default_environment;
int i,j,msg[8] = { 0,0x6100,0x0100,0,0,0,0,0 };
struct mod_list *mods;
l4_msgdope_t result;
Elf32_Phdr *phdr;
l4_threadid_t msvr;
int mobj, pagerid, tobj;
int blockID=0;
int found_root=0;
int totalBlock=0;
init_global_data();
printf("Booter task (%x) starting, pager is %X\n", booter.raw, sigma0.raw);
check_multiboot_header(mb_magic,&mbi);
printf("Multiboot header found at %X\n", (dword_t) mbi);
mods = (mod_list*) mbi->mods_addr;
secure_modules(mods, (int)mbi->mods_count);
launch_aux_pager();
task[0].active=1;
task[0].root.svr.raw=0;
task[0].root.obj=0;
task[0].memory.svr=sigma0;
task[0].memory.obj=DEFAULT_OBJECT;
strncpy(task[0].cmdline,(char*)mods[BOOTER_MODULE_NR].cmdline,MAXLENGTH);
task[0].task_id=booter;
task[0].owner=booter;
// *************************************************************************
// *** bootup sequence
if (mbi->mods_count < (BOOTER_MODULE_NR+2))
enter_kdebug("nothing to load");
mods = (struct mod_list *) mbi->mods_addr;
nexttask = booter;
(void)nexttask.id.task++;
for (j=BOOTER_MODULE_NR+1;j<(int)mbi->mods_count;j++)
{
Elf32_Ehdr *file_hdr;
// *** check sanity of elf file
file_hdr = (Elf32_Ehdr *) mods[j].mod_start;
if (file_hdr->e_ident[EI_MAG0] != ELFMAG0
|| file_hdr->e_ident[EI_MAG1] != ELFMAG1
|| file_hdr->e_ident[EI_MAG2] != ELFMAG2
|| file_hdr->e_ident[EI_MAG3] != ELFMAG3)
{
i=0;
while ((i<MAXBLOCKS) && (block[i].active)) i++;
if (i<MAXBLOCKS)
{
block[i].active=1;
block[i].phys_addr=(int)mods[j].mod_start;
block[i].capacity=((int)mods[j].mod_end-(int)mods[j].mod_start)/512;
block[i].blocksize=512;
totalBlock++;
if (found_root)
{
char name[20];
sprintf(name,"hd%c",'a'+(blockID++));
directory_link(dev.svr,dev.obj,3,name,&booter,MAXTASKS+i,&env);
}
}
continue;
}
if (file_hdr->e_type != ET_EXEC)
enter_kdebug("unexpected e_type");
if (file_hdr->e_machine != EM_386)
enter_kdebug("not an intel binary");
if (file_hdr->e_version != EV_CURRENT)
enter_kdebug("version mismatch?");
if (file_hdr->e_flags != 0)
enter_kdebug("unexpected flags?");
if (file_hdr->e_phnum <= 0)
enter_kdebug("No loadable program sections");
// *** create the task. this will map the trampoline code into page 0
// of the newly created address space
printf("Task %d: %s\n",(int)nexttask.id.task,(char*)mods[j].cmdline);
l4_task_new(nexttask, 255, 0, 0, auxpager);
// *** if the memory server is already running, make it the new task's
// pager. (should be replaced by dynamic object creation)
if (j>(BOOTER_MODULE_NR+1))
{
if (creator_create(memsvr,DEFAULT_OBJECT,sizeof(api_mem)/sizeof(int),
(sdword*)&api_mem,&msvr,&mobj,&env)!=ESUCCESS)
enter_kdebug("Memory object creation failed");
memory_set_maxpages(msvr,mobj,99999999,&env);
memory_attach(msvr,mobj,&nexttask,&env);
memory_get_pagerid(msvr,mobj,&pagerid,&env);
l4_ipc_send(nexttask,0,TRAMPOLINE_NEW_PAGER,pagerid,0,L4_IPC_NEVER,&result);
} else {
msvr = sigma0;mobj=DEFAULT_OBJECT;
}
// *** allocate struct for the task
tobj=0;
while ((tobj<MAXTASKS) && (task[tobj].active))
tobj++;
if (tobj==MAXTASKS)
enter_kdebug("Too many tasks");
task[tobj].active=1;
if (found_root)
{
task[tobj].root.svr=root.svr;
task[tobj].root.obj=root.obj;
} else {
task[tobj].root.svr.raw=0;
task[tobj].root.obj=0;
}
task[tobj].memory.svr=msvr;
task[tobj].memory.obj=mobj;
strncpy(task[tobj].cmdline,(char*)mods[j].cmdline,MAXLENGTH);
task[tobj].cmdline[MAXLENGTH-1]=0;
task[tobj].task_id=nexttask;
task[tobj].owner=booter;
// *** parse all the headers
phdr = (Elf32_Phdr *) (file_hdr->e_phoff + (unsigned int) file_hdr);
for (i=0;i<file_hdr->e_phnum;i++)
if (phdr[i].p_type == PT_LOAD)
{
// *** notify the trampoline
l4_ipc_send(nexttask,0,TRAMPOLINE_RECEIVE,(int)phdr[i].p_vaddr,
(int)phdr[i].p_filesz,L4_IPC_NEVER,&result);
msg[6]=(int)phdr[i].p_filesz;
msg[7]=(int)file_hdr + phdr[i].p_offset;
// *** send the string ipc. this will cause a bunch of pagefaults,
// which will be handled by the child's pager
#ifdef DEBUG
printf("Copying segment of size %x from address %x to %x\n",msg[6],msg[7],(int)phdr[i].p_vaddr);
#endif
l4_ipc_send(nexttask,&msg,0,0,0,L4_IPC_NEVER,&result);
// *** zero out any bss segments
if (phdr[i].p_memsz>phdr[i].p_filesz)
{
int zero_base = phdr[i].p_vaddr+phdr[i].p_filesz;
int zero_size = phdr[i].p_memsz-phdr[i].p_filesz;
#ifdef DEBUG
printf("Erasing zone at %x, size %x\n",zero_base,zero_size);
#endif
l4_ipc_send(nexttask,0,TRAMPOLINE_ZERO_ZONE,
zero_base,zero_size,L4_IPC_NEVER,&result);
}
}
// *** if this is the memory server, change the pager to sigma0
if (j==(BOOTER_MODULE_NR+1))
l4_ipc_send(nexttask,0,TRAMPOLINE_NEW_PAGER,sigma0.raw,0,L4_IPC_NEVER,&result);
// *** start the program
#ifdef DEBUG
printf("Jumping to program entry point at %x [objID=%d]\n\n",(int)file_hdr->e_entry,tobj);
#endif
l4_ipc_send(nexttask,0,TRAMPOLINE_LAUNCH,tobj,file_hdr->e_entry,L4_IPC_NEVER,&result);
// *** wait until thread leaves the trampoline code
for (i=0;i<3;i++)
l4_thread_switch(nexttask);
// *** flush the trampoline
l4_fpage_unmap(l4_fpage((int)&_trampoline,L4_LOG2_PAGESIZE,0,0),L4_FP_FLUSH_PAGE);
// *** see about the supported interfaces
if (j==(BOOTER_MODULE_NR+1))
{
memsvr=nexttask;
if (generic_implements(nexttask,DEFAULT_OBJECT,sizeof(api_creator)/sizeof(int),(sdword*)&api_creator,&env)!=EYES)
enter_kdebug("Memory server does not support Creator API");
if (creator_can_create(nexttask,DEFAULT_OBJECT,sizeof(api_mem)/sizeof(int),(sdword*)&api_mem,&env)!=EYES)
enter_kdebug("Memory server cannot create memory objects");
}
if (!found_root)
if (generic_implements(nexttask,DEFAULT_OBJECT,sizeof(api_creator)/sizeof(int),(sdword*)&api_creator,&env)==EYES)
if (creator_can_create(nexttask,DEFAULT_OBJECT,sizeof(api_directory)/sizeof(int),(sdword*)&api_directory,&env)==EYES)
{
root.svr=nexttask;found_root=1;
#ifdef DEBUG
printf("Found root nameserver (%X), creating /...\n",root.svr.raw);
#endif
if (creator_create(root.svr,DEFAULT_OBJECT,sizeof(api_directory)/sizeof(int),(sdword*)&api_directory,&root.svr,&root.obj,&env)!=ESUCCESS)
enter_kdebug("Root directory creation failed");
if (creator_create(root.svr,DEFAULT_OBJECT,sizeof(api_directory)/sizeof(int),(sdword*)&api_directory,&dev.svr,&dev.obj,&env)!=ESUCCESS)
enter_kdebug("/dev directory creation failed");
if (generic_implements(root.svr,root.obj,sizeof(api_directory)/sizeof(int),(sdword*)&api_directory,&env)!=EYES)
enter_kdebug("Defective root directory");
if (directory_link(root.svr,root.obj,3,"dev",&dev.svr,dev.obj,&env)!=ESUCCESS)
enter_kdebug("Cannot link dev into /");
if (directory_link(dev.svr,dev.obj,7,"tasksvr",&booter,0,&env)!=ESUCCESS)
enter_kdebug("Cannot link tasksvr into /dev/");
for (int i=0;i<MAXBLOCKS;i++)
if (block[i].active)
{
char name[20];
sprintf(name,"hd%c",'a'+(blockID++));
directory_link(dev.svr,dev.obj,3,name,&booter,MAXTASKS+i,&env);
}
for (int k=0;k<MAXTASKS;k++)
if ((task[k].active) && (!task[k].root.svr.raw))
{
task[k].root.svr=root.svr;
task[k].root.obj=root.obj;
}
#ifdef DEBUG
printf("Root creation completed, all servers notified\n\n");
#endif
}
(void)nexttask.id.task++;
}
// *** modify the trampoline to work with elf launcher
// *** this is BAD magic!
int *m1=(int*)(((int)&_m1)+1);
int *m2=(int*)(((int)&_m2)+1);
*m1=0x04041001;
*m2=0x04041001;
if (totalBlock)
printf("Created %d block device(s)\n",totalBlock);
// *** enter server loop
booter_server();
}