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                         retval = WAIT_TIMEOUT;
 104                         callback = s->callback;
 105                         callback_arg = s->callback_arg;
 106                         break;
 107                     }
 108
 109             if ( s->flags & SERVICE_USE_TIMEOUT )
 110                 if ( timercmp( &s->expire, &curTime, < ) )
 111                 {
 112                     SERVICE_AddTimeval( &s->expire, s->rate );
 113                     callback = s->callback;
 114                     callback_arg = s->callback_arg;
 115                     break;
 116                 }
 117         }
 118
 119         HeapUnlock( service->heap );
 120
 121
 122         /* If found, call callback routine */
 123
 124         if ( callback )
 125         {
 126             callback( callback_arg );
 127             continue;
 128         }
 129
 130
 131         /* If not found, determine wait condition */
 132
 133         HeapLock( service->heap );
 134
 135         count = 0;
 136         timeout = INFINITE;
 137         for ( s = service->first; s; s = s->next )
 138         {
 139             if ( s->flags & SERVICE_DISABLED )
 140                 continue;
 141
 142             if ( s->flags & SERVICE_USE_OBJECT )
 143                 if ( count < MAXIMUM_WAIT_OBJECTS )
 144                     handles[count++] = s->object;
 145
 146             if ( s->flags & SERVICE_USE_TIMEOUT )
 147             {
 148                 long delta = SERVICE_DiffTimeval( &s->expire, &curTime );
 149                 long time  = (delta + 999L) / 1000L;
 150                 if ( time < 1 ) time = 1;
 151                 if ( time < timeout ) timeout =  time;
 152             }
 153         }
 154
 155         HeapUnlock( service->heap );
 156
 157
 158         /* Wait until some condition satisfied */
 159
 160         TRACE( timer, "Waiting for %d objects with timeout %ld\n",
 161                       count, timeout );
 162
 163         retval = WaitForMultipleObjectsEx( count, handles,
 164                                            FALSE, timeout, TRUE );
 165
 166         TRACE( timer, "Wait returned: %ld\n", retval );
 167     }
 168
 169     return 0L;
 170 }
 171
 172 /***********************************************************************
 173  *           SERVICE_Init
 174  */
 175 BOOL SERVICE_Init( void )
 176 {
 177     HANDLE heap, thread;
 178
 179     heap = HeapCreate( HEAP_GROWABLE, 0x1000, 0 );
 180     if ( !heap ) return FALSE;
 181
 182     Service = HeapAlloc( heap, HEAP_ZERO_MEMORY, sizeof(SERVICETABLE) );
 183     if ( !Service )
 184     {
 185         HeapDestroy( heap );
 186         return FALSE;
 187     }
 188
 189     Service->heap = heap;
 190
 191     thread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)SERVICE_Loop,
 192                            Service, 0, NULL );
 193     if ( thread == INVALID_HANDLE_VALUE )
 194     {
 195         HeapDestroy( heap );
 196         return FALSE;
 197     }
 198
 199     Service->thread = ConvertToGlobalHandle( thread );
 200
 201     return TRUE;
 202 }
 203
 204 /***********************************************************************
 205  *           SERVICE_Exit
 206  */
 207 void SERVICE_Exit( void )
 208 {
 209     TerminateThread( Service->thread, 0 );
 210 }
 211
 212 /***********************************************************************
 213  *           SERVICE_AddObject
 214  */
 215 HANDLE SERVICE_AddObject( HANDLE object,
 216                           PAPCFUNC callback, ULONG_PTR callback_arg )
 217 {
 218     SERVICE *s;
 219     HANDLE handle;
 220
 221     object = ConvertToGlobalHandle( object ); /* FIXME */
 222
 223     if ( !Service || object == INVALID_HANDLE_VALUE || !callback )
 224         return INVALID_HANDLE_VALUE;
 225
 226     s = HeapAlloc( Service->heap, HEAP_ZERO_MEMORY, sizeof(SERVICE) );
 227     if ( !s ) return INVALID_HANDLE_VALUE;
 228
 229     HeapLock( Service->heap );
 230
 231     s->callback = callback;
 232     s->callback_arg = callback_arg;
 233     s->object = object;
 234     s->flags = SERVICE_USE_OBJECT;
 235
 236     s->self = handle = (HANDLE)++Service->counter;
 237     s->next = Service->first;
 238     Service->first = s;
 239
 240     HeapUnlock( Service->heap );
 241
 242     QueueUserAPC( NULL, Service->thread, 0L );
 243
 244     return handle;
 245 }
 246
 247 /***********************************************************************
 248  *           SERVICE_AddTimer
 249  */
 250 HANDLE SERVICE_AddTimer( LONG rate,
 251                          PAPCFUNC callback, ULONG_PTR callback_arg )
 252 {
 253     SERVICE *s;
 254     HANDLE handle;
 255
 256     if ( !Service || !rate || !callback )
 257         return INVALID_HANDLE_VALUE;
 258
 259     s = HeapAlloc( Service->heap, HEAP_ZERO_MEMORY, sizeof(SERVICE) );
 260     if ( !s ) return INVALID_HANDLE_VALUE;
 261
 262     HeapLock( Service->heap );
 263
 264     s->callback = callback;
 265     s->callback_arg = callback_arg;
 266     s->rate = rate;
 267     s->flags = SERVICE_USE_TIMEOUT;
 268
 269     gettimeofday( &s->expire, NULL );
 270     SERVICE_AddTimeval( &s->expire, s->rate );
 271
 272     s->self = handle = (HANDLE)++Service->counter;
 273     s->next = Service->first;
 274     Service->first = s;
 275
 276     HeapUnlock( Service->heap );
 277
 278     QueueUserAPC( NULL, Service->thread, 0L );
 279
 280     return handle;
 281 }
 282
 283 /***********************************************************************
 284  *           SERVICE_Delete
 285  */
 286 BOOL SERVICE_Delete( HANDLE service )
 287 {
 288     HANDLE handle = INVALID_HANDLE_VALUE;
 289     BOOL retv = TRUE;
 290     SERVICE **s, *next;
 291
 292     if ( !Service ) return retv;
 293
 294     HeapLock( Service->heap );
 295
 296     for ( s = &Service->first; *s; s = &(*s)->next )
 297         if ( (*s)->self == service )
 298         {
 299             if ( (*s)->flags & SERVICE_USE_OBJECT )
 300                 handle = (*s)->object;
 301
 302             next = (*s)->next;
 303             HeapFree( Service->heap, 0, *s );
 304             *s = next;
 305             retv = FALSE;
 306             break;
 307         }
 308
 309     HeapUnlock( Service->heap );
 310
 311     if ( handle != INVALID_HANDLE_VALUE )
 312         CloseHandle( handle );
 313
 314     QueueUserAPC( NULL, Service->thread, 0L );
 315
 316     return retv;
 317 }
 318
 319 /***********************************************************************
 320  *           SERVICE_Enable
 321  */
 322 BOOL SERVICE_Enable( HANDLE service )
 323 {
 324     BOOL retv = TRUE;
 325     SERVICE *s;
 326
 327     if ( !Service ) return retv;
 328
 329     HeapLock( Service->heap );
 330
 331     for ( s = Service->first; s; s = s->next )
 332         if ( s->self == service )
 333         {
 334             if ( s->flags & SERVICE_DISABLED )
 335             {
 336                 s->flags &= ~SERVICE_DISABLED;
 337
 338                 if ( s->flags & SERVICE_USE_TIMEOUT )
 339                 {
 340                     long delta;
 341                     struct timeval curTime;
 342                     gettimeofday( &curTime, NULL );
 343
 344                     delta = SERVICE_DiffTimeval( &s->expire, &curTime );
 345                     if ( delta > 0 )
 346                         SERVICE_AddTimeval( &s->expire,
 347                                            (delta / s->rate) * s->rate );
 348                 }
 349             }
 350             retv = FALSE;
 351             break;
 352         }
 353
 354     HeapUnlock( Service->heap );
 355
 356     QueueUserAPC( NULL, Service->thread, 0L );
 357
 358     return retv;
 359 }
 360
 361 /***********************************************************************
 362  *           SERVICE_Disable
 363  */
 364 BOOL SERVICE_Disable( HANDLE service )
 365 {
 366     BOOL retv = TRUE;
 367     SERVICE *s;
 368
 369     if ( !Service ) return retv;
 370
 371     HeapLock( Service->heap );
 372
 373     for ( s = Service->first; s; s = s->next )
 374         if ( s->self == service )
 375         {
 376             s->flags |= SERVICE_DISABLED;
 377             retv = FALSE;
 378             break;
 379         }
 380
 381     HeapUnlock( Service->heap );
 382
 383     QueueUserAPC( NULL, Service->thread, 0L );
 384
 385     return retv;
 386 }
 387
 388