Only in ./spread-updated: cscope.out diff -r -u ./spread-src-4.0.0rc2/daemon/events.c ./spread-updated/daemon/events.c --- ./spread-src-4.0.0rc2/daemon/events.c 2006-03-02 11:03:45.000000000 -0800 +++ ./spread-updated/daemon/events.c 2006-09-06 13:38:44.000000000 -0700 @@ -85,46 +85,91 @@ fd_event events[MAX_FD_EVENTS]; } fd_queue; -static time_event *Time_queue; -static sp_time Now; +/* + * Avoid double initializing the events + * sub-system. + */ +static int E_initialized = 0; + +typedef struct dummy_event_queue { + time_event *Time_queue; + sp_time Now; + fd_queue Fd_queue[NUM_PRIORITY]; + fd_set Fd_mask[NUM_FDTYPES]; + int Active_priority; + int Exit_events; +} event_queue; + +/* + * We retain the static nature of the default + * event queue. + */ +static event_queue default_event_queue; -static fd_queue Fd_queue[NUM_PRIORITY]; -static fd_set Fd_mask[NUM_FDTYPES]; -static int Active_priority; -static int Exit_events; +sp_eq default_eq = (sp_eq)&default_event_queue; + +int E_init_eq(sp_eq speq) +{ + event_queue *queue = (event_queue *)speq; + int i; + + queue->Time_queue = NULL; + for ( i=0; i < NUM_PRIORITY; i++ ) + { + queue->Fd_queue[i].num_fds = 0; + queue->Fd_queue[i].num_active_fds = 0; + } + for ( i=0; i < NUM_FDTYPES; i++ ) + { + FD_ZERO( &(queue->Fd_mask[i]) ); + } + queue->Active_priority = LOW_PRIORITY; + + E_get_time_eq(queue); + + Alarm( EVENTS, "E_init: went ok\n"); + + return( 0 ); +} int E_init(void) { - int i,ret; + int ret; - Time_queue = NULL; + if (E_initialized) { + return 0; + } ret = Mem_init_object(TIME_EVENT, sizeof(time_event), 100,0); if (ret < 0) { Alarm(EXIT, "E_Init: Failure to Initialize TIME_EVENT memory objects\n"); } - - for ( i=0; i < NUM_PRIORITY; i++ ) - { - Fd_queue[i].num_fds = 0; - Fd_queue[i].num_active_fds = 0; - } - for ( i=0; i < NUM_FDTYPES; i++ ) + ret = Mem_init_object(EVENT_QUEUE, sizeof(event_queue), 100,0); + if (ret < 0) { - FD_ZERO( &Fd_mask[i] ); + Alarm(EXIT, "E_Init: Failure to Initialize EVENT_QUEUE memory objects\n"); } - Active_priority = LOW_PRIORITY; - E_get_time(); + E_initialized = 1; + return E_init_eq(default_eq); +} - Alarm( EVENTS, "E_init: went ok\n"); +sp_eq E_alloc_eq(void) +{ + event_queue *queue = new( EVENT_QUEUE ); + E_init_eq(queue); + return (sp_eq)queue; +} - return( 0 ); +void E_destroy_eq(sp_eq speq) +{ + dispose( speq ); } -sp_time E_get_time(void) +sp_time E_get_time_eq(sp_eq speq) { + event_queue *queue = (event_queue *)speq; #ifndef ARCH_PC_WIN95 struct timeval read_time; @@ -137,8 +182,8 @@ ret = gettimeofday( &read_time, &dummy_tz ); if ( ret < 0 ) Alarm( EXIT, "E_get_time: gettimeofday problems.\n" ); - Now.sec = read_time.tv_sec; - Now.usec = read_time.tv_usec; + queue->Now.sec = read_time.tv_sec; + queue->Now.usec = read_time.tv_usec; #else /* ARCH_PC_WIN95 */ @@ -146,15 +191,20 @@ _ftime( &timebuffer ); - Now.sec = timebuffer.time; - Now.usec= timebuffer.millitm; - Now.usec= Now.usec * 1000; + queue->Now.sec = timebuffer.time; + queue->Now.usec= timebuffer.millitm; + queue->Now.usec= Now.usec * 1000; #endif /* ARCH_PC_WIN95 */ #if 0 Alarm( EVENTS, "E_get_time: time is (%d, %d)\n", Now.sec, Now.usec); #endif - return ( Now ); + return ( queue->Now ); +} + +sp_time E_get_time(void) +{ + return E_get_time_eq(default_eq); } sp_time E_sub_time( sp_time t, sp_time delta_t ) @@ -195,9 +245,11 @@ else return ( 0 ); } -int E_queue( void (* func)( int code, void *data ), int code, void *data, +int E_queue_eq(sp_eq speq, + void (* func)( int code, void *data ), int code, void *data, sp_time delta_time ) { + event_queue *queue = (event_queue *)speq; time_event *t_pre; time_event *t_post; time_event *t_e; @@ -214,37 +266,37 @@ deleted = 0; inserted = 0; - if( Time_queue != NULL ) + if( queue->Time_queue != NULL ) { - if( Time_queue->func == t_e->func && - Time_queue->data == t_e->data && - Time_queue->code == t_e->code ) + if( queue->Time_queue->func == t_e->func && + queue->Time_queue->data == t_e->data && + queue->Time_queue->code == t_e->code ) { - t_pre = Time_queue; - Time_queue = Time_queue->next; + t_pre = queue->Time_queue; + queue->Time_queue = queue->Time_queue->next; dispose( t_pre ); deleted = 1; Alarm( EVENTS, "E_queue: dequeued a (first) simillar event\n" ); } } - if( Time_queue == NULL ) + if( queue->Time_queue == NULL ) { t_e->next = NULL; - Time_queue = t_e; + queue->Time_queue = t_e; Alarm( EVENTS, "E_queue: (only) event queued func 0x%x code %d data 0x%x in future (%u:%u)\n",t_e->func,t_e->code, t_e->data, delta_time.sec, delta_time.usec ); return( 0 ); }else{ - compare = E_compare_time ( t_e->t, Time_queue->t ); + compare = E_compare_time ( t_e->t, queue->Time_queue->t ); if( compare < 0 ) { - t_e->next = Time_queue; - Time_queue = t_e; + t_e->next = queue->Time_queue; + queue->Time_queue = t_e; inserted = 1; Alarm( EVENTS, "E_queue: (first) event queued func 0x%x code %d data 0x%x in future (%u:%u)\n",t_e->func,t_e->code, t_e->data, delta_time.sec,delta_time.usec ); } } - t_pre = Time_queue ; - t_post = Time_queue->next; + t_pre = queue->Time_queue ; + t_post = queue->Time_queue->next; while ( t_post != NULL && ( !inserted || !deleted ) ) { if( t_post->func == t_e->func && @@ -285,30 +337,38 @@ return( 0 ); } -int E_dequeue( void (* func)( int code, void *data ), int code, +int E_queue( void (* func)( int code, void *data ), int code, void *data, + sp_time delta_time ) +{ + return E_queue_eq(default_eq, func, code, data, delta_time); +} + +int E_dequeue_eq( sp_eq speq, + void (* func)( int code, void *data ), int code, void *data ) { + event_queue *queue = (event_queue *)speq; time_event *t_pre; time_event *t_ptr; - if( Time_queue == NULL ) + if( queue->Time_queue == NULL ) { Alarm( EVENTS, "E_dequeue: no such event\n" ); return( -1 ); } - if( Time_queue->func == func && - Time_queue->data == data && - Time_queue->code == code ) + if( queue->Time_queue->func == func && + queue->Time_queue->data == data && + queue->Time_queue->code == code ) { - t_ptr = Time_queue; - Time_queue = Time_queue->next; + t_ptr = queue->Time_queue; + queue->Time_queue = queue->Time_queue->next; dispose( t_ptr ); Alarm( EVENTS, "E_dequeue: first event dequeued func 0x%x code %d data 0x%x\n",func,code, data); return( 0 ); } - t_pre = Time_queue; + t_pre = queue->Time_queue; while ( t_pre->next != NULL ) { t_ptr = t_pre->next; @@ -328,6 +388,12 @@ return( -1 ); } +int E_dequeue( void (* func)( int code, void *data ), int code, + void *data ) +{ + return E_dequeue_eq(default_eq, func, code, data); +} + void E_delay( sp_time t ) { struct timeval tmp_t; @@ -346,10 +412,11 @@ } -int E_attach_fd( int fd, int fd_type, +int E_attach_fd_eq( sp_eq speq, int fd, int fd_type, void (* func)( mailbox mbox, int code, void *data ), int code, void *data, int priority ) { + event_queue *queue = (event_queue *)speq; int num_fds; int j; @@ -373,45 +440,54 @@ return( -1 ); } #endif - for( j=0; j < Fd_queue[priority].num_fds; j++ ) + for( j=0; j < queue->Fd_queue[priority].num_fds; j++ ) { - if( ( Fd_queue[priority].events[j].fd == fd ) && ( Fd_queue[priority].events[j].fd_type == fd_type ) ) + if( ( queue->Fd_queue[priority].events[j].fd == fd ) && + ( queue->Fd_queue[priority].events[j].fd_type == fd_type ) ) { - Fd_queue[priority].events[j].func = func; - Fd_queue[priority].events[j].code = code; - Fd_queue[priority].events[j].data = data; - if ( !(Fd_queue[priority].events[j].active) ) - Fd_queue[priority].num_active_fds++; - Fd_queue[priority].events[j].active = TRUE; + queue->Fd_queue[priority].events[j].func = func; + queue->Fd_queue[priority].events[j].code = code; + queue->Fd_queue[priority].events[j].data = data; + if ( !(queue->Fd_queue[priority].events[j].active) ) + queue->Fd_queue[priority].num_active_fds++; + queue->Fd_queue[priority].events[j].active = TRUE; Alarm( PRINT, "E_attach_fd: fd %d with type %d exists & replaced & activated\n", fd, fd_type ); return( 1 ); } } - num_fds = Fd_queue[priority].num_fds; + num_fds = queue->Fd_queue[priority].num_fds; if ( num_fds == MAX_FD_EVENTS ) { Alarm( PRINT, "E_attach_fd: Reached Maximum number of events. Recompile with larger MAX_FD_EVENTS\n"); return( -1 ); } - Fd_queue[priority].events[num_fds].fd = fd; - Fd_queue[priority].events[num_fds].fd_type = fd_type; - Fd_queue[priority].events[num_fds].func = func; - Fd_queue[priority].events[num_fds].code = code; - Fd_queue[priority].events[num_fds].data = data; - Fd_queue[priority].events[num_fds].active = TRUE; - Fd_queue[priority].num_fds++; - Fd_queue[priority].num_active_fds++; - if( Active_priority <= priority ) FD_SET( fd, &Fd_mask[fd_type] ); + queue->Fd_queue[priority].events[num_fds].fd = fd; + queue->Fd_queue[priority].events[num_fds].fd_type = fd_type; + queue->Fd_queue[priority].events[num_fds].func = func; + queue->Fd_queue[priority].events[num_fds].code = code; + queue->Fd_queue[priority].events[num_fds].data = data; + queue->Fd_queue[priority].events[num_fds].active = TRUE; + queue->Fd_queue[priority].num_fds++; + queue->Fd_queue[priority].num_active_fds++; + if( queue->Active_priority <= priority ) FD_SET( fd, &(queue->Fd_mask[fd_type]) ); Alarm( EVENTS, "E_attach_fd: fd %d, fd_type %d, code %d, data 0x%x, priority %d Active_priority %d\n", - fd, fd_type, code, data, priority, Active_priority ); + fd, fd_type, code, data, priority, queue->Active_priority ); return( 0 ); } -int E_detach_fd( int fd, int fd_type ) +int E_attach_fd( int fd, int fd_type, + void (* func)( mailbox mbox, int code, void *data ), + int code, void *data, int priority ) { + return E_attach_fd_eq(default_eq, fd, fd_type, func, code, data, priority); +} + +int E_detach_fd_eq( sp_eq speq, int fd, int fd_type ) +{ + event_queue *queue = (event_queue *)speq; int i,j; int found; @@ -423,16 +499,18 @@ found = 0; for( i=0; i < NUM_PRIORITY; i++ ) - for( j=0; j < Fd_queue[i].num_fds; j++ ) + for( j=0; j < queue->Fd_queue[i].num_fds; j++ ) { - if( ( Fd_queue[i].events[j].fd == fd ) && ( Fd_queue[i].events[j].fd_type == fd_type ) ) + if( ( queue->Fd_queue[i].events[j].fd == fd ) && + ( queue->Fd_queue[i].events[j].fd_type == fd_type ) ) { - if (Fd_queue[i].events[j].active) - Fd_queue[i].num_active_fds--; - Fd_queue[i].num_fds--; - Fd_queue[i].events[j] = Fd_queue[i].events[Fd_queue[i].num_fds]; + if (queue->Fd_queue[i].events[j].active) + queue->Fd_queue[i].num_active_fds--; + queue->Fd_queue[i].num_fds--; + queue->Fd_queue[i].events[j] = + queue->Fd_queue[i].events[queue->Fd_queue[i].num_fds]; - FD_CLR( fd, &Fd_mask[fd_type] ); + FD_CLR( fd, &(queue->Fd_mask[fd_type]) ); found = 1; break; /* from the j for only */ @@ -444,8 +522,14 @@ return( 0 ); } -int E_deactivate_fd( int fd, int fd_type ) +int E_detach_fd( int fd, int fd_type ) { + return E_detach_fd_eq(default_eq, fd, fd_type); +} + +int E_deactivate_fd_eq(sp_eq speq, int fd, int fd_type ) +{ + event_queue *queue = (event_queue *)speq; int i,j; int found; @@ -458,14 +542,15 @@ found = 0; for( i=0; i < NUM_PRIORITY; i++ ) - for( j=0; j < Fd_queue[i].num_fds; j++ ) + for( j=0; j < queue->Fd_queue[i].num_fds; j++ ) { - if( ( Fd_queue[i].events[j].fd == fd ) && ( Fd_queue[i].events[j].fd_type == fd_type ) ) + if( ( queue->Fd_queue[i].events[j].fd == fd ) && + ( queue->Fd_queue[i].events[j].fd_type == fd_type ) ) { - if (Fd_queue[i].events[j].active) - Fd_queue[i].num_active_fds--; - Fd_queue[i].events[j].active = FALSE; - FD_CLR( fd, &Fd_mask[fd_type] ); + if (queue->Fd_queue[i].events[j].active) + queue->Fd_queue[i].num_active_fds--; + queue->Fd_queue[i].events[j].active = FALSE; + FD_CLR( fd, &(queue->Fd_mask[fd_type]) ); found = 1; break; /* from the j for only */ @@ -476,8 +561,14 @@ return( 0 ); } -int E_activate_fd( int fd, int fd_type ) +int E_deactivate_fd( int fd, int fd_type ) { + return E_deactivate_fd_eq(default_eq, fd, fd_type); +} + +int E_activate_fd_eq(sp_eq speq, int fd, int fd_type ) +{ + event_queue *queue = (event_queue *)speq; int i,j; int found; @@ -490,14 +581,15 @@ found = 0; for( i=0; i < NUM_PRIORITY; i++ ) - for( j=0; j < Fd_queue[i].num_fds; j++ ) + for( j=0; j < queue->Fd_queue[i].num_fds; j++ ) { - if( ( Fd_queue[i].events[j].fd == fd ) && ( Fd_queue[i].events[j].fd_type == fd_type ) ) + if( ( queue->Fd_queue[i].events[j].fd == fd ) && + ( queue->Fd_queue[i].events[j].fd_type == fd_type ) ) { - if ( !(Fd_queue[i].events[j].active) ) - Fd_queue[i].num_active_fds++; - Fd_queue[i].events[j].active = TRUE; - if( i >= Active_priority ) FD_SET( fd, &Fd_mask[ fd_type ] ); + if ( !(queue->Fd_queue[i].events[j].active) ) + queue->Fd_queue[i].num_active_fds++; + queue->Fd_queue[i].events[j].active = TRUE; + if( i >= queue->Active_priority ) FD_SET( fd, &(queue->Fd_mask[ fd_type ]) ); found = 1; break; /* from the j for only */ @@ -508,8 +600,14 @@ return( 0 ); } -int E_set_active_threshold( int priority ) +int E_activate_fd( int fd, int fd_type ) { + return E_activate_fd_eq(default_eq, fd, fd_type); +} + +int E_set_active_threshold_eq(sp_eq speq, int priority ) +{ + event_queue *queue = (event_queue *)speq; int fd_type; int i,j; @@ -519,39 +617,51 @@ return( -1 ); } - if( priority == Active_priority ) return( priority ); + if( priority == queue->Active_priority ) return( priority ); - Active_priority = priority; + queue->Active_priority = priority; for ( i=0; i < NUM_FDTYPES; i++ ) { - FD_ZERO( &Fd_mask[i] ); + FD_ZERO( &(queue->Fd_mask[i]) ); } for( i = priority; i < NUM_PRIORITY; i++ ) - for( j=0; j < Fd_queue[i].num_fds; j++ ) + for( j=0; j < queue->Fd_queue[i].num_fds; j++ ) { - fd_type = Fd_queue[i].events[j].fd_type; - if (Fd_queue[i].events[j].active) - FD_SET( Fd_queue[i].events[j].fd, &Fd_mask[fd_type] ); + fd_type = queue->Fd_queue[i].events[j].fd_type; + if (queue->Fd_queue[i].events[j].active) + FD_SET( queue->Fd_queue[i].events[j].fd, &(queue->Fd_mask[fd_type]) ); } - Alarm( EVENTS, "E_set_active_threshold: changed to %d\n",Active_priority); + Alarm( EVENTS, "E_set_active_threshold: changed to %d\n",queue->Active_priority); return( priority ); } -int E_num_active( int priority ) +int E_set_active_threshold( int priority ) { + return E_set_active_threshold_eq(default_eq, priority); +} + +int E_num_active_eq(sp_eq speq, int priority ) +{ + event_queue *queue = (event_queue *)speq; if( priority < 0 || priority > NUM_PRIORITY ) { Alarm( PRINT, "E_num_active: invalid priority %d\n", priority ); return( -1 ); } - return( Fd_queue[priority].num_active_fds ); + return( queue->Fd_queue[priority].num_active_fds ); } -void E_handle_events(void) +int E_num_active( int priority ) { + return E_num_active_eq(default_eq, priority); +} + +void E_handle_events_eq(sp_eq speq) +{ + event_queue *queue = (event_queue *)speq; static int Round_robin = 0; static const sp_time long_timeout = { 10000, 0}; static const sp_time zero_sec = { 0, 0}; @@ -575,16 +685,16 @@ #ifdef BADCLOCK clock_sync = 0; #endif - for( Exit_events = 0 ; !Exit_events ; ) + for( queue->Exit_events = 0 ; !queue->Exit_events ; ) { Alarm( EVENTS, "E_handle_events: next event \n"); /* Handle time events */ timeout = long_timeout; #ifdef TESTTIME - start = E_get_time(); + start = E_get_time_eq(queue); #endif - while( Time_queue != NULL ) + while( queue->Time_queue != NULL ) { #ifdef BADCLOCK if ( clock_sync >= 0 ) @@ -593,15 +703,15 @@ clock_sync = -20; } #else - E_get_time(); + E_get_time_eq(queue); #endif - if ( !first && E_compare_time( Now, Time_queue->t ) >= 0 ) + if ( !first && E_compare_time( queue->Now, queue->Time_queue->t ) >= 0 ) { #ifdef TESTTIME - tmp_late = E_sub_time( Now, Time_queue->t ); + tmp_late = E_sub_time( queue->Now, queue->Time_queue->t ); #endif - temp_ptr = Time_queue; - Time_queue = Time_queue->next; + temp_ptr = queue->Time_queue; + queue->Time_queue = queue->Time_queue->next; Alarm( EVENTS, "E_handle_events: exec time event \n"); #ifdef TESTTIME Alarm( DEBUG, "Events: TimeEv is %d %d late\n",tmp_late.sec, tmp_late.usec); @@ -609,28 +719,28 @@ temp_ptr->func( temp_ptr->code, temp_ptr->data ); dispose( temp_ptr ); #ifdef BADCLOCK - Now = E_add_time( Now, mili_sec ); + queue->Now = E_add_time( queue->Now, mili_sec ); clock_sync++; #else - E_get_time(); + E_get_time_eq(queue); #endif - if (Exit_events) goto end_handler; + if (queue->Exit_events) goto end_handler; }else{ - timeout = E_sub_time( Time_queue->t, Now ); + timeout = E_sub_time( queue->Time_queue->t, queue->Now ); break; } } if (timeout.sec < 0 ) timeout.sec = timeout.usec = 0; /* this can happen until first is unset */ #ifdef TESTTIME - stop = E_get_time(); + stop = E_get_time_eq(queue); tmp_late = E_sub_time(stop, start); Alarm(DEBUG, "Events: TimeEv's took %d %d to handle\n", tmp_late.sec, tmp_late.usec); #endif /* Handle fd events */ for( i=0; i < NUM_FDTYPES; i++ ) { - current_mask[i] = Fd_mask[i]; + current_mask[i] = queue->Fd_mask[i]; } Alarm( EVENTS, "E_handle_events: poll select\n"); #ifdef TESTTIME @@ -640,14 +750,14 @@ wait_timeout.tv_usec = zero_sec.usec; num_set = select( FD_SETSIZE, ¤t_mask[READ_FD], ¤t_mask[WRITE_FD], ¤t_mask[EXCEPT_FD], &wait_timeout ); - if (num_set == 0 && !Exit_events) + if (num_set == 0 && !queue->Exit_events) { #ifdef BADCLOCK clock_sync = 0; #endif for( i=0; i < NUM_FDTYPES; i++ ) { - current_mask[i] = Fd_mask[i]; + current_mask[i] = queue->Fd_mask[i]; } Alarm( EVENTS, "E_handle_events: select with timeout (%d, %d)\n", timeout.sec,timeout.usec ); @@ -660,7 +770,7 @@ ¤t_mask[EXCEPT_FD], &sel_timeout ); } #ifdef TESTTIME - start = E_get_time(); + start = E_get_time_eq(queue); tmp_late = E_sub_time(start, stop); Alarm( DEBUG, "Events: Waiting for fd or timout took %d %d asked for %d %d\n", tmp_late.sec, tmp_late.usec, req_time.sec, req_time.usec); #endif @@ -669,27 +779,27 @@ i > LOW_PRIORITY && num_set > 0 && !treated; i-- ) { - for( j=0; j < Fd_queue[i].num_fds && num_set > 0; j++ ) + for( j=0; j < queue->Fd_queue[i].num_fds && num_set > 0; j++ ) { - fd = Fd_queue[i].events[j].fd; - fd_type = Fd_queue[i].events[j].fd_type; + fd = queue->Fd_queue[i].events[j].fd; + fd_type = queue->Fd_queue[i].events[j].fd_type; if( FD_ISSET( fd, ¤t_mask[fd_type] ) ) { Alarm( EVENTS, "E_handle_events: exec handler for fd %d, fd_type %d, priority %d\n", fd, fd_type, i ); - Fd_queue[i].events[j].func( - Fd_queue[i].events[j].fd, - Fd_queue[i].events[j].code, - Fd_queue[i].events[j].data ); + queue->Fd_queue[i].events[j].func( + queue->Fd_queue[i].events[j].fd, + queue->Fd_queue[i].events[j].code, + queue->Fd_queue[i].events[j].data ); treated = 1; num_set--; #ifdef BADCLOCK - Now = E_add_time( Now, mili_sec ); + queue->Now = E_add_time( queue->Now, mili_sec ); clock_sync++; #else - E_get_time(); + E_get_time_eq(queue); #endif - if (Exit_events) goto end_handler; + if (queue->Exit_events) goto end_handler; } } } @@ -703,7 +813,7 @@ first = 0; #ifdef TESTTIME - stop = E_get_time(); + stop = E_get_time_eq(queue); tmp_late = E_sub_time(stop, start); Alarm(DEBUG, "Events: High & Med took %d %d time to handle\n", tmp_late.sec, tmp_late.usec); #endif @@ -711,36 +821,36 @@ However, verify that Active_priority still allows LOW_PRIORITY events. Active_priority can change because of calls to E_set_threshold() during the current select loop. */ - for( i=0; i < Fd_queue[LOW_PRIORITY].num_fds + for( i=0; i < queue->Fd_queue[LOW_PRIORITY].num_fds && num_set > 0 - && Active_priority == LOW_PRIORITY; + && queue->Active_priority == LOW_PRIORITY; i++ ) { - j = ( i + Round_robin ) % Fd_queue[LOW_PRIORITY].num_fds; - fd = Fd_queue[LOW_PRIORITY].events[j].fd; - fd_type = Fd_queue[LOW_PRIORITY].events[j].fd_type; + j = ( i + Round_robin ) % queue->Fd_queue[LOW_PRIORITY].num_fds; + fd = queue->Fd_queue[LOW_PRIORITY].events[j].fd; + fd_type = queue->Fd_queue[LOW_PRIORITY].events[j].fd_type; if( FD_ISSET( fd, ¤t_mask[fd_type] ) ) { - Round_robin = ( j + 1 ) % Fd_queue[LOW_PRIORITY].num_fds; + Round_robin = ( j + 1 ) % queue->Fd_queue[LOW_PRIORITY].num_fds; Alarm( EVENTS , "E_handle_events: exec ext fd event \n"); - Fd_queue[LOW_PRIORITY].events[j].func( - Fd_queue[LOW_PRIORITY].events[j].fd, - Fd_queue[LOW_PRIORITY].events[j].code, - Fd_queue[LOW_PRIORITY].events[j].data ); + queue->Fd_queue[LOW_PRIORITY].events[j].func( + queue->Fd_queue[LOW_PRIORITY].events[j].fd, + queue->Fd_queue[LOW_PRIORITY].events[j].code, + queue->Fd_queue[LOW_PRIORITY].events[j].data ); num_set--; #ifdef BADCLOCK - Now = E_add_time( Now, mili_sec ); + queue->Now = E_add_time( queue->Now, mili_sec ); clock_sync++; #else - E_get_time(); + E_get_time_eq(queue); #endif - if (Exit_events) goto end_handler; + if (queue->Exit_events) goto end_handler; break; } } #ifdef TESTTIME - start = E_get_time(); + start = E_get_time_eq(queue); tmp_late = E_sub_time(start, stop); Alarm(DEBUG, "Events: Low priority took %d %d to handle\n", tmp_late.sec, tmp_late.usec); #endif @@ -756,8 +866,19 @@ return; } -void E_exit_events(void) +void E_handle_events(void) +{ + E_handle_events_eq(default_eq); +} + +void E_exit_events_eq(sp_eq speq) { + event_queue *queue = (event_queue *)speq; Alarm( EVENTS, "E_exit_events:\n"); - Exit_events = 1; + queue->Exit_events = 1; +} + +void E_exit_events(void) +{ + E_exit_events_eq(default_eq); } diff -r -u ./spread-src-4.0.0rc2/daemon/objects.h ./spread-updated/daemon/objects.h --- ./spread-src-4.0.0rc2/daemon/objects.h 2006-03-02 11:03:45.000000000 -0800 +++ ./spread-updated/daemon/objects.h 2006-09-06 09:10:36.000000000 -0700 @@ -117,6 +117,13 @@ * i.e. when internal structure of object is not accessed. * This is mainly used with queues */ +/* + * Event queue objects. + */ +#define EVENT_QUEUE 56 /* this should possibly go before UNKNOWN_OBJ, but + * that may break something since UNKNOWN_OBJ may be + * a 'well known value' by now. + */ #define Is_Pack_Head_Obj( type ) ( (type) == PACK_HEAD_OBJ ) #define Is_Message_Obj( type ) ( (type) == MESSAGE_OBJ ) Only in ./spread-updated/examples: spuser_eq Only in ./spread-updated/examples: user_eq.c diff -r -u ./spread-src-4.0.0rc2/include/sp_events.h ./spread-updated/include/sp_events.h --- ./spread-src-4.0.0rc2/include/sp_events.h 2006-03-02 11:03:45.000000000 -0800 +++ ./spread-updated/include/sp_events.h 2006-09-06 09:48:23.000000000 -0700 @@ -73,6 +73,7 @@ /* Event routines */ + int E_init(void); sp_time E_get_time(void); sp_time E_sub_time( sp_time t, sp_time delta_t ); @@ -101,4 +102,44 @@ void E_handle_events(void); void E_exit_events(void); +/* + * This type and the E_* variant routines below allow + * for the event library to handle multiple queues, this + * is useful in multi-tier applications that make use + * of spread at various protocol levels in the same + * application stack. Each protocol level can allocate + * its own private event queue and thus avoid queue + * contention induced deadlocks (in conjuction with + * appropriate use of worker threads etc). + * + * Said another way: if you are writting a library that + * uses spread, allocate a private sp_eq and use these + * variants when using the E_ routines. Unless you + * know you are the top level spread user it is not safe + * to use the non E_*_eq() routines. + */ +typedef void * sp_eq; + +sp_eq E_alloc_eq(void); +void E_destroy_eq(sp_eq queue); +sp_time E_get_time_eq(sp_eq queue); +int E_queue_eq(sp_eq queue, void (* func)( int code, void *data ), int code, void *data, + sp_time delta_time ); +/* Note: This does not dispose/free the data pointed at by the void + *data pointer */ +int E_dequeue_eq(sp_eq queue, void (* func)( int code, void *data ), int code, + void *data ); + +int E_attach_fd_eq(sp_eq queue, int fd, int fd_type, + void (* func)( int fd, int code, void *data), int code, + void *data, int priority ); +int E_detach_fd_eq(sp_eq queue, int fd, int fd_type ); +int E_set_active_threshold_eq(sp_eq queue, int priority ); +int E_activate_fd_eq(sp_eq queue, int fd, int fd_type ); +int E_deactivate_fd_eq(sp_eq queue, int fd, int fd_type ); +int E_num_active_eq(sp_eq queue, int priority ); + +void E_handle_events_eq(sp_eq queue); +void E_exit_events_eq(sp_eq queue); + #endif /* INC_SP_EVENTS */