mutex.c 5.46 KB
Newer Older
Alexandre Julliard's avatar
Alexandre Julliard committed
1 2 3 4
/*
 * Server-side mutex management
 *
 * Copyright (C) 1998 Alexandre Julliard
5 6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Alexandre Julliard's avatar
Alexandre Julliard committed
19 20
 */

21 22 23
#include "config.h"
#include "wine/port.h"

Alexandre Julliard's avatar
Alexandre Julliard committed
24 25 26 27
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

28
#include "windef.h"
29 30 31

#include "handle.h"
#include "thread.h"
32
#include "request.h"
Alexandre Julliard's avatar
Alexandre Julliard committed
33 34 35 36 37 38 39 40 41 42 43

struct mutex
{
    struct object  obj;             /* object header */
    struct thread *owner;           /* mutex owner */
    unsigned int   count;           /* recursion count */
    int            abandoned;       /* has it been abandoned? */
    struct mutex  *next;
    struct mutex  *prev;
};

44
static void mutex_dump( struct object *obj, int verbose );
Alexandre Julliard's avatar
Alexandre Julliard committed
45 46
static int mutex_signaled( struct object *obj, struct thread *thread );
static int mutex_satisfied( struct object *obj, struct thread *thread );
47
static void mutex_destroy( struct object *obj );
Alexandre Julliard's avatar
Alexandre Julliard committed
48 49 50

static const struct object_ops mutex_ops =
{
51 52 53 54 55 56
    sizeof(struct mutex),      /* size */
    mutex_dump,                /* dump */
    add_queue,                 /* add_queue */
    remove_queue,              /* remove_queue */
    mutex_signaled,            /* signaled */
    mutex_satisfied,           /* satisfied */
57
    no_get_fd,                 /* get_fd */
58
    mutex_destroy              /* destroy */
Alexandre Julliard's avatar
Alexandre Julliard committed
59 60 61
};


62
static struct mutex *create_mutex( const WCHAR *name, size_t len, int owned )
Alexandre Julliard's avatar
Alexandre Julliard committed
63 64 65
{
    struct mutex *mutex;

66
    if ((mutex = create_named_object( sync_namespace, &mutex_ops, name, len )))
Alexandre Julliard's avatar
Alexandre Julliard committed
67
    {
68
        if (get_error() != STATUS_OBJECT_NAME_COLLISION)
69 70 71 72 73 74 75 76
        {
            /* initialize it if it didn't already exist */
            mutex->count = 0;
            mutex->owner = NULL;
            mutex->abandoned = 0;
            mutex->next = mutex->prev = NULL;
            if (owned) mutex_satisfied( &mutex->obj, current );
        }
Alexandre Julliard's avatar
Alexandre Julliard committed
77
    }
78
    return mutex;
Alexandre Julliard's avatar
Alexandre Julliard committed
79 80 81
}

/* release a mutex once the recursion count is 0 */
82
static void do_release( struct mutex *mutex )
Alexandre Julliard's avatar
Alexandre Julliard committed
83 84 85 86 87
{
    assert( !mutex->count );
    /* remove the mutex from the thread list of owned mutexes */
    if (mutex->next) mutex->next->prev = mutex->prev;
    if (mutex->prev) mutex->prev->next = mutex->next;
88
    else mutex->owner->mutex = mutex->next;
Alexandre Julliard's avatar
Alexandre Julliard committed
89 90 91 92 93 94 95 96 97 98 99 100 101
    mutex->owner = NULL;
    mutex->next = mutex->prev = NULL;
    wake_up( &mutex->obj, 0 );
}

void abandon_mutexes( struct thread *thread )
{
    while (thread->mutex)
    {
        struct mutex *mutex = thread->mutex;
        assert( mutex->owner == thread );
        mutex->count = 0;
        mutex->abandoned = 1;
102
        do_release( mutex );
Alexandre Julliard's avatar
Alexandre Julliard committed
103 104 105
    }
}

106
static void mutex_dump( struct object *obj, int verbose )
Alexandre Julliard's avatar
Alexandre Julliard committed
107 108 109
{
    struct mutex *mutex = (struct mutex *)obj;
    assert( obj->ops == &mutex_ops );
110 111 112
    fprintf( stderr, "Mutex count=%u owner=%p ", mutex->count, mutex->owner );
    dump_object_name( &mutex->obj );
    fputc( '\n', stderr );
Alexandre Julliard's avatar
Alexandre Julliard committed
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
}

static int mutex_signaled( struct object *obj, struct thread *thread )
{
    struct mutex *mutex = (struct mutex *)obj;
    assert( obj->ops == &mutex_ops );
    return (!mutex->count || (mutex->owner == thread));
}

static int mutex_satisfied( struct object *obj, struct thread *thread )
{
    struct mutex *mutex = (struct mutex *)obj;
    assert( obj->ops == &mutex_ops );
    assert( !mutex->count || (mutex->owner == thread) );

    if (!mutex->count++)  /* FIXME: avoid wrap-around */
    {
        assert( !mutex->owner );
        mutex->owner = thread;
        mutex->prev  = NULL;
        if ((mutex->next = thread->mutex)) mutex->next->prev = mutex;
        thread->mutex = mutex;
    }
    if (!mutex->abandoned) return 0;
    mutex->abandoned = 0;
    return 1;
}

141 142 143 144 145 146 147 148 149 150
static void mutex_destroy( struct object *obj )
{
    struct mutex *mutex = (struct mutex *)obj;
    assert( obj->ops == &mutex_ops );

    if (!mutex->count) return;
    mutex->count = 0;
    do_release( mutex );
}

151 152 153
/* create a mutex */
DECL_HANDLER(create_mutex)
{
154 155
    struct mutex *mutex;

156 157
    reply->handle = 0;
    if ((mutex = create_mutex( get_req_data(), get_req_data_size(), req->owned )))
158
    {
159
        reply->handle = alloc_handle( current->process, mutex, req->access, req->inherit );
160
        release_object( mutex );
161 162 163 164 165 166
    }
}

/* open a handle to a mutex */
DECL_HANDLER(open_mutex)
{
167
    reply->handle = open_object( sync_namespace, get_req_data(), get_req_data_size(),
168
                                 &mutex_ops, req->access, req->inherit );
169 170 171 172 173
}

/* release a mutex */
DECL_HANDLER(release_mutex)
{
174 175 176 177 178
    struct mutex *mutex;

    if ((mutex = (struct mutex *)get_handle_obj( current->process, req->handle,
                                                 MUTEX_MODIFY_STATE, &mutex_ops )))
    {
179
        if (!mutex->count || (mutex->owner != current)) set_error( STATUS_MUTANT_NOT_OWNED );
180 181 182 183 184
        else
        {
            reply->prev_count = mutex->count;
            if (!--mutex->count) do_release( mutex );
        }
185 186
        release_object( mutex );
    }
187
}