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 "winnt.h"
  12
  13 #include "handle.h"
  14 #include "thread.h"
  15 #include "request.h"
  16
  17 struct semaphore
  18 {
  19     struct object  obj;    /* object header */
  20     unsigned int   count;  /* current count */
  21     unsigned int   max;    /* maximum possible count */
  22 };
  23
  24 static void semaphore_dump( struct object *obj, int verbose );
  25 static int semaphore_signaled( struct object *obj, struct thread *thread );
  26 static int semaphore_satisfied( struct object *obj, struct thread *thread );
  27
  28 static const struct object_ops semaphore_ops =
  29 {
  30     sizeof(struct semaphore),      /* size */
  31     semaphore_dump,                /* dump */
  32     add_queue,                     /* add_queue */
  33     remove_queue,                  /* remove_queue */
  34     semaphore_signaled,            /* signaled */
  35     semaphore_satisfied,           /* satisfied */
  36     NULL,                          /* get_poll_events */
  37     NULL,                          /* poll_event */
  38     no_get_fd,                     /* get_fd */
  39     no_flush,                      /* flush */
  40     no_get_file_info,              /* get_file_info */
  41     no_destroy                     /* 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( STATUS_INVALID_PARAMETER );
  53         return NULL;
  54     }
  55     if ((sem = create_named_object( &semaphore_ops, name, len )))
  56     {
  57         if (get_error() != STATUS_OBJECT_NAME_COLLISION)
  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( handle_t 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( STATUS_SEMAPHORE_LIMIT_EXCEEDED );
  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     struct semaphore *sem;
 125
 126     req->handle = 0;
 127     if ((sem = create_semaphore( get_req_data(req), get_req_data_size(req),
 128                                  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     req->handle = open_object( get_req_data(req), get_req_data_size(req),
 139                                &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 }