int spnav_remove_events(int type)
{
int rm_count = 0;
#ifdef USE_X11
if(dpy) {
XEvent xev;
while(XCheckIfEvent(dpy, &xev, match_events, (char*)&type)) {
rm_count++;
}
return rm_count;
}
#endif
if(sock) {
struct event_node *tmplist, *tmptail;
if(!(tmplist = tmptail = malloc(sizeof *tmplist))) {
return -1;
}
tmplist->next = 0;
/* while there are events in the event queue, or the daemon socket */
while(event_pending(sock)) {
spnav_event event;
read_event(sock, &event); /* remove next event */
if(event.type != type) {
/* We don't want to drop this one, wrong type. Keep the event
* in the temporary list, for deferred reinsertion
*/
enqueue_event(&event, &tmptail);
} else {
rm_count++;
}
}
/* reinsert any events we removed that we didn't mean to */
while(tmplist->next) {
struct event_node *node = tmplist->next;
enqueue_event(&node->event, 0);
free(tmplist);
tmplist = node;
}
return rm_count;
}
return 0;
}
static void events_put_mouse(void *opaque, int dx, int dy, int dz, int buttons_state)
{
events_state *s = (events_state *) opaque;
/* in the Android emulator, we use dz == 0 for touchscreen events,
* and dz == 1 for trackball events. See the kbd_mouse_event calls
* in android/skin/trackball.c and android/skin/window.c
*/
if (dz == 0) {
if (androidHwConfig_isScreenMultiTouch(android_hw)) {
/* Convert mouse event into multi-touch event */
multitouch_update_pointer(MTES_MOUSE, 0, dx, dy,
(buttons_state & 1) ? 0x81 : 0);
} else if (androidHwConfig_isScreenTouch(android_hw)) {
enqueue_event(s, EV_ABS, ABS_X, dx);
enqueue_event(s, EV_ABS, ABS_Y, dy);
enqueue_event(s, EV_ABS, ABS_Z, dz);
enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state&1);
enqueue_event(s, EV_SYN, 0, 0);
}
} else {
enqueue_event(s, EV_REL, REL_X, dx);
enqueue_event(s, EV_REL, REL_Y, dy);
enqueue_event(s, EV_SYN, 0, 0);
}
}
/* function :: add_event_game()
* arguments :: the event and the delay
* ======================================================
* This funtion attaches an event to the list og game
* events, and makes sure it's enqueued with the correct
* delay time.
*/
void add_event_game(EVENT_DATA *event, int delay)
{
/* check to see if the event has a type */
if (event->type == EVENT_NONE)
{
bug("add_event_game: no type.");
return;
}
/* check to see of the event has a callback function */
if (event->fun == NULL)
{
bug("add_event_game: event type %d has no callback function.", event->type);
return;
}
/* set the correct variables for this event */
event->ownertype = EVENT_OWNER_GAME;
/* attach the event to the gamelist */
AttachToList(event, global_events);
/* attempt to enqueue the event */
if (enqueue_event(event, delay) == FALSE)
bug("add_event_game: event type %d failed to be enqueued.", event->type);
}
/* function :: add_event_mobile()
* arguments :: the event, the owner and the delay
* ======================================================
* This function attaches an event to a mobile, and sets
* all the correct values, and makes sure it is enqueued
* into the event queue.
*/
void add_event_mobile(EVENT_DATA *event, D_MOBILE *dMob, int delay)
{
/* check to see if the event has a type */
if (event->type == EVENT_NONE)
{
bug("add_event_mobile: no type.");
return;
}
/* check to see of the event has a callback function */
if (event->fun == NULL)
{
bug("add_event_mobile: event type %d has no callback function.", event->type);
return;
}
/* set the correct variables for this event */
event->ownertype = EVENT_OWNER_DMOB;
event->owner.dMob = dMob;
/* attach the event to the mobiles local list */
AttachToList(event, dMob->events);
/* attempt to enqueue the event */
if (enqueue_event(event, delay) == FALSE)
bug("add_event_mobile: event type %d failed to be enqueued.", event->type);
}
/* function :: add_event_socket()
* arguments :: the event, the owner and the delay
* ======================================================
* This function attaches an event to a socket, and sets
* all the correct values, and makes sure it is enqueued
* into the event queue.
*/
void add_event_socket(EVENT_DATA *event, D_SOCKET *dSock, int delay)
{
/* check to see if the event has a type */
if (event->type == EVENT_NONE)
{
bug("add_event_socket: no type.");
return;
}
/* check to see of the event has a callback function */
if (event->fun == NULL)
{
bug("add_event_socket: event type %d has no callback function.", event->type);
return;
}
/* set the correct variables for this event */
event->ownertype = EVENT_OWNER_DSOCKET;
event->owner.dSock = dSock;
/* attach the event to the sockets local list */
AttachToList(event, dSock->events);
/* attempt to enqueue the event */
if (enqueue_event(event, delay) == FALSE)
bug("add_event_socket: event type %d failed to be enqueued.", event->type);
}
static void events_put_keycode(void *x, int keycode)
{
fprintf(stderr, "%s enter..., keycode = %d\n", __func__, keycode);
events_state *s = (events_state *) x;
enqueue_event(s, EV_KEY, keycode&0x1ff, (keycode&0x200) ? 1 : 0);
}
static void distribute_event(struct auditd_reply_list *rep)
{
int attempt = 0;
/* Make first attempt to send to plugins */
if (dispatch_event(&rep->reply, attempt) == 1)
attempt++; /* Failed sending, retry after writing to disk */
/* End of Event is for realtime interface - skip local logging of it */
if (rep->reply.type != AUDIT_EOE) {
int yield = rep->reply.type <= AUDIT_LAST_DAEMON &&
rep->reply.type >= AUDIT_FIRST_DAEMON ? 1 : 0;
/* Write to local disk */
enqueue_event(rep);
if (yield) {
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 2 * 1000 * 1000; // 2 milliseconds
nanosleep(&ts, NULL); // Let other thread try to log it
}
} else
free(rep); // This function takes custody of the memory
// FIXME: This is commented out since it fails to work. The
// problem is that the logger thread free's the buffer. Probably
// need a way to flag in the buffer if logger thread should free or
// move the free to this function.
/* Last chance to send...maybe the pipe is empty now. */
// if (attempt)
// dispatch_event(&rep->reply, attempt);
}
static void events_put_generic(void* opaque, int type, int code, int value)
{
fprintf(stderr, "%s enter...\n", __func__);
fprintf(stderr, "%s: type=%d code=%d value=%d\n", __func__, type, code, value);
events_state *s = (events_state *) opaque;
enqueue_event(s, type, code, value);
}
static int hone_event_handler(struct notifier_block *nb, unsigned long val, void *v)
{
struct hone_reader *reader =
container_of(nb, struct hone_reader, nb);
if (enqueue_event(reader, v))
wake_up_interruptible_all(&reader->event_wait_queue);
return 0;
}
//--------------------------------------------------------------------------
void linux_debmod_t::new_thread(thrinfo_t *info)
{
int tid = info->ti_lid;
threads_t::iterator p = threads.find(tid);
if ( p == threads.end() ) // not found
{
#ifdef LDEB
msg("thread %d is new\n", tid);
::display_thrinfo(*info);
#endif
td_err_e err;
td_thr_events_t events;
td_event_emptyset(&events);
td_event_addset(&events, TD_CREATE);
td_event_addset(&events, TD_DEATH);
td_event_addset(&events, TD_CATCHSIG);
err = td_thr_set_event(info->th_p, &events);
DIE_IF_FAILED("td_thr_set_event", err);
err = td_thr_event_enable(info->th_p, 1);
COMPLAIN_IF_FAILED("td_thr_event_enable", err);
if ( err != TD_OK )
{
#ifdef LDEB
msg("%d: thread dead already? not adding to list.\n", tid);
#endif
return;
}
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGSTOP);
td_thr_setsigpending(info->th_p, 1, &set);
debug_event_t ev;
ev.eid = THREAD_START;
ev.pid = process_handle;
ev.tid = tid;
ev.ea = (ea_t)info->ti_startfunc;
ev.handled = true;
add_thread(tid);
// attach to the thread and make is ready for debugging
qptrace(PTRACE_ATTACH, tid, 0, 0);
int status;
int tid2 = waitpid(tid, &status, __WCLONE); // (must succeed) consume SIGSTOP
QASSERT(tid2 != -1 && WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP);
get_thread(tid)->waiting_sigstop = false;
enqueue_event(ev, IN_FRONT);
}
get_thread(tid)->thr = info->th_p;
}
int acquire_a_local_lock(state_type *state, time_type timeout, int timeout_event_type, event_content_type *event_content, double now) {
SERVER_lp_state_type *pointer = &state->type.server_state;
if (pointer->configuration.cc_verbose)
printf("cc%d - oggetto %d per la transizione %i da lockare\n", pointer->server_id, event_content->applicative_content.object_key_id, event_content->applicative_content.tx_id);
//check lock...
if (pointer->cc_metadata->locks[event_content->applicative_content.object_key_id] == -1) {
//not locked
pointer->cc_metadata->lock_retry_num = 0;
//acquire lock
pointer->cc_metadata->locks[event_content->applicative_content.object_key_id] = event_content->applicative_content.tx_id;
if (pointer->configuration.cc_verbose)
printf("cc%d - oggetto %d per la transizione %i lockato al tempo %f \n", pointer->server_id, event_content->applicative_content.object_key_id, event_content->applicative_content.tx_id,
now);
return 1;
} else if (pointer->cc_metadata->locks[event_content->applicative_content.object_key_id] == event_content->applicative_content.tx_id) {
// already locked by me
return 1;
} else {
//already locked by another transaction
pointer->cc_metadata->lock_retry_num++;
//check deadlocks (if enabled)
if (pointer->configuration.deadlock_detection_enabled && check_deadlock(event_content, pointer)) {
return -1;
}
//add the timeout event
event_content_type new_event_content;
memcpy(&new_event_content, event_content, sizeof(event_content_type));
ScheduleNewEvent(pointer->server_id, now + timeout, timeout_event_type, &new_event_content, sizeof(event_content_type));
//enqueue event
memcpy(&new_event_content, event_content, sizeof(event_content_type));
new_event_content.applicative_content.object_key_id = event_content->applicative_content.object_key_id;
enqueue_event(pointer, &new_event_content);
transaction_metadata *transaction = get_transaction_metadata(event_content->applicative_content.tx_id, pointer);
if (transaction == NULL) {
if (pointer->configuration.cc_verbose) {
printf("cc%d - la tx %i non è locale\n", pointer->server_id, event_content->applicative_content.tx_id);
printf("cc%d - prepare of tx %i added in the waiting event queue %f due to a lock on object :%d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now,
event_content->applicative_content.object_key_id, new_event_content.applicative_content.tx_id);
}
return 0;
} else {
transaction->is_blocked = 1;
if (pointer->configuration.cc_verbose)
printf("cc%d - tx %i is waiting at time %f due to a lock lock on object :%d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now,
event_content->applicative_content.object_key_id, new_event_content.applicative_content.tx_id);
return 0;
}
}
}
static void events_put_mouse(void *opaque, int dx, int dy, int dz, int buttons_state)
{
events_state *s = (events_state *) opaque;
/* in the Android emulator, we use dz == 0 for touchscreen events,
* and dz == 1 for trackball events. See the kbd_mouse_event calls
* in android/skin/trackball.c and android/skin/window.c
*/
if (dz == 0) {
enqueue_event(s, EV_ABS, ABS_X, dx);
enqueue_event(s, EV_ABS, ABS_Y, dy);
enqueue_event(s, EV_ABS, ABS_Z, dz);
enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state&1);
} else {
enqueue_event(s, EV_REL, REL_X, dx);
enqueue_event(s, EV_REL, REL_Y, dy);
}
enqueue_event(s, EV_SYN, 0, 0);
}
static int WANIPConnectionInit(struct Service *psvc, service_state_t state)
{
struct itimerspec timer;
PWANIPConnectionData pdata;
PWANDevicePrivateData pdevdata;
switch (state) {
case SERVICE_CREATE:
pdevdata = (PWANDevicePrivateData) psvc->device->parent->opaque;
pdata = (PWANIPConnectionData) malloc(sizeof(WANIPConnectionData));
if (pdata) {
memset(pdata, 0, sizeof(WANIPConnectionData));
pdata->connection_status = IP_CONNECTING;
pdata->connected_time = time(NULL);
pdata->igd_generation = igd_config_generation;
mapmgr_update();
pdata->nportmappings = mapmgr_port_map_count();
osl_ifaddr(pdevdata->ifname, &pdata->external_ipaddr);
psvc->opaque = (void *) pdata;
/* once a second we want to update the statistics variables in the WANIPConnection service */
memset(&timer, 0, sizeof(timer));
timer.it_interval.tv_sec = 2;
timer.it_value.tv_sec = 2;
pdata->eventhandle = enqueue_event(&timer, (event_callback_t)WANIPConnection_Update, (void *) psvc );
}
break;
case SERVICE_DESTROY:
pdata = (PWANIPConnectionData) psvc->opaque;
timer_delete(pdata->eventhandle);
free(pdata);
break;
} /* end switch */
return 0;
}
static void events_put_mouse(void *opaque, int dx, int dy, int dz, int buttons_state)
{
fprintf(stderr, "%s enter...\n", __func__);
events_state *s = (events_state *) opaque;
/* in the Android emulator, we use dz == 0 for touchscreen events,
* and dz == 1 for trackball events. See the kbd_mouse_event calls
* in android/skin/trackball.c and android/skin/window.c
*/
if (dz == 0) {
fprintf(stderr, "%s:touchsscreen events:dx = %d, dy= %d, dz = %d, buttons_state = %d\n", __func__, dx, dy, dz, buttons_state);
enqueue_event(s, EV_ABS, ABS_X, dx);
enqueue_event(s, EV_ABS, ABS_Y, dy);
enqueue_event(s, EV_ABS, ABS_Z, dz);
enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state&1);
} else {
fprintf(stderr, "%s:trackball events...\n", __func__);
enqueue_event(s, EV_REL, REL_X, dx);
enqueue_event(s, EV_REL, REL_Y, dy);
}
enqueue_event(s, EV_SYN, 0, 0);
}
//--------------------------------------------------------------------------
void linux_debmod_t::dead_thread(int tid)
{
threads_t::iterator p = threads.find(tid);
if ( p != threads.end() ) // not found
{
#ifdef LDEB
msg("thread %d died\n", tid);
#endif
if ( p->second.state == STOPPED )
p->second.state = DYING;
debug_event_t ev;
ev.eid = THREAD_EXIT;
ev.pid = process_handle;
ev.tid = tid;
ev.ea = BADADDR;
ev.handled = true;
ev.exit_code = 0; // ???
enqueue_event(ev, IN_BACK);
}
else
{
msg("unknown thread %d died\n", tid);
}
}
int acquire_local_locks(state_type *state, data_set_entry *data_set, time_type timeout, int timeout_event_type, event_content_type *event_content, double now) {
SERVER_lp_state_type *pointer = &state->type.server_state;
data_set_entry *entry = data_set;
if (entry == NULL) {
if (pointer->configuration.cc_verbose)
printf("cc%d - write set of transaction %d is empty\n", pointer->server_id, event_content->applicative_content.tx_id);
return 1;
}
while (entry != NULL) {
int need_to_lock = 0;
if (pointer->configuration.concurrency_control_type == ETL_2PL || pointer->configuration.concurrency_control_type == CTL_2PL)
need_to_lock = is_owner(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients, state->object_replication_degree);
else if (pointer->configuration.concurrency_control_type == PRIMARY_OWNER_CTL_2PL)
need_to_lock = is_primary(entry->object_key_id, pointer->server_id, state->num_servers, state->num_clients);
if (need_to_lock) {
if (pointer->configuration.cc_verbose)
printf("cc%d - object %d for transaction %i to be locked\n", pointer->server_id, entry->object_key_id, event_content->applicative_content.tx_id);
//check lock...
if (pointer->cc_metadata->locks[entry->object_key_id] == -1) {
//not locked
pointer->cc_metadata->lock_retry_num = 0;
//acquire lock
pointer->cc_metadata->locks[entry->object_key_id] = event_content->applicative_content.tx_id;
if (pointer->configuration.cc_verbose)
printf("cc%d - pbject %d for transaction %i locked at time %f \n", pointer->server_id, entry->object_key_id, event_content->applicative_content.tx_id, now);
} else if (pointer->cc_metadata->locks[entry->object_key_id] == event_content->applicative_content.tx_id) {
// already locked by me
// go to the next entry
} else {
//already locked by another transaction
pointer->cc_metadata->lock_retry_num++;
//check deadlock (if enabled)
if (pointer->configuration.deadlock_detection_enabled && check_deadlock(event_content, pointer)) {
return -1;
}
//add the timeout event
event_content_type new_event_content;
memcpy(&new_event_content, event_content, sizeof(event_content_type));
ScheduleNewEvent(pointer->server_id, now + timeout, timeout_event_type, &new_event_content, sizeof(event_content_type));
//enqueue transaction
memcpy(&new_event_content, event_content, sizeof(event_content_type));
new_event_content.applicative_content.object_key_id = entry->object_key_id;
enqueue_event(pointer, &new_event_content);
transaction_metadata *transaction = get_transaction_metadata(event_content->applicative_content.tx_id, pointer);
if (transaction == NULL) {
if (pointer->configuration.cc_verbose) {
printf("cc%d - transaction %i is not local\n", pointer->server_id, event_content->applicative_content.tx_id);
printf("cc%d - prepare of tx %i added in the waiting event queue %f due to a lock on object %d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now,
entry->object_key_id, new_event_content.applicative_content.tx_id);
}
return 0;
} else {
transaction->is_blocked = 1;
if (pointer->configuration.cc_verbose)
printf("cc%d - transaction %i is waiting at time %f due to a lock on object%d tx:%i\n", pointer->server_id, event_content->applicative_content.tx_id, now, entry->object_key_id,
new_event_content.applicative_content.tx_id);
return 0;
}
}
}
entry = entry->next;
}
return 1;
}
//--------------------------------------------------------------------------
void linux_debmod_t::tdb_update_threads(void)
{
if ( ta != NULL )
{
thrinfovec_t newlist;
td_err_e err = td_ta_thr_iter(ta, update_threads_cb, &newlist,
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
COMPLAIN_IF_FAILED("td_ta_thr_iter", err);
if ( err != TD_OK )
return;
// generate THREAD_EXIT events
for ( threads_t::iterator p=threads.begin(); p != threads.end(); ++p )
{
int i;
int tid = p->first;
for ( i=0; i < newlist.size(); i++ )
if ( newlist[i].ti_lid == tid )
break;
if ( i == newlist.size() ) // not found
{
debug_event_t ev;
ev.eid = THREAD_EXIT;
ev.pid = process_handle;
ev.tid = tid;
ev.ea = BADADDR;
ev.handled = true;
ev.exit_code = 0; // ???
enqueue_event(ev, IN_BACK);
}
}
// generate THREAD_START events
for ( int i=0; i < newlist.size(); i++ )
{
int tid = newlist[i].ti_lid;
// display_thrinfo(tid);
threads_t::iterator p = threads.find(tid);
if ( p == threads.end() ) // not found
{
debug_event_t ev;
ev.eid = THREAD_START;
ev.pid = process_handle;
ev.tid = tid;
ev.ea = birth_bpt.bpt_addr; // just to show something
ev.handled = true;
add_thread(tid);
enqueue_event(ev, IN_FRONT);
// attach to the thread and make is ready for debugging
qptrace(PTRACE_ATTACH, tid, 0, 0);
int status;
int tid2 = waitpid(tid, &status, __WCLONE); // (must succeed) consume SIGSTOP
QASSERT(tid2 != -1 && WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP);
get_thread(tid)->waiting_sigstop = false;
}
get_thread(tid)->thr = newlist[i].th_p;
}
}
}
static void events_put_generic(void* opaque, int type, int code, int value)
{
events_state *s = (events_state *) opaque;
enqueue_event(s, type, code, value);
}
static void events_put_keycode(void *x, int keycode)
{
events_state *s = (events_state *) x;
enqueue_event(s, EV_KEY, keycode&0x1ff, (keycode&0x200) ? 1 : 0);
}
