From 64b7a679a0270e0af71e5f4d288f0e3782c0dcf6 Mon Sep 17 00:00:00 2001 From: Jeff Hill Date: Wed, 26 Apr 1995 03:11:02 +0000 Subject: [PATCH] Use vxWorks sem for locks and free lists when fdmgr delete (none of this is currently used under UNIX) --- src/libCom/fdmgr.c | 87 +++++++++++++++++++++++++++++++--------------- 1 file changed, 59 insertions(+), 28 deletions(-) diff --git a/src/libCom/fdmgr.c b/src/libCom/fdmgr.c index acd127092..f5d3a8cee 100644 --- a/src/libCom/fdmgr.c +++ b/src/libCom/fdmgr.c @@ -111,6 +111,7 @@ static char *pSccsId = "@(#) $Id$"; #include #include #include +#include #endif #include @@ -151,19 +152,23 @@ typedef struct{ }fdentry; #if defined(vxWorks) -# define LOCK(PFDCTX) FASTLOCK(&(PFDCTX)->lock) -# define UNLOCK(PFDCTX) FASTUNLOCK(&(PFDCTX)->lock) +# define LOCK(PFDCTX) assert(semTake((PFDCTX)->lock, WAIT_FOREVER)==OK); +# define UNLOCK(PFDCTX) assert(semGive((PFDCTX)->lock)==OK); + # define UNLOCK_FDMGR_PEND_EVENT(PFDCTX) \ - FASTUNLOCK(&(PFDCTX)->fdmgr_pend_event_lock) \ - (PFDCTX)->fdmgr_pend_event_tid = NULL; + {(PFDCTX)->fdmgr_pend_event_tid = NULL; \ + assert(semGive((PFDCTX)->fdmgr_pend_event_lock)==OK);} + # define LOCK_EXPIRED(PFDCTX) \ - FASTLOCK(&(PFDCTX)->expired_alarm_lock) + assert(semTake((PFDCTX)->expired_alarm_lock, WAIT_FOREVER)==OK); # define UNLOCK_EXPIRED(PFDCTX) \ - FASTUNLOCK(&(PFDCTX)->expired_alarm_lock) + assert(semGive((PFDCTX)->expired_alarm_lock)==OK); + # define LOCK_FD_HANDLER(PFDCTX) \ - FASTLOCK(&(PFDCTX)->fd_handler_lock) + assert(semTake((PFDCTX)->fd_handler_lock, WAIT_FOREVER)==OK); # define UNLOCK_FD_HANDLER(PFDCTX) \ - FASTUNLOCK(&(PFDCTX)->fd_handler_lock) + assert(semGive((PFDCTX)->fd_handler_lock)==OK); + #elif defined(UNIX) || defined(VMS) || defined(_WIN32) # define LOCK(PFDCTX) # define UNLOCK(PFDCTX) @@ -224,10 +229,22 @@ fdctx *fdmgr_init(void) pfdctx = (fdctx *) calloc(1, sizeof(fdctx)); # if defined(vxWorks) - FASTLOCKINIT(&pfdctx->lock); - FASTLOCKINIT(&pfdctx->fdmgr_pend_event_lock); - FASTLOCKINIT(&pfdctx->expired_alarm_lock); - FASTLOCKINIT(&pfdctx->fd_handler_lock); + pfdctx->lock = semMCreate (SEM_DELETE_SAFE); + if (pfdctx->lock == NULL){ + return NULL; + } + pfdctx->fdmgr_pend_event_lock = semMCreate (SEM_DELETE_SAFE); + if (pfdctx->fdmgr_pend_event_lock == NULL){ + return NULL; + } + pfdctx->expired_alarm_lock = semMCreate (SEM_DELETE_SAFE); + if (pfdctx->expired_alarm_lock == NULL) { + return NULL; + } + pfdctx->fd_handler_lock = semMCreate (SEM_DELETE_SAFE); + if (pfdctx->fd_handler_lock == NULL) { + return NULL; + } pfdctx->clk_rate = sysClkRateGet(); pfdctx->last_tick_count = tickGet(); # endif @@ -239,7 +256,7 @@ fdctx *fdmgr_init(void) ellInit(&pfdctx->free_alarm_list); /* - * returns NULL if unsuccessfull + * returns NULL if unsuccessful */ return pfdctx; } @@ -252,17 +269,30 @@ fdctx *fdmgr_init(void) */ int fdmgr_delete(fdctx *pfdctx) { + int status; + if(!pfdctx){ return ERROR; } # if defined(vxWorks) - FASTLOCKFREE(&pfdctx->lock); - FASTLOCKFREE(&pfdctx->fdmgr_pend_event_lock); - FASTLOCKFREE(&pfdctx->expired_alarm_lock); - FASTLOCKFREE(&pfdctx->fd_handler_lock); + status = semDelete (pfdctx->lock); + assert (status == OK); + status = semDelete (pfdctx->fdmgr_pend_event_lock); + assert (status == OK); + status = semDelete (pfdctx->expired_alarm_lock); + assert (status == OK); + status = semDelete (pfdctx->fd_handler_lock); + assert (status == OK); # endif + ellFree(&pfdctx->fdentry_list); + ellFree(&pfdctx->fdentry_in_use_list); + ellFree(&pfdctx->fdentry_free_list); + ellFree(&pfdctx->alarm_list); + ellFree(&pfdctx->expired_alarm_list); + ellFree(&pfdctx->free_alarm_list); + return OK; } @@ -334,7 +364,7 @@ void *param } } if(pa){ - ellInsert(&pfdctx->alarm_list, pa->node.previous, &palarm->node); + ellInsert(&pfdctx->alarm_list, pa->node.previous, &palarm->node); } else{ ellAdd(&pfdctx->alarm_list, &palarm->node); @@ -421,7 +451,7 @@ fdmgrAlarm *palarm * * fdmgr_add_fd() * - * this rouitine is supplied solely for compatibility + * this routine is supplied solely for compatibility * with earlier versions of this software */ int fdmgr_add_fd( @@ -574,10 +604,14 @@ enum fdi_type fdi /* * wait for it to finish if it is in progress * when running in a multithreaded environment + * + * Taking the lock here guarantees that if the + * event we are deleting is in progress then + * we will wait for it to complete prior to + * proceeding */ # ifdef vxWorks if(delete_pending == TRUE){ -@@@@ review all of this delete pending stuff LOCK_FD_HANDLER(pfdctx); UNLOCK_FD_HANDLER(pfdctx); } @@ -777,6 +811,9 @@ struct timeval *ptimeout /* * sync with clear + * + * This allows the clearing thread to wait + * until the event that it is clearing completes */ LOCK_FD_HANDLER(pfdctx); @@ -859,12 +896,6 @@ struct timeval *poffset * they are in an alarm handler (and potentially modifying * the alarm queue). */ - /* - * no need to lock here since this list is only touched - * by this routine, this routine is not exported - * and I am only allowing one thread in fdmgr_pend_event() - * at at time. - */ /* * I dont want the primary LOCK to be applied while in their * alarm handler as this would prevent them from @@ -878,7 +909,7 @@ struct timeval *poffset LOCK_EXPIRED(pfdctx); pa = (fdmgrAlarm*) pfdctx->expired_alarm_list.node.next; while(pa){ - void (*pfunc)(); + void (*pfunc)(void *pParam); /* * check to see if it has been disabled @@ -1019,7 +1050,7 @@ struct timeval *pt LOCAL void lockFDMGRPendEvent (fdctx *pfdctx) { # if defined(vxWorks) - FASTLOCK(&pfdctx->fdmgr_pend_event_lock); + assert(semTake (pfdctx->fdmgr_pend_event_lock, WAIT_FOREVER)==OK); pfdctx->fdmgr_pend_event_tid = taskIdCurrent; # else assert (pfdctx->fdmgr_pend_event_in_use==0);