/*
* sem_init - initialize a semaphore.
*
* sem_init() creates a new semaphore if the specified
* semaphore does not exist yet. If the semaphore already
* exists, it is re-initialized only if nobody is waiting for
* it. The initial semaphore value is set to the requested
* value.
*/
int
sem_init(sem_t *sem, u_int value)
{
struct sem *s;
int err = 0;
if (value > MAXSEMVAL)
return EINVAL;
if (umem_copyin(sem, &s, sizeof(sem)))
return EFAULT;
/*
* An application can call sem_init() to reset the
* value of existing semaphore. So, we have to check
* whether the semaphore is already allocated.
*/
sched_lock();
if (s && sem_valid(s)) {
/*
* Semaphore already exists.
*/
if (s->task != cur_task() &&
!task_capable(CAP_SEMAPHORE))
err = EPERM;
else if (event_waiting(&s->event))
err = EBUSY;
else
s->value = value;
} else {
/*
* Create new semaphore.
*/
if ((s = kmem_alloc(sizeof(*s))) == NULL)
err = ENOSPC;
else {
event_init(&s->event, "semaphore");
s->task = cur_task();
s->value = value;
s->magic = SEM_MAGIC;
if (umem_copyout(&s, sem, sizeof(s))) {
kmem_free(s);
err = EFAULT;
}
}
}
sched_unlock();
return err;
}
/*
* Destroy a condition variable.
*
* If there are any blocked thread waiting for the specified
* CV, it returns EBUSY.
*/
int
cond_destroy(cond_t *cond)
{
cond_t c;
int err;
sched_lock();
if ((err = cond_copyin(cond, &c))) {
sched_unlock();
return err;
}
if (event_waiting(&c->event)) {
sched_unlock();
return DERR(EBUSY);
}
c->magic = 0;
kmem_free(c);
sched_unlock();
return 0;
}
/*
* Destroy a semaphore.
* If some thread is waiting for the specified semaphore,
* this routine fails with EBUSY.
*/
int
sem_destroy(sem_t *sem)
{
sem_t s;
int err;
sched_lock();
if ((err = sem_copyin(sem, &s))) {
sched_unlock();
return err;
}
if (event_waiting(&s->event)) {
sched_unlock();
return EBUSY;
}
s->magic = 0;
kmem_free(s);
sched_unlock();
return 0;
}
//
// get_event()
// Get and handle waiting events
//
void event_handler::get_event(event &ev) {
event *ep;
while (!ewaiting) {
event_waiting();
if (!ewaiting) {
// Sleep for 1 millisecond if there are no events
Timer tmp;
tmp.WaitMs(1);
}
}
ep = (event *) events.first();
if (ep) {
ev = *ep;
events.unlink(ep);
delete ep;
ewaiting = events.first() != NULL;
} else {
// NOTE : that the mouse status should be known
// even if another event has occurred.
ev.mouse_move.x = mouse->x();
ev.mouse_move.y = mouse->y();
ev.mouse_button = mouse->button();
// Gather events
SDL_Event event;
if (SDL_PollEvent(&event)) {
// always sort the mouse out
handle_mouse(ev);
mouse->update(ev.mouse_move.x, ev.mouse_move.y, ev.mouse_button);
switch (event.type) {
case SDL_QUIT: {
exit(0);
break;
}
case SDL_MOUSEBUTTONUP: {
switch (event.button.button) {
case 4: // Mouse wheel goes up...
{
ev.key = get_key_binding("b4", 0);
ev.type = EV_KEYRELEASE;
break;
}
case 5: // Mouse wheel goes down...
{
ev.key = get_key_binding("b3", 0);
ev.type = EV_KEYRELEASE;
break;
}
}
break;
}
case SDL_MOUSEBUTTONDOWN: {
switch (event.button.button) {
case 4: // Mouse wheel goes up...
{
ev.key = get_key_binding("b4", 0);
ev.type = EV_KEY;
break;
}
case 5: // Mouse wheel goes down...
{
ev.key = get_key_binding("b3", 0);
ev.type = EV_KEY;
break;
}
}
break;
}
case SDL_KEYDOWN:
case SDL_KEYUP: {
// Default to EV_SPURIOUS
ev.key = EV_SPURIOUS;
if (event.type == SDL_KEYDOWN) {
ev.type = EV_KEY;
} else {
ev.type = EV_KEYRELEASE;
}
switch (event.key.keysym.sym) {
case SDLK_DOWN:
ev.key = JK_DOWN;
break;
case SDLK_UP:
ev.key = JK_UP;
break;
case SDLK_LEFT:
ev.key = JK_LEFT;
break;
case SDLK_RIGHT:
ev.key = JK_RIGHT;
break;
case SDLK_LCTRL:
ev.key = JK_CTRL_L;
break;
case SDLK_RCTRL:
ev.key = JK_CTRL_R;
break;
case SDLK_LALT:
ev.key = JK_ALT_L;
break;
case SDLK_RALT:
ev.key = JK_ALT_R;
break;
case SDLK_LSHIFT:
ev.key = JK_SHIFT_L;
break;
case SDLK_RSHIFT:
ev.key = JK_SHIFT_R;
break;
case SDLK_NUMLOCK:
ev.key = JK_NUM_LOCK;
break;
case SDLK_HOME:
ev.key = JK_HOME;
break;
case SDLK_END:
ev.key = JK_END;
break;
case SDLK_BACKSPACE:
ev.key = JK_BACKSPACE;
break;
case SDLK_TAB:
ev.key = JK_TAB;
break;
case SDLK_RETURN:
ev.key = JK_ENTER;
break;
case SDLK_SPACE:
ev.key = JK_SPACE;
break;
case SDLK_CAPSLOCK:
ev.key = JK_CAPS;
break;
case SDLK_ESCAPE:
ev.key = JK_ESC;
break;
case SDLK_F1:
ev.key = JK_F1;
break;
case SDLK_F2:
ev.key = JK_F2;
break;
case SDLK_F3:
ev.key = JK_F3;
break;
case SDLK_F4:
ev.key = JK_F4;
break;
case SDLK_F5:
ev.key = JK_F5;
break;
case SDLK_F6:
ev.key = JK_F6;
break;
case SDLK_F7:
ev.key = JK_F7;
break;
case SDLK_F8:
ev.key = JK_F8;
break;
case SDLK_F9:
ev.key = JK_F9;
break;
case SDLK_F10:
ev.key = JK_F10;
break;
case SDLK_INSERT:
ev.key = JK_INSERT;
break;
case SDLK_KP0:
ev.key = JK_INSERT;
break;
case SDLK_PAGEUP:
ev.key = JK_PAGEUP;
break;
case SDLK_PAGEDOWN:
ev.key = JK_PAGEDOWN;
break;
case SDLK_KP8:
ev.key = JK_UP;
break;
case SDLK_KP2:
ev.key = JK_DOWN;
break;
case SDLK_KP4:
ev.key = JK_LEFT;
break;
case SDLK_KP6:
ev.key = JK_RIGHT;
break;
case SDLK_F11: {
// Only handle key down
if (ev.type == EV_KEY) {
// Toggle fullscreen
SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
}
ev.key = EV_SPURIOUS;
break;
}
case SDLK_F12: {
// Only handle key down
if (ev.type == EV_KEY) {
// Toggle grab mouse
if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON) {
the_game->show_help("Grab Mouse: OFF\n");
SDL_WM_GrabInput (SDL_GRAB_OFF);
} else {
the_game->show_help("Grab Mouse: ON\n");
SDL_WM_GrabInput (SDL_GRAB_ON);
}
}
ev.key = EV_SPURIOUS;
break;
}
case SDLK_PRINT: // print-screen key
{
// Only handle key down
if (ev.type == EV_KEY) {
// Grab a screenshot
SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
the_game->show_help(
"Screenshot saved to: screenshot.bmp.\n");
}
ev.key = EV_SPURIOUS;
break;
}
default: {
ev.key = (int) event.key.keysym.sym;
// Need to handle the case of shift being pressed
// There has to be a better way
if ((event.key.keysym.mod & KMOD_SHIFT) != 0) {
if (event.key.keysym.sym >= SDLK_a
&& event.key.keysym.sym <= SDLK_z) {
ev.key -= 32;
} else if (event.key.keysym.sym >= SDLK_1
&& event.key.keysym.sym <= SDLK_5) {
ev.key -= 16;
} else {
switch (event.key.keysym.sym) {
case SDLK_6:
ev.key = SDLK_CARET;
break;
case SDLK_7:
case SDLK_9:
case SDLK_0:
ev.key -= 17;
break;
case SDLK_8:
ev.key = SDLK_ASTERISK;
break;
case SDLK_MINUS:
ev.key = SDLK_UNDERSCORE;
break;
case SDLK_EQUALS:
ev.key = SDLK_PLUS;
break;
case SDLK_COMMA:
ev.key = SDLK_LESS;
break;
case SDLK_PERIOD:
ev.key = SDLK_GREATER;
break;
case SDLK_SLASH:
ev.key = SDLK_QUESTION;
break;
case SDLK_SEMICOLON:
ev.key = SDLK_COLON;
break;
case SDLK_QUOTE:
ev.key = SDLK_QUOTEDBL;
break;
default:
break;
}
}
}
}
}
break;
}
}
}
// No more events
ewaiting = 0;
}
}
void
cos_init(void *d)
{
DOUT("CBUFMgr: %d in spd %ld cbuf mgr running.....\n", cos_get_thd_id(), cos_spd_id());
LOCK_INIT();
cos_map_init_static(&cb_ids);
BUG_ON(cos_map_add(&cb_ids, NULL)); /* reserve id 0 */
int i;
memset(spd_tmem_info_list, 0, sizeof(struct spd_tmem_info) * MAX_NUM_SPDS);
for(i = 0; i < MAX_NUM_SPDS; i++){
spd_tmem_info_list[i].spdid = i;
INIT_LIST(&spd_tmem_info_list[i].ci, next, prev);
INIT_LIST(&spd_tmem_info_list[i].tmem_list, next, prev);
INIT_LIST(&spd_tmem_info_list[i].bthd_list, next, prev);
}
free_tmem_list = NULL;
INIT_LIST(&global_blk_list, next, prev);
tmems_allocated = 0;
// Map all of the spds we can into this component
for (i = 0 ; i < MAX_NUM_SPDS ; i++) {
spdid_t spdid = i;
void *hp;
hp = valloc_alloc(cos_spd_id(), cos_spd_id(), 1);
spdid = cinfo_get_spdid(i);
if (!spdid) break;
if(cinfo_map(cos_spd_id(), (vaddr_t)hp, spdid)){
DOUT("Could not map cinfo page for %d\n", spdid);
BUG();
}
/* spd_tmem_info_list[spdid].ci = hp; */
spd_tmem_info_list[spdid].ci.spd_cinfo_page = hp;
/* spd_tmem_info_list[spdid].spd_cinfo_page = hp; */
spd_tmem_info_list[spdid].ci.meta = NULL;
spd_tmem_info_list[spdid].managed = 1;
spd_tmem_info_list[spdid].relinquish_mark = 0;
tmems_target += DEFAULT_TARGET_ALLOC;
spd_tmem_info_list[spdid].num_allocated = 0;
spd_tmem_info_list[spdid].num_desired = DEFAULT_TARGET_ALLOC;
spd_tmem_info_list[spdid].num_blocked_thds = 0;
spd_tmem_info_list[spdid].num_waiting_thds = 0;
spd_tmem_info_list[spdid].num_glb_blocked = 0;
spd_tmem_info_list[spdid].ss_counter = 0;
spd_tmem_info_list[spdid].ss_max = MAX_NUM_MEM;
empty_comps++;
}
over_quota_total = 0;
over_quota_limit = MAX_NUM_MEM;
event_waiting();
return;
}
