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