scheduler/services.c

   1 /*
   2  * Kernel Services Thread
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  */
   6
   7 #include <sys/time.h>
   8 #include <unistd.h>
   9
  10 #include "services.h"
  11 #include "debug.h"
  12
  13 DEFAULT_DEBUG_CHANNEL(timer)
  14
  15
  16 #define SERVICE_USE_OBJECT      0x0001
  17 #define SERVICE_USE_TIMEOUT     0x0002
  18 #define SERVICE_DISABLED        0x8000
  19
  20 typedef struct _SERVICE
  21 {
  22    struct _SERVICE *next;
  23    HANDLE           self;
  24
  25    PAPCFUNC       callback;
  26    ULONG_PTR      callback_arg;
  27
  28    int            flags;
  29
  30    HANDLE         object;
  31    long           rate;
  32
  33    struct timeval expire;
  34
  35 } SERVICE;
  36
  37 typedef struct
  38 {
  39    HANDLE heap;
  40    HANDLE thread;
  41
  42    SERVICE *first;
  43    DWORD    counter;
  44
  45 } SERVICETABLE;
  46
  47 static SERVICETABLE *Service = NULL;
  48
  49
  50 /***********************************************************************
  51  *           SERVICE_AddTimeval
  52  */
  53 static void SERVICE_AddTimeval( struct timeval *time, long delta )
  54 {
  55     delta += time->tv_usec;
  56     time->tv_sec += delta / 1000000L;
  57     time->tv_usec = delta % 1000000L;
  58 }
  59
  60 /***********************************************************************
  61  *           SERVICE_DiffTimeval
  62  */
  63 static long SERVICE_DiffTimeval( struct timeval *time1, struct timeval *time2 )
  64 {
  65     return   ( time1->tv_sec  - time2->tv_sec  ) * 1000000L
  66            + ( time1->tv_usec - time2->tv_usec );
  67 }
  68
  69 /***********************************************************************
  70  *           SERVICE_Loop
  71  */
  72 static DWORD CALLBACK SERVICE_Loop( SERVICETABLE *service )
  73 {
  74     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  75     int count = 0;
  76     DWORD timeout = INFINITE;
  77     DWORD retval = WAIT_FAILED;
  78
  79     while ( TRUE )
  80     {
  81         PAPCFUNC callback;
  82         ULONG_PTR callback_arg;
  83         SERVICE *s;
  84
  85         /* Check whether some condition is fulfilled */
  86
  87         struct timeval curTime;
  88         gettimeofday( &curTime, NULL );
  89
  90         HeapLock( service->heap );
  91
  92         callback = NULL;
  93         callback_arg = 0L;
  94         for ( s = service->first; s; s = s->next )
  95         {
  96             if ( s->flags & SERVICE_DISABLED )
  97                 continue;
  98
  99             if ( s->flags & SERVICE_USE_OBJECT )
 100                 if ( retval >= WAIT_OBJECT_0 && retval < WAIT_OBJECT_0 + count )
 101                     if ( handles[retval - WAIT_OBJECT_0] == s->object )
 102                     {
 103                         callback = s->callback;
 104                         callback_arg = s->callback_arg;
 105                         break;
 106                     }
 107
 108             if ( s->flags & SERVICE_USE_TIMEOUT )
 109                 if ( timercmp( &s->expire, &curTime, < ) )
 110                 {
 111                     SERVICE_AddTimeval( &s->expire, s->rate );
 112                     callback = s->callback;
 113                     callback_arg = s->callback_arg;
 114                     break;
 115                 }
 116         }
 117
 118         HeapUnlock( service->heap );
 119
 120
 121         /* If found, call callback routine */
 122
 123         if ( callback )
 124         {
 125             callback( callback_arg );
 126             continue;
 127         }
 128
 129
 130         /* If not found, determine wait condition */
 131
 132         HeapLock( service->heap );
 133
 134         count = 0;
 135         timeout = INFINITE;
 136         for ( s = service->first; s; s = s->next )
 137         {
 138             if ( s->flags & SERVICE_DISABLED )
 139                 continue;
 140
 141             if ( s->flags & SERVICE_USE_OBJECT )
 142                 handles[count++] = s->object;
 143
 144             if ( s->flags & SERVICE_USE_TIMEOUT )
 145             {
 146                 long delta = SERVICE_DiffTimeval( &s->expire, &curTime );
 147                 long time  = (delta + 999L) / 1000L;
 148                 if ( time < 1 ) time = 1;
 149                 if ( time < timeout ) timeout =  time;
 150             }
 151         }
 152
 153         HeapUnlock( service->heap );
 154
 155
 156         /* Wait until some condition satisfied */
 157
 158         TRACE( timer, "Waiting for %d objects with timeout %ld\n",
 159                       count, timeout );
 160
 161         retval = WaitForMultipleObjectsEx( count, handles,
 162                                            FALSE, timeout, TRUE );
 163
 164         TRACE( timer, "Wait returned: %ld\n", retval );
 165     }
 166
 167     return 0L;
 168 }
 169
 170 /***********************************************************************
 171  *           SERVICE_Init
 172  */
 173 BOOL SERVICE_Init( void )
 174 {
 175     HANDLE heap, thread;
 176
 177     heap = HeapCreate( HEAP_GROWABLE, 0x1000, 0 );
 178     if ( !heap ) return FALSE;
 179
 180     Service = HeapAlloc( heap, HEAP_ZERO_MEMORY, sizeof(SERVICETABLE) );
 181     if ( !Service )
 182     {
 183         HeapDestroy( heap );
 184         return FALSE;
 185     }
 186
 187     Service->heap = heap;
 188
 189     thread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)SERVICE_Loop,
 190                            Service, 0, NULL );
 191     if ( thread == INVALID_HANDLE_VALUE )
 192     {
 193         HeapDestroy( heap );
 194         return FALSE;
 195     }
 196
 197     Service->thread = ConvertToGlobalHandle( thread );
 198
 199     return TRUE;
 200 }
 201
 202 /***********************************************************************
 203  *           SERVICE_AddObject
 204  */
 205 HANDLE SERVICE_AddObject( HANDLE object,
 206                           PAPCFUNC callback, ULONG_PTR callback_arg )
 207 {
 208     SERVICE *s;
 209     HANDLE handle;
 210
 211     if ( !Service || object == INVALID_HANDLE_VALUE || !callback )
 212         return INVALID_HANDLE_VALUE;
 213
 214     s = HeapAlloc( Service->heap, HEAP_ZERO_MEMORY, sizeof(SERVICE) );
 215     if ( !s ) return INVALID_HANDLE_VALUE;
 216
 217     HeapLock( Service->heap );
 218
 219     s->callback = callback;
 220     s->callback_arg = callback_arg;
 221     s->object = object;
 222     s->flags = SERVICE_USE_OBJECT;
 223
 224     s->self = handle = (HANDLE)++Service->counter;
 225     s->next = Service->first;
 226     Service->first = s;
 227
 228     HeapUnlock( Service->heap );
 229
 230     QueueUserAPC( NULL, Service->thread, 0L );
 231
 232     return handle;
 233 }
 234
 235 /***********************************************************************
 236  *           SERVICE_AddTimer
 237  */
 238 HANDLE SERVICE_AddTimer( LONG rate,
 239                          PAPCFUNC callback, ULONG_PTR callback_arg )
 240 {
 241     SERVICE *s;
 242     HANDLE handle;
 243
 244     if ( !Service || !rate || !callback )
 245         return INVALID_HANDLE_VALUE;
 246
 247     s = HeapAlloc( Service->heap, HEAP_ZERO_MEMORY, sizeof(SERVICE) );
 248     if ( !s ) return INVALID_HANDLE_VALUE;
 249
 250     HeapLock( Service->heap );
 251
 252     s->callback = callback;
 253     s->callback_arg = callback_arg;
 254     s->rate = rate;
 255     s->flags = SERVICE_USE_TIMEOUT;
 256
 257     gettimeofday( &s->expire, NULL );
 258     SERVICE_AddTimeval( &s->expire, s->rate );
 259
 260     s->self = handle = (HANDLE)++Service->counter;
 261     s->next = Service->first;
 262     Service->first = s;
 263
 264     HeapUnlock( Service->heap );
 265
 266     QueueUserAPC( NULL, Service->thread, 0L );
 267
 268     return handle;
 269 }
 270
 271 /***********************************************************************
 272  *           SERVICE_Delete
 273  */
 274 BOOL SERVICE_Delete( HANDLE service )
 275 {
 276     BOOL retv = TRUE;
 277     SERVICE **s;
 278
 279     if ( !Service ) return retv;
 280
 281     HeapLock( Service->heap );
 282
 283     for ( s = &Service->first; *s; s = &(*s)->next )
 284         if ( (*s)->self == service )
 285         {
 286             *s = (*s)->next;
 287             HeapFree( Service->heap, 0, *s );
 288             retv = FALSE;
 289             break;
 290         }
 291
 292     HeapUnlock( Service->heap );
 293
 294     QueueUserAPC( NULL, Service->thread, 0L );
 295
 296     return retv;
 297 }
 298
 299 /***********************************************************************
 300  *           SERVICE_Enable
 301  */
 302 BOOL SERVICE_Enable( HANDLE service )
 303 {
 304     BOOL retv = TRUE;
 305     SERVICE *s;
 306
 307     if ( !Service ) return retv;
 308
 309     HeapLock( Service->heap );
 310
 311     for ( s = Service->first; s; s = s->next )
 312         if ( s->self == service )
 313         {
 314             if ( s->flags & SERVICE_DISABLED )
 315             {
 316                 s->flags &= ~SERVICE_DISABLED;
 317
 318                 if ( s->flags & SERVICE_USE_TIMEOUT )
 319                 {
 320                     long delta;
 321                     struct timeval curTime;
 322                     gettimeofday( &curTime, NULL );
 323
 324                     delta = SERVICE_DiffTimeval( &s->expire, &curTime );
 325                     if ( delta > 0 )
 326                         SERVICE_AddTimeval( &s->expire,
 327                                            (delta / s->rate) * s->rate );
 328                 }
 329             }
 330             retv = FALSE;
 331             break;
 332         }
 333
 334     HeapUnlock( Service->heap );
 335
 336     QueueUserAPC( NULL, Service->thread, 0L );
 337
 338     return retv;
 339 }
 340
 341 /***********************************************************************
 342  *           SERVICE_Disable
 343  */
 344 BOOL SERVICE_Disable( HANDLE service )
 345 {
 346     BOOL retv = TRUE;
 347     SERVICE *s;
 348
 349     if ( !Service ) return retv;
 350
 351     HeapLock( Service->heap );
 352
 353     for ( s = Service->first; s; s = s->next )
 354         if ( s->self == service )
 355         {
 356             s->flags |= SERVICE_DISABLED;
 357             retv = FALSE;
 358             break;
 359         }
 360
 361     HeapUnlock( Service->heap );
 362
 363     QueueUserAPC( NULL, Service->thread, 0L );
 364
 365     return retv;
 366 }
 367
 368