server/semaphore.c

   1 /*
   2  * Server-side semaphore management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10
  11 #include "winerror.h"
  12 #include "winnt.h"
  13 #include "server/thread.h"
  14
  15 struct semaphore
  16 {
  17     struct object  obj;    /* object header */
  18     unsigned int   count;  /* current count */
  19     unsigned int   max;    /* maximum possible count */
  20 };
  21
  22 static void semaphore_dump( struct object *obj, int verbose );
  23 static int semaphore_signaled( struct object *obj, struct thread *thread );
  24 static int semaphore_satisfied( struct object *obj, struct thread *thread );
  25 static void semaphore_destroy( struct object *obj );
  26
  27 static const struct object_ops semaphore_ops =
  28 {
  29     semaphore_dump,
  30     add_queue,
  31     remove_queue,
  32     semaphore_signaled,
  33     semaphore_satisfied,
  34     semaphore_destroy
  35 };
  36
  37
  38 struct object *create_semaphore( const char *name, unsigned int initial, unsigned int max )
  39 {
  40     struct semaphore *sem;
  41
  42     if (!max || (initial > max))
  43     {
  44         SET_ERROR( ERROR_INVALID_PARAMETER );
  45         return NULL;
  46     }
  47     if (!(sem = (struct semaphore *)create_named_object( name, &semaphore_ops, sizeof(*sem) )))
  48         return NULL;
  49     if (GET_ERROR() != ERROR_ALREADY_EXISTS)
  50     {
  51         /* initialize it if it didn't already exist */
  52         sem->count = initial;
  53         sem->max   = max;
  54     }
  55     return &sem->obj;
  56 }
  57
  58 int open_semaphore( unsigned int access, int inherit, const char *name )
  59 {
  60     return open_object( name, &semaphore_ops, access, inherit );
  61 }
  62
  63 int release_semaphore( int handle, unsigned int count, unsigned int *prev_count )
  64 {
  65     struct semaphore *sem;
  66
  67     if (!(sem = (struct semaphore *)get_handle_obj( current->process, handle,
  68                                                     SEMAPHORE_MODIFY_STATE, &semaphore_ops )))
  69         return 0;
  70
  71     *prev_count = sem->count;
  72     if (sem->count + count < sem->count || sem->count + count > sem->max)
  73     {
  74         SET_ERROR( ERROR_TOO_MANY_POSTS );
  75         return 0;
  76     }
  77     if (sem->count)
  78     {
  79         /* there cannot be any thread waiting if the count is != 0 */
  80         assert( !sem->obj.head );
  81         sem->count += count;
  82     }
  83     else
  84     {
  85         sem->count = count;
  86         wake_up( &sem->obj, count );
  87     }
  88     release_object( sem );
  89     return 1;
  90 }
  91
  92 static void semaphore_dump( struct object *obj, int verbose )
  93 {
  94     struct semaphore *sem = (struct semaphore *)obj;
  95     assert( obj->ops == &semaphore_ops );
  96     printf( "Semaphore count=%d max=%d\n", sem->count, sem->max );
  97 }
  98
  99 static int semaphore_signaled( struct object *obj, struct thread *thread )
 100 {
 101     struct semaphore *sem = (struct semaphore *)obj;
 102     assert( obj->ops == &semaphore_ops );
 103     return (sem->count > 0);
 104 }
 105
 106 static int semaphore_satisfied( struct object *obj, struct thread *thread )
 107 {
 108     struct semaphore *sem = (struct semaphore *)obj;
 109     assert( obj->ops == &semaphore_ops );
 110     assert( sem->count );
 111     sem->count--;
 112     return 0;  /* not abandoned */
 113 }
 114
 115 static void semaphore_destroy( struct object *obj )
 116 {
 117     struct semaphore *sem = (struct semaphore *)obj;
 118     assert( obj->ops == &semaphore_ops );
 119     free( sem );
 120 }