/* OBS! For fsrouter to work it must be initialized from globals.c:init_globals() */
int io_load_file33(const char * filename, void ** addr, unsigned long * size) {
static l4_threadid_t fs_drvc_id;
l4_threadid_t dm_id;
l4dm_dataspace_t ds;
CORBA_Environment _env = dice_default_environment;
char drv = get_drv(filename);
if(drv == '\0') {
//io_printf("io.c Warning, no drive in filename, assume c: for now.\n");
drv = 'c';
}
/* How to find the working directory? From this thread ( l4thread_myself() ) find the thread's
process (our own prcess structure) and lookup the working directory there.
L4 has a task- and thread number, as seen in output by [x.y] */
struct I_Fs_srv *target_fs_srv = FSRouter_route(&fsrouter, drv );
//io_printf("io_load_file: '%s'\n", filename);
if(target_fs_srv) {
if (!names_waitfor_name(target_fs_srv->server, &fs_drvc_id, 10000))
{
io_printf("File provider %s doesn't answer\n", target_fs_srv->mountpoint);
return 2;
};
dm_id = l4env_get_default_dsm();
if (l4_is_invalid_id(dm_id))
{
io_printf("Bad dataspace!\n");
return 1;
}
int f_status = l4fprov_file_open_call(&fs_drvc_id,
filename, /* OBS! Ta bort enheten från sökvägen! */
&dm_id,
0, &ds, size, &_env);
if(f_status)
return 2;
f_status=l4rm_attach(&ds, *size, 0,
L4DM_RO | L4RM_MAP, addr);
if(f_status)
{
io_printf("error %s\n", l4env_errstr(f_status));
return 2;
}
//io_printf("io_load_file(: '%s', 0x%x, %d )\n", filename, *addr, *size);
return 0;
} else {
io_printf("target_fs_srv: 0x%x\n", target_fs_srv);
return 2; /* ERROR_FILE_NOT_FOUND; */
}
static void get_fb(void)
{
l4_addr_t fpage_addr;
l4_size_t fpage_size;
l4dm_dataspace_t ds;
CORBA_Environment env = dice_default_environment;
int i, pages, error;
struct stat st;
/* check if we're running under L4Linux */
if (stat("/proc/l4", &st) == -1) {
fprintf(stderr, "Error: /proc/l4 doesn't exist, not running on L4Linux?!\n");
exit(1);
}
/* ask for 'con' (timeout = 5000 ms) */
if (names_waitfor_name(CON_NAMES_STR, &con_l4id, 5000) == 0) {
fprintf(stderr, "PANIC: %s not registered at names", CON_NAMES_STR);
exit(1);
}
INFO("Found my console through names, it's at "l4util_idfmt".\n",
l4util_idstr(con_l4id));
PRINT("Screenshot'ing, please smile... ;-)\n");
/* get screenshot */
if (con_if_screenshot_call(&con_l4id, get_vc, &ds,
&xres, &yres, &bpp, &env)) {
fprintf(stderr, "Could not get screenshot\n");
exit(1);
}
INFO("Got screenshot: res: %dx%d, bpp: %d\n", xres, yres, bpp);
if (l4dm_mem_size(&ds, &fb_size)) {
fprintf(stderr, "Couldn't get size of data space\n");
exit(1);
}
INFO("Size of data space: %d\n", fb_size);
if ((fb_mem = malloc(fb_size)) == NULL) {
fprintf(stderr, "Couldn't malloc %d Bytes of memory!\n", fb_size);
exit(1);
}
raw_pic_size = xres*yres*3;
if ((raw_pic_mem = malloc(raw_pic_size)) == NULL) {
fprintf(stderr, "Couldn't malloc %d bytes of memory!\n", raw_pic_size);
exit(1);
}
pages = fb_size / L4_PAGESIZE; // size is always a multiple of L4_PAGESIZE?
for (i = 0; i < pages; i++) {
/* unmap memory */
l4_fpage_unmap(l4_fpage((l4_umword_t)map_page, L4_LOG2_PAGESIZE,
L4_FPAGE_RW, L4_MAP_ITEM_MAP),
L4_FP_FLUSH_PAGE|L4_FP_ALL_SPACES);
/* page in L4 page */
if ((error = l4dm_map_pages(&ds, i*L4_PAGESIZE, L4_PAGESIZE,
(l4_addr_t)map_page, L4_LOG2_PAGESIZE,
0, L4DM_RO, &fpage_addr,&fpage_size)) < 0) {
fprintf(stderr, "Error %d requesting ds %d at ds_manager "
l4util_idfmt"\n",
error, ds.id, l4util_idstr(ds.manager));
l4dm_close(&ds);
exit(error);
}
memcpy(fb_mem + i*L4_PAGESIZE, map_page, L4_PAGESIZE);
}
if (l4dm_close(&ds)) {
fprintf(stderr, "Error on closing dataspace, expect memory leakage...\n");
}
}
/******************************************************************************
* main *
* *
* Main function *
******************************************************************************/
int main(int argc, char *argv[])
{
int error = 0, i=1;
l4_threadid_t dummy_l4id = L4_NIL_ID, loader_id;
// l4events_event_t event;
// l4events_nr_t eventnr;
CORBA_Environment _env = dice_default_environment;
/* init */
do_args(argc, argv);
my_l4id = l4thread_l4_id( l4thread_myself() );
LOG("Hello, I'm running as "l4util_idfmt, l4util_idstr(my_l4id));
/* ask for 'con' (timeout = 5000 ms) */
if (names_waitfor_name(CON_NAMES_STR, &con_l4id, 50000) == 0)
{
LOG("PANIC: %s not registered at names", CON_NAMES_STR);
enter_kdebug("panic");
}
if (names_waitfor_name("LOADER", &loader_id, 50000) == 0)
{
LOG("PANIC: LOADER not registered at names");
enter_kdebug("panic");
}
if (con_if_openqry_call(&con_l4id, MY_SBUF_SIZE, 0, 0,
L4THREAD_DEFAULT_PRIO,
&vc_l4id,
CON_VFB, &_env))
enter_kdebug("Ouch, open vc failed");
if (con_vc_smode_call(&vc_l4id, CON_OUT, &dummy_l4id, &_env))
enter_kdebug("Ouch, setup vc failed");
if (con_vc_graph_gmode_call(&vc_l4id, &gmode, &xres, &yres,
&bits_per_pixel, &bytes_per_pixel,
&bytes_per_line, &accel_flags,
&fn_x, &fn_y, &_env))
enter_kdebug("Ouch, graph_gmode failed");
if (bytes_per_pixel != 2)
{
printf("Graphics mode not 2 bytes/pixel, exiting\n");
con_vc_close_call(&vc_l4id, &_env);
exit(0);
}
if (create_logo())
enter_kdebug("Ouch, logo creation failed");
while (!error && (i>0))
{
if ((error = clear_screen()))
enter_kdebug("Ouch, clear_screen failed");
if ((error = logo()))
enter_kdebug("Ouch, logo failed");
l4_sleep(500);
i--;
}
if (con_vc_close_call(&vc_l4id, &_env))
enter_kdebug("Ouch, close vc failed?!");
LOG("Finally closed vc");
LOG("Going to bed ...");
names_register("CON_DEMO1");
/*
my_id = l4_myself();
event.len=sizeof(l4_umword_t);
*(l4_umword_t*)event.str=my_id.id.task;
l4events_send(1, &event, &eventnr, L4EVENTS_SEND_ACK);
l4events_get_ack(eventnr, L4_IPC_NEVER);
*/
return 0;
}
/******************************************************************************
* main *
* *
* Main function *
******************************************************************************/
int main(int argc, char *argv[])
{
int error = 0;
l4_threadid_t dummy_l4id = L4_NIL_ID;
CORBA_Environment _env = dice_default_environment;
/* init */
do_args(argc, argv);
my_l4id = l4thread_l4_id( l4thread_myself() );
LOG("Hello, I'm running as "l4util_idfmt, l4util_idstr(my_l4id));
/* ask for 'con' (timeout = 5000 ms) */
if (names_waitfor_name(CON_NAMES_STR, &con_l4id, 50000) == 0)
{
LOG("PANIC: %s not registered at names", CON_NAMES_STR);
enter_kdebug("panic");
}
if (con_if_openqry_call(&con_l4id, MY_SBUF_SIZE, 0, 0,
L4THREAD_DEFAULT_PRIO,
&vc_l4id,
CON_VFB, &_env))
enter_kdebug("Ouch, open vc failed");
if (con_vc_smode_call(&vc_l4id, CON_OUT, &dummy_l4id, &_env))
enter_kdebug("Ouch, setup vc failed");
if (con_vc_graph_gmode_call(&vc_l4id, &gmode, &xres, &yres,
&bits_per_pixel, &bytes_per_pixel,
&bytes_per_line, &accel_flags,
&fn_x, &fn_y, &_env))
enter_kdebug("Ouch, graph_gmode failed");
if (bytes_per_pixel != 2)
{
printf("Graphics mode not 2 bytes/pixel, exiting\n");
con_vc_close_call(&vc_l4id, &_env);
exit(0);
}
if (create_logo())
enter_kdebug("Ouch, logo creation failed");
while (!error)
{
if ((error = clear_screen()))
enter_kdebug("Ouch, clear_screen failed");
if ((error = logo()))
enter_kdebug("Ouch, logo failed");
l4_sleep(2000);
}
if (con_vc_close_call(&vc_l4id, &_env))
enter_kdebug("Ouch, close vc failed?!");
LOG("Finally closed vc");
LOG("Going to bed ...");
l4_sleep(-1);
return 0;
}
void
exec_runserver(int ppid)
{
int i, j;
char *s, *p, *q, *name;
char params[] = "";
char server[0x20];
char *srv, *to;
int timeout = 30000;
l4_threadid_t tid;
struct t_os2process *proc; // server PTDA/proc
for (i = 0; i < 5; i++)
{
name = (char *)type[i].name;
io_log("name=%s\n", name);
if (!strcmp(name, "RUNSERVER"))
{
for (j = 0; j < type[i].ip; j++)
{
s = type[i].sp[j].string;
p = getcmd (s);
s = skipto(0, s);
q = strdup(p);
// create proc/PTDA structure
proc = PrcCreate(ppid, // ppid
basename(q), // pPrg
NULL, // pArg
NULL); // pEnv
free(q);
l4os3_exec (p, params, &tid);
io_log("started task: %x.%x\n", tid.id.task, tid.id.lthread);
/* set task number */
proc->task = tid;
if (strstr(p, "os2fs"))
{
io_log("os2fs started\n");
if (!names_waitfor_name("os2fs", &fs, 30000))
{
io_log("Can't find os2fs on name server!\n");
return;
}
}
srv = getcmd (skipto(0, strstr(s, "-LOOKFOR")));
/* skip spaces and quotes */
for (p = srv; *p == '"' || *p == ' '; p++) ;
srv = p;
for (p = srv + strlen(srv) - 1; *p == '"' || *p == ' '; p--) *p = '\0';
strcpy (server, srv);
to = getcmd (skipto(0, strstr(s, "-TIMEOUT")));
timeout = atoi (to);
io_log("LOOKFOR:%s, TIMEOUT:%d\n", server, timeout);
if (*server && !names_waitfor_name(server, &tid, timeout))
{
io_log("Timeout waiting for %s\n", server);
return;
}
}
io_log("Server %s started\n", server);
}
}
return;
}
int main (int argc, char *argv[])
{
//CORBA_Environment env = dice_default_environment;
l4_uint32_t area;
int rc = 0;
int optionid;
int opt = 0;
const struct option long_options[] =
{
{ "events", no_argument, NULL, 'e'},
{ 0, 0, 0, 0}
};
if (!names_waitfor_name("os2srv", &os2srv, 30000))
{
LOG("Can't find os2srv on names, exiting...");
__exit(1, 1);
}
if (!names_waitfor_name(fprov, &fprov_id, 30000))
{
LOG("Can't find %s on names, exiting...", fprov);
__exit(1, 1);
}
// reserve the lower 64 Mb for OS/2 app
rc = l4rm_area_reserve_region(0x10000, 0x04000000 - 0x10000, 0, &area);
if (rc < 0)
{
LOG("Panic: something is using memory within the 1st 64 Mb!");
__exit(1, 1);
}
/* query default dataspace manager id */
dsm = l4env_get_default_dsm();
if (l4_is_invalid_id(dsm))
{
LOG("No dataspace manager found\n");
__exit(1, 1);
}
LOG("dsm=%u.%u", dsm.id.task, dsm.id.lthread);
LOG("frov_id=%u.%u", fprov_id.id.task, fprov_id.id.lthread);
l4env_infopage = &infopg;
l4env_infopage->fprov_id = fprov_id;
l4env_infopage->memserv_id = dsm;
if ((rc = DlOpen("/file/system/libkal.s.so", &kalHandle)))
{
LOG("Can't load libkal.s.so");
__exit(1, 1);
}
LOG("kalHandle=%lu", kalHandle);
// fill in the parameter structure for KalInit
initstr.stack = __stack;
initstr.l4rm_do_attach = l4rm_do_attach;
initstr.l4rm_detach = l4rm_detach;
initstr.l4rm_lookup = l4rm_lookup;
initstr.l4rm_lookup_region = l4rm_lookup_region;
initstr.l4rm_do_reserve = l4rm_do_reserve;
initstr.l4rm_set_userptr = l4rm_set_userptr;
initstr.l4rm_get_userptr = l4rm_get_userptr;
initstr.l4rm_area_release = l4rm_area_release;
initstr.l4rm_area_release_addr = l4rm_area_release_addr;
initstr.l4rm_show_region_list = l4rm_show_region_list;
initstr.l4env_get_default_dsm = l4env_get_default_dsm;
initstr.fiasco_gdt_set = __fiasco_gdt_set;
initstr.fiasco_gdt_get_entry_offset = __fiasco_gdt_get_entry_offset;
initstr.logtag = LOG_tag;
// init kal.dll
DlRoute(0, "KalInit", &initstr);
// Parse command line arguments
for (;;)
{
opt = getopt_long(argc, argv, "e", long_options, &optionid);
if (opt == -1) break;
switch (opt)
{
case 'e':
LOG("using events server");
use_events = 1;
break;
default:
LOG("Error: Unknown option %c", opt);
usage();
__exit(1, 2);
}
}
// start events thread
if (use_events)
{
// start events thread
l4thread_create((void *)event_thread, 0, L4THREAD_CREATE_ASYNC);
LOG("event thread started");
}
// release the reserved area for application
rc = l4rm_area_release(area);
LOG("calling KalStartApp...");
DlRoute(0, "KalStartApp", argv[argc - 1]);
return 0;
}
void main (int argc, char *argv[])
{
CORBA_Server_Environment env = dice_default_server_environment;
l4dm_dataspace_t ds;
l4_threadid_t pager;
l4_addr_t addr;
l4_size_t size;
int rc, t;
int is_int = 0;
int value_int = 0;
char buf[0x1000];
char *p = buf;
int optionid;
int opt = 0;
const struct option long_options[] =
{
{ "events", no_argument, NULL, 'e'},
{ 0, 0, 0, 0}
};
//init_globals();
if (!names_register("os2exec"))
{
LOG("Error registering on the name server!");
return;
}
if (!names_waitfor_name("os2srv", &os2srv, 30000))
{
LOG("os2srv not found on name server!");
return;
}
if (!names_waitfor_name("os2fs", &fs, 30000))
{
LOG("os2fs not found on name server!");
return;
}
LOG("os2fs tid:%x.%x", fs.id.task, fs.id.lthread);
if (!names_waitfor_name("LOADER", &loader, 30000))
{
LOG("LOADER not found on name server!");
return;
}
execsrv = l4_myself();
// Parse command line arguments
for (;;)
{
opt = getopt_long(argc, argv, "e", long_options, &optionid);
if (opt == -1) break;
switch (opt)
{
case 'e':
LOG("using events server");
use_events = 1;
break;
default:
LOG("Error: Unknown option %c", opt);
usage();
return;
}
}
// start events thread
if (use_events)
{
// start events thread
l4thread_create(event_thread, 0, L4THREAD_CREATE_ASYNC);
LOG("event thread started");
}
/* reserve the area below 64 Mb for application private code
(not for use by libraries, loaded by execsrv) */
addr = 0x2f000; size = 0x04000000 - addr;
if ((rc = l4rm_direct_area_setup_region(addr,
size,
L4RM_DEFAULT_REGION_AREA,
L4RM_REGION_BLOCKED, 0,
L4_INVALID_ID)) < 0)
{
LOG_printf("main(): setup region %x-%x failed (%d)!\n",
addr, addr + size, rc);
l4rm_show_region_list();
enter_kdebug("PANIC");
}
memset (&options, 0, sizeof(options));
#if 0
if (!CfgGetopt("debugmodmgr", &is_int, &value_int, (char **)&p))
if (is_int)
options.debugmodmgr = value_int;
if (!CfgGetopt("debugixfmgr", &is_int, &value_int, (char **)&p))
if (is_int)
options.debugixfmgr = value_int;
if (!CfgGetopt("libpath", &is_int, &value_int, (char **)&p))
if (!is_int)
{
options.libpath = (char *)malloc(strlen(p) + 1);
strcpy(options.libpath, p);
}
LOG("debugmodmgr=%d", options.debugmodmgr);
LOG("debugixfmgr=%d", options.debugixfmgr);
LOG("libpath=%s", options.libpath);
#endif
options.libpath = (char *)malloc(4);
strcpy(options.libpath, "c:\\");
/* get our l4env infopage as a dataspace */
rc = l4loader_app_info_call(&loader, l4_myself().id.task,
0, &p, &ds, &env);
/* attach it */
attach_ds(&ds, L4DM_RO, &infopage);
#if 0
/* load shared libs */
rc = loadso();
if (rc)
{
LOG("Error loading shared libraries");
return;
}
#endif
init_memmgr(&root_area);
/* load IXF's */
rc = load_ixfs();
if (rc)
{
LOG("Error loading IXF driver");
return;
}
/* Initializes the module list. Keeps info about which dlls an process have loaded and
has linked to it (Only support for LX dlls so far). The head of the linked list is
declared as a global inside dynlink.c */
rc = ModInitialize();
if (rc)
{
LOG("Can't initialize module manager");
return;
}
// server loop
LOG("execsrv started.");
env.malloc = (dice_malloc_func)malloc;
env.free = (dice_free_func)free;
os2exec_server_loop(&env);
}
int main(int argc, char **argv)
{
CORBA_Environment env = dice_default_environment;
int optionid;
int opt = 0;
const struct option long_options[] =
{
{ "events", no_argument, NULL, 'e'},
{ 0, 0, 0, 0}
};
//int rc;
init_globals();
//FSR_INIT();
if (!names_register("os2fs"))
{
LOG("Can't register on the name server!");
return 1;
}
LOG("registered at the name server");
if (!names_waitfor_name("os2srv", &os2srv, 30000))
{
LOG("Can't find os2srv on names, exiting...");
return 1;
}
LOG("got os2srv tid from the name server");
LOG("argc=%d", argc);
// Parse command line arguments
for (;;)
{
opt = getopt_long(argc, argv, "e", long_options, &optionid);
LOG("opt=%d", opt);
if (opt == -1) break;
switch (opt)
{
case 'e':
LOG("using events server");
use_events = 1;
break;
default:
LOG("Error: Unknown option %c", opt);
usage();
break;
}
}
// start events thread
if (use_events)
{
// start events thread
l4thread_create((void *)event_thread, 0, L4THREAD_CREATE_ASYNC);
LOG("event thread started");
}
// my id
fs = l4_myself();
// server loop
LOG("going to the server loop");
env.malloc = (dice_malloc_func)malloc;
env.free = (dice_free_func)free;
os2fs_server_loop(&env);
return 0;
}
