2 * Server-side mutex management
4 * Copyright (C) 1998 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
30 #define WIN32_NO_STATUS
40 struct object obj
; /* object header */
41 struct thread
*owner
; /* mutex owner */
42 unsigned int count
; /* recursion count */
43 int abandoned
; /* has it been abandoned? */
44 struct list entry
; /* entry in owner thread mutex list */
47 static void mutex_dump( struct object
*obj
, int verbose
);
48 static int mutex_signaled( struct object
*obj
, struct thread
*thread
);
49 static int mutex_satisfied( struct object
*obj
, struct thread
*thread
);
50 static unsigned int mutex_map_access( struct object
*obj
, unsigned int access
);
51 static void mutex_destroy( struct object
*obj
);
52 static int mutex_signal( struct object
*obj
, unsigned int access
);
54 static const struct object_ops mutex_ops
=
56 sizeof(struct mutex
), /* size */
57 mutex_dump
, /* dump */
58 add_queue
, /* add_queue */
59 remove_queue
, /* remove_queue */
60 mutex_signaled
, /* signaled */
61 mutex_satisfied
, /* satisfied */
62 mutex_signal
, /* signal */
63 no_get_fd
, /* get_fd */
64 mutex_map_access
, /* map_access */
65 default_get_sd
, /* get_sd */
66 default_set_sd
, /* set_sd */
67 no_lookup_name
, /* lookup_name */
68 no_open_file
, /* open_file */
69 no_close_handle
, /* close_handle */
70 mutex_destroy
/* destroy */
74 static struct mutex
*create_mutex( struct directory
*root
, const struct unicode_str
*name
,
75 unsigned int attr
, int owned
)
79 if ((mutex
= create_named_object_dir( root
, name
, attr
, &mutex_ops
)))
81 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
83 /* initialize it if it didn't already exist */
87 if (owned
) mutex_satisfied( &mutex
->obj
, current
);
93 /* release a mutex once the recursion count is 0 */
94 static void do_release( struct mutex
*mutex
)
96 assert( !mutex
->count
);
97 /* remove the mutex from the thread list of owned mutexes */
98 list_remove( &mutex
->entry
);
100 wake_up( &mutex
->obj
, 0 );
103 void abandon_mutexes( struct thread
*thread
)
107 while ((ptr
= list_head( &thread
->mutex_list
)) != NULL
)
109 struct mutex
*mutex
= LIST_ENTRY( ptr
, struct mutex
, entry
);
110 assert( mutex
->owner
== thread
);
112 mutex
->abandoned
= 1;
117 static void mutex_dump( struct object
*obj
, int verbose
)
119 struct mutex
*mutex
= (struct mutex
*)obj
;
120 assert( obj
->ops
== &mutex_ops
);
121 fprintf( stderr
, "Mutex count=%u owner=%p ", mutex
->count
, mutex
->owner
);
122 dump_object_name( &mutex
->obj
);
123 fputc( '\n', stderr
);
126 static int mutex_signaled( struct object
*obj
, struct thread
*thread
)
128 struct mutex
*mutex
= (struct mutex
*)obj
;
129 assert( obj
->ops
== &mutex_ops
);
130 return (!mutex
->count
|| (mutex
->owner
== thread
));
133 static int mutex_satisfied( struct object
*obj
, struct thread
*thread
)
135 struct mutex
*mutex
= (struct mutex
*)obj
;
136 assert( obj
->ops
== &mutex_ops
);
137 assert( !mutex
->count
|| (mutex
->owner
== thread
) );
139 if (!mutex
->count
++) /* FIXME: avoid wrap-around */
141 assert( !mutex
->owner
);
142 mutex
->owner
= thread
;
143 list_add_head( &thread
->mutex_list
, &mutex
->entry
);
145 if (!mutex
->abandoned
) return 0;
146 mutex
->abandoned
= 0;
150 static unsigned int mutex_map_access( struct object
*obj
, unsigned int access
)
152 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| SYNCHRONIZE
;
153 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
| MUTEX_MODIFY_STATE
;
154 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
;
155 if (access
& GENERIC_ALL
) access
|= STANDARD_RIGHTS_ALL
| MUTEX_ALL_ACCESS
;
156 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
159 static int mutex_signal( struct object
*obj
, unsigned int access
)
161 struct mutex
*mutex
= (struct mutex
*)obj
;
162 assert( obj
->ops
== &mutex_ops
);
164 if (!(access
& SYNCHRONIZE
)) /* FIXME: MUTEX_MODIFY_STATE? */
166 set_error( STATUS_ACCESS_DENIED
);
169 if (!mutex
->count
|| (mutex
->owner
!= current
))
171 set_error( STATUS_MUTANT_NOT_OWNED
);
174 if (!--mutex
->count
) do_release( mutex
);
178 static void mutex_destroy( struct object
*obj
)
180 struct mutex
*mutex
= (struct mutex
*)obj
;
181 assert( obj
->ops
== &mutex_ops
);
183 if (!mutex
->count
) return;
189 DECL_HANDLER(create_mutex
)
192 struct unicode_str name
;
193 struct directory
*root
= NULL
;
196 get_req_unicode_str( &name
);
197 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
200 if ((mutex
= create_mutex( root
, &name
, req
->attributes
, req
->owned
)))
202 reply
->handle
= alloc_handle( current
->process
, mutex
, req
->access
, req
->attributes
);
203 release_object( mutex
);
206 if (root
) release_object( root
);
209 /* open a handle to a mutex */
210 DECL_HANDLER(open_mutex
)
212 struct unicode_str name
;
213 struct directory
*root
= NULL
;
216 get_req_unicode_str( &name
);
217 if (req
->rootdir
&& !(root
= get_directory_obj( current
->process
, req
->rootdir
, 0 )))
220 if ((mutex
= open_object_dir( root
, &name
, req
->attributes
, &mutex_ops
)))
222 reply
->handle
= alloc_handle( current
->process
, &mutex
->obj
, req
->access
, req
->attributes
);
223 release_object( mutex
);
226 if (root
) release_object( root
);
229 /* release a mutex */
230 DECL_HANDLER(release_mutex
)
234 if ((mutex
= (struct mutex
*)get_handle_obj( current
->process
, req
->handle
,
235 MUTEX_MODIFY_STATE
, &mutex_ops
)))
237 if (!mutex
->count
|| (mutex
->owner
!= current
)) set_error( STATUS_MUTANT_NOT_OWNED
);
240 reply
->prev_count
= mutex
->count
;
241 if (!--mutex
->count
) do_release( mutex
);
243 release_object( mutex
);