Return failure if native function failed. one more test passes
[reactos.git] / reactos / lib / kernel32 / thread / thread.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: lib/kernel32/thread/thread.c
5 * PURPOSE: Thread functions
6 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7 * Ariadne ( ariadne@xs4all.nl)
8 *
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <k32.h>
14
15 #define NDEBUG
16 #include "../include/debug.h"
17
18 /* FIXME: NDK */
19 #define HIGH_PRIORITY 31
20
21 /* FUNCTIONS *****************************************************************/
22 _SEH_FILTER(BaseThreadExceptionFilter)
23 {
24 EXCEPTION_POINTERS * ExceptionInfo = _SEH_GetExceptionPointers();
25 LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER;
26
27 if (GlobalTopLevelExceptionFilter != NULL)
28 {
29 _SEH_TRY
30 {
31 ExceptionDisposition = GlobalTopLevelExceptionFilter(ExceptionInfo);
32 }
33 _SEH_HANDLE
34 {
35 ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo);
36 }
37 _SEH_END;
38 }
39
40 return ExceptionDisposition;
41 }
42
43 __declspec(noreturn)
44 VOID
45 STDCALL
46 BaseThreadStartup(LPTHREAD_START_ROUTINE lpStartAddress,
47 LPVOID lpParameter)
48 {
49 volatile UINT uExitCode = 0;
50
51 /* Attempt to call the Thread Start Address */
52 _SEH_TRY
53 {
54 /* Get the exit code from the Thread Start */
55 uExitCode = (lpStartAddress)((PVOID)lpParameter);
56 }
57 _SEH_EXCEPT(BaseThreadExceptionFilter)
58 {
59 /* Get the Exit code from the SEH Handler */
60 uExitCode = _SEH_GetExceptionCode();
61 } _SEH_END;
62
63 /* Exit the Thread */
64 ExitThread(uExitCode);
65 }
66
67 /*
68 * @implemented
69 */
70 HANDLE
71 STDCALL
72 CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
73 DWORD dwStackSize,
74 LPTHREAD_START_ROUTINE lpStartAddress,
75 LPVOID lpParameter,
76 DWORD dwCreationFlags,
77 LPDWORD lpThreadId)
78 {
79 /* Act as if we're going to create a remote thread in ourselves */
80 return CreateRemoteThread(NtCurrentProcess(),
81 lpThreadAttributes,
82 dwStackSize,
83 lpStartAddress,
84 lpParameter,
85 dwCreationFlags,
86 lpThreadId);
87 }
88
89 /*
90 * @implemented
91 */
92 HANDLE
93 STDCALL
94 CreateRemoteThread(HANDLE hProcess,
95 LPSECURITY_ATTRIBUTES lpThreadAttributes,
96 DWORD dwStackSize,
97 LPTHREAD_START_ROUTINE lpStartAddress,
98 LPVOID lpParameter,
99 DWORD dwCreationFlags,
100 LPDWORD lpThreadId)
101 {
102 NTSTATUS Status;
103 INITIAL_TEB InitialTeb;
104 CONTEXT Context;
105 CLIENT_ID ClientId;
106 OBJECT_ATTRIBUTES LocalObjectAttributes;
107 POBJECT_ATTRIBUTES ObjectAttributes;
108 HANDLE hThread;
109 ULONG Dummy;
110
111 DPRINT("CreateRemoteThread: hProcess: %ld dwStackSize: %ld lpStartAddress"
112 ": %p lpParameter: %lx, dwCreationFlags: %lx\n", hProcess,
113 dwStackSize, lpStartAddress, lpParameter, dwCreationFlags);
114
115 /* Clear the Context */
116 RtlZeroMemory(&Context, sizeof(CONTEXT));
117
118 /* Write PID */
119 ClientId.UniqueProcess = hProcess;
120
121 /* Create the Stack */
122 Status = BasepCreateStack(hProcess,
123 dwStackSize,
124 dwCreationFlags & STACK_SIZE_PARAM_IS_A_RESERVATION ?
125 dwStackSize : 0,
126 &InitialTeb);
127 if(!NT_SUCCESS(Status))
128 {
129 SetLastErrorByStatus(Status);
130 return NULL;
131 }
132
133 /* Create Initial Context */
134 BasepInitializeContext(&Context,
135 lpParameter,
136 lpStartAddress,
137 InitialTeb.StackBase,
138 1);
139
140 /* initialize the attributes for the thread object */
141 ObjectAttributes = BasepConvertObjectAttributes(&LocalObjectAttributes,
142 lpThreadAttributes,
143 NULL);
144
145 /* Create the Kernel Thread Object */
146 Status = NtCreateThread(&hThread,
147 THREAD_ALL_ACCESS,
148 ObjectAttributes,
149 hProcess,
150 &ClientId,
151 &Context,
152 &InitialTeb,
153 TRUE);
154 if(!NT_SUCCESS(Status))
155 {
156 BasepFreeStack(hProcess, &InitialTeb);
157 SetLastErrorByStatus(Status);
158 return NULL;
159 }
160
161 #ifdef SXS_SUPPORT_ENABLED
162 /* Are we in the same process? */
163 if (Process = NtCurrentProcess())
164 {
165 PTEB Teb;
166 PVOID ActivationContextStack;
167 PTHREAD_BASIC_INFORMATION ThreadBasicInfo;
168 PACTIVATION_CONTEXT_BASIC_INFORMATION ActivationCtxInfo;
169 ULONG_PTR Cookie;
170
171 /* Get the TEB */
172 Status = NtQueryInformationThread(hThread,
173 ThreadBasicIformation,
174 &ThreadBasicInfo,
175 sizeof(ThreadBasicInfo),
176 NULL);
177
178 /* Allocate the Activation Context Stack */
179 Status = RtlAllocateActivationContextStack(&ActivationContextStack);
180 Teb = ThreadBasicInfo.TebBaseAddress;
181
182 /* Save it */
183 Teb->ActivationContextStackPointer = ActivationContextStack;
184
185 /* Query the Context */
186 Status = RtlQueryInformationActivationContext(1,
187 0,
188 NULL,
189 ActivationContextBasicInformation,
190 &ActivationCtxInfo,
191 sizeof(ActivationCtxInfo),
192 NULL);
193
194 /* Does it need to be activated? */
195 if (!ActivationCtxInfo.hActCtx)
196 {
197 /* Activate it */
198 Status = RtlActivateActivationContextEx(1,
199 Teb,
200 ActivationCtxInfo.hActCtx,
201 &Cookie);
202 }
203 }
204 #endif
205
206 /* FIXME: Notify CSR */
207
208 /* Success */
209 if(lpThreadId) *lpThreadId = (DWORD)ClientId.UniqueThread;
210
211 /* Resume it if asked */
212 if (!(dwCreationFlags & CREATE_SUSPENDED))
213 {
214 NtResumeThread(hThread, &Dummy);
215 }
216
217 /* Return handle to thread */
218 return hThread;
219 }
220
221 /*
222 * @implemented
223 */
224 VOID
225 STDCALL
226 ExitThread(DWORD uExitCode)
227 {
228 NTSTATUS Status;
229 BOOLEAN LastThread;
230
231 /*
232 * Terminate process if this is the last thread
233 * of the current process
234 */
235 Status = NtQueryInformationThread(NtCurrentThread(),
236 ThreadAmILastThread,
237 &LastThread,
238 sizeof(BOOLEAN),
239 NULL);
240 if (NT_SUCCESS(Status) && LastThread)
241 {
242 /* Exit the Process */
243 ExitProcess(uExitCode);
244 }
245
246 /* Notify DLLs and TLS Callbacks of termination */
247 LdrShutdownThread();
248
249 /* Tell the Kernel to free the Stack */
250 NtCurrentTeb()->FreeStackOnTermination = TRUE;
251 NtTerminateThread(NULL, uExitCode);
252
253 /* We will never reach this place. This silences the compiler */
254 ExitThread(uExitCode);
255 }
256
257 /*
258 * @implemented
259 */
260 HANDLE
261 STDCALL
262 OpenThread(
263 DWORD dwDesiredAccess,
264 BOOL bInheritHandle,
265 DWORD dwThreadId
266 )
267 {
268 NTSTATUS errCode;
269 HANDLE ThreadHandle;
270 OBJECT_ATTRIBUTES ObjectAttributes;
271 CLIENT_ID ClientId ;
272
273 ClientId.UniqueProcess = 0;
274 ClientId.UniqueThread = (HANDLE)dwThreadId;
275
276 InitializeObjectAttributes (&ObjectAttributes,
277 NULL,
278 (bInheritHandle ? OBJ_INHERIT : 0),
279 NULL,
280 NULL);
281
282 errCode = NtOpenThread(&ThreadHandle,
283 dwDesiredAccess,
284 &ObjectAttributes,
285 &ClientId);
286 if (!NT_SUCCESS(errCode))
287 {
288 SetLastErrorByStatus (errCode);
289 return NULL;
290 }
291 return ThreadHandle;
292 }
293
294
295 /*
296 * @implemented
297 */
298 PTEB
299 GetTeb(VOID)
300 {
301 return(NtCurrentTeb());
302 }
303
304
305 /*
306 * @implemented
307 */
308 BOOL STDCALL
309 SwitchToThread(VOID)
310 {
311 NTSTATUS Status;
312 Status = NtYieldExecution();
313 return Status != STATUS_NO_YIELD_PERFORMED;
314 }
315
316
317 /*
318 * @implemented
319 */
320 DWORD STDCALL
321 GetCurrentThreadId(VOID)
322 {
323 return((DWORD)(NtCurrentTeb()->Cid).UniqueThread);
324 }
325
326 /*
327 * @implemented
328 */
329 BOOL STDCALL
330 GetThreadTimes(HANDLE hThread,
331 LPFILETIME lpCreationTime,
332 LPFILETIME lpExitTime,
333 LPFILETIME lpKernelTime,
334 LPFILETIME lpUserTime)
335 {
336 KERNEL_USER_TIMES KernelUserTimes;
337 NTSTATUS Status;
338
339 Status = NtQueryInformationThread(hThread,
340 ThreadTimes,
341 &KernelUserTimes,
342 sizeof(KERNEL_USER_TIMES),
343 NULL);
344 if (!NT_SUCCESS(Status))
345 {
346 SetLastErrorByStatus(Status);
347 return(FALSE);
348 }
349
350 lpCreationTime->dwLowDateTime = KernelUserTimes.CreateTime.u.LowPart;
351 lpCreationTime->dwHighDateTime = KernelUserTimes.CreateTime.u.HighPart;
352
353 lpExitTime->dwLowDateTime = KernelUserTimes.ExitTime.u.LowPart;
354 lpExitTime->dwHighDateTime = KernelUserTimes.ExitTime.u.HighPart;
355
356 lpKernelTime->dwLowDateTime = KernelUserTimes.KernelTime.u.LowPart;
357 lpKernelTime->dwHighDateTime = KernelUserTimes.KernelTime.u.HighPart;
358
359 lpUserTime->dwLowDateTime = KernelUserTimes.UserTime.u.LowPart;
360 lpUserTime->dwHighDateTime = KernelUserTimes.UserTime.u.HighPart;
361
362 return(TRUE);
363 }
364
365
366 /*
367 * @implemented
368 */
369 BOOL STDCALL
370 GetThreadContext(HANDLE hThread,
371 LPCONTEXT lpContext)
372 {
373 NTSTATUS Status;
374
375 Status = NtGetContextThread(hThread,
376 lpContext);
377 if (!NT_SUCCESS(Status))
378 {
379 SetLastErrorByStatus(Status);
380 return(FALSE);
381 }
382
383 return(TRUE);
384 }
385
386
387 /*
388 * @implemented
389 */
390 BOOL STDCALL
391 SetThreadContext(HANDLE hThread,
392 CONST CONTEXT *lpContext)
393 {
394 NTSTATUS Status;
395
396 Status = NtSetContextThread(hThread,
397 (void *)lpContext);
398 if (!NT_SUCCESS(Status))
399 {
400 SetLastErrorByStatus(Status);
401 return(FALSE);
402 }
403
404 return(TRUE);
405 }
406
407
408 /*
409 * @implemented
410 */
411 BOOL STDCALL
412 GetExitCodeThread(HANDLE hThread,
413 LPDWORD lpExitCode)
414 {
415 THREAD_BASIC_INFORMATION ThreadBasic;
416 NTSTATUS Status;
417
418 Status = NtQueryInformationThread(hThread,
419 ThreadBasicInformation,
420 &ThreadBasic,
421 sizeof(THREAD_BASIC_INFORMATION),
422 NULL);
423 if (!NT_SUCCESS(Status))
424 {
425 SetLastErrorByStatus(Status);
426 return(FALSE);
427 }
428
429 memcpy(lpExitCode, &ThreadBasic.ExitStatus, sizeof(DWORD));
430
431 return(TRUE);
432 }
433
434
435 /*
436 * @implemented
437 */
438 DWORD STDCALL
439 ResumeThread(HANDLE hThread)
440 {
441 ULONG PreviousResumeCount;
442 NTSTATUS Status;
443
444 Status = NtResumeThread(hThread,
445 &PreviousResumeCount);
446 if (!NT_SUCCESS(Status))
447 {
448 SetLastErrorByStatus(Status);
449 return(-1);
450 }
451
452 return(PreviousResumeCount);
453 }
454
455
456 /*
457 * @implemented
458 */
459 BOOL STDCALL
460 TerminateThread(HANDLE hThread,
461 DWORD dwExitCode)
462 {
463 NTSTATUS Status;
464
465 if (0 == hThread)
466 {
467 SetLastError(ERROR_INVALID_HANDLE);
468 return(FALSE);
469 }
470
471 Status = NtTerminateThread(hThread,
472 dwExitCode);
473 if (!NT_SUCCESS(Status))
474 {
475 SetLastErrorByStatus(Status);
476 return(FALSE);
477 }
478
479 return(TRUE);
480 }
481
482
483 /*
484 * @implemented
485 */
486 DWORD STDCALL
487 SuspendThread(HANDLE hThread)
488 {
489 ULONG PreviousSuspendCount;
490 NTSTATUS Status;
491
492 Status = NtSuspendThread(hThread,
493 &PreviousSuspendCount);
494 if (!NT_SUCCESS(Status))
495 {
496 SetLastErrorByStatus(Status);
497 return(-1);
498 }
499
500 return(PreviousSuspendCount);
501 }
502
503
504 /*
505 * @implemented
506 */
507 DWORD STDCALL
508 SetThreadAffinityMask(HANDLE hThread,
509 DWORD dwThreadAffinityMask)
510 {
511 THREAD_BASIC_INFORMATION ThreadBasic;
512 KAFFINITY AffinityMask;
513 NTSTATUS Status;
514
515 AffinityMask = (KAFFINITY)dwThreadAffinityMask;
516
517 Status = NtQueryInformationThread(hThread,
518 ThreadBasicInformation,
519 &ThreadBasic,
520 sizeof(THREAD_BASIC_INFORMATION),
521 NULL);
522 if (!NT_SUCCESS(Status))
523 {
524 SetLastErrorByStatus(Status);
525 return(0);
526 }
527
528 Status = NtSetInformationThread(hThread,
529 ThreadAffinityMask,
530 &AffinityMask,
531 sizeof(KAFFINITY));
532 if (!NT_SUCCESS(Status))
533 {
534 SetLastErrorByStatus(Status);
535 ThreadBasic.AffinityMask = 0;
536 }
537
538 return(ThreadBasic.AffinityMask);
539 }
540
541
542 /*
543 * @implemented
544 */
545 BOOL
546 STDCALL
547 SetThreadPriority(HANDLE hThread,
548 int nPriority)
549 {
550 ULONG Prio = nPriority;
551 NTSTATUS Status;
552
553 /* Check if values forcing saturation should be used */
554 if (Prio == THREAD_PRIORITY_TIME_CRITICAL)
555 {
556 Prio = (HIGH_PRIORITY + 1) / 2;
557 }
558 else if (Prio == THREAD_PRIORITY_IDLE)
559 {
560 Prio = -((HIGH_PRIORITY + 1) / 2);
561 }
562
563 /* Set the Base Priority */
564 Status = NtSetInformationThread(hThread,
565 ThreadBasePriority,
566 &Prio,
567 sizeof(ULONG));
568 if (!NT_SUCCESS(Status))
569 {
570 /* Failure */
571 SetLastErrorByStatus(Status);
572 return FALSE;
573 }
574
575 /* Return */
576 return TRUE;
577 }
578
579 /*
580 * @implemented
581 */
582 int
583 STDCALL
584 GetThreadPriority(HANDLE hThread)
585 {
586 THREAD_BASIC_INFORMATION ThreadBasic;
587 NTSTATUS Status;
588
589 /* Query the Base Priority Increment */
590 Status = NtQueryInformationThread(hThread,
591 ThreadBasicInformation,
592 &ThreadBasic,
593 sizeof(THREAD_BASIC_INFORMATION),
594 NULL);
595 if (!NT_SUCCESS(Status))
596 {
597 /* Failure */
598 SetLastErrorByStatus(Status);
599 return THREAD_PRIORITY_ERROR_RETURN;
600 }
601
602 /* Do some conversions for out of boundary values */
603 if (ThreadBasic.BasePriority > THREAD_BASE_PRIORITY_MAX)
604 {
605 ThreadBasic.BasePriority = THREAD_PRIORITY_TIME_CRITICAL;
606 }
607 else if (ThreadBasic.BasePriority < THREAD_BASE_PRIORITY_MIN)
608 {
609 ThreadBasic.BasePriority = THREAD_PRIORITY_IDLE;
610 }
611
612 /* Return the final result */
613 return ThreadBasic.BasePriority;
614 }
615
616 /*
617 * @implemented
618 */
619 BOOL STDCALL
620 GetThreadPriorityBoost(IN HANDLE hThread,
621 OUT PBOOL pDisablePriorityBoost)
622 {
623 ULONG PriorityBoost;
624 NTSTATUS Status;
625
626 Status = NtQueryInformationThread(hThread,
627 ThreadPriorityBoost,
628 &PriorityBoost,
629 sizeof(ULONG),
630 NULL);
631 if (!NT_SUCCESS(Status))
632 {
633 SetLastErrorByStatus(Status);
634 return(FALSE);
635 }
636
637 *pDisablePriorityBoost = !((BOOL)PriorityBoost);
638
639 return(TRUE);
640 }
641
642
643 /*
644 * @implemented
645 */
646 BOOL STDCALL
647 SetThreadPriorityBoost(IN HANDLE hThread,
648 IN BOOL bDisablePriorityBoost)
649 {
650 ULONG PriorityBoost;
651 NTSTATUS Status;
652
653 PriorityBoost = (ULONG)!bDisablePriorityBoost;
654
655 Status = NtSetInformationThread(hThread,
656 ThreadPriorityBoost,
657 &PriorityBoost,
658 sizeof(ULONG));
659 if (!NT_SUCCESS(Status))
660 {
661 SetLastErrorByStatus(Status);
662 return(FALSE);
663 }
664
665 return(TRUE);
666 }
667
668
669 /*
670 * @implemented
671 */
672 BOOL STDCALL
673 GetThreadSelectorEntry(IN HANDLE hThread,
674 IN DWORD dwSelector,
675 OUT LPLDT_ENTRY lpSelectorEntry)
676 {
677 DESCRIPTOR_TABLE_ENTRY DescriptionTableEntry;
678 NTSTATUS Status;
679
680 DescriptionTableEntry.Selector = dwSelector;
681 Status = NtQueryInformationThread(hThread,
682 ThreadDescriptorTableEntry,
683 &DescriptionTableEntry,
684 sizeof(DESCRIPTOR_TABLE_ENTRY),
685 NULL);
686 if(!NT_SUCCESS(Status))
687 {
688 SetLastErrorByStatus(Status);
689 return FALSE;
690 }
691
692 *lpSelectorEntry = DescriptionTableEntry.Descriptor;
693 return TRUE;
694 }
695
696
697 /*
698 * @implemented
699 */
700 DWORD STDCALL
701 SetThreadIdealProcessor(HANDLE hThread,
702 DWORD dwIdealProcessor)
703 {
704 NTSTATUS Status;
705
706 Status = NtSetInformationThread(hThread,
707 ThreadIdealProcessor,
708 &dwIdealProcessor,
709 sizeof(ULONG));
710 if (!NT_SUCCESS(Status))
711 {
712 SetLastErrorByStatus(Status);
713 return -1;
714 }
715
716 return dwIdealProcessor;
717 }
718
719
720 /*
721 * @implemented
722 */
723 DWORD STDCALL
724 GetProcessIdOfThread(HANDLE Thread)
725 {
726 THREAD_BASIC_INFORMATION ThreadBasic;
727 NTSTATUS Status;
728
729 Status = NtQueryInformationThread(Thread,
730 ThreadBasicInformation,
731 &ThreadBasic,
732 sizeof(THREAD_BASIC_INFORMATION),
733 NULL);
734 if(!NT_SUCCESS(Status))
735 {
736 SetLastErrorByStatus(Status);
737 return 0;
738 }
739
740 return (DWORD)ThreadBasic.ClientId.UniqueProcess;
741 }
742
743
744 /*
745 * @implemented
746 */
747 DWORD STDCALL
748 GetThreadId(HANDLE Thread)
749 {
750 THREAD_BASIC_INFORMATION ThreadBasic;
751 NTSTATUS Status;
752
753 Status = NtQueryInformationThread(Thread,
754 ThreadBasicInformation,
755 &ThreadBasic,
756 sizeof(THREAD_BASIC_INFORMATION),
757 NULL);
758 if(!NT_SUCCESS(Status))
759 {
760 SetLastErrorByStatus(Status);
761 return 0;
762 }
763
764 return (DWORD)ThreadBasic.ClientId.UniqueThread;
765 }
766
767 /*
768 * @unimplemented
769 */
770 LANGID STDCALL
771 SetThreadUILanguage(WORD wReserved)
772 {
773 DPRINT1("SetThreadUILanguage(0x%4x) unimplemented!\n", wReserved);
774 return 0;
775 }
776
777 static void CALLBACK
778 IntCallUserApc(PVOID Function, PVOID dwData, PVOID Argument3)
779 {
780 PAPCFUNC pfnAPC = (PAPCFUNC)Function;
781 pfnAPC((ULONG_PTR)dwData);
782 }
783
784 /*
785 * @implemented
786 */
787 DWORD STDCALL
788 QueueUserAPC(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData)
789 {
790 NTSTATUS Status;
791
792 Status = NtQueueApcThread(hThread, IntCallUserApc, pfnAPC,
793 (PVOID)dwData, NULL);
794 if (Status)
795 SetLastErrorByStatus(Status);
796
797 return NT_SUCCESS(Status);
798 }
799
800 /*
801 * @implemented
802 */
803 BOOL STDCALL
804 GetThreadIOPendingFlag(HANDLE hThread,
805 PBOOL lpIOIsPending)
806 {
807 ULONG IoPending;
808 NTSTATUS Status;
809
810 if(lpIOIsPending == NULL)
811 {
812 SetLastError(ERROR_INVALID_PARAMETER);
813 return FALSE;
814 }
815
816 Status = NtQueryInformationThread(hThread,
817 ThreadIsIoPending,
818 (PVOID)&IoPending,
819 sizeof(IoPending),
820 NULL);
821 if(NT_SUCCESS(Status))
822 {
823 *lpIOIsPending = ((IoPending != 0) ? TRUE : FALSE);
824 return TRUE;
825 }
826
827 SetLastErrorByStatus(Status);
828 return FALSE;
829 }
830
831
832 /*
833 * @implemented
834 */
835 VOID STDCALL
836 Sleep(DWORD dwMilliseconds)
837 {
838 SleepEx(dwMilliseconds, FALSE);
839 return;
840 }
841
842
843 /*
844 * @implemented
845 */
846 DWORD STDCALL
847 SleepEx(DWORD dwMilliseconds,
848 BOOL bAlertable)
849 {
850 LARGE_INTEGER Interval;
851 NTSTATUS errCode;
852
853 if (dwMilliseconds != INFINITE)
854 {
855 /*
856 * System time units are 100 nanoseconds (a nanosecond is a billionth of
857 * a second).
858 */
859 Interval.QuadPart = -((ULONGLONG)dwMilliseconds * 10000);
860 }
861 else
862 {
863 /* Approximately 292000 years hence */
864 Interval.QuadPart = -0x7FFFFFFFFFFFFFFFLL;
865 }
866
867 errCode = NtDelayExecution ((bAlertable ? TRUE : FALSE), &Interval);
868 if (!NT_SUCCESS(errCode))
869 {
870 SetLastErrorByStatus (errCode);
871 return -1;
872 }
873 return 0;
874 }
875
876 /* EOF */