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
  14 #include "handle.h"
  15 #include "thread.h"
  16 #include "request.h"
  17
  18 struct semaphore
  19 {
  20     struct object  obj;    /* object header */
  21     unsigned int   count;  /* current count */
  22     unsigned int   max;    /* maximum possible count */
  23 };
  24
  25 static void semaphore_dump( struct object *obj, int verbose );
  26 static int semaphore_signaled( struct object *obj, struct thread *thread );
  27 static int semaphore_satisfied( struct object *obj, struct thread *thread );
  28
  29 static const struct object_ops semaphore_ops =
  30 {
  31     sizeof(struct semaphore),
  32     semaphore_dump,
  33     add_queue,
  34     remove_queue,
  35     semaphore_signaled,
  36     semaphore_satisfied,
  37     no_read_fd,
  38     no_write_fd,
  39     no_flush,
  40     no_get_file_info,
  41     no_destroy
  42 };
  43
  44
  45 static struct semaphore *create_semaphore( const WCHAR *name, size_t len,
  46                                            unsigned int initial, unsigned int max )
  47 {
  48     struct semaphore *sem;
  49
  50     if (!max || (initial > max))
  51     {
  52         set_error( ERROR_INVALID_PARAMETER );
  53         return NULL;
  54     }
  55     if ((sem = create_named_object( &semaphore_ops, name, len )))
  56     {
  57         if (get_error() != ERROR_ALREADY_EXISTS)
  58         {
  59             /* initialize it if it didn't already exist */
  60             sem->count = initial;
  61             sem->max   = max;
  62         }
  63     }
  64     return sem;
  65 }
  66
  67 static unsigned int release_semaphore( int handle, unsigned int count )
  68 {
  69     struct semaphore *sem;
  70     unsigned int prev = 0;
  71
  72     if ((sem = (struct semaphore *)get_handle_obj( current->process, handle,
  73                                                    SEMAPHORE_MODIFY_STATE, &semaphore_ops )))
  74     {
  75         prev = sem->count;
  76         if (sem->count + count < sem->count || sem->count + count > sem->max)
  77         {
  78             set_error( ERROR_TOO_MANY_POSTS );
  79         }
  80         else if (sem->count)
  81         {
  82             /* there cannot be any thread waiting if the count is != 0 */
  83             assert( !sem->obj.head );
  84             sem->count += count;
  85         }
  86         else
  87         {
  88             sem->count = count;
  89             wake_up( &sem->obj, count );
  90         }
  91         release_object( sem );
  92     }
  93     return prev;
  94 }
  95
  96 static void semaphore_dump( struct object *obj, int verbose )
  97 {
  98     struct semaphore *sem = (struct semaphore *)obj;
  99     assert( obj->ops == &semaphore_ops );
 100     fprintf( stderr, "Semaphore count=%d max=%d ", sem->count, sem->max );
 101     dump_object_name( &sem->obj );
 102     fputc( '\n', stderr );
 103 }
 104
 105 static int semaphore_signaled( struct object *obj, struct thread *thread )
 106 {
 107     struct semaphore *sem = (struct semaphore *)obj;
 108     assert( obj->ops == &semaphore_ops );
 109     return (sem->count > 0);
 110 }
 111
 112 static int semaphore_satisfied( struct object *obj, struct thread *thread )
 113 {
 114     struct semaphore *sem = (struct semaphore *)obj;
 115     assert( obj->ops == &semaphore_ops );
 116     assert( sem->count );
 117     sem->count--;
 118     return 0;  /* not abandoned */
 119 }
 120
 121 /* create a semaphore */
 122 DECL_HANDLER(create_semaphore)
 123 {
 124     size_t len = get_req_strlenW( req->name );
 125     struct semaphore *sem;
 126
 127     req->handle = -1;
 128     if ((sem = create_semaphore( req->name, len, req->initial, req->max )))
 129     {
 130         req->handle = alloc_handle( current->process, sem, SEMAPHORE_ALL_ACCESS, req->inherit );
 131         release_object( sem );
 132     }
 133 }
 134
 135 /* open a handle to a semaphore */
 136 DECL_HANDLER(open_semaphore)
 137 {
 138     size_t len = get_req_strlenW( req->name );
 139     req->handle = open_object( req->name, len, &semaphore_ops, req->access, req->inherit );
 140 }
 141
 142 /* release a semaphore */
 143 DECL_HANDLER(release_semaphore)
 144 {
 145     req->prev_count = release_semaphore( req->handle, req->count );
 146 }