← Back to branch summary

~svn/ubuntu/oneiric/subversion/ppa

« back to all changes in this revision

Viewing changes to apr/locks/win32/thread_rwlock.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-12-13 17:57:16 UTC
  • mfrom: (1.1.6 upstream) (0.1.3 etch)
  • Revision ID: james.westby@ubuntu.com-20061213175716-2ysv6z4w5dpa2r2f
Tags: 1.4.2dfsg1-2ubuntu1
* Merge with Debian unstable; remaining changes:
  - Create pot file on build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
apr/locks/win32/thread_rwlock.c
1
 
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
2
 
 * applicable.
3
 
 *
4
 
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 
 * you may not use this file except in compliance with the License.
6
 
 * You may obtain a copy of the License at
7
 
 *
8
 
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 
 *
10
 
 * Unless required by applicable law or agreed to in writing, software
11
 
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 
 * See the License for the specific language governing permissions and
14
 
 * limitations under the License.
15
 
 */
16
 
 
17
 
#include "apr.h"
18
 
#include "apr_private.h"
19
 
#include "apr_general.h"
20
 
#include "apr_strings.h"
21
 
#include "win32/apr_arch_thread_rwlock.h"
22
 
#include "apr_portable.h"
23
 
 
24
 
static apr_status_t thread_rwlock_cleanup(void *data)
25
 
{
26
 
    return apr_thread_rwlock_destroy((apr_thread_rwlock_t *) data);
27
 
}
28
 
 
29
 
APR_DECLARE(apr_status_t)apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
30
 
                                                  apr_pool_t *pool)
31
 
{
32
 
    *rwlock = apr_palloc(pool, sizeof(**rwlock));
33
 
 
34
 
    (*rwlock)->pool        = pool;
35
 
    (*rwlock)->readers     = 0;
36
 
 
37
 
    if (! ((*rwlock)->read_event = CreateEvent(NULL, TRUE, FALSE, NULL))) {
38
 
        *rwlock = NULL;
39
 
        return apr_get_os_error();
40
 
    }
41
 
 
42
 
    if (! ((*rwlock)->write_mutex = CreateMutex(NULL, FALSE, NULL))) {
43
 
        CloseHandle((*rwlock)->read_event);
44
 
        *rwlock = NULL;
45
 
        return apr_get_os_error();
46
 
    }
47
 
 
48
 
    apr_pool_cleanup_register(pool, *rwlock, thread_rwlock_cleanup,
49
 
                              apr_pool_cleanup_null);
50
 
 
51
 
    return APR_SUCCESS;
52
 
}
53
 
 
54
 
static apr_status_t apr_thread_rwlock_rdlock_core(apr_thread_rwlock_t *rwlock,
55
 
                                                  DWORD  milliseconds)
56
 
{
57
 
    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
58
 
 
59
 
    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
60
 
        return APR_FROM_OS_ERROR(code);
61
 
 
62
 
    /* We've successfully acquired the writer mutex, we can't be locked
63
 
     * for write, so it's OK to add the reader lock.  The writer mutex
64
 
     * doubles as race condition protection for the readers counter.   
65
 
     */
66
 
    InterlockedIncrement(&rwlock->readers);
67
 
    
68
 
    if (! ResetEvent(rwlock->read_event))
69
 
        return apr_get_os_error();
70
 
    
71
 
    if (! ReleaseMutex(rwlock->write_mutex))
72
 
        return apr_get_os_error();
73
 
    
74
 
    return APR_SUCCESS;
75
 
}
76
 
 
77
 
APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
78
 
{
79
 
    return apr_thread_rwlock_rdlock_core(rwlock, INFINITE);
80
 
}
81
 
 
82
 
APR_DECLARE(apr_status_t) 
83
 
apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
84
 
{
85
 
    return apr_thread_rwlock_rdlock_core(rwlock, 0);
86
 
}
87
 
 
88
 
static apr_status_t 
89
 
apr_thread_rwlock_wrlock_core(apr_thread_rwlock_t *rwlock, DWORD milliseconds)
90
 
{
91
 
    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
92
 
 
93
 
    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
94
 
        return APR_FROM_OS_ERROR(code);
95
 
 
96
 
    /* We've got the writer lock but we have to wait for all readers to
97
 
     * unlock before it's ok to use it.
98
 
     */
99
 
    if (rwlock->readers) {
100
 
        /* Must wait for readers to finish before returning, unless this
101
 
         * is an trywrlock (milliseconds == 0):
102
 
         */
103
 
        code = milliseconds
104
 
          ? WaitForSingleObject(rwlock->read_event, milliseconds)
105
 
          : WAIT_TIMEOUT;
106
 
        
107
 
        if (code == WAIT_FAILED || code == WAIT_TIMEOUT) {
108
 
            /* Unable to wait for readers to finish, release write lock: */
109
 
            if (! ReleaseMutex(rwlock->write_mutex))
110
 
                return apr_get_os_error();
111
 
            
112
 
            return APR_FROM_OS_ERROR(code);
113
 
        }
114
 
    }
115
 
 
116
 
    return APR_SUCCESS;
117
 
}
118
 
 
119
 
APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
120
 
{
121
 
    return apr_thread_rwlock_wrlock_core(rwlock, INFINITE);
122
 
}
123
 
 
124
 
APR_DECLARE(apr_status_t)apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
125
 
{
126
 
    return apr_thread_rwlock_wrlock_core(rwlock, 0);
127
 
}
128
 
 
129
 
APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
130
 
{
131
 
    apr_status_t rv = 0;
132
 
 
133
 
    /* First, guess that we're unlocking a writer */
134
 
    if (! ReleaseMutex(rwlock->write_mutex))
135
 
        rv = apr_get_os_error();
136
 
    
137
 
    if (rv == APR_FROM_OS_ERROR(ERROR_NOT_OWNER)) {
138
 
        /* Nope, we must have a read lock */
139
 
        if (rwlock->readers &&
140
 
            ! InterlockedDecrement(&rwlock->readers) &&
141
 
            ! SetEvent(rwlock->read_event)) {
142
 
            rv = apr_get_os_error();
143
 
        }
144
 
        else {
145
 
            rv = 0;
146
 
        }
147
 
    }
148
 
 
149
 
    return rv;
150
 
}
151
 
 
152
 
APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
153
 
{
154
 
    if (! CloseHandle(rwlock->read_event))
155
 
        return apr_get_os_error();
156
 
 
157
 
    if (! CloseHandle(rwlock->write_mutex))
158
 
        return apr_get_os_error();
159
 
    
160
 
    return APR_SUCCESS;
161
 
}
162
 
 
163
 
APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)