git.oblomov.eu Git - wine/blob - 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 char *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 name='%s'\n",
 101              sem->count, sem->max, get_object_name( &sem->obj ) );
 102 }
 103
 104 static int semaphore_signaled( struct object *obj, struct thread *thread )
 105 {
 106     struct semaphore *sem = (struct semaphore *)obj;
 107     assert( obj->ops == &semaphore_ops );
 108     return (sem->count > 0);
 109 }
 110
 111 static int semaphore_satisfied( struct object *obj, struct thread *thread )
 112 {
 113     struct semaphore *sem = (struct semaphore *)obj;
 114     assert( obj->ops == &semaphore_ops );
 115     assert( sem->count );
 116     sem->count--;
 117     return 0;  /* not abandoned */
 118 }
 119
 120 /* create a semaphore */
 121 DECL_HANDLER(create_semaphore)
 122 {
 123     size_t len = get_req_strlen( req->name );
 124     struct semaphore *sem;
 125
 126     req->handle = -1;
 127     if ((sem = create_semaphore( req->name, len, req->initial, req->max )))
 128     {
 129         req->handle = alloc_handle( current->process, sem, SEMAPHORE_ALL_ACCESS, req->inherit );
 130         release_object( sem );
 131     }
 132 }
 133
 134 /* open a handle to a semaphore */
 135 DECL_HANDLER(open_semaphore)
 136 {
 137     size_t len = get_req_strlen( req->name );
 138     req->handle = open_object( req->name, len, &semaphore_ops, req->access, req->inherit );
 139 }
 140
 141 /* release a semaphore */
 142 DECL_HANDLER(release_semaphore)
 143 {
 144     req->prev_count = release_semaphore( req->handle, req->count );
 145 }