?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Improve the Nt{Query,Set}TimerResolution() stubs.
[wine.git] / dlls / ntdll / unix / sync.c
bloba13e53a437b53e6b92ca184de990ee24de760ff4
1 /*
2 * Process synchronisation
3 *
4 * Copyright 1996, 1997, 1998 Marcus Meissner
5 * Copyright 1997, 1999 Alexandre Julliard
6 * Copyright 1999, 2000 Juergen Schmied
7 * Copyright 2003 Eric Pouech
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #if 0
25 #pragma makedep unix
26 #endif
27
28 #include "config.h"
29 #include "wine/port.h"
30
31 #include <assert.h>
32 #include <errno.h>
33 #include <limits.h>
34 #include <signal.h>
35 #ifdef HAVE_SYS_SYSCALL_H
36 #include <sys/syscall.h>
37 #endif
38 #ifdef HAVE_SYS_TIME_H
39 # include <sys/time.h>
40 #endif
41 #ifdef HAVE_POLL_H
42 #include <poll.h>
43 #endif
44 #ifdef HAVE_SYS_POLL_H
45 # include <sys/poll.h>
46 #endif
47 #ifdef HAVE_UNISTD_H
48 # include <unistd.h>
49 #endif
50 #ifdef HAVE_SCHED_H
51 # include <sched.h>
52 #endif
53 #include <string.h>
54 #include <stdarg.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <time.h>
58 #ifdef __APPLE__
59 # include <mach/mach.h>
60 # include <mach/task.h>
61 # include <mach/semaphore.h>
62 # include <mach/mach_time.h>
63 #endif
64
65 #include "ntstatus.h"
66 #define WIN32_NO_STATUS
67 #define NONAMELESSUNION
68 #include "windef.h"
69 #include "winternl.h"
70 #include "ddk/wdm.h"
71 #include "wine/server.h"
72 #include "wine/exception.h"
73 #include "wine/debug.h"
74 #include "unix_private.h"
75
76 WINE_DEFAULT_DEBUG_CHANNEL(sync);
77
78 HANDLE keyed_event = 0;
79
80 static const LARGE_INTEGER zero_timeout;
81
82 static pthread_mutex_t addr_mutex = PTHREAD_MUTEX_INITIALIZER;
83
84 /* return a monotonic time counter, in Win32 ticks */
85 static inline ULONGLONG monotonic_counter(void)
86 {
87 struct timeval now;
88 #ifdef __APPLE__
89 static mach_timebase_info_data_t timebase;
90
91 if (!timebase.denom) mach_timebase_info( &timebase );
92 #ifdef HAVE_MACH_CONTINUOUS_TIME
93 if (&mach_continuous_time != NULL)
94 return mach_continuous_time() * timebase.numer / timebase.denom / 100;
95 #endif
96 return mach_absolute_time() * timebase.numer / timebase.denom / 100;
97 #elif defined(HAVE_CLOCK_GETTIME)
98 struct timespec ts;
99 #ifdef CLOCK_MONOTONIC_RAW
100 if (!clock_gettime( CLOCK_MONOTONIC_RAW, &ts ))
101 return ts.tv_sec * (ULONGLONG)TICKSPERSEC + ts.tv_nsec / 100;
102 #endif
103 if (!clock_gettime( CLOCK_MONOTONIC, &ts ))
104 return ts.tv_sec * (ULONGLONG)TICKSPERSEC + ts.tv_nsec / 100;
105 #endif
106 gettimeofday( &now, 0 );
107 return ticks_from_time_t( now.tv_sec ) + now.tv_usec * 10 - server_start_time;
108 }
109
110
111 #ifdef __linux__
112
113 #define FUTEX_WAIT 0
114 #define FUTEX_WAKE 1
115 #define FUTEX_WAIT_BITSET 9
116 #define FUTEX_WAKE_BITSET 10
117
118 static int futex_private = 128;
119
120 static inline int futex_wait( const int *addr, int val, struct timespec *timeout )
121 {
122 return syscall( __NR_futex, addr, FUTEX_WAIT | futex_private, val, timeout, 0, 0 );
123 }
124
125 static inline int futex_wake( const int *addr, int val )
126 {
127 return syscall( __NR_futex, addr, FUTEX_WAKE | futex_private, val, NULL, 0, 0 );
128 }
129
130 static inline int futex_wait_bitset( const int *addr, int val, struct timespec *timeout, int mask )
131 {
132 return syscall( __NR_futex, addr, FUTEX_WAIT_BITSET | futex_private, val, timeout, 0, mask );
133 }
134
135 static inline int futex_wake_bitset( const int *addr, int val, int mask )
136 {
137 return syscall( __NR_futex, addr, FUTEX_WAKE_BITSET | futex_private, val, NULL, 0, mask );
138 }
139
140 static inline int use_futexes(void)
141 {
142 static int supported = -1;
143
144 if (supported == -1)
145 {
146 futex_wait( &supported, 10, NULL );
147 if (errno == ENOSYS)
148 {
149 futex_private = 0;
150 futex_wait( &supported, 10, NULL );
151 }
152 supported = (errno != ENOSYS);
153 }
154 return supported;
155 }
156
157 static int *get_futex(void **ptr)
158 {
159 if (sizeof(void *) == 8)
160 return (int *)((((ULONG_PTR)ptr) + 3) & ~3);
161 else if (!(((ULONG_PTR)ptr) & 3))
162 return (int *)ptr;
163 else
164 return NULL;
165 }
166
167 static void timespec_from_timeout( struct timespec *timespec, const LARGE_INTEGER *timeout )
168 {
169 LARGE_INTEGER now;
170 timeout_t diff;
171
172 if (timeout->QuadPart > 0)
173 {
174 NtQuerySystemTime( &now );
175 diff = timeout->QuadPart - now.QuadPart;
176 }
177 else
178 diff = -timeout->QuadPart;
179
180 timespec->tv_sec = diff / TICKSPERSEC;
181 timespec->tv_nsec = (diff % TICKSPERSEC) * 100;
182 }
183
184 #endif
185
186
187 static BOOL compare_addr( const void *addr, const void *cmp, SIZE_T size )
188 {
189 switch (size)
190 {
191 case 1:
192 return (*(const UCHAR *)addr == *(const UCHAR *)cmp);
193 case 2:
194 return (*(const USHORT *)addr == *(const USHORT *)cmp);
195 case 4:
196 return (*(const ULONG *)addr == *(const ULONG *)cmp);
197 case 8:
198 return (*(const ULONG64 *)addr == *(const ULONG64 *)cmp);
199 }
200
201 return FALSE;
202 }
203
204
205 /* create a struct security_descriptor and contained information in one contiguous piece of memory */
206 NTSTATUS alloc_object_attributes( const OBJECT_ATTRIBUTES *attr, struct object_attributes **ret,
207 data_size_t *ret_len )
208 {
209 unsigned int len = sizeof(**ret);
210 SID *owner = NULL, *group = NULL;
211 ACL *dacl = NULL, *sacl = NULL;
212 SECURITY_DESCRIPTOR *sd;
213
214 *ret = NULL;
215 *ret_len = 0;
216
217 if (!attr) return STATUS_SUCCESS;
218
219 if (attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
220
221 if ((sd = attr->SecurityDescriptor))
222 {
223 len += sizeof(struct security_descriptor);
224 if (sd->Revision != SECURITY_DESCRIPTOR_REVISION) return STATUS_UNKNOWN_REVISION;
225 if (sd->Control & SE_SELF_RELATIVE)
226 {
227 SECURITY_DESCRIPTOR_RELATIVE *rel = (SECURITY_DESCRIPTOR_RELATIVE *)sd;
228 if (rel->Owner) owner = (PSID)((BYTE *)rel + rel->Owner);
229 if (rel->Group) group = (PSID)((BYTE *)rel + rel->Group);
230 if ((sd->Control & SE_SACL_PRESENT) && rel->Sacl) sacl = (PSID)((BYTE *)rel + rel->Sacl);
231 if ((sd->Control & SE_DACL_PRESENT) && rel->Dacl) dacl = (PSID)((BYTE *)rel + rel->Dacl);
232 }
233 else
234 {
235 owner = sd->Owner;
236 group = sd->Group;
237 if (sd->Control & SE_SACL_PRESENT) sacl = sd->Sacl;
238 if (sd->Control & SE_DACL_PRESENT) dacl = sd->Dacl;
239 }
240
241 if (owner) len += offsetof( SID, SubAuthority[owner->SubAuthorityCount] );
242 if (group) len += offsetof( SID, SubAuthority[group->SubAuthorityCount] );
243 if (sacl) len += sacl->AclSize;
244 if (dacl) len += dacl->AclSize;
245
246 /* fix alignment for the Unicode name that follows the structure */
247 len = (len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
248 }
249
250 if (attr->ObjectName)
251 {
252 if ((ULONG_PTR)attr->ObjectName->Buffer & (sizeof(WCHAR) - 1)) return STATUS_DATATYPE_MISALIGNMENT;
253 if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
254 len += attr->ObjectName->Length;
255 }
256 else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
257
258 len = (len + 3) & ~3; /* DWORD-align the entire structure */
259
260 if (!(*ret = calloc( len, 1 ))) return STATUS_NO_MEMORY;
261
262 (*ret)->rootdir = wine_server_obj_handle( attr->RootDirectory );
263 (*ret)->attributes = attr->Attributes;
264
265 if (attr->SecurityDescriptor)
266 {
267 struct security_descriptor *descr = (struct security_descriptor *)(*ret + 1);
268 unsigned char *ptr = (unsigned char *)(descr + 1);
269
270 descr->control = sd->Control & ~SE_SELF_RELATIVE;
271 if (owner) descr->owner_len = offsetof( SID, SubAuthority[owner->SubAuthorityCount] );
272 if (group) descr->group_len = offsetof( SID, SubAuthority[group->SubAuthorityCount] );
273 if (sacl) descr->sacl_len = sacl->AclSize;
274 if (dacl) descr->dacl_len = dacl->AclSize;
275
276 memcpy( ptr, owner, descr->owner_len );
277 ptr += descr->owner_len;
278 memcpy( ptr, group, descr->group_len );
279 ptr += descr->group_len;
280 memcpy( ptr, sacl, descr->sacl_len );
281 ptr += descr->sacl_len;
282 memcpy( ptr, dacl, descr->dacl_len );
283 (*ret)->sd_len = (sizeof(*descr) + descr->owner_len + descr->group_len + descr->sacl_len +
284 descr->dacl_len + sizeof(WCHAR) - 1) & ~(sizeof(WCHAR) - 1);
285 }
286
287 if (attr->ObjectName)
288 {
289 unsigned char *ptr = (unsigned char *)(*ret + 1) + (*ret)->sd_len;
290 (*ret)->name_len = attr->ObjectName->Length;
291 memcpy( ptr, attr->ObjectName->Buffer, (*ret)->name_len );
292 }
293
294 *ret_len = len;
295 return STATUS_SUCCESS;
296 }
297
298
299 static NTSTATUS validate_open_object_attributes( const OBJECT_ATTRIBUTES *attr )
300 {
301 if (!attr || attr->Length != sizeof(*attr)) return STATUS_INVALID_PARAMETER;
302
303 if (attr->ObjectName)
304 {
305 if ((ULONG_PTR)attr->ObjectName->Buffer & (sizeof(WCHAR) - 1)) return STATUS_DATATYPE_MISALIGNMENT;
306 if (attr->ObjectName->Length & (sizeof(WCHAR) - 1)) return STATUS_OBJECT_NAME_INVALID;
307 }
308 else if (attr->RootDirectory) return STATUS_OBJECT_NAME_INVALID;
309
310 return STATUS_SUCCESS;
311 }
312
313
314 /******************************************************************************
315 * NtCreateSemaphore (NTDLL.@)
316 */
317 NTSTATUS WINAPI NtCreateSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
318 LONG initial, LONG max )
319 {
320 NTSTATUS ret;
321 data_size_t len;
322 struct object_attributes *objattr;
323
324 *handle = 0;
325 if (max <= 0 || initial < 0 || initial > max) return STATUS_INVALID_PARAMETER;
326 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
327
328 SERVER_START_REQ( create_semaphore )
329 {
330 req->access = access;
331 req->initial = initial;
332 req->max = max;
333 wine_server_add_data( req, objattr, len );
334 ret = wine_server_call( req );
335 *handle = wine_server_ptr_handle( reply->handle );
336 }
337 SERVER_END_REQ;
338
339 free( objattr );
340 return ret;
341 }
342
343
344 /******************************************************************************
345 * NtOpenSemaphore (NTDLL.@)
346 */
347 NTSTATUS WINAPI NtOpenSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
348 {
349 NTSTATUS ret;
350
351 *handle = 0;
352 if ((ret = validate_open_object_attributes( attr ))) return ret;
353
354 SERVER_START_REQ( open_semaphore )
355 {
356 req->access = access;
357 req->attributes = attr->Attributes;
358 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
359 if (attr->ObjectName)
360 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
361 ret = wine_server_call( req );
362 *handle = wine_server_ptr_handle( reply->handle );
363 }
364 SERVER_END_REQ;
365 return ret;
366 }
367
368
369 /******************************************************************************
370 * NtQuerySemaphore (NTDLL.@)
371 */
372 NTSTATUS WINAPI NtQuerySemaphore( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
373 void *info, ULONG len, ULONG *ret_len )
374 {
375 NTSTATUS ret;
376 SEMAPHORE_BASIC_INFORMATION *out = info;
377
378 TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
379
380 if (class != SemaphoreBasicInformation)
381 {
382 FIXME("(%p,%d,%u) Unknown class\n", handle, class, len);
383 return STATUS_INVALID_INFO_CLASS;
384 }
385
386 if (len != sizeof(SEMAPHORE_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
387
388 SERVER_START_REQ( query_semaphore )
389 {
390 req->handle = wine_server_obj_handle( handle );
391 if (!(ret = wine_server_call( req )))
392 {
393 out->CurrentCount = reply->current;
394 out->MaximumCount = reply->max;
395 if (ret_len) *ret_len = sizeof(SEMAPHORE_BASIC_INFORMATION);
396 }
397 }
398 SERVER_END_REQ;
399 return ret;
400 }
401
402
403 /******************************************************************************
404 * NtReleaseSemaphore (NTDLL.@)
405 */
406 NTSTATUS WINAPI NtReleaseSemaphore( HANDLE handle, ULONG count, ULONG *previous )
407 {
408 NTSTATUS ret;
409
410 SERVER_START_REQ( release_semaphore )
411 {
412 req->handle = wine_server_obj_handle( handle );
413 req->count = count;
414 if (!(ret = wine_server_call( req )))
415 {
416 if (previous) *previous = reply->prev_count;
417 }
418 }
419 SERVER_END_REQ;
420 return ret;
421 }
422
423
424 /**************************************************************************
425 * NtCreateEvent (NTDLL.@)
426 */
427 NTSTATUS WINAPI NtCreateEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
428 EVENT_TYPE type, BOOLEAN state )
429 {
430 NTSTATUS ret;
431 data_size_t len;
432 struct object_attributes *objattr;
433
434 *handle = 0;
435 if (type != NotificationEvent && type != SynchronizationEvent) return STATUS_INVALID_PARAMETER;
436 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
437
438 SERVER_START_REQ( create_event )
439 {
440 req->access = access;
441 req->manual_reset = (type == NotificationEvent);
442 req->initial_state = state;
443 wine_server_add_data( req, objattr, len );
444 ret = wine_server_call( req );
445 *handle = wine_server_ptr_handle( reply->handle );
446 }
447 SERVER_END_REQ;
448
449 free( objattr );
450 return ret;
451 }
452
453
454 /******************************************************************************
455 * NtOpenEvent (NTDLL.@)
456 */
457 NTSTATUS WINAPI NtOpenEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
458 {
459 NTSTATUS ret;
460
461 *handle = 0;
462 if ((ret = validate_open_object_attributes( attr ))) return ret;
463
464 SERVER_START_REQ( open_event )
465 {
466 req->access = access;
467 req->attributes = attr->Attributes;
468 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
469 if (attr->ObjectName)
470 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
471 ret = wine_server_call( req );
472 *handle = wine_server_ptr_handle( reply->handle );
473 }
474 SERVER_END_REQ;
475 return ret;
476 }
477
478
479 /******************************************************************************
480 * NtSetEvent (NTDLL.@)
481 */
482 NTSTATUS WINAPI NtSetEvent( HANDLE handle, LONG *prev_state )
483 {
484 NTSTATUS ret;
485
486 SERVER_START_REQ( event_op )
487 {
488 req->handle = wine_server_obj_handle( handle );
489 req->op = SET_EVENT;
490 ret = wine_server_call( req );
491 if (!ret && prev_state) *prev_state = reply->state;
492 }
493 SERVER_END_REQ;
494 return ret;
495 }
496
497
498 /******************************************************************************
499 * NtResetEvent (NTDLL.@)
500 */
501 NTSTATUS WINAPI NtResetEvent( HANDLE handle, LONG *prev_state )
502 {
503 NTSTATUS ret;
504
505 SERVER_START_REQ( event_op )
506 {
507 req->handle = wine_server_obj_handle( handle );
508 req->op = RESET_EVENT;
509 ret = wine_server_call( req );
510 if (!ret && prev_state) *prev_state = reply->state;
511 }
512 SERVER_END_REQ;
513 return ret;
514 }
515
516
517 /******************************************************************************
518 * NtClearEvent (NTDLL.@)
519 */
520 NTSTATUS WINAPI NtClearEvent( HANDLE handle )
521 {
522 /* FIXME: same as NtResetEvent ??? */
523 return NtResetEvent( handle, NULL );
524 }
525
526
527 /******************************************************************************
528 * NtPulseEvent (NTDLL.@)
529 */
530 NTSTATUS WINAPI NtPulseEvent( HANDLE handle, LONG *prev_state )
531 {
532 NTSTATUS ret;
533
534 SERVER_START_REQ( event_op )
535 {
536 req->handle = wine_server_obj_handle( handle );
537 req->op = PULSE_EVENT;
538 ret = wine_server_call( req );
539 if (!ret && prev_state) *prev_state = reply->state;
540 }
541 SERVER_END_REQ;
542 return ret;
543 }
544
545
546 /******************************************************************************
547 * NtQueryEvent (NTDLL.@)
548 */
549 NTSTATUS WINAPI NtQueryEvent( HANDLE handle, EVENT_INFORMATION_CLASS class,
550 void *info, ULONG len, ULONG *ret_len )
551 {
552 NTSTATUS ret;
553 EVENT_BASIC_INFORMATION *out = info;
554
555 TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
556
557 if (class != EventBasicInformation)
558 {
559 FIXME("(%p, %d, %d) Unknown class\n",
560 handle, class, len);
561 return STATUS_INVALID_INFO_CLASS;
562 }
563
564 if (len != sizeof(EVENT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
565
566 SERVER_START_REQ( query_event )
567 {
568 req->handle = wine_server_obj_handle( handle );
569 if (!(ret = wine_server_call( req )))
570 {
571 out->EventType = reply->manual_reset ? NotificationEvent : SynchronizationEvent;
572 out->EventState = reply->state;
573 if (ret_len) *ret_len = sizeof(EVENT_BASIC_INFORMATION);
574 }
575 }
576 SERVER_END_REQ;
577 return ret;
578 }
579
580
581 /******************************************************************************
582 * NtCreateMutant (NTDLL.@)
583 */
584 NTSTATUS WINAPI NtCreateMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
585 BOOLEAN owned )
586 {
587 NTSTATUS ret;
588 data_size_t len;
589 struct object_attributes *objattr;
590
591 *handle = 0;
592 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
593
594 SERVER_START_REQ( create_mutex )
595 {
596 req->access = access;
597 req->owned = owned;
598 wine_server_add_data( req, objattr, len );
599 ret = wine_server_call( req );
600 *handle = wine_server_ptr_handle( reply->handle );
601 }
602 SERVER_END_REQ;
603
604 free( objattr );
605 return ret;
606 }
607
608
609 /**************************************************************************
610 * NtOpenMutant (NTDLL.@)
611 */
612 NTSTATUS WINAPI NtOpenMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
613 {
614 NTSTATUS ret;
615
616 *handle = 0;
617 if ((ret = validate_open_object_attributes( attr ))) return ret;
618
619 SERVER_START_REQ( open_mutex )
620 {
621 req->access = access;
622 req->attributes = attr->Attributes;
623 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
624 if (attr->ObjectName)
625 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
626 ret = wine_server_call( req );
627 *handle = wine_server_ptr_handle( reply->handle );
628 }
629 SERVER_END_REQ;
630 return ret;
631 }
632
633
634 /**************************************************************************
635 * NtReleaseMutant (NTDLL.@)
636 */
637 NTSTATUS WINAPI NtReleaseMutant( HANDLE handle, LONG *prev_count )
638 {
639 NTSTATUS ret;
640
641 SERVER_START_REQ( release_mutex )
642 {
643 req->handle = wine_server_obj_handle( handle );
644 ret = wine_server_call( req );
645 if (prev_count) *prev_count = 1 - reply->prev_count;
646 }
647 SERVER_END_REQ;
648 return ret;
649 }
650
651
652 /******************************************************************
653 * NtQueryMutant (NTDLL.@)
654 */
655 NTSTATUS WINAPI NtQueryMutant( HANDLE handle, MUTANT_INFORMATION_CLASS class,
656 void *info, ULONG len, ULONG *ret_len )
657 {
658 NTSTATUS ret;
659 MUTANT_BASIC_INFORMATION *out = info;
660
661 TRACE("(%p, %u, %p, %u, %p)\n", handle, class, info, len, ret_len);
662
663 if (class != MutantBasicInformation)
664 {
665 FIXME( "(%p, %d, %d) Unknown class\n", handle, class, len );
666 return STATUS_INVALID_INFO_CLASS;
667 }
668
669 if (len != sizeof(MUTANT_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
670
671 SERVER_START_REQ( query_mutex )
672 {
673 req->handle = wine_server_obj_handle( handle );
674 if (!(ret = wine_server_call( req )))
675 {
676 out->CurrentCount = 1 - reply->count;
677 out->OwnedByCaller = reply->owned;
678 out->AbandonedState = reply->abandoned;
679 if (ret_len) *ret_len = sizeof(MUTANT_BASIC_INFORMATION);
680 }
681 }
682 SERVER_END_REQ;
683 return ret;
684 }
685
686
687 /**************************************************************************
688 * NtCreateJobObject (NTDLL.@)
689 */
690 NTSTATUS WINAPI NtCreateJobObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
691 {
692 NTSTATUS ret;
693 data_size_t len;
694 struct object_attributes *objattr;
695
696 *handle = 0;
697 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
698
699 SERVER_START_REQ( create_job )
700 {
701 req->access = access;
702 wine_server_add_data( req, objattr, len );
703 ret = wine_server_call( req );
704 *handle = wine_server_ptr_handle( reply->handle );
705 }
706 SERVER_END_REQ;
707 free( objattr );
708 return ret;
709 }
710
711
712 /**************************************************************************
713 * NtOpenJobObject (NTDLL.@)
714 */
715 NTSTATUS WINAPI NtOpenJobObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
716 {
717 NTSTATUS ret;
718
719 *handle = 0;
720 if ((ret = validate_open_object_attributes( attr ))) return ret;
721
722 SERVER_START_REQ( open_job )
723 {
724 req->access = access;
725 req->attributes = attr->Attributes;
726 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
727 if (attr->ObjectName)
728 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
729 ret = wine_server_call( req );
730 *handle = wine_server_ptr_handle( reply->handle );
731 }
732 SERVER_END_REQ;
733 return ret;
734 }
735
736
737 /**************************************************************************
738 * NtTerminateJobObject (NTDLL.@)
739 */
740 NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status )
741 {
742 NTSTATUS ret;
743
744 TRACE( "(%p, %d)\n", handle, status );
745
746 SERVER_START_REQ( terminate_job )
747 {
748 req->handle = wine_server_obj_handle( handle );
749 req->status = status;
750 ret = wine_server_call( req );
751 }
752 SERVER_END_REQ;
753
754 return ret;
755 }
756
757
758 /**************************************************************************
759 * NtQueryInformationJobObject (NTDLL.@)
760 */
761 NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, void *info,
762 ULONG len, ULONG *ret_len )
763 {
764 NTSTATUS ret;
765
766 TRACE( "semi-stub: %p %u %p %u %p\n", handle, class, info, len, ret_len );
767
768 if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
769
770 switch (class)
771 {
772 case JobObjectBasicAccountingInformation:
773 {
774 JOBOBJECT_BASIC_ACCOUNTING_INFORMATION *accounting = info;
775
776 if (len < sizeof(*accounting)) return STATUS_INFO_LENGTH_MISMATCH;
777 SERVER_START_REQ(get_job_info)
778 {
779 req->handle = wine_server_obj_handle( handle );
780 if (!(ret = wine_server_call( req )))
781 {
782 memset( accounting, 0, sizeof(*accounting) );
783 accounting->TotalProcesses = reply->total_processes;
784 accounting->ActiveProcesses = reply->active_processes;
785 }
786 }
787 SERVER_END_REQ;
788 if (ret_len) *ret_len = sizeof(*accounting);
789 return ret;
790 }
791 case JobObjectBasicProcessIdList:
792 {
793 JOBOBJECT_BASIC_PROCESS_ID_LIST *process = info;
794
795 if (len < sizeof(*process)) return STATUS_INFO_LENGTH_MISMATCH;
796 memset( process, 0, sizeof(*process) );
797 if (ret_len) *ret_len = sizeof(*process);
798 return STATUS_SUCCESS;
799 }
800 case JobObjectExtendedLimitInformation:
801 {
802 JOBOBJECT_EXTENDED_LIMIT_INFORMATION *extended_limit = info;
803
804 if (len < sizeof(*extended_limit)) return STATUS_INFO_LENGTH_MISMATCH;
805 memset( extended_limit, 0, sizeof(*extended_limit) );
806 if (ret_len) *ret_len = sizeof(*extended_limit);
807 return STATUS_SUCCESS;
808 }
809 case JobObjectBasicLimitInformation:
810 {
811 JOBOBJECT_BASIC_LIMIT_INFORMATION *basic_limit = info;
812
813 if (len < sizeof(*basic_limit)) return STATUS_INFO_LENGTH_MISMATCH;
814 memset( basic_limit, 0, sizeof(*basic_limit) );
815 if (ret_len) *ret_len = sizeof(*basic_limit);
816 return STATUS_SUCCESS;
817 }
818 default:
819 return STATUS_NOT_IMPLEMENTED;
820 }
821 }
822
823
824 /**************************************************************************
825 * NtSetInformationJobObject (NTDLL.@)
826 */
827 NTSTATUS WINAPI NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, void *info, ULONG len )
828 {
829 NTSTATUS status = STATUS_NOT_IMPLEMENTED;
830 JOBOBJECT_BASIC_LIMIT_INFORMATION *basic_limit;
831 ULONG info_size = sizeof(JOBOBJECT_BASIC_LIMIT_INFORMATION);
832 DWORD limit_flags = JOB_OBJECT_BASIC_LIMIT_VALID_FLAGS;
833
834 TRACE( "(%p, %u, %p, %u)\n", handle, class, info, len );
835
836 if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER;
837
838 switch (class)
839 {
840
841 case JobObjectExtendedLimitInformation:
842 info_size = sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION);
843 limit_flags = JOB_OBJECT_EXTENDED_LIMIT_VALID_FLAGS;
844 /* fall through */
845 case JobObjectBasicLimitInformation:
846 if (len != info_size) return STATUS_INVALID_PARAMETER;
847 basic_limit = info;
848 if (basic_limit->LimitFlags & ~limit_flags) return STATUS_INVALID_PARAMETER;
849 SERVER_START_REQ( set_job_limits )
850 {
851 req->handle = wine_server_obj_handle( handle );
852 req->limit_flags = basic_limit->LimitFlags;
853 status = wine_server_call( req );
854 }
855 SERVER_END_REQ;
856 break;
857 case JobObjectAssociateCompletionPortInformation:
858 if (len != sizeof(JOBOBJECT_ASSOCIATE_COMPLETION_PORT)) return STATUS_INVALID_PARAMETER;
859 SERVER_START_REQ( set_job_completion_port )
860 {
861 JOBOBJECT_ASSOCIATE_COMPLETION_PORT *port_info = info;
862 req->job = wine_server_obj_handle( handle );
863 req->port = wine_server_obj_handle( port_info->CompletionPort );
864 req->key = wine_server_client_ptr( port_info->CompletionKey );
865 status = wine_server_call( req );
866 }
867 SERVER_END_REQ;
868 break;
869 case JobObjectBasicUIRestrictions:
870 status = STATUS_SUCCESS;
871 /* fall through */
872 default:
873 FIXME( "stub: %p %u %p %u\n", handle, class, info, len );
874 }
875 return status;
876 }
877
878
879 /**************************************************************************
880 * NtIsProcessInJob (NTDLL.@)
881 */
882 NTSTATUS WINAPI NtIsProcessInJob( HANDLE process, HANDLE job )
883 {
884 NTSTATUS status;
885
886 TRACE( "(%p %p)\n", job, process );
887
888 SERVER_START_REQ( process_in_job )
889 {
890 req->job = wine_server_obj_handle( job );
891 req->process = wine_server_obj_handle( process );
892 status = wine_server_call( req );
893 }
894 SERVER_END_REQ;
895 return status;
896 }
897
898
899 /**************************************************************************
900 * NtAssignProcessToJobObject (NTDLL.@)
901 */
902 NTSTATUS WINAPI NtAssignProcessToJobObject( HANDLE job, HANDLE process )
903 {
904 NTSTATUS status;
905
906 TRACE( "(%p %p)\n", job, process );
907
908 SERVER_START_REQ( assign_job )
909 {
910 req->job = wine_server_obj_handle( job );
911 req->process = wine_server_obj_handle( process );
912 status = wine_server_call( req );
913 }
914 SERVER_END_REQ;
915 return status;
916 }
917
918
919 /**********************************************************************
920 * NtCreateDebugObject (NTDLL.@)
921 */
922 NTSTATUS WINAPI NtCreateDebugObject( HANDLE *handle, ACCESS_MASK access,
923 OBJECT_ATTRIBUTES *attr, ULONG flags )
924 {
925 NTSTATUS ret;
926 data_size_t len;
927 struct object_attributes *objattr;
928
929 *handle = 0;
930 if (flags & ~DEBUG_KILL_ON_CLOSE) return STATUS_INVALID_PARAMETER;
931 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
932
933 SERVER_START_REQ( create_debug_obj )
934 {
935 req->access = access;
936 req->flags = flags;
937 wine_server_add_data( req, objattr, len );
938 ret = wine_server_call( req );
939 *handle = wine_server_ptr_handle( reply->handle );
940 }
941 SERVER_END_REQ;
942 free( objattr );
943 return ret;
944 }
945
946
947 /**********************************************************************
948 * NtSetInformationDebugObject (NTDLL.@)
949 */
950 NTSTATUS WINAPI NtSetInformationDebugObject( HANDLE handle, DEBUGOBJECTINFOCLASS class,
951 void *info, ULONG len, ULONG *ret_len )
952 {
953 NTSTATUS ret;
954 ULONG flags;
955
956 if (class != DebugObjectKillProcessOnExitInformation) return STATUS_INVALID_PARAMETER;
957 if (len != sizeof(ULONG))
958 {
959 if (ret_len) *ret_len = sizeof(ULONG);
960 return STATUS_INFO_LENGTH_MISMATCH;
961 }
962 flags = *(ULONG *)info;
963 if (flags & ~DEBUG_KILL_ON_CLOSE) return STATUS_INVALID_PARAMETER;
964
965 SERVER_START_REQ( set_debug_obj_info )
966 {
967 req->debug = wine_server_obj_handle( handle );
968 req->flags = flags;
969 ret = wine_server_call( req );
970 }
971 SERVER_END_REQ;
972 if (!ret && ret_len) *ret_len = 0;
973 return ret;
974 }
975
976
977 /* convert the server event data to an NT state change; helper for NtWaitForDebugEvent */
978 static NTSTATUS event_data_to_state_change( const debug_event_t *data, DBGUI_WAIT_STATE_CHANGE *state )
979 {
980 int i;
981
982 switch (data->code)
983 {
984 case DbgIdle:
985 case DbgReplyPending:
986 return STATUS_PENDING;
987 case DbgCreateThreadStateChange:
988 {
989 DBGUI_CREATE_THREAD *info = &state->StateInfo.CreateThread;
990 info->HandleToThread = wine_server_ptr_handle( data->create_thread.handle );
991 info->NewThread.StartAddress = wine_server_get_ptr( data->create_thread.start );
992 return STATUS_SUCCESS;
993 }
994 case DbgCreateProcessStateChange:
995 {
996 DBGUI_CREATE_PROCESS *info = &state->StateInfo.CreateProcessInfo;
997 info->HandleToProcess = wine_server_ptr_handle( data->create_process.process );
998 info->HandleToThread = wine_server_ptr_handle( data->create_process.thread );
999 info->NewProcess.FileHandle = wine_server_ptr_handle( data->create_process.file );
1000 info->NewProcess.BaseOfImage = wine_server_get_ptr( data->create_process.base );
1001 info->NewProcess.DebugInfoFileOffset = data->create_process.dbg_offset;
1002 info->NewProcess.DebugInfoSize = data->create_process.dbg_size;
1003 info->NewProcess.InitialThread.StartAddress = wine_server_get_ptr( data->create_process.start );
1004 return STATUS_SUCCESS;
1005 }
1006 case DbgExitThreadStateChange:
1007 state->StateInfo.ExitThread.ExitStatus = data->exit.exit_code;
1008 return STATUS_SUCCESS;
1009 case DbgExitProcessStateChange:
1010 state->StateInfo.ExitProcess.ExitStatus = data->exit.exit_code;
1011 return STATUS_SUCCESS;
1012 case DbgExceptionStateChange:
1013 case DbgBreakpointStateChange:
1014 case DbgSingleStepStateChange:
1015 {
1016 DBGKM_EXCEPTION *info = &state->StateInfo.Exception;
1017 info->FirstChance = data->exception.first;
1018 info->ExceptionRecord.ExceptionCode = data->exception.exc_code;
1019 info->ExceptionRecord.ExceptionFlags = data->exception.flags;
1020 info->ExceptionRecord.ExceptionRecord = wine_server_get_ptr( data->exception.record );
1021 info->ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data->exception.address );
1022 info->ExceptionRecord.NumberParameters = data->exception.nb_params;
1023 for (i = 0; i < data->exception.nb_params; i++)
1024 info->ExceptionRecord.ExceptionInformation[i] = data->exception.params[i];
1025 return STATUS_SUCCESS;
1026 }
1027 case DbgLoadDllStateChange:
1028 {
1029 DBGKM_LOAD_DLL *info = &state->StateInfo.LoadDll;
1030 info->FileHandle = wine_server_ptr_handle( data->load_dll.handle );
1031 info->BaseOfDll = wine_server_get_ptr( data->load_dll.base );
1032 info->DebugInfoFileOffset = data->load_dll.dbg_offset;
1033 info->DebugInfoSize = data->load_dll.dbg_size;
1034 info->NamePointer = wine_server_get_ptr( data->load_dll.name );
1035 return STATUS_SUCCESS;
1036 }
1037 case DbgUnloadDllStateChange:
1038 state->StateInfo.UnloadDll.BaseAddress = wine_server_get_ptr( data->unload_dll.base );
1039 return STATUS_SUCCESS;
1040 }
1041 return STATUS_INTERNAL_ERROR;
1042 }
1043
1044 /**********************************************************************
1045 * NtWaitForDebugEvent (NTDLL.@)
1046 */
1047 NTSTATUS WINAPI NtWaitForDebugEvent( HANDLE handle, BOOLEAN alertable, LARGE_INTEGER *timeout,
1048 DBGUI_WAIT_STATE_CHANGE *state )
1049 {
1050 debug_event_t data;
1051 NTSTATUS ret;
1052 BOOL wait = TRUE;
1053
1054 for (;;)
1055 {
1056 SERVER_START_REQ( wait_debug_event )
1057 {
1058 req->debug = wine_server_obj_handle( handle );
1059 wine_server_set_reply( req, &data, sizeof(data) );
1060 ret = wine_server_call( req );
1061 if (!ret && !(ret = event_data_to_state_change( &data, state )))
1062 {
1063 state->NewState = data.code;
1064 state->AppClientId.UniqueProcess = ULongToHandle( reply->pid );
1065 state->AppClientId.UniqueThread = ULongToHandle( reply->tid );
1066 }
1067 }
1068 SERVER_END_REQ;
1069
1070 if (ret != STATUS_PENDING) return ret;
1071 if (!wait) return STATUS_TIMEOUT;
1072 wait = FALSE;
1073 ret = NtWaitForSingleObject( handle, alertable, timeout );
1074 if (ret != STATUS_WAIT_0) return ret;
1075 }
1076 }
1077
1078
1079 /**************************************************************************
1080 * NtCreateDirectoryObject (NTDLL.@)
1081 */
1082 NTSTATUS WINAPI NtCreateDirectoryObject( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
1083 {
1084 NTSTATUS ret;
1085 data_size_t len;
1086 struct object_attributes *objattr;
1087
1088 *handle = 0;
1089 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1090
1091 SERVER_START_REQ( create_directory )
1092 {
1093 req->access = access;
1094 wine_server_add_data( req, objattr, len );
1095 ret = wine_server_call( req );
1096 *handle = wine_server_ptr_handle( reply->handle );
1097 }
1098 SERVER_END_REQ;
1099 free( objattr );
1100 return ret;
1101 }
1102
1103
1104 /**************************************************************************
1105 * NtOpenDirectoryObject (NTDLL.@)
1106 */
1107 NTSTATUS WINAPI NtOpenDirectoryObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1108 {
1109 NTSTATUS ret;
1110
1111 *handle = 0;
1112 if ((ret = validate_open_object_attributes( attr ))) return ret;
1113
1114 SERVER_START_REQ( open_directory )
1115 {
1116 req->access = access;
1117 req->attributes = attr->Attributes;
1118 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
1119 if (attr->ObjectName)
1120 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
1121 ret = wine_server_call( req );
1122 *handle = wine_server_ptr_handle( reply->handle );
1123 }
1124 SERVER_END_REQ;
1125 return ret;
1126 }
1127
1128
1129 /**************************************************************************
1130 * NtQueryDirectoryObject (NTDLL.@)
1131 */
1132 NTSTATUS WINAPI NtQueryDirectoryObject( HANDLE handle, DIRECTORY_BASIC_INFORMATION *buffer,
1133 ULONG size, BOOLEAN single_entry, BOOLEAN restart,
1134 ULONG *context, ULONG *ret_size )
1135 {
1136 NTSTATUS ret;
1137
1138 if (restart) *context = 0;
1139
1140 if (single_entry)
1141 {
1142 if (size <= sizeof(*buffer) + 2 * sizeof(WCHAR)) return STATUS_BUFFER_OVERFLOW;
1143
1144 SERVER_START_REQ( get_directory_entry )
1145 {
1146 req->handle = wine_server_obj_handle( handle );
1147 req->index = *context;
1148 wine_server_set_reply( req, buffer + 1, size - sizeof(*buffer) - 2*sizeof(WCHAR) );
1149 if (!(ret = wine_server_call( req )))
1150 {
1151 buffer->ObjectName.Buffer = (WCHAR *)(buffer + 1);
1152 buffer->ObjectName.Length = reply->name_len;
1153 buffer->ObjectName.MaximumLength = reply->name_len + sizeof(WCHAR);
1154 buffer->ObjectTypeName.Buffer = (WCHAR *)(buffer + 1) + reply->name_len/sizeof(WCHAR) + 1;
1155 buffer->ObjectTypeName.Length = wine_server_reply_size( reply ) - reply->name_len;
1156 buffer->ObjectTypeName.MaximumLength = buffer->ObjectTypeName.Length + sizeof(WCHAR);
1157 /* make room for the terminating null */
1158 memmove( buffer->ObjectTypeName.Buffer, buffer->ObjectTypeName.Buffer - 1,
1159 buffer->ObjectTypeName.Length );
1160 buffer->ObjectName.Buffer[buffer->ObjectName.Length/sizeof(WCHAR)] = 0;
1161 buffer->ObjectTypeName.Buffer[buffer->ObjectTypeName.Length/sizeof(WCHAR)] = 0;
1162 (*context)++;
1163 }
1164 }
1165 SERVER_END_REQ;
1166 if (ret_size)
1167 *ret_size = buffer->ObjectName.MaximumLength + buffer->ObjectTypeName.MaximumLength + sizeof(*buffer);
1168 }
1169 else
1170 {
1171 FIXME("multiple entries not implemented\n");
1172 ret = STATUS_NOT_IMPLEMENTED;
1173 }
1174 return ret;
1175 }
1176
1177
1178 /**************************************************************************
1179 * NtCreateSymbolicLinkObject (NTDLL.@)
1180 */
1181 NTSTATUS WINAPI NtCreateSymbolicLinkObject( HANDLE *handle, ACCESS_MASK access,
1182 OBJECT_ATTRIBUTES *attr, UNICODE_STRING *target )
1183 {
1184 NTSTATUS ret;
1185 data_size_t len;
1186 struct object_attributes *objattr;
1187
1188 *handle = 0;
1189 if (!target->MaximumLength) return STATUS_INVALID_PARAMETER;
1190 if (!target->Buffer) return STATUS_ACCESS_VIOLATION;
1191 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1192
1193 SERVER_START_REQ( create_symlink )
1194 {
1195 req->access = access;
1196 wine_server_add_data( req, objattr, len );
1197 wine_server_add_data( req, target->Buffer, target->Length );
1198 ret = wine_server_call( req );
1199 *handle = wine_server_ptr_handle( reply->handle );
1200 }
1201 SERVER_END_REQ;
1202 free( objattr );
1203 return ret;
1204 }
1205
1206
1207 /**************************************************************************
1208 * NtOpenSymbolicLinkObject (NTDLL.@)
1209 */
1210 NTSTATUS WINAPI NtOpenSymbolicLinkObject( HANDLE *handle, ACCESS_MASK access,
1211 const OBJECT_ATTRIBUTES *attr )
1212 {
1213 NTSTATUS ret;
1214
1215 *handle = 0;
1216 if ((ret = validate_open_object_attributes( attr ))) return ret;
1217
1218 SERVER_START_REQ( open_symlink )
1219 {
1220 req->access = access;
1221 req->attributes = attr->Attributes;
1222 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
1223 if (attr->ObjectName)
1224 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
1225 ret = wine_server_call( req );
1226 *handle = wine_server_ptr_handle( reply->handle );
1227 }
1228 SERVER_END_REQ;
1229 return ret;
1230 }
1231
1232
1233 /**************************************************************************
1234 * NtQuerySymbolicLinkObject (NTDLL.@)
1235 */
1236 NTSTATUS WINAPI NtQuerySymbolicLinkObject( HANDLE handle, UNICODE_STRING *target, ULONG *length )
1237 {
1238 NTSTATUS ret;
1239
1240 if (!target) return STATUS_ACCESS_VIOLATION;
1241
1242 SERVER_START_REQ( query_symlink )
1243 {
1244 req->handle = wine_server_obj_handle( handle );
1245 if (target->MaximumLength >= sizeof(WCHAR))
1246 wine_server_set_reply( req, target->Buffer, target->MaximumLength - sizeof(WCHAR) );
1247 if (!(ret = wine_server_call( req )))
1248 {
1249 target->Length = wine_server_reply_size(reply);
1250 target->Buffer[target->Length / sizeof(WCHAR)] = 0;
1251 if (length) *length = reply->total + sizeof(WCHAR);
1252 }
1253 else if (length && ret == STATUS_BUFFER_TOO_SMALL) *length = reply->total + sizeof(WCHAR);
1254 }
1255 SERVER_END_REQ;
1256 return ret;
1257 }
1258
1259
1260 /**************************************************************************
1261 * NtMakeTemporaryObject (NTDLL.@)
1262 */
1263 NTSTATUS WINAPI NtMakeTemporaryObject( HANDLE handle )
1264 {
1265 NTSTATUS ret;
1266
1267 TRACE("%p\n", handle);
1268
1269 SERVER_START_REQ( make_temporary )
1270 {
1271 req->handle = wine_server_obj_handle( handle );
1272 ret = wine_server_call( req );
1273 }
1274 SERVER_END_REQ;
1275 return ret;
1276 }
1277
1278
1279 /**************************************************************************
1280 * NtCreateTimer (NTDLL.@)
1281 */
1282 NTSTATUS WINAPI NtCreateTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
1283 TIMER_TYPE type )
1284 {
1285 NTSTATUS ret;
1286 data_size_t len;
1287 struct object_attributes *objattr;
1288
1289 *handle = 0;
1290 if (type != NotificationTimer && type != SynchronizationTimer) return STATUS_INVALID_PARAMETER;
1291 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1292
1293 SERVER_START_REQ( create_timer )
1294 {
1295 req->access = access;
1296 req->manual = (type == NotificationTimer);
1297 wine_server_add_data( req, objattr, len );
1298 ret = wine_server_call( req );
1299 *handle = wine_server_ptr_handle( reply->handle );
1300 }
1301 SERVER_END_REQ;
1302
1303 free( objattr );
1304 return ret;
1305
1306 }
1307
1308
1309 /**************************************************************************
1310 * NtOpenTimer (NTDLL.@)
1311 */
1312 NTSTATUS WINAPI NtOpenTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1313 {
1314 NTSTATUS ret;
1315
1316 *handle = 0;
1317 if ((ret = validate_open_object_attributes( attr ))) return ret;
1318
1319 SERVER_START_REQ( open_timer )
1320 {
1321 req->access = access;
1322 req->attributes = attr->Attributes;
1323 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
1324 if (attr->ObjectName)
1325 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
1326 ret = wine_server_call( req );
1327 *handle = wine_server_ptr_handle( reply->handle );
1328 }
1329 SERVER_END_REQ;
1330 return ret;
1331 }
1332
1333
1334 /**************************************************************************
1335 * NtSetTimer (NTDLL.@)
1336 */
1337 NTSTATUS WINAPI NtSetTimer( HANDLE handle, const LARGE_INTEGER *when, PTIMER_APC_ROUTINE callback,
1338 void *arg, BOOLEAN resume, ULONG period, BOOLEAN *state )
1339 {
1340 NTSTATUS ret = STATUS_SUCCESS;
1341
1342 TRACE( "(%p,%p,%p,%p,%08x,0x%08x,%p)\n", handle, when, callback, arg, resume, period, state );
1343
1344 SERVER_START_REQ( set_timer )
1345 {
1346 req->handle = wine_server_obj_handle( handle );
1347 req->period = period;
1348 req->expire = when->QuadPart;
1349 req->callback = wine_server_client_ptr( callback );
1350 req->arg = wine_server_client_ptr( arg );
1351 ret = wine_server_call( req );
1352 if (state) *state = reply->signaled;
1353 }
1354 SERVER_END_REQ;
1355
1356 /* set error but can still succeed */
1357 if (resume && ret == STATUS_SUCCESS) return STATUS_TIMER_RESUME_IGNORED;
1358 return ret;
1359 }
1360
1361
1362 /**************************************************************************
1363 * NtCancelTimer (NTDLL.@)
1364 */
1365 NTSTATUS WINAPI NtCancelTimer( HANDLE handle, BOOLEAN *state )
1366 {
1367 NTSTATUS ret;
1368
1369 SERVER_START_REQ( cancel_timer )
1370 {
1371 req->handle = wine_server_obj_handle( handle );
1372 ret = wine_server_call( req );
1373 if (state) *state = reply->signaled;
1374 }
1375 SERVER_END_REQ;
1376 return ret;
1377 }
1378
1379
1380 /******************************************************************************
1381 * NtQueryTimer (NTDLL.@)
1382 */
1383 NTSTATUS WINAPI NtQueryTimer( HANDLE handle, TIMER_INFORMATION_CLASS class,
1384 void *info, ULONG len, ULONG *ret_len )
1385 {
1386 TIMER_BASIC_INFORMATION *basic_info = info;
1387 NTSTATUS ret;
1388 LARGE_INTEGER now;
1389
1390 TRACE( "(%p,%d,%p,0x%08x,%p)\n", handle, class, info, len, ret_len );
1391
1392 switch (class)
1393 {
1394 case TimerBasicInformation:
1395 if (len < sizeof(TIMER_BASIC_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1396
1397 SERVER_START_REQ( get_timer_info )
1398 {
1399 req->handle = wine_server_obj_handle( handle );
1400 ret = wine_server_call(req);
1401 /* convert server time to absolute NTDLL time */
1402 basic_info->RemainingTime.QuadPart = reply->when;
1403 basic_info->TimerState = reply->signaled;
1404 }
1405 SERVER_END_REQ;
1406
1407 /* convert into relative time */
1408 if (basic_info->RemainingTime.QuadPart > 0) NtQuerySystemTime( &now );
1409 else
1410 {
1411 NtQueryPerformanceCounter( &now, NULL );
1412 basic_info->RemainingTime.QuadPart = -basic_info->RemainingTime.QuadPart;
1413 }
1414
1415 if (now.QuadPart > basic_info->RemainingTime.QuadPart)
1416 basic_info->RemainingTime.QuadPart = 0;
1417 else
1418 basic_info->RemainingTime.QuadPart -= now.QuadPart;
1419
1420 if (ret_len) *ret_len = sizeof(TIMER_BASIC_INFORMATION);
1421 return ret;
1422 }
1423
1424 FIXME( "Unhandled class %d\n", class );
1425 return STATUS_INVALID_INFO_CLASS;
1426 }
1427
1428
1429 /******************************************************************
1430 * NtWaitForMultipleObjects (NTDLL.@)
1431 */
1432 NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles, BOOLEAN wait_any,
1433 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1434 {
1435 select_op_t select_op;
1436 UINT i, flags = SELECT_INTERRUPTIBLE;
1437
1438 if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
1439
1440 if (alertable) flags |= SELECT_ALERTABLE;
1441 select_op.wait.op = wait_any ? SELECT_WAIT : SELECT_WAIT_ALL;
1442 for (i = 0; i < count; i++) select_op.wait.handles[i] = wine_server_obj_handle( handles[i] );
1443 return server_wait( &select_op, offsetof( select_op_t, wait.handles[count] ), flags, timeout );
1444 }
1445
1446
1447 /******************************************************************
1448 * NtWaitForSingleObject (NTDLL.@)
1449 */
1450 NTSTATUS WINAPI NtWaitForSingleObject( HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1451 {
1452 return NtWaitForMultipleObjects( 1, &handle, FALSE, alertable, timeout );
1453 }
1454
1455
1456 /******************************************************************
1457 * NtSignalAndWaitForSingleObject (NTDLL.@)
1458 */
1459 NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE signal, HANDLE wait,
1460 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1461 {
1462 select_op_t select_op;
1463 UINT flags = SELECT_INTERRUPTIBLE;
1464
1465 if (!signal) return STATUS_INVALID_HANDLE;
1466
1467 if (alertable) flags |= SELECT_ALERTABLE;
1468 select_op.signal_and_wait.op = SELECT_SIGNAL_AND_WAIT;
1469 select_op.signal_and_wait.wait = wine_server_obj_handle( wait );
1470 select_op.signal_and_wait.signal = wine_server_obj_handle( signal );
1471 return server_wait( &select_op, sizeof(select_op.signal_and_wait), flags, timeout );
1472 }
1473
1474
1475 /******************************************************************
1476 * NtYieldExecution (NTDLL.@)
1477 */
1478 NTSTATUS WINAPI NtYieldExecution(void)
1479 {
1480 #ifdef HAVE_SCHED_YIELD
1481 sched_yield();
1482 return STATUS_SUCCESS;
1483 #else
1484 return STATUS_NO_YIELD_PERFORMED;
1485 #endif
1486 }
1487
1488
1489 /******************************************************************
1490 * NtDelayExecution (NTDLL.@)
1491 */
1492 NTSTATUS WINAPI NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
1493 {
1494 /* if alertable, we need to query the server */
1495 if (alertable) return server_wait( NULL, 0, SELECT_INTERRUPTIBLE | SELECT_ALERTABLE, timeout );
1496
1497 if (!timeout || timeout->QuadPart == TIMEOUT_INFINITE) /* sleep forever */
1498 {
1499 for (;;) select( 0, NULL, NULL, NULL, NULL );
1500 }
1501 else
1502 {
1503 LARGE_INTEGER now;
1504 timeout_t when, diff;
1505
1506 if ((when = timeout->QuadPart) < 0)
1507 {
1508 NtQuerySystemTime( &now );
1509 when = now.QuadPart - when;
1510 }
1511
1512 /* Note that we yield after establishing the desired timeout */
1513 NtYieldExecution();
1514 if (!when) return STATUS_SUCCESS;
1515
1516 for (;;)
1517 {
1518 struct timeval tv;
1519 NtQuerySystemTime( &now );
1520 diff = (when - now.QuadPart + 9) / 10;
1521 if (diff <= 0) break;
1522 tv.tv_sec = diff / 1000000;
1523 tv.tv_usec = diff % 1000000;
1524 if (select( 0, NULL, NULL, NULL, &tv ) != -1) break;
1525 }
1526 }
1527 return STATUS_SUCCESS;
1528 }
1529
1530
1531 /******************************************************************************
1532 * NtQueryPerformanceCounter (NTDLL.@)
1533 */
1534 NTSTATUS WINAPI NtQueryPerformanceCounter( LARGE_INTEGER *counter, LARGE_INTEGER *frequency )
1535 {
1536 counter->QuadPart = monotonic_counter();
1537 if (frequency) frequency->QuadPart = TICKSPERSEC;
1538 return STATUS_SUCCESS;
1539 }
1540
1541
1542 /***********************************************************************
1543 * NtQuerySystemTime (NTDLL.@)
1544 */
1545 NTSTATUS WINAPI NtQuerySystemTime( LARGE_INTEGER *time )
1546 {
1547 #ifdef HAVE_CLOCK_GETTIME
1548 struct timespec ts;
1549 static clockid_t clock_id = CLOCK_MONOTONIC; /* placeholder */
1550
1551 if (clock_id == CLOCK_MONOTONIC)
1552 {
1553 #ifdef CLOCK_REALTIME_COARSE
1554 struct timespec res;
1555
1556 /* Use CLOCK_REALTIME_COARSE if it has 1 ms or better resolution */
1557 if (!clock_getres( CLOCK_REALTIME_COARSE, &res ) && res.tv_sec == 0 && res.tv_nsec <= 1000000)
1558 clock_id = CLOCK_REALTIME_COARSE;
1559 else
1560 #endif /* CLOCK_REALTIME_COARSE */
1561 clock_id = CLOCK_REALTIME;
1562 }
1563
1564 if (!clock_gettime( clock_id, &ts ))
1565 {
1566 time->QuadPart = ticks_from_time_t( ts.tv_sec ) + (ts.tv_nsec + 50) / 100;
1567 }
1568 else
1569 #endif /* HAVE_CLOCK_GETTIME */
1570 {
1571 struct timeval now;
1572
1573 gettimeofday( &now, 0 );
1574 time->QuadPart = ticks_from_time_t( now.tv_sec ) + now.tv_usec * 10;
1575 }
1576 return STATUS_SUCCESS;
1577 }
1578
1579
1580 /***********************************************************************
1581 * NtSetSystemTime (NTDLL.@)
1582 */
1583 NTSTATUS WINAPI NtSetSystemTime( const LARGE_INTEGER *new, LARGE_INTEGER *old )
1584 {
1585 LARGE_INTEGER now;
1586 LONGLONG diff;
1587
1588 NtQuerySystemTime( &now );
1589 if (old) *old = now;
1590 diff = new->QuadPart - now.QuadPart;
1591 if (diff > -TICKSPERSEC / 2 && diff < TICKSPERSEC / 2) return STATUS_SUCCESS;
1592 ERR( "not allowed: difference %d ms\n", (int)(diff / 10000) );
1593 return STATUS_PRIVILEGE_NOT_HELD;
1594 }
1595
1596
1597 /***********************************************************************
1598 * NtQueryTimerResolution (NTDLL.@)
1599 */
1600 NTSTATUS WINAPI NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *current_res )
1601 {
1602 TRACE( "(%p,%p,%p)\n", min_res, max_res, current_res );
1603 *max_res = *current_res = 10000; /* See NtSetTimerResolution() */
1604 *min_res = 156250;
1605 return STATUS_SUCCESS;
1606 }
1607
1608
1609 /***********************************************************************
1610 * NtSetTimerResolution (NTDLL.@)
1611 */
1612 NTSTATUS WINAPI NtSetTimerResolution( ULONG res, BOOLEAN set, ULONG *current_res )
1613 {
1614 static BOOL has_request = FALSE;
1615
1616 TRACE( "(%u,%u,%p), semi-stub!\n", res, set, current_res );
1617
1618 /* Wine has no support for anything other that 1 ms and does not keep of
1619 * track resolution requests anyway.
1620 * Fortunately NtSetTimerResolution() should ignore requests to lower the
1621 * timer resolution. So by claiming that 'some other process' requested the
1622 * max resolution already, there no need to actually change it.
1623 */
1624 *current_res = 10000;
1625
1626 /* Just keep track of whether this process requested a specific timer
1627 * resolution.
1628 */
1629 if (!has_request && !set)
1630 return STATUS_TIMER_RESOLUTION_NOT_SET;
1631 has_request = set;
1632
1633 return STATUS_SUCCESS;
1634 }
1635
1636
1637 /******************************************************************************
1638 * NtSetIntervalProfile (NTDLL.@)
1639 */
1640 NTSTATUS WINAPI NtSetIntervalProfile( ULONG interval, KPROFILE_SOURCE source )
1641 {
1642 FIXME( "%u,%d\n", interval, source );
1643 return STATUS_SUCCESS;
1644 }
1645
1646
1647 /******************************************************************************
1648 * NtGetTickCount (NTDLL.@)
1649 */
1650 ULONG WINAPI NtGetTickCount(void)
1651 {
1652 /* note: we ignore TickCountMultiplier */
1653 return user_shared_data->u.TickCount.LowPart;
1654 }
1655
1656
1657 /******************************************************************************
1658 * RtlGetSystemTimePrecise (NTDLL.@)
1659 */
1660 LONGLONG WINAPI RtlGetSystemTimePrecise(void)
1661 {
1662 struct timeval now;
1663 #ifdef HAVE_CLOCK_GETTIME
1664 struct timespec ts;
1665
1666 if (!clock_gettime( CLOCK_REALTIME, &ts ))
1667 return ticks_from_time_t( ts.tv_sec ) + (ts.tv_nsec + 50) / 100;
1668 #endif
1669 gettimeofday( &now, 0 );
1670 return ticks_from_time_t( now.tv_sec ) + now.tv_usec * 10;
1671 }
1672
1673
1674 /******************************************************************************
1675 * NtCreateKeyedEvent (NTDLL.@)
1676 */
1677 NTSTATUS WINAPI NtCreateKeyedEvent( HANDLE *handle, ACCESS_MASK access,
1678 const OBJECT_ATTRIBUTES *attr, ULONG flags )
1679 {
1680 NTSTATUS ret;
1681 data_size_t len;
1682 struct object_attributes *objattr;
1683
1684 *handle = 0;
1685 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1686
1687 SERVER_START_REQ( create_keyed_event )
1688 {
1689 req->access = access;
1690 wine_server_add_data( req, objattr, len );
1691 ret = wine_server_call( req );
1692 *handle = wine_server_ptr_handle( reply->handle );
1693 }
1694 SERVER_END_REQ;
1695
1696 free( objattr );
1697 return ret;
1698 }
1699
1700
1701 /******************************************************************************
1702 * NtOpenKeyedEvent (NTDLL.@)
1703 */
1704 NTSTATUS WINAPI NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1705 {
1706 NTSTATUS ret;
1707
1708 *handle = 0;
1709 if ((ret = validate_open_object_attributes( attr ))) return ret;
1710
1711 SERVER_START_REQ( open_keyed_event )
1712 {
1713 req->access = access;
1714 req->attributes = attr->Attributes;
1715 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
1716 if (attr->ObjectName)
1717 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
1718 ret = wine_server_call( req );
1719 *handle = wine_server_ptr_handle( reply->handle );
1720 }
1721 SERVER_END_REQ;
1722 return ret;
1723 }
1724
1725 /******************************************************************************
1726 * NtWaitForKeyedEvent (NTDLL.@)
1727 */
1728 NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
1729 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1730 {
1731 select_op_t select_op;
1732 UINT flags = SELECT_INTERRUPTIBLE;
1733
1734 if (!handle) handle = keyed_event;
1735 if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
1736 if (alertable) flags |= SELECT_ALERTABLE;
1737 select_op.keyed_event.op = SELECT_KEYED_EVENT_WAIT;
1738 select_op.keyed_event.handle = wine_server_obj_handle( handle );
1739 select_op.keyed_event.key = wine_server_client_ptr( key );
1740 return server_wait( &select_op, sizeof(select_op.keyed_event), flags, timeout );
1741 }
1742
1743
1744 /******************************************************************************
1745 * NtReleaseKeyedEvent (NTDLL.@)
1746 */
1747 NTSTATUS WINAPI NtReleaseKeyedEvent( HANDLE handle, const void *key,
1748 BOOLEAN alertable, const LARGE_INTEGER *timeout )
1749 {
1750 select_op_t select_op;
1751 UINT flags = SELECT_INTERRUPTIBLE;
1752
1753 if (!handle) handle = keyed_event;
1754 if ((ULONG_PTR)key & 1) return STATUS_INVALID_PARAMETER_1;
1755 if (alertable) flags |= SELECT_ALERTABLE;
1756 select_op.keyed_event.op = SELECT_KEYED_EVENT_RELEASE;
1757 select_op.keyed_event.handle = wine_server_obj_handle( handle );
1758 select_op.keyed_event.key = wine_server_client_ptr( key );
1759 return server_wait( &select_op, sizeof(select_op.keyed_event), flags, timeout );
1760 }
1761
1762
1763 /***********************************************************************
1764 * NtCreateIoCompletion (NTDLL.@)
1765 */
1766 NTSTATUS WINAPI NtCreateIoCompletion( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
1767 ULONG threads )
1768 {
1769 NTSTATUS status;
1770 data_size_t len;
1771 struct object_attributes *objattr;
1772
1773 TRACE( "(%p, %x, %p, %d)\n", handle, access, attr, threads );
1774
1775 *handle = 0;
1776 if ((status = alloc_object_attributes( attr, &objattr, &len ))) return status;
1777
1778 SERVER_START_REQ( create_completion )
1779 {
1780 req->access = access;
1781 req->concurrent = threads;
1782 wine_server_add_data( req, objattr, len );
1783 if (!(status = wine_server_call( req ))) *handle = wine_server_ptr_handle( reply->handle );
1784 }
1785 SERVER_END_REQ;
1786
1787 free( objattr );
1788 return status;
1789 }
1790
1791
1792 /***********************************************************************
1793 * NtOpenIoCompletion (NTDLL.@)
1794 */
1795 NTSTATUS WINAPI NtOpenIoCompletion( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
1796 {
1797 NTSTATUS status;
1798
1799 *handle = 0;
1800 if ((status = validate_open_object_attributes( attr ))) return status;
1801
1802 SERVER_START_REQ( open_completion )
1803 {
1804 req->access = access;
1805 req->attributes = attr->Attributes;
1806 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
1807 if (attr->ObjectName)
1808 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
1809 status = wine_server_call( req );
1810 *handle = wine_server_ptr_handle( reply->handle );
1811 }
1812 SERVER_END_REQ;
1813 return status;
1814 }
1815
1816
1817 /***********************************************************************
1818 * NtSetIoCompletion (NTDLL.@)
1819 */
1820 NTSTATUS WINAPI NtSetIoCompletion( HANDLE handle, ULONG_PTR key, ULONG_PTR value,
1821 NTSTATUS status, SIZE_T count )
1822 {
1823 NTSTATUS ret;
1824
1825 TRACE( "(%p, %lx, %lx, %x, %lx)\n", handle, key, value, status, count );
1826
1827 SERVER_START_REQ( add_completion )
1828 {
1829 req->handle = wine_server_obj_handle( handle );
1830 req->ckey = key;
1831 req->cvalue = value;
1832 req->status = status;
1833 req->information = count;
1834 ret = wine_server_call( req );
1835 }
1836 SERVER_END_REQ;
1837 return ret;
1838 }
1839
1840
1841 /***********************************************************************
1842 * NtRemoveIoCompletion (NTDLL.@)
1843 */
1844 NTSTATUS WINAPI NtRemoveIoCompletion( HANDLE handle, ULONG_PTR *key, ULONG_PTR *value,
1845 IO_STATUS_BLOCK *io, LARGE_INTEGER *timeout )
1846 {
1847 NTSTATUS status;
1848
1849 TRACE( "(%p, %p, %p, %p, %p)\n", handle, key, value, io, timeout );
1850
1851 for (;;)
1852 {
1853 SERVER_START_REQ( remove_completion )
1854 {
1855 req->handle = wine_server_obj_handle( handle );
1856 if (!(status = wine_server_call( req )))
1857 {
1858 *key = reply->ckey;
1859 *value = reply->cvalue;
1860 io->Information = reply->information;
1861 io->u.Status = reply->status;
1862 }
1863 }
1864 SERVER_END_REQ;
1865 if (status != STATUS_PENDING) return status;
1866 status = NtWaitForSingleObject( handle, FALSE, timeout );
1867 if (status != WAIT_OBJECT_0) return status;
1868 }
1869 }
1870
1871
1872 /***********************************************************************
1873 * NtRemoveIoCompletionEx (NTDLL.@)
1874 */
1875 NTSTATUS WINAPI NtRemoveIoCompletionEx( HANDLE handle, FILE_IO_COMPLETION_INFORMATION *info, ULONG count,
1876 ULONG *written, LARGE_INTEGER *timeout, BOOLEAN alertable )
1877 {
1878 NTSTATUS status;
1879 ULONG i = 0;
1880
1881 TRACE( "%p %p %u %p %p %u\n", handle, info, count, written, timeout, alertable );
1882
1883 for (;;)
1884 {
1885 while (i < count)
1886 {
1887 SERVER_START_REQ( remove_completion )
1888 {
1889 req->handle = wine_server_obj_handle( handle );
1890 if (!(status = wine_server_call( req )))
1891 {
1892 info[i].CompletionKey = reply->ckey;
1893 info[i].CompletionValue = reply->cvalue;
1894 info[i].IoStatusBlock.Information = reply->information;
1895 info[i].IoStatusBlock.u.Status = reply->status;
1896 }
1897 }
1898 SERVER_END_REQ;
1899 if (status != STATUS_SUCCESS) break;
1900 ++i;
1901 }
1902 if (i || status != STATUS_PENDING)
1903 {
1904 if (status == STATUS_PENDING) status = STATUS_SUCCESS;
1905 break;
1906 }
1907 status = NtWaitForSingleObject( handle, alertable, timeout );
1908 if (status != WAIT_OBJECT_0) break;
1909 }
1910 *written = i ? i : 1;
1911 return status;
1912 }
1913
1914
1915 /***********************************************************************
1916 * NtQueryIoCompletion (NTDLL.@)
1917 */
1918 NTSTATUS WINAPI NtQueryIoCompletion( HANDLE handle, IO_COMPLETION_INFORMATION_CLASS class,
1919 void *buffer, ULONG len, ULONG *ret_len )
1920 {
1921 NTSTATUS status;
1922
1923 TRACE( "(%p, %d, %p, 0x%x, %p)\n", handle, class, buffer, len, ret_len );
1924
1925 if (!buffer) return STATUS_INVALID_PARAMETER;
1926
1927 switch (class)
1928 {
1929 case IoCompletionBasicInformation:
1930 {
1931 ULONG *info = buffer;
1932 if (ret_len) *ret_len = sizeof(*info);
1933 if (len == sizeof(*info))
1934 {
1935 SERVER_START_REQ( query_completion )
1936 {
1937 req->handle = wine_server_obj_handle( handle );
1938 if (!(status = wine_server_call( req ))) *info = reply->depth;
1939 }
1940 SERVER_END_REQ;
1941 }
1942 else status = STATUS_INFO_LENGTH_MISMATCH;
1943 break;
1944 }
1945 default:
1946 return STATUS_INVALID_PARAMETER;
1947 }
1948 return status;
1949 }
1950
1951
1952 /***********************************************************************
1953 * NtCreateSection (NTDLL.@)
1954 */
1955 NTSTATUS WINAPI NtCreateSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
1956 const LARGE_INTEGER *size, ULONG protect,
1957 ULONG sec_flags, HANDLE file )
1958 {
1959 NTSTATUS ret;
1960 unsigned int file_access;
1961 data_size_t len;
1962 struct object_attributes *objattr;
1963
1964 *handle = 0;
1965
1966 switch (protect & 0xff)
1967 {
1968 case PAGE_READONLY:
1969 case PAGE_EXECUTE_READ:
1970 case PAGE_WRITECOPY:
1971 case PAGE_EXECUTE_WRITECOPY:
1972 file_access = FILE_READ_DATA;
1973 break;
1974 case PAGE_READWRITE:
1975 case PAGE_EXECUTE_READWRITE:
1976 if (sec_flags & SEC_IMAGE) file_access = FILE_READ_DATA;
1977 else file_access = FILE_READ_DATA | FILE_WRITE_DATA;
1978 break;
1979 case PAGE_EXECUTE:
1980 case PAGE_NOACCESS:
1981 file_access = 0;
1982 break;
1983 default:
1984 return STATUS_INVALID_PAGE_PROTECTION;
1985 }
1986
1987 if ((ret = alloc_object_attributes( attr, &objattr, &len ))) return ret;
1988
1989 SERVER_START_REQ( create_mapping )
1990 {
1991 req->access = access;
1992 req->flags = sec_flags;
1993 req->file_handle = wine_server_obj_handle( file );
1994 req->file_access = file_access;
1995 req->size = size ? size->QuadPart : 0;
1996 wine_server_add_data( req, objattr, len );
1997 ret = wine_server_call( req );
1998 *handle = wine_server_ptr_handle( reply->handle );
1999 }
2000 SERVER_END_REQ;
2001
2002 free( objattr );
2003 return ret;
2004 }
2005
2006
2007 /***********************************************************************
2008 * NtOpenSection (NTDLL.@)
2009 */
2010 NTSTATUS WINAPI NtOpenSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
2011 {
2012 NTSTATUS ret;
2013
2014 *handle = 0;
2015 if ((ret = validate_open_object_attributes( attr ))) return ret;
2016
2017 SERVER_START_REQ( open_mapping )
2018 {
2019 req->access = access;
2020 req->attributes = attr->Attributes;
2021 req->rootdir = wine_server_obj_handle( attr->RootDirectory );
2022 if (attr->ObjectName)
2023 wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
2024 ret = wine_server_call( req );
2025 *handle = wine_server_ptr_handle( reply->handle );
2026 }
2027 SERVER_END_REQ;
2028 return ret;
2029 }
2030
2031
2032 /***********************************************************************
2033 * NtCreatePort (NTDLL.@)
2034 */
2035 NTSTATUS WINAPI NtCreatePort( HANDLE *handle, OBJECT_ATTRIBUTES *attr, ULONG info_len,
2036 ULONG data_len, ULONG *reserved )
2037 {
2038 FIXME( "(%p,%p,%u,%u,%p),stub!\n", handle, attr, info_len, data_len, reserved );
2039 return STATUS_NOT_IMPLEMENTED;
2040 }
2041
2042
2043 /***********************************************************************
2044 * NtConnectPort (NTDLL.@)
2045 */
2046 NTSTATUS WINAPI NtConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QUALITY_OF_SERVICE *qos,
2047 LPC_SECTION_WRITE *write, LPC_SECTION_READ *read, ULONG *max_len,
2048 void *info, ULONG *info_len )
2049 {
2050 FIXME( "(%p,%s,%p,%p,%p,%p,%p,%p),stub!\n", handle, debugstr_us(name), qos,
2051 write, read, max_len, info, info_len );
2052 if (info && info_len) TRACE("msg = %s\n", debugstr_an( info, *info_len ));
2053 return STATUS_NOT_IMPLEMENTED;
2054 }
2055
2056
2057 /***********************************************************************
2058 * NtSecureConnectPort (NTDLL.@)
2059 */
2060 NTSTATUS WINAPI NtSecureConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QUALITY_OF_SERVICE *qos,
2061 LPC_SECTION_WRITE *write, PSID sid, LPC_SECTION_READ *read,
2062 ULONG *max_len, void *info, ULONG *info_len )
2063 {
2064 FIXME( "(%p,%s,%p,%p,%p,%p,%p,%p,%p),stub!\n", handle, debugstr_us(name), qos,
2065 write, sid, read, max_len, info, info_len );
2066 return STATUS_NOT_IMPLEMENTED;
2067 }
2068
2069
2070 /***********************************************************************
2071 * NtListenPort (NTDLL.@)
2072 */
2073 NTSTATUS WINAPI NtListenPort( HANDLE handle, LPC_MESSAGE *msg )
2074 {
2075 FIXME("(%p,%p),stub!\n", handle, msg );
2076 return STATUS_NOT_IMPLEMENTED;
2077 }
2078
2079
2080 /***********************************************************************
2081 * NtAcceptConnectPort (NTDLL.@)
2082 */
2083 NTSTATUS WINAPI NtAcceptConnectPort( HANDLE *handle, ULONG id, LPC_MESSAGE *msg, BOOLEAN accept,
2084 LPC_SECTION_WRITE *write, LPC_SECTION_READ *read )
2085 {
2086 FIXME("(%p,%u,%p,%d,%p,%p),stub!\n", handle, id, msg, accept, write, read );
2087 return STATUS_NOT_IMPLEMENTED;
2088 }
2089
2090
2091 /***********************************************************************
2092 * NtCompleteConnectPort (NTDLL.@)
2093 */
2094 NTSTATUS WINAPI NtCompleteConnectPort( HANDLE handle )
2095 {
2096 FIXME( "(%p),stub!\n", handle );
2097 return STATUS_NOT_IMPLEMENTED;
2098 }
2099
2100
2101 /***********************************************************************
2102 * NtRegisterThreadTerminatePort (NTDLL.@)
2103 */
2104 NTSTATUS WINAPI NtRegisterThreadTerminatePort( HANDLE handle )
2105 {
2106 FIXME( "(%p),stub!\n", handle );
2107 return STATUS_NOT_IMPLEMENTED;
2108 }
2109
2110
2111 /***********************************************************************
2112 * NtRequestWaitReplyPort (NTDLL.@)
2113 */
2114 NTSTATUS WINAPI NtRequestWaitReplyPort( HANDLE handle, LPC_MESSAGE *msg_in, LPC_MESSAGE *msg_out )
2115 {
2116 FIXME( "(%p,%p,%p),stub!\n", handle, msg_in, msg_out );
2117 if (msg_in)
2118 TRACE("datasize %u msgsize %u type %u ranges %u client %p/%p msgid %lu size %lu data %s\n",
2119 msg_in->DataSize, msg_in->MessageSize, msg_in->MessageType, msg_in->VirtualRangesOffset,
2120 msg_in->ClientId.UniqueProcess, msg_in->ClientId.UniqueThread, msg_in->MessageId,
2121 msg_in->SectionSize, debugstr_an( (const char *)msg_in->Data, msg_in->DataSize ));
2122 return STATUS_NOT_IMPLEMENTED;
2123 }
2124
2125
2126 /***********************************************************************
2127 * NtReplyWaitReceivePort (NTDLL.@)
2128 */
2129 NTSTATUS WINAPI NtReplyWaitReceivePort( HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg )
2130 {
2131 FIXME("(%p,%p,%p,%p),stub!\n", handle, id, reply, msg );
2132 return STATUS_NOT_IMPLEMENTED;
2133 }
2134
2135
2136 #define MAX_ATOM_LEN 255
2137 #define IS_INTATOM(x) (((ULONG_PTR)(x) >> 16) == 0)
2138
2139 static NTSTATUS is_integral_atom( const WCHAR *atomstr, ULONG len, RTL_ATOM *ret_atom )
2140 {
2141 RTL_ATOM atom;
2142
2143 if ((ULONG_PTR)atomstr >> 16)
2144 {
2145 const WCHAR* ptr = atomstr;
2146 if (!len) return STATUS_OBJECT_NAME_INVALID;
2147
2148 if (*ptr++ == '#')
2149 {
2150 atom = 0;
2151 while (ptr < atomstr + len && *ptr >= '0' && *ptr <= '9')
2152 {
2153 atom = atom * 10 + *ptr++ - '0';
2154 }
2155 if (ptr > atomstr + 1 && ptr == atomstr + len) goto done;
2156 }
2157 if (len > MAX_ATOM_LEN) return STATUS_INVALID_PARAMETER;
2158 return STATUS_MORE_ENTRIES;
2159 }
2160 else atom = LOWORD( atomstr );
2161 done:
2162 if (!atom || atom >= MAXINTATOM) return STATUS_INVALID_PARAMETER;
2163 *ret_atom = atom;
2164 return STATUS_SUCCESS;
2165 }
2166
2167 static ULONG integral_atom_name( WCHAR *buffer, ULONG len, RTL_ATOM atom )
2168 {
2169 char tmp[16];
2170 int ret = sprintf( tmp, "#%u", atom );
2171
2172 len /= sizeof(WCHAR);
2173 if (len)
2174 {
2175 if (len <= ret) ret = len - 1;
2176 ascii_to_unicode( buffer, tmp, ret );
2177 buffer[ret] = 0;
2178 }
2179 return ret * sizeof(WCHAR);
2180 }
2181
2182
2183 /***********************************************************************
2184 * NtAddAtom (NTDLL.@)
2185 */
2186 NTSTATUS WINAPI NtAddAtom( const WCHAR *name, ULONG length, RTL_ATOM *atom )
2187 {
2188 NTSTATUS status = is_integral_atom( name, length / sizeof(WCHAR), atom );
2189
2190 if (status == STATUS_MORE_ENTRIES)
2191 {
2192 SERVER_START_REQ( add_atom )
2193 {
2194 wine_server_add_data( req, name, length );
2195 status = wine_server_call( req );
2196 *atom = reply->atom;
2197 }
2198 SERVER_END_REQ;
2199 }
2200 TRACE( "%s -> %x\n", debugstr_wn(name, length/sizeof(WCHAR)), status == STATUS_SUCCESS ? *atom : 0 );
2201 return status;
2202 }
2203
2204
2205 /***********************************************************************
2206 * NtDeleteAtom (NTDLL.@)
2207 */
2208 NTSTATUS WINAPI NtDeleteAtom( RTL_ATOM atom )
2209 {
2210 NTSTATUS status;
2211
2212 SERVER_START_REQ( delete_atom )
2213 {
2214 req->atom = atom;
2215 status = wine_server_call( req );
2216 }
2217 SERVER_END_REQ;
2218 return status;
2219 }
2220
2221
2222 /***********************************************************************
2223 * NtFindAtom (NTDLL.@)
2224 */
2225 NTSTATUS WINAPI NtFindAtom( const WCHAR *name, ULONG length, RTL_ATOM *atom )
2226 {
2227 NTSTATUS status = is_integral_atom( name, length / sizeof(WCHAR), atom );
2228
2229 if (status == STATUS_MORE_ENTRIES)
2230 {
2231 SERVER_START_REQ( find_atom )
2232 {
2233 wine_server_add_data( req, name, length );
2234 status = wine_server_call( req );
2235 *atom = reply->atom;
2236 }
2237 SERVER_END_REQ;
2238 }
2239 TRACE( "%s -> %x\n", debugstr_wn(name, length/sizeof(WCHAR)), status == STATUS_SUCCESS ? *atom : 0 );
2240 return status;
2241 }
2242
2243
2244 /***********************************************************************
2245 * NtQueryInformationAtom (NTDLL.@)
2246 */
2247 NTSTATUS WINAPI NtQueryInformationAtom( RTL_ATOM atom, ATOM_INFORMATION_CLASS class,
2248 void *ptr, ULONG size, ULONG *retsize )
2249 {
2250 NTSTATUS status;
2251
2252 switch (class)
2253 {
2254 case AtomBasicInformation:
2255 {
2256 ULONG name_len;
2257 ATOM_BASIC_INFORMATION *abi = ptr;
2258
2259 if (size < sizeof(ATOM_BASIC_INFORMATION)) return STATUS_INVALID_PARAMETER;
2260 name_len = size - sizeof(ATOM_BASIC_INFORMATION);
2261
2262 if (atom < MAXINTATOM)
2263 {
2264 if (atom)
2265 {
2266 abi->NameLength = integral_atom_name( abi->Name, name_len, atom );
2267 status = name_len ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
2268 abi->ReferenceCount = 1;
2269 abi->Pinned = 1;
2270 }
2271 else status = STATUS_INVALID_PARAMETER;
2272 }
2273 else
2274 {
2275 SERVER_START_REQ( get_atom_information )
2276 {
2277 req->atom = atom;
2278 if (name_len) wine_server_set_reply( req, abi->Name, name_len );
2279 status = wine_server_call( req );
2280 if (status == STATUS_SUCCESS)
2281 {
2282 name_len = wine_server_reply_size( reply );
2283 if (name_len)
2284 {
2285 abi->NameLength = name_len;
2286 abi->Name[name_len / sizeof(WCHAR)] = 0;
2287 }
2288 else
2289 {
2290 name_len = reply->total;
2291 abi->NameLength = name_len;
2292 status = STATUS_BUFFER_TOO_SMALL;
2293 }
2294 abi->ReferenceCount = reply->count;
2295 abi->Pinned = reply->pinned;
2296 }
2297 else name_len = 0;
2298 }
2299 SERVER_END_REQ;
2300 }
2301 TRACE( "%x -> %s (%u)\n", atom, debugstr_wn(abi->Name, abi->NameLength / sizeof(WCHAR)), status );
2302 if (retsize) *retsize = sizeof(ATOM_BASIC_INFORMATION) + name_len;
2303 break;
2304 }
2305
2306 default:
2307 FIXME( "Unsupported class %u\n", class );
2308 status = STATUS_INVALID_INFO_CLASS;
2309 break;
2310 }
2311 return status;
2312 }
2313
2314
2315 #ifdef __linux__
2316
2317 NTSTATUS CDECL fast_RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit, int timeout )
2318 {
2319 int val;
2320 struct timespec timespec;
2321
2322 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2323
2324 timespec.tv_sec = timeout;
2325 timespec.tv_nsec = 0;
2326 while ((val = InterlockedCompareExchange( (int *)&crit->LockSemaphore, 0, 1 )) != 1)
2327 {
2328 /* note: this may wait longer than specified in case of signals or */
2329 /* multiple wake-ups, but that shouldn't be a problem */
2330 if (futex_wait( (int *)&crit->LockSemaphore, val, &timespec ) == -1 && errno == ETIMEDOUT)
2331 return STATUS_TIMEOUT;
2332 }
2333 return STATUS_WAIT_0;
2334 }
2335
2336 NTSTATUS CDECL fast_RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
2337 {
2338 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2339
2340 *(int *)&crit->LockSemaphore = 1;
2341 futex_wake( (int *)&crit->LockSemaphore, 1 );
2342 return STATUS_SUCCESS;
2343 }
2344
2345 NTSTATUS CDECL fast_RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
2346 {
2347 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2348 return STATUS_SUCCESS;
2349 }
2350
2351 #elif defined(__APPLE__)
2352
2353 static inline semaphore_t get_mach_semaphore( RTL_CRITICAL_SECTION *crit )
2354 {
2355 semaphore_t ret = *(int *)&crit->LockSemaphore;
2356 if (!ret)
2357 {
2358 semaphore_t sem;
2359 if (semaphore_create( mach_task_self(), &sem, SYNC_POLICY_FIFO, 0 )) return 0;
2360 if (!(ret = InterlockedCompareExchange( (int *)&crit->LockSemaphore, sem, 0 )))
2361 ret = sem;
2362 else
2363 semaphore_destroy( mach_task_self(), sem ); /* somebody beat us to it */
2364 }
2365 return ret;
2366 }
2367
2368 NTSTATUS CDECL fast_RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit, int timeout )
2369 {
2370 mach_timespec_t timespec;
2371 semaphore_t sem = get_mach_semaphore( crit );
2372
2373 timespec.tv_sec = timeout;
2374 timespec.tv_nsec = 0;
2375 for (;;)
2376 {
2377 switch( semaphore_timedwait( sem, timespec ))
2378 {
2379 case KERN_SUCCESS:
2380 return STATUS_WAIT_0;
2381 case KERN_ABORTED:
2382 continue; /* got a signal, restart */
2383 case KERN_OPERATION_TIMED_OUT:
2384 return STATUS_TIMEOUT;
2385 default:
2386 return STATUS_INVALID_HANDLE;
2387 }
2388 }
2389 }
2390
2391 NTSTATUS CDECL fast_RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
2392 {
2393 semaphore_t sem = get_mach_semaphore( crit );
2394 semaphore_signal( sem );
2395 return STATUS_SUCCESS;
2396 }
2397
2398 NTSTATUS CDECL fast_RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
2399 {
2400 semaphore_destroy( mach_task_self(), *(int *)&crit->LockSemaphore );
2401 return STATUS_SUCCESS;
2402 }
2403
2404 #else /* __APPLE__ */
2405
2406 NTSTATUS CDECL fast_RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit, int timeout )
2407 {
2408 return STATUS_NOT_IMPLEMENTED;
2409 }
2410
2411 NTSTATUS CDECL fast_RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit )
2412 {
2413 return STATUS_NOT_IMPLEMENTED;
2414 }
2415
2416 NTSTATUS CDECL fast_RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit )
2417 {
2418 return STATUS_NOT_IMPLEMENTED;
2419 }
2420
2421 #endif
2422
2423
2424 #ifdef __linux__
2425
2426 /* Futex-based SRW lock implementation:
2427 *
2428 * Since we can rely on the kernel to release all threads and don't need to
2429 * worry about NtReleaseKeyedEvent(), we can simplify the layout a bit. The
2430 * layout looks like this:
2431 *
2432 * 31 - Exclusive lock bit, set if the resource is owned exclusively.
2433 * 30-16 - Number of exclusive waiters. Unlike the fallback implementation,
2434 * this does not include the thread owning the lock, or shared threads
2435 * waiting on the lock.
2436 * 15 - Does this lock have any shared waiters? We use this as an
2437 * optimization to avoid unnecessary FUTEX_WAKE_BITSET calls when
2438 * releasing an exclusive lock.
2439 * 14-0 - Number of shared owners. Unlike the fallback implementation, this
2440 * does not include the number of shared threads waiting on the lock.
2441 * Thus the state [1, x, >=1] will never occur.
2442 */
2443
2444 #define SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT 0x80000000
2445 #define SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK 0x7fff0000
2446 #define SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_INC 0x00010000
2447 #define SRWLOCK_FUTEX_SHARED_WAITERS_BIT 0x00008000
2448 #define SRWLOCK_FUTEX_SHARED_OWNERS_MASK 0x00007fff
2449 #define SRWLOCK_FUTEX_SHARED_OWNERS_INC 0x00000001
2450
2451 /* Futex bitmasks; these are independent from the bits in the lock itself. */
2452 #define SRWLOCK_FUTEX_BITSET_EXCLUSIVE 1
2453 #define SRWLOCK_FUTEX_BITSET_SHARED 2
2454
2455 NTSTATUS CDECL fast_RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
2456 {
2457 int old, new, *futex;
2458 NTSTATUS ret;
2459
2460 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2461
2462 if (!(futex = get_futex( &lock->Ptr )))
2463 return STATUS_NOT_IMPLEMENTED;
2464
2465 do
2466 {
2467 old = *futex;
2468
2469 if (!(old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT)
2470 && !(old & SRWLOCK_FUTEX_SHARED_OWNERS_MASK))
2471 {
2472 /* Not locked exclusive or shared. We can try to grab it. */
2473 new = old | SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT;
2474 ret = STATUS_SUCCESS;
2475 }
2476 else
2477 {
2478 new = old;
2479 ret = STATUS_TIMEOUT;
2480 }
2481 } while (InterlockedCompareExchange( futex, new, old ) != old);
2482
2483 return ret;
2484 }
2485
2486 NTSTATUS CDECL fast_RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
2487 {
2488 int old, new, *futex;
2489 BOOLEAN wait;
2490
2491 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2492
2493 if (!(futex = get_futex( &lock->Ptr )))
2494 return STATUS_NOT_IMPLEMENTED;
2495
2496 /* Atomically increment the exclusive waiter count. */
2497 do
2498 {
2499 old = *futex;
2500 new = old + SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_INC;
2501 assert(new & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK);
2502 } while (InterlockedCompareExchange( futex, new, old ) != old);
2503
2504 for (;;)
2505 {
2506 do
2507 {
2508 old = *futex;
2509
2510 if (!(old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT)
2511 && !(old & SRWLOCK_FUTEX_SHARED_OWNERS_MASK))
2512 {
2513 /* Not locked exclusive or shared. We can try to grab it. */
2514 new = old | SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT;
2515 assert(old & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK);
2516 new -= SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_INC;
2517 wait = FALSE;
2518 }
2519 else
2520 {
2521 new = old;
2522 wait = TRUE;
2523 }
2524 } while (InterlockedCompareExchange( futex, new, old ) != old);
2525
2526 if (!wait)
2527 return STATUS_SUCCESS;
2528
2529 futex_wait_bitset( futex, new, NULL, SRWLOCK_FUTEX_BITSET_EXCLUSIVE );
2530 }
2531
2532 return STATUS_SUCCESS;
2533 }
2534
2535 NTSTATUS CDECL fast_RtlTryAcquireSRWLockShared( RTL_SRWLOCK *lock )
2536 {
2537 int new, old, *futex;
2538 NTSTATUS ret;
2539
2540 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2541
2542 if (!(futex = get_futex( &lock->Ptr )))
2543 return STATUS_NOT_IMPLEMENTED;
2544
2545 do
2546 {
2547 old = *futex;
2548
2549 if (!(old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT)
2550 && !(old & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK))
2551 {
2552 /* Not locked exclusive, and no exclusive waiters. We can try to
2553 * grab it. */
2554 new = old + SRWLOCK_FUTEX_SHARED_OWNERS_INC;
2555 assert(new & SRWLOCK_FUTEX_SHARED_OWNERS_MASK);
2556 ret = STATUS_SUCCESS;
2557 }
2558 else
2559 {
2560 new = old;
2561 ret = STATUS_TIMEOUT;
2562 }
2563 } while (InterlockedCompareExchange( futex, new, old ) != old);
2564
2565 return ret;
2566 }
2567
2568 NTSTATUS CDECL fast_RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
2569 {
2570 int old, new, *futex;
2571 BOOLEAN wait;
2572
2573 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2574
2575 if (!(futex = get_futex( &lock->Ptr )))
2576 return STATUS_NOT_IMPLEMENTED;
2577
2578 for (;;)
2579 {
2580 do
2581 {
2582 old = *futex;
2583
2584 if (!(old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT)
2585 && !(old & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK))
2586 {
2587 /* Not locked exclusive, and no exclusive waiters. We can try
2588 * to grab it. */
2589 new = old + SRWLOCK_FUTEX_SHARED_OWNERS_INC;
2590 assert(new & SRWLOCK_FUTEX_SHARED_OWNERS_MASK);
2591 wait = FALSE;
2592 }
2593 else
2594 {
2595 new = old | SRWLOCK_FUTEX_SHARED_WAITERS_BIT;
2596 wait = TRUE;
2597 }
2598 } while (InterlockedCompareExchange( futex, new, old ) != old);
2599
2600 if (!wait)
2601 return STATUS_SUCCESS;
2602
2603 futex_wait_bitset( futex, new, NULL, SRWLOCK_FUTEX_BITSET_SHARED );
2604 }
2605
2606 return STATUS_SUCCESS;
2607 }
2608
2609 NTSTATUS CDECL fast_RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
2610 {
2611 int old, new, *futex;
2612
2613 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2614
2615 if (!(futex = get_futex( &lock->Ptr )))
2616 return STATUS_NOT_IMPLEMENTED;
2617
2618 do
2619 {
2620 old = *futex;
2621
2622 if (!(old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT))
2623 {
2624 ERR("Lock %p is not owned exclusive! (%#x)\n", lock, *futex);
2625 return STATUS_RESOURCE_NOT_OWNED;
2626 }
2627
2628 new = old & ~SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT;
2629
2630 if (!(new & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK))
2631 new &= ~SRWLOCK_FUTEX_SHARED_WAITERS_BIT;
2632 } while (InterlockedCompareExchange( futex, new, old ) != old);
2633
2634 if (new & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK)
2635 futex_wake_bitset( futex, 1, SRWLOCK_FUTEX_BITSET_EXCLUSIVE );
2636 else if (old & SRWLOCK_FUTEX_SHARED_WAITERS_BIT)
2637 futex_wake_bitset( futex, INT_MAX, SRWLOCK_FUTEX_BITSET_SHARED );
2638
2639 return STATUS_SUCCESS;
2640 }
2641
2642 NTSTATUS CDECL fast_RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
2643 {
2644 int old, new, *futex;
2645
2646 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2647
2648 if (!(futex = get_futex( &lock->Ptr )))
2649 return STATUS_NOT_IMPLEMENTED;
2650
2651 do
2652 {
2653 old = *futex;
2654
2655 if (old & SRWLOCK_FUTEX_EXCLUSIVE_LOCK_BIT)
2656 {
2657 ERR("Lock %p is owned exclusive! (%#x)\n", lock, *futex);
2658 return STATUS_RESOURCE_NOT_OWNED;
2659 }
2660 else if (!(old & SRWLOCK_FUTEX_SHARED_OWNERS_MASK))
2661 {
2662 ERR("Lock %p is not owned shared! (%#x)\n", lock, *futex);
2663 return STATUS_RESOURCE_NOT_OWNED;
2664 }
2665
2666 new = old - SRWLOCK_FUTEX_SHARED_OWNERS_INC;
2667 } while (InterlockedCompareExchange( futex, new, old ) != old);
2668
2669 /* Optimization: only bother waking if there are actually exclusive waiters. */
2670 if (!(new & SRWLOCK_FUTEX_SHARED_OWNERS_MASK) && (new & SRWLOCK_FUTEX_EXCLUSIVE_WAITERS_MASK))
2671 futex_wake_bitset( futex, 1, SRWLOCK_FUTEX_BITSET_EXCLUSIVE );
2672
2673 return STATUS_SUCCESS;
2674 }
2675
2676 NTSTATUS CDECL fast_wait_cv( RTL_CONDITION_VARIABLE *variable, const void *value, const LARGE_INTEGER *timeout )
2677 {
2678 const char *value_ptr;
2679 int aligned_value, *futex;
2680 struct timespec timespec;
2681 int ret;
2682
2683 if (!use_futexes())
2684 return STATUS_NOT_IMPLEMENTED;
2685
2686 if (!(futex = get_futex( &variable->Ptr )))
2687 return STATUS_NOT_IMPLEMENTED;
2688
2689 value_ptr = (const char *)&value;
2690 value_ptr += ((ULONG_PTR)futex) - ((ULONG_PTR)&variable->Ptr);
2691 aligned_value = *(int *)value_ptr;
2692
2693 if (timeout && timeout->QuadPart != TIMEOUT_INFINITE)
2694 {
2695 timespec_from_timeout( &timespec, timeout );
2696 ret = futex_wait( futex, aligned_value, &timespec );
2697 }
2698 else
2699 ret = futex_wait( futex, aligned_value, NULL );
2700
2701 if (ret == -1 && errno == ETIMEDOUT)
2702 return STATUS_TIMEOUT;
2703 return STATUS_WAIT_0;
2704 }
2705
2706 NTSTATUS CDECL fast_RtlWakeConditionVariable( RTL_CONDITION_VARIABLE *variable, int count )
2707 {
2708 int *futex;
2709
2710 if (!use_futexes()) return STATUS_NOT_IMPLEMENTED;
2711
2712 if (!(futex = get_futex( &variable->Ptr )))
2713 return STATUS_NOT_IMPLEMENTED;
2714
2715 InterlockedIncrement( futex );
2716 futex_wake( futex, count );
2717 return STATUS_SUCCESS;
2718 }
2719
2720
2721 /* We can't map addresses to futex directly, because an application can wait on
2722 * 8 bytes, and we can't pass all 8 as the compare value to futex(). Instead we
2723 * map all addresses to a small fixed table of futexes. This may result in
2724 * spurious wakes, but the application is already expected to handle those. */
2725
2726 static int addr_futex_table[256];
2727
2728 static inline int *hash_addr( const void *addr )
2729 {
2730 ULONG_PTR val = (ULONG_PTR)addr;
2731
2732 return &addr_futex_table[(val >> 2) & 255];
2733 }
2734
2735 static inline NTSTATUS fast_wait_addr( const void *addr, const void *cmp, SIZE_T size,
2736 const LARGE_INTEGER *timeout )
2737 {
2738 int *futex;
2739 int val;
2740 struct timespec timespec;
2741 int ret;
2742
2743 if (!use_futexes())
2744 return STATUS_NOT_IMPLEMENTED;
2745
2746 futex = hash_addr( addr );
2747
2748 /* We must read the previous value of the futex before checking the value
2749 * of the address being waited on. That way, if we receive a wake between
2750 * now and waiting on the futex, we know that val will have changed.
2751 * Use an atomic load so that memory accesses are ordered between this read
2752 * and the increment below. */
2753 val = InterlockedCompareExchange( futex, 0, 0 );
2754 if (!compare_addr( addr, cmp, size ))
2755 return STATUS_SUCCESS;
2756
2757 if (timeout)
2758 {
2759 timespec_from_timeout( &timespec, timeout );
2760 ret = futex_wait( futex, val, &timespec );
2761 }
2762 else
2763 ret = futex_wait( futex, val, NULL );
2764
2765 if (ret == -1 && errno == ETIMEDOUT)
2766 return STATUS_TIMEOUT;
2767 return STATUS_SUCCESS;
2768 }
2769
2770 static inline NTSTATUS fast_wake_addr( const void *addr )
2771 {
2772 int *futex;
2773
2774 if (!use_futexes())
2775 return STATUS_NOT_IMPLEMENTED;
2776
2777 futex = hash_addr( addr );
2778
2779 InterlockedIncrement( futex );
2780
2781 futex_wake( futex, INT_MAX );
2782 return STATUS_SUCCESS;
2783 }
2784
2785 #else
2786
2787 NTSTATUS CDECL fast_RtlTryAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
2788 {
2789 return STATUS_NOT_IMPLEMENTED;
2790 }
2791
2792 NTSTATUS CDECL fast_RtlAcquireSRWLockExclusive( RTL_SRWLOCK *lock )
2793 {
2794 return STATUS_NOT_IMPLEMENTED;
2795 }
2796
2797 NTSTATUS CDECL fast_RtlTryAcquireSRWLockShared( RTL_SRWLOCK *lock )
2798 {
2799 return STATUS_NOT_IMPLEMENTED;
2800 }
2801
2802 NTSTATUS CDECL fast_RtlAcquireSRWLockShared( RTL_SRWLOCK *lock )
2803 {
2804 return STATUS_NOT_IMPLEMENTED;
2805 }
2806
2807 NTSTATUS CDECL fast_RtlReleaseSRWLockExclusive( RTL_SRWLOCK *lock )
2808 {
2809 return STATUS_NOT_IMPLEMENTED;
2810 }
2811
2812 NTSTATUS CDECL fast_RtlReleaseSRWLockShared( RTL_SRWLOCK *lock )
2813 {
2814 return STATUS_NOT_IMPLEMENTED;
2815 }
2816
2817 NTSTATUS CDECL fast_RtlWakeConditionVariable( RTL_CONDITION_VARIABLE *variable, int count )
2818 {
2819 return STATUS_NOT_IMPLEMENTED;
2820 }
2821
2822 NTSTATUS CDECL fast_wait_cv( RTL_CONDITION_VARIABLE *variable, const void *value, const LARGE_INTEGER *timeout )
2823 {
2824 return STATUS_NOT_IMPLEMENTED;
2825 }
2826
2827 static inline NTSTATUS fast_wait_addr( const void *addr, const void *cmp, SIZE_T size,
2828 const LARGE_INTEGER *timeout )
2829 {
2830 return STATUS_NOT_IMPLEMENTED;
2831 }
2832
2833 static inline NTSTATUS fast_wake_addr( const void *addr )
2834 {
2835 return STATUS_NOT_IMPLEMENTED;
2836 }
2837
2838 #endif
2839
2840
2841 /***********************************************************************
2842 * RtlWaitOnAddress (NTDLL.@)
2843 */
2844 NTSTATUS WINAPI RtlWaitOnAddress( const void *addr, const void *cmp, SIZE_T size,
2845 const LARGE_INTEGER *timeout )
2846 {
2847 select_op_t select_op;
2848 NTSTATUS ret;
2849 timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
2850
2851 if (size != 1 && size != 2 && size != 4 && size != 8)
2852 return STATUS_INVALID_PARAMETER;
2853
2854 if ((ret = fast_wait_addr( addr, cmp, size, timeout )) != STATUS_NOT_IMPLEMENTED)
2855 return ret;
2856
2857 mutex_lock( &addr_mutex );
2858 if (!compare_addr( addr, cmp, size ))
2859 {
2860 mutex_unlock( &addr_mutex );
2861 return STATUS_SUCCESS;
2862 }
2863
2864 if (abs_timeout < 0)
2865 {
2866 LARGE_INTEGER now;
2867
2868 NtQueryPerformanceCounter( &now, NULL );
2869 abs_timeout -= now.QuadPart;
2870 }
2871
2872 select_op.keyed_event.op = SELECT_KEYED_EVENT_WAIT;
2873 select_op.keyed_event.handle = wine_server_obj_handle( keyed_event );
2874 select_op.keyed_event.key = wine_server_client_ptr( addr );
2875
2876 return server_select( &select_op, sizeof(select_op.keyed_event), SELECT_INTERRUPTIBLE,
2877 abs_timeout, NULL, &addr_mutex, NULL );
2878 }
2879
2880 /***********************************************************************
2881 * RtlWakeAddressAll (NTDLL.@)
2882 */
2883 void WINAPI RtlWakeAddressAll( const void *addr )
2884 {
2885 if (fast_wake_addr( addr ) != STATUS_NOT_IMPLEMENTED) return;
2886
2887 mutex_lock( &addr_mutex );
2888 while (NtReleaseKeyedEvent( 0, addr, 0, &zero_timeout ) == STATUS_SUCCESS) {}
2889 mutex_unlock( &addr_mutex );
2890 }
2891
2892 /***********************************************************************
2893 * RtlWakeAddressSingle (NTDLL.@)
2894 */
2895 void WINAPI RtlWakeAddressSingle( const void *addr )
2896 {
2897 if (fast_wake_addr( addr ) != STATUS_NOT_IMPLEMENTED) return;
2898
2899 mutex_lock( &addr_mutex );
2900 NtReleaseKeyedEvent( 0, addr, 0, &zero_timeout );
2901 mutex_unlock( &addr_mutex );
2902 }
Windows API implementation