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
41 struct object obj
; /* object header */
42 struct thread
*owner
; /* mutex owner */
43 unsigned int count
; /* recursion count */
44 int abandoned
; /* has it been abandoned? */
45 struct list entry
; /* entry in owner thread mutex list */
48 static void mutex_dump( struct object
*obj
, int verbose
);
49 static struct object_type
*mutex_get_type( struct object
*obj
);
50 static int mutex_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
51 static void mutex_satisfied( struct object
*obj
, struct wait_queue_entry
*entry
);
52 static unsigned int mutex_map_access( struct object
*obj
, unsigned int access
);
53 static void mutex_destroy( struct object
*obj
);
54 static int mutex_signal( struct object
*obj
, unsigned int access
);
56 static const struct object_ops mutex_ops
=
58 sizeof(struct mutex
), /* size */
59 mutex_dump
, /* dump */
60 mutex_get_type
, /* get_type */
61 add_queue
, /* add_queue */
62 remove_queue
, /* remove_queue */
63 mutex_signaled
, /* signaled */
64 mutex_satisfied
, /* satisfied */
65 mutex_signal
, /* signal */
66 no_get_fd
, /* get_fd */
67 mutex_map_access
, /* map_access */
68 default_get_sd
, /* get_sd */
69 default_set_sd
, /* set_sd */
70 no_lookup_name
, /* lookup_name */
71 directory_link_name
, /* link_name */
72 default_unlink_name
, /* unlink_name */
73 no_open_file
, /* open_file */
74 no_close_handle
, /* close_handle */
75 mutex_destroy
/* destroy */
79 /* grab a mutex for a given thread */
80 static void do_grab( struct mutex
*mutex
, struct thread
*thread
)
82 assert( !mutex
->count
|| (mutex
->owner
== thread
) );
84 if (!mutex
->count
++) /* FIXME: avoid wrap-around */
86 assert( !mutex
->owner
);
87 mutex
->owner
= thread
;
88 list_add_head( &thread
->mutex_list
, &mutex
->entry
);
92 /* release a mutex once the recursion count is 0 */
93 static void do_release( struct mutex
*mutex
)
95 assert( !mutex
->count
);
96 /* remove the mutex from the thread list of owned mutexes */
97 list_remove( &mutex
->entry
);
99 wake_up( &mutex
->obj
, 0 );
102 static struct mutex
*create_mutex( struct directory
*root
, const struct unicode_str
*name
,
103 unsigned int attr
, int owned
, const struct security_descriptor
*sd
)
107 if ((mutex
= create_named_object_dir( root
, name
, attr
, &mutex_ops
)))
109 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
111 /* initialize it if it didn't already exist */
114 mutex
->abandoned
= 0;
115 if (owned
) do_grab( mutex
, current
);
116 if (sd
) default_set_sd( &mutex
->obj
, sd
, OWNER_SECURITY_INFORMATION
|
117 GROUP_SECURITY_INFORMATION
|
118 DACL_SECURITY_INFORMATION
|
119 SACL_SECURITY_INFORMATION
);
125 void abandon_mutexes( struct thread
*thread
)
129 while ((ptr
= list_head( &thread
->mutex_list
)) != NULL
)
131 struct mutex
*mutex
= LIST_ENTRY( ptr
, struct mutex
, entry
);
132 assert( mutex
->owner
== thread
);
134 mutex
->abandoned
= 1;
139 static void mutex_dump( struct object
*obj
, int verbose
)
141 struct mutex
*mutex
= (struct mutex
*)obj
;
142 assert( obj
->ops
== &mutex_ops
);
143 fprintf( stderr
, "Mutex count=%u owner=%p\n", mutex
->count
, mutex
->owner
);
146 static struct object_type
*mutex_get_type( struct object
*obj
)
148 static const WCHAR name
[] = {'M','u','t','a','n','t'};
149 static const struct unicode_str str
= { name
, sizeof(name
) };
150 return get_object_type( &str
);
153 static int mutex_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
155 struct mutex
*mutex
= (struct mutex
*)obj
;
156 assert( obj
->ops
== &mutex_ops
);
157 return (!mutex
->count
|| (mutex
->owner
== get_wait_queue_thread( entry
)));
160 static void mutex_satisfied( struct object
*obj
, struct wait_queue_entry
*entry
)
162 struct mutex
*mutex
= (struct mutex
*)obj
;
163 assert( obj
->ops
== &mutex_ops
);
165 do_grab( mutex
, get_wait_queue_thread( entry
));
166 if (mutex
->abandoned
) make_wait_abandoned( entry
);
167 mutex
->abandoned
= 0;
170 static unsigned int mutex_map_access( struct object
*obj
, unsigned int access
)
172 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| MUTANT_QUERY_STATE
;
173 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
;
174 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE
;
175 if (access
& GENERIC_ALL
) access
|= STANDARD_RIGHTS_ALL
| MUTEX_ALL_ACCESS
;
176 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
179 static int mutex_signal( struct object
*obj
, unsigned int access
)
181 struct mutex
*mutex
= (struct mutex
*)obj
;
182 assert( obj
->ops
== &mutex_ops
);
184 if (!(access
& SYNCHRONIZE
))
186 set_error( STATUS_ACCESS_DENIED
);
189 if (!mutex
->count
|| (mutex
->owner
!= current
))
191 set_error( STATUS_MUTANT_NOT_OWNED
);
194 if (!--mutex
->count
) do_release( mutex
);
198 static void mutex_destroy( struct object
*obj
)
200 struct mutex
*mutex
= (struct mutex
*)obj
;
201 assert( obj
->ops
== &mutex_ops
);
203 if (!mutex
->count
) return;
209 DECL_HANDLER(create_mutex
)
212 struct unicode_str name
;
213 struct directory
*root
;
214 const struct security_descriptor
*sd
;
215 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &name
, &root
);
217 if (!objattr
) return;
219 if ((mutex
= create_mutex( root
, &name
, objattr
->attributes
, req
->owned
, sd
)))
221 if (get_error() == STATUS_OBJECT_NAME_EXISTS
)
222 reply
->handle
= alloc_handle( current
->process
, mutex
, req
->access
, objattr
->attributes
);
224 reply
->handle
= alloc_handle_no_access_check( current
->process
, mutex
,
225 req
->access
, objattr
->attributes
);
226 release_object( mutex
);
229 if (root
) release_object( root
);
232 /* open a handle to a mutex */
233 DECL_HANDLER(open_mutex
)
235 struct unicode_str name
= get_req_unicode_str();
237 reply
->handle
= open_object( current
->process
, req
->rootdir
, req
->access
,
238 &mutex_ops
, &name
, req
->attributes
);
241 /* release a mutex */
242 DECL_HANDLER(release_mutex
)
246 if ((mutex
= (struct mutex
*)get_handle_obj( current
->process
, req
->handle
,
249 if (!mutex
->count
|| (mutex
->owner
!= current
)) set_error( STATUS_MUTANT_NOT_OWNED
);
252 reply
->prev_count
= mutex
->count
;
253 if (!--mutex
->count
) do_release( mutex
);
255 release_object( mutex
);