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