4 * Copyright 1996 Alexandre Julliard
11 #include <sys/types.h>
12 #ifdef HAVE_SYS_MMAN_H
16 #include "wine/winbase16.h"
24 #include "selectors.h"
28 #include "stackframe.h"
29 #include "builtin16.h"
30 #include "debugtools.h"
34 DEFAULT_DEBUG_CHANNEL(thread
)
36 /* TEB of the initial thread */
37 static TEB initial_teb
;
39 /* Global thread list (FIXME: not thread-safe) */
40 TEB
*THREAD_First
= &initial_teb
;
42 /***********************************************************************
45 BOOL
THREAD_IsWin16( TEB
*teb
)
47 return !teb
|| !(teb
->tibflags
& TEBF_WIN32
);
50 /***********************************************************************
53 * Convert a thread id to a TEB, making sure it is valid.
55 TEB
*THREAD_IdToTEB( DWORD id
)
57 TEB
*teb
= THREAD_First
;
59 if (!id
) return NtCurrentTeb();
62 if ((DWORD
)teb
->tid
== id
) return teb
;
65 /* Allow task handles to be used; convert to main thread */
68 TDB
*pTask
= (TDB
*)GlobalLock16( id
);
69 if (pTask
) return pTask
->teb
;
71 SetLastError( ERROR_INVALID_PARAMETER
);
76 /***********************************************************************
79 * Initialization of a newly created TEB.
81 static BOOL
THREAD_InitTEB( TEB
*teb
, DWORD stack_size
, BOOL alloc_stack16
,
82 LPSECURITY_ATTRIBUTES sa
)
86 /* Allocate the stack */
89 * If stacksize smaller than 1 MB, allocate 1MB
90 * (one program wanted only 10 kB, which is recommendable, but some WINE
91 * functions, noteably in the files subdir, push HUGE structures and
92 * arrays on the stack. They probably shouldn't.)
93 * If stacksize larger than 16 MB, warn the user. (We could shrink the stack
94 * but this could give more or less unexplainable crashes.)
96 if (stack_size
<1024*1024)
97 stack_size
= 1024 * 1024;
98 if (stack_size
>= 16*1024*1024)
99 WARN("Thread stack size is %ld MB.\n",stack_size
/1024/1024);
100 teb
->stack_base
= VirtualAlloc(NULL
, stack_size
+ SIGNAL_STACK_SIZE
+
101 (alloc_stack16
? 0x10000 : 0),
102 MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
103 if (!teb
->stack_base
) goto error
;
104 /* Set a guard page at the bottom of the stack */
105 VirtualProtect( teb
->stack_base
, 1, PAGE_EXECUTE_READWRITE
| PAGE_GUARD
, &old_prot
);
106 teb
->stack_top
= (char *)teb
->stack_base
+ stack_size
;
107 teb
->stack_low
= teb
->stack_base
;
108 teb
->signal_stack
= teb
->stack_top
; /* start of signal stack */
110 /* Allocate the 16-bit stack selector */
114 teb
->stack_sel
= SELECTOR_AllocBlock( teb
->stack_top
, 0x10000, SEGMENT_DATA
,
116 if (!teb
->stack_sel
) goto error
;
117 teb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( teb
->stack_sel
,
118 0x10000 - sizeof(STACK16FRAME
) );
119 teb
->signal_stack
= (char *)teb
->signal_stack
+ 0x10000;
122 /* StaticUnicodeString */
124 teb
->StaticUnicodeString
.MaximumLength
= sizeof(teb
->StaticUnicodeBuffer
);
125 teb
->StaticUnicodeString
.Buffer
= (PWSTR
)teb
->StaticUnicodeBuffer
;
130 if (teb
->stack_sel
) SELECTOR_FreeBlock( teb
->stack_sel
, 1 );
131 if (teb
->stack_base
) VirtualFree( teb
->stack_base
, 0, MEM_RELEASE
);
136 /***********************************************************************
139 * Free data structures associated with a thread.
140 * Must be called from the context of another thread.
142 void CALLBACK
THREAD_FreeTEB( ULONG_PTR arg
)
144 TEB
*teb
= (TEB
*)arg
;
145 TEB
**pptr
= &THREAD_First
;
147 TRACE("(%p) called\n", teb
);
148 SERVICE_Delete( teb
->cleanup
);
150 PROCESS_CallUserSignalProc( USIG_THREAD_EXIT
, (DWORD
)teb
->tid
, 0 );
152 while (*pptr
&& (*pptr
!= teb
)) pptr
= &(*pptr
)->next
;
153 if (*pptr
) *pptr
= teb
->next
;
155 /* Free the associated memory */
157 if (teb
->stack_sel
) SELECTOR_FreeBlock( teb
->stack_sel
, 1 );
158 SELECTOR_FreeBlock( teb
->teb_sel
, 1 );
159 close( teb
->socket
);
160 if (teb
->buffer
) munmap( teb
->buffer
, teb
->buffer_size
);
161 if (teb
->debug_info
) HeapFree( GetProcessHeap(), 0, teb
->debug_info
);
162 VirtualFree( teb
->stack_base
, 0, MEM_RELEASE
);
163 VirtualFree( teb
, 0, MEM_FREE
);
167 /***********************************************************************
168 * THREAD_CreateInitialThread
170 * Create the initial thread.
172 TEB
*THREAD_CreateInitialThread( PDB
*pdb
, int server_fd
)
174 initial_teb
.except
= (void *)-1;
175 initial_teb
.self
= &initial_teb
;
176 initial_teb
.tibflags
= (pdb
->flags
& PDB32_WIN16_PROC
)? 0 : TEBF_WIN32
;
177 initial_teb
.tls_ptr
= initial_teb
.tls_array
;
178 initial_teb
.process
= pdb
;
179 initial_teb
.exit_code
= STILL_ACTIVE
;
180 initial_teb
.socket
= server_fd
;
182 /* Allocate the TEB selector (%fs register) */
184 if (!(initial_teb
.teb_sel
= SELECTOR_AllocBlock( &initial_teb
, 0x1000,
185 SEGMENT_DATA
, TRUE
, FALSE
)))
187 MESSAGE("Could not allocate fs register for initial thread\n" );
190 SYSDEPS_SetCurThread( &initial_teb
);
192 /* Now proceed with normal initialization */
194 if (CLIENT_InitThread()) return NULL
;
195 if (!THREAD_InitTEB( &initial_teb
, 0, TRUE
, NULL
)) return NULL
;
200 /***********************************************************************
204 * Native NT dlls are using the space left on the allocated page
205 * the first allocated TEB on NT is at 0x7ffde000, since we can't
206 * allocate in this area and don't support a granularity of 4kb
207 * yet we leave it to VirtualAlloc to choose an address.
209 TEB
*THREAD_Create( PDB
*pdb
, int fd
, DWORD flags
, DWORD stack_size
, BOOL alloc_stack16
,
210 LPSECURITY_ATTRIBUTES sa
, int *server_handle
)
212 struct new_thread_request
*req
= get_req_buffer();
213 HANDLE cleanup_object
;
215 TEB
*teb
= VirtualAlloc(0, 0x1000, MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
216 if (!teb
) return NULL
;
217 teb
->except
= (void *)-1;
218 teb
->htask16
= pdb
->task
;
220 teb
->tibflags
= (pdb
->flags
& PDB32_WIN16_PROC
)? 0 : TEBF_WIN32
;
221 teb
->tls_ptr
= teb
->tls_array
;
223 teb
->exit_code
= STILL_ACTIVE
;
226 /* Allocate the TEB selector (%fs register) */
229 teb
->teb_sel
= SELECTOR_AllocBlock( teb
, 0x1000, SEGMENT_DATA
, TRUE
, FALSE
);
230 if (!teb
->teb_sel
) goto error
;
232 /* Create the thread on the server side */
234 if (teb
->socket
== -1)
236 req
->suspend
= ((flags
& CREATE_SUSPENDED
) != 0);
237 req
->inherit
= (sa
&& (sa
->nLength
>=sizeof(*sa
)) && sa
->bInheritHandle
);
238 if (server_call_fd( REQ_NEW_THREAD
, -1, &teb
->socket
)) goto error
;
240 *server_handle
= req
->handle
;
241 fcntl( teb
->socket
, F_SETFD
, 1 ); /* set close on exec flag */
244 /* Do the rest of the initialization */
246 if (!THREAD_InitTEB( teb
, stack_size
, alloc_stack16
, sa
)) goto error
;
247 teb
->next
= THREAD_First
;
250 /* Install cleanup handler */
251 if ( !DuplicateHandle( GetCurrentProcess(), *server_handle
,
252 GetCurrentProcess(), &cleanup_object
,
253 0, FALSE
, DUPLICATE_SAME_ACCESS
) ) goto error
;
254 teb
->cleanup
= SERVICE_AddObject( cleanup_object
, THREAD_FreeTEB
, (ULONG_PTR
)teb
);
256 TRACE("(%p) succeeded\n", teb
);
260 if (*server_handle
!= -1) CloseHandle( *server_handle
);
261 if (teb
->teb_sel
) SELECTOR_FreeBlock( teb
->teb_sel
, 1 );
262 if (teb
->socket
!= -1) close( teb
->socket
);
263 VirtualFree( teb
, 0, MEM_FREE
);
268 /***********************************************************************
271 * Start execution of a newly created thread. Does not return.
273 static void THREAD_Start(void)
275 LPTHREAD_START_ROUTINE func
= (LPTHREAD_START_ROUTINE
)NtCurrentTeb()->entry_point
;
276 PROCESS_CallUserSignalProc( USIG_THREAD_INIT
, (DWORD
)NtCurrentTeb()->tid
, 0 );
278 MODULE_DllThreadAttach( NULL
);
279 ExitThread( func( NtCurrentTeb()->entry_arg
) );
283 /***********************************************************************
284 * CreateThread (KERNEL32.63)
286 HANDLE WINAPI
CreateThread( SECURITY_ATTRIBUTES
*sa
, DWORD stack
,
287 LPTHREAD_START_ROUTINE start
, LPVOID param
,
288 DWORD flags
, LPDWORD id
)
291 TEB
*teb
= THREAD_Create( PROCESS_Current(), -1, flags
, stack
, TRUE
, sa
, &handle
);
293 teb
->tibflags
|= TEBF_WIN32
;
294 teb
->entry_point
= start
;
295 teb
->entry_arg
= param
;
296 teb
->startup
= THREAD_Start
;
297 if (SYSDEPS_SpawnThread( teb
) == -1)
299 CloseHandle( handle
);
302 if (id
) *id
= (DWORD
)teb
->tid
;
306 /***********************************************************************
307 * CreateThread16 (KERNEL.441)
309 static DWORD CALLBACK
THREAD_StartThread16( LPVOID threadArgs
)
311 FARPROC16 start
= ((FARPROC16
*)threadArgs
)[0];
312 DWORD param
= ((DWORD
*)threadArgs
)[1];
313 HeapFree( GetProcessHeap(), 0, threadArgs
);
315 ((LPDWORD
)CURRENT_STACK16
)[-1] = param
;
316 return CallTo16Long( start
, sizeof(DWORD
) );
318 HANDLE WINAPI
CreateThread16( SECURITY_ATTRIBUTES
*sa
, DWORD stack
,
319 FARPROC16 start
, SEGPTR param
,
320 DWORD flags
, LPDWORD id
)
322 DWORD
*threadArgs
= HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD
) );
323 if (!threadArgs
) return INVALID_HANDLE_VALUE
;
324 threadArgs
[0] = (DWORD
)start
;
325 threadArgs
[1] = (DWORD
)param
;
327 return CreateThread( sa
, stack
, THREAD_StartThread16
, threadArgs
, flags
, id
);
331 /***********************************************************************
332 * ExitThread [KERNEL32.215] Ends a thread
337 void WINAPI
ExitThread( DWORD code
) /* [in] Exit code for this thread */
339 struct terminate_thread_request
*req
= get_req_buffer();
341 /* send the exit code to the server */
342 req
->handle
= GetCurrentThread();
343 req
->exit_code
= code
;
344 server_call( REQ_TERMINATE_THREAD
);
347 MODULE_DllProcessDetach( TRUE
, (LPVOID
)1 );
353 MODULE_DllThreadDetach( NULL
);
354 SYSDEPS_ExitThread( code
);
359 /***********************************************************************
360 * GetCurrentThread [KERNEL32.200] Gets pseudohandle for current thread
363 * Pseudohandle for the current thread
365 HANDLE WINAPI
GetCurrentThread(void)
367 return CURRENT_THREAD_PSEUDOHANDLE
;
371 /**********************************************************************
372 * SetLastErrorEx [USER32.485] Sets the last-error code.
377 void WINAPI
SetLastErrorEx(
378 DWORD error
, /* [in] Per-thread error code */
379 DWORD type
) /* [in] Error type */
381 TRACE("(0x%08lx, 0x%08lx)\n", error
,type
);
388 /* Fall through for now */
390 FIXME("(error=%08lx, type=%08lx): Unhandled type\n", error
,type
);
393 SetLastError( error
);
397 /**********************************************************************
398 * TlsAlloc [KERNEL32.530] Allocates a TLS index.
400 * Allocates a thread local storage index
404 * Failure: 0xFFFFFFFF
406 DWORD WINAPI
TlsAlloc( void )
408 PDB
*process
= PROCESS_Current();
409 DWORD i
, mask
, ret
= 0;
410 DWORD
*bits
= process
->tls_bits
;
411 EnterCriticalSection( &process
->crit_section
);
412 if (*bits
== 0xffffffff)
416 if (*bits
== 0xffffffff)
418 LeaveCriticalSection( &process
->crit_section
);
419 SetLastError( ERROR_NO_MORE_ITEMS
);
423 for (i
= 0, mask
= 1; i
< 32; i
++, mask
<<= 1) if (!(*bits
& mask
)) break;
425 LeaveCriticalSection( &process
->crit_section
);
430 /**********************************************************************
431 * TlsFree [KERNEL32.531] Releases a TLS index.
433 * Releases a thread local storage index, making it available for reuse
440 DWORD index
) /* [in] TLS Index to free */
442 PDB
*process
= PROCESS_Current();
444 DWORD
*bits
= process
->tls_bits
;
447 SetLastError( ERROR_INVALID_PARAMETER
);
450 EnterCriticalSection( &process
->crit_section
);
451 if (index
>= 32) bits
++;
452 mask
= (1 << (index
& 31));
453 if (!(*bits
& mask
)) /* already free? */
455 LeaveCriticalSection( &process
->crit_section
);
456 SetLastError( ERROR_INVALID_PARAMETER
);
460 NtCurrentTeb()->tls_array
[index
] = 0;
461 /* FIXME: should zero all other thread values */
462 LeaveCriticalSection( &process
->crit_section
);
467 /**********************************************************************
468 * TlsGetValue [KERNEL32.532] Gets value in a thread's TLS slot
471 * Success: Value stored in calling thread's TLS slot for index
472 * Failure: 0 and GetLastError returns NO_ERROR
474 LPVOID WINAPI
TlsGetValue(
475 DWORD index
) /* [in] TLS index to retrieve value for */
479 SetLastError( ERROR_INVALID_PARAMETER
);
482 SetLastError( ERROR_SUCCESS
);
483 return NtCurrentTeb()->tls_array
[index
];
487 /**********************************************************************
488 * TlsSetValue [KERNEL32.533] Stores a value in the thread's TLS slot.
494 BOOL WINAPI
TlsSetValue(
495 DWORD index
, /* [in] TLS index to set value for */
496 LPVOID value
) /* [in] Value to be stored */
500 SetLastError( ERROR_INVALID_PARAMETER
);
503 NtCurrentTeb()->tls_array
[index
] = value
;
508 /***********************************************************************
509 * SetThreadContext [KERNEL32.670] Sets context of thread.
515 BOOL WINAPI
SetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
516 const CONTEXT
*context
) /* [in] Address of context structure */
518 struct set_thread_context_request
*req
= get_req_buffer();
519 req
->handle
= handle
;
520 req
->flags
= context
->ContextFlags
;
521 memcpy( &req
->context
, context
, sizeof(*context
) );
522 return !server_call( REQ_SET_THREAD_CONTEXT
);
526 /***********************************************************************
527 * GetThreadContext [KERNEL32.294] Retrieves context of thread.
533 BOOL WINAPI
GetThreadContext( HANDLE handle
, /* [in] Handle to thread with context */
534 CONTEXT
*context
) /* [out] Address of context structure */
536 struct get_thread_context_request
*req
= get_req_buffer();
537 req
->handle
= handle
;
538 req
->flags
= context
->ContextFlags
;
539 memcpy( &req
->context
, context
, sizeof(*context
) );
540 if (server_call( REQ_GET_THREAD_CONTEXT
)) return FALSE
;
541 memcpy( context
, &req
->context
, sizeof(*context
) );
546 /**********************************************************************
547 * GetThreadPriority [KERNEL32.296] Returns priority for thread.
550 * Success: Thread's priority level.
551 * Failure: THREAD_PRIORITY_ERROR_RETURN
553 INT WINAPI
GetThreadPriority(
554 HANDLE hthread
) /* [in] Handle to thread */
556 INT ret
= THREAD_PRIORITY_ERROR_RETURN
;
557 struct get_thread_info_request
*req
= get_req_buffer();
558 req
->handle
= hthread
;
559 if (!server_call( REQ_GET_THREAD_INFO
)) ret
= req
->priority
;
564 /**********************************************************************
565 * SetThreadPriority [KERNEL32.514] Sets priority for thread.
571 BOOL WINAPI
SetThreadPriority(
572 HANDLE hthread
, /* [in] Handle to thread */
573 INT priority
) /* [in] Thread priority level */
575 struct set_thread_info_request
*req
= get_req_buffer();
576 req
->handle
= hthread
;
577 req
->priority
= priority
;
578 req
->mask
= SET_THREAD_INFO_PRIORITY
;
579 return !server_call( REQ_SET_THREAD_INFO
);
583 /**********************************************************************
584 * SetThreadAffinityMask (KERNEL32.669)
586 DWORD WINAPI
SetThreadAffinityMask( HANDLE hThread
, DWORD dwThreadAffinityMask
)
588 struct set_thread_info_request
*req
= get_req_buffer();
589 req
->handle
= hThread
;
590 req
->affinity
= dwThreadAffinityMask
;
591 req
->mask
= SET_THREAD_INFO_AFFINITY
;
592 if (server_call( REQ_SET_THREAD_INFO
)) return 0;
593 return 1; /* FIXME: should return previous value */
597 /**********************************************************************
598 * TerminateThread [KERNEL32.685] Terminates a thread
604 BOOL WINAPI
TerminateThread(
605 HANDLE handle
, /* [in] Handle to thread */
606 DWORD exitcode
) /* [in] Exit code for thread */
609 struct terminate_thread_request
*req
= get_req_buffer();
610 req
->handle
= handle
;
611 req
->exit_code
= exitcode
;
612 if ((ret
= !server_call( REQ_TERMINATE_THREAD
)) && req
->self
)
614 if (req
->last
) exit( exitcode
);
615 else SYSDEPS_ExitThread( exitcode
);
621 /**********************************************************************
622 * GetExitCodeThread [KERNEL32.???] Gets termination status of thread.
628 BOOL WINAPI
GetExitCodeThread(
629 HANDLE hthread
, /* [in] Handle to thread */
630 LPDWORD exitcode
) /* [out] Address to receive termination status */
633 struct get_thread_info_request
*req
= get_req_buffer();
634 req
->handle
= hthread
;
635 if (!server_call( REQ_GET_THREAD_INFO
))
637 if (exitcode
) *exitcode
= req
->exit_code
;
644 /**********************************************************************
645 * ResumeThread [KERNEL32.587] Resumes a thread.
647 * Decrements a thread's suspend count. When count is zero, the
648 * execution of the thread is resumed.
651 * Success: Previous suspend count
652 * Failure: 0xFFFFFFFF
655 DWORD WINAPI
ResumeThread(
656 HANDLE hthread
) /* [in] Identifies thread to restart */
658 DWORD ret
= 0xffffffff;
659 struct resume_thread_request
*req
= get_req_buffer();
660 req
->handle
= hthread
;
661 if (!server_call( REQ_RESUME_THREAD
)) ret
= req
->count
;
666 /**********************************************************************
667 * SuspendThread [KERNEL32.681] Suspends a thread.
670 * Success: Previous suspend count
671 * Failure: 0xFFFFFFFF
673 DWORD WINAPI
SuspendThread(
674 HANDLE hthread
) /* [in] Handle to the thread */
676 DWORD ret
= 0xffffffff;
677 struct suspend_thread_request
*req
= get_req_buffer();
678 req
->handle
= hthread
;
679 if (!server_call( REQ_SUSPEND_THREAD
)) ret
= req
->count
;
684 /***********************************************************************
685 * QueueUserAPC (KERNEL32.566)
687 DWORD WINAPI
QueueUserAPC( PAPCFUNC func
, HANDLE hthread
, ULONG_PTR data
)
689 struct queue_apc_request
*req
= get_req_buffer();
690 req
->handle
= hthread
;
692 req
->param
= (void *)data
;
693 return !server_call( REQ_QUEUE_APC
);
697 /**********************************************************************
698 * GetThreadTimes [KERNEL32.???] Obtains timing information.
701 * What are the fields where these values are stored?
707 BOOL WINAPI
GetThreadTimes(
708 HANDLE thread
, /* [in] Specifies the thread of interest */
709 LPFILETIME creationtime
, /* [out] When the thread was created */
710 LPFILETIME exittime
, /* [out] When the thread was destroyed */
711 LPFILETIME kerneltime
, /* [out] Time thread spent in kernel mode */
712 LPFILETIME usertime
) /* [out] Time thread spent in user mode */
714 FIXME("(0x%08x): stub\n",thread
);
715 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
720 /**********************************************************************
721 * AttachThreadInput [KERNEL32.8] Attaches input of 1 thread to other
723 * Attaches the input processing mechanism of one thread to that of
731 * 1. Reset the Key State (currenly per thread key state is not maintained)
733 BOOL WINAPI
AttachThreadInput(
734 DWORD idAttach
, /* [in] Thread to attach */
735 DWORD idAttachTo
, /* [in] Thread to attach to */
736 BOOL fAttach
) /* [in] Attach or detach */
738 MESSAGEQUEUE
*pSrcMsgQ
= 0, *pTgtMsgQ
= 0;
741 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
743 /* A thread cannot attach to itself */
744 if ( idAttach
== idAttachTo
)
747 /* According to the docs this method should fail if a
748 * "Journal record" hook is installed. (attaches all input queues together)
750 if ( HOOK_IsHooked( WH_JOURNALRECORD
) )
753 /* Retrieve message queues corresponding to the thread id's */
754 pTgtMsgQ
= (MESSAGEQUEUE
*)QUEUE_Lock( GetThreadQueue16( idAttach
) );
755 pSrcMsgQ
= (MESSAGEQUEUE
*)QUEUE_Lock( GetThreadQueue16( idAttachTo
) );
757 /* Ensure we have message queues and that Src and Tgt threads
758 * are not system threads.
760 if ( !pSrcMsgQ
|| !pTgtMsgQ
|| !pSrcMsgQ
->pQData
|| !pTgtMsgQ
->pQData
)
763 if (fAttach
) /* Attach threads */
765 /* Only attach if currently detached */
766 if ( pTgtMsgQ
->pQData
!= pSrcMsgQ
->pQData
)
768 /* First release the target threads perQData */
769 PERQDATA_Release( pTgtMsgQ
->pQData
);
771 /* Share a reference to the source threads perQDATA */
772 PERQDATA_Addref( pSrcMsgQ
->pQData
);
773 pTgtMsgQ
->pQData
= pSrcMsgQ
->pQData
;
776 else /* Detach threads */
778 /* Only detach if currently attached */
779 if ( pTgtMsgQ
->pQData
== pSrcMsgQ
->pQData
)
781 /* First release the target threads perQData */
782 PERQDATA_Release( pTgtMsgQ
->pQData
);
784 /* Give the target thread its own private perQDATA once more */
785 pTgtMsgQ
->pQData
= PERQDATA_CreateInstance();
789 /* TODO: Reset the Key State */
791 bRet
= 1; /* Success */
795 /* Unlock the queues before returning */
797 QUEUE_Unlock( pSrcMsgQ
);
799 QUEUE_Unlock( pTgtMsgQ
);
804 /**********************************************************************
805 * VWin32_BoostThreadGroup [KERNEL.535]
807 VOID WINAPI
VWin32_BoostThreadGroup( DWORD threadId
, INT boost
)
809 FIXME("(0x%08lx,%d): stub\n", threadId
, boost
);
812 /**********************************************************************
813 * VWin32_BoostThreadStatic [KERNEL.536]
815 VOID WINAPI
VWin32_BoostThreadStatic( DWORD threadId
, INT boost
)
817 FIXME("(0x%08lx,%d): stub\n", threadId
, boost
);
820 /**********************************************************************
821 * SetThreadLocale [KERNEL32.671] Sets the calling threads current locale.
828 * Implemented in NT only (3.1 and above according to MS
830 BOOL WINAPI
SetThreadLocale(
831 LCID lcid
) /* [in] Locale identifier */
833 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
840 /* void WINAPI SetLastError( DWORD error ); */
841 __ASM_GLOBAL_FUNC( SetLastError
,
842 "movl 4(%esp),%eax\n\t"
847 /* DWORD WINAPI GetLastError(void); */
848 __ASM_GLOBAL_FUNC( GetLastError
, ".byte 0x64\n\tmovl 0x60,%eax\n\tret" );
850 /* DWORD WINAPI GetCurrentThreadId(void) */
851 __ASM_GLOBAL_FUNC( GetCurrentThreadId
, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" );
855 /**********************************************************************
856 * SetLastError [KERNEL.147] [KERNEL32.497] Sets the last-error code.
858 void WINAPI
SetLastError( DWORD error
) /* [in] Per-thread error code */
860 NtCurrentTeb()->last_error
= error
;
863 /**********************************************************************
864 * GetLastError [KERNEL.148] [KERNEL32.227] Returns last-error code.
866 DWORD WINAPI
GetLastError(void)
868 return NtCurrentTeb()->last_error
;
871 /***********************************************************************
872 * GetCurrentThreadId [KERNEL32.201] Returns thread identifier.
874 DWORD WINAPI
GetCurrentThreadId(void)
876 return (DWORD
)NtCurrentTeb()->tid
;
879 #endif /* __i386__ */