Silently ignore 'so' loadorder in the config file instead of
[wine] / scheduler / thread.c
1 /*
2  * Win32 threads
3  *
4  * Copyright 1996 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <fcntl.h>
26 #include <sys/types.h>
27 #ifdef HAVE_SYS_MMAN_H
28 #include <sys/mman.h>
29 #endif
30 #ifdef HAVE_SYS_TIMES_H
31 #include <sys/times.h>
32 #endif
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36 #include "wine/winbase16.h"
37 #include "thread.h"
38 #include "task.h"
39 #include "module.h"
40 #include "winerror.h"
41 #include "selectors.h"
42 #include "winnt.h"
43 #include "wine/server.h"
44 #include "stackframe.h"
45 #include "wine/debug.h"
46 #include "winnls.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(thread);
49 WINE_DECLARE_DEBUG_CHANNEL(relay);
50
51 /* TEB of the initial thread */
52 static TEB initial_teb;
53
54 extern struct _PDB current_process;
55
56 /***********************************************************************
57  *           THREAD_IdToTEB
58  *
59  * Convert a thread id to a TEB, making sure it is valid.
60  */
61 TEB *THREAD_IdToTEB( DWORD id )
62 {
63     TEB *ret = NULL;
64
65     if (!id || id == GetCurrentThreadId()) return NtCurrentTeb();
66
67     SERVER_START_REQ( get_thread_info )
68     {
69         req->handle = 0;
70         req->tid_in = id;
71         if (!wine_server_call( req )) ret = reply->teb;
72     }
73     SERVER_END_REQ;
74
75     if (!ret)
76     {
77         /* Allow task handles to be used; convert to main thread */
78         if ( IsTask16( id ) )
79         {
80             TDB *pTask = TASK_GetPtr( id );
81             if (pTask) return pTask->teb;
82         }
83         SetLastError( ERROR_INVALID_PARAMETER );
84     }
85     return ret;
86 }
87
88
89 /***********************************************************************
90  *           THREAD_InitTEB
91  *
92  * Initialization of a newly created TEB.
93  */
94 static BOOL THREAD_InitTEB( TEB *teb )
95 {
96     teb->except    = (void *)~0UL;
97     teb->self      = teb;
98     teb->tibflags  = TEBF_WIN32;
99     teb->tls_ptr   = teb->tls_array;
100     teb->exit_code = STILL_ACTIVE;
101     teb->request_fd = -1;
102     teb->reply_fd   = -1;
103     teb->wait_fd[0] = -1;
104     teb->wait_fd[1] = -1;
105     teb->stack_top  = (void *)~0UL;
106     teb->StaticUnicodeString.MaximumLength = sizeof(teb->StaticUnicodeBuffer);
107     teb->StaticUnicodeString.Buffer = (PWSTR)teb->StaticUnicodeBuffer;
108     teb->teb_sel = wine_ldt_alloc_fs();
109     return (teb->teb_sel != 0);
110 }
111
112
113 /***********************************************************************
114  *           THREAD_FreeTEB
115  *
116  * Free data structures associated with a thread.
117  * Must be called from the context of another thread.
118  */
119 static void THREAD_FreeTEB( TEB *teb )
120 {
121     TRACE("(%p) called\n", teb );
122     /* Free the associated memory */
123     wine_ldt_free_entries( teb->stack_sel, 1 );
124     wine_ldt_free_fs( teb->teb_sel );
125     VirtualFree( teb->stack_base, 0, MEM_RELEASE );
126 }
127
128
129 /***********************************************************************
130  *           THREAD_InitStack
131  *
132  * Allocate the stack of a thread.
133  */
134 TEB *THREAD_InitStack( TEB *teb, DWORD stack_size )
135 {
136     DWORD old_prot, total_size;
137     DWORD page_size = getpagesize();
138     void *base;
139
140     /* Allocate the stack */
141
142     if (stack_size >= 16*1024*1024)
143         WARN("Thread stack size is %ld MB.\n",stack_size/1024/1024);
144
145     /* if size is smaller than default, get stack size from parent */
146     if (stack_size < 1024 * 1024)
147     {
148         if (teb)
149             stack_size = 1024 * 1024;  /* no parent */
150         else
151             stack_size = ((char *)NtCurrentTeb()->stack_top - (char *)NtCurrentTeb()->stack_base
152                           - SIGNAL_STACK_SIZE - 3 * page_size);
153     }
154
155     /* FIXME: some Wine functions use a lot of stack, so we add 64Kb here */
156     stack_size += 64 * 1024;
157
158     /* Memory layout in allocated block:
159      *
160      *   size                 contents
161      * 1 page              NOACCESS guard page
162      * SIGNAL_STACK_SIZE   signal stack
163      * 1 page              NOACCESS guard page
164      * 1 page              PAGE_GUARD guard page
165      * stack_size          normal stack
166      * 64Kb                16-bit stack (optional)
167      * 1 page              TEB (except for initial thread)
168      * 1 page              debug info (except for initial thread)
169      */
170
171     stack_size = (stack_size + (page_size - 1)) & ~(page_size - 1);
172     total_size = stack_size + SIGNAL_STACK_SIZE + 3 * page_size;
173     total_size += 0x10000; /* 16-bit stack */
174     if (!teb) total_size += 2 * page_size;
175
176     if (!(base = VirtualAlloc( NULL, total_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE )))
177         return NULL;
178
179     if (!teb)
180     {
181         teb = (TEB *)((char *)base + total_size - 2 * page_size);
182         if (!THREAD_InitTEB( teb )) goto error;
183         teb->debug_info = (char *)teb + page_size;
184     }
185
186     teb->stack_low    = base;
187     teb->stack_base   = base;
188     teb->signal_stack = (char *)base + page_size;
189     teb->stack_top    = (char *)base + 3 * page_size + SIGNAL_STACK_SIZE + stack_size;
190
191     /* Setup guard pages */
192
193     VirtualProtect( base, 1, PAGE_NOACCESS, &old_prot );
194     VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE, 1, PAGE_NOACCESS, &old_prot );
195     VirtualProtect( (char *)teb->signal_stack + SIGNAL_STACK_SIZE + page_size, 1,
196                     PAGE_EXECUTE_READWRITE | PAGE_GUARD, &old_prot );
197
198     /* Allocate the 16-bit stack selector */
199
200     teb->stack_sel = SELECTOR_AllocBlock( teb->stack_top, 0x10000, WINE_LDT_FLAGS_DATA );
201     if (!teb->stack_sel) goto error;
202     teb->cur_stack = MAKESEGPTR( teb->stack_sel, 0x10000 - sizeof(STACK16FRAME) );
203
204     return teb;
205
206 error:
207     wine_ldt_free_fs( teb->teb_sel );
208     VirtualFree( base, 0, MEM_RELEASE );
209     return NULL;
210 }
211
212
213 /***********************************************************************
214  *           THREAD_Init
215  *
216  * Setup the initial thread.
217  *
218  * NOTES: The first allocated TEB on NT is at 0x7ffde000.
219  */
220 void THREAD_Init(void)
221 {
222     if (!initial_teb.self)  /* do it only once */
223     {
224         THREAD_InitTEB( &initial_teb );
225         assert( initial_teb.teb_sel );
226         initial_teb.process = &current_process;
227         SYSDEPS_SetCurThread( &initial_teb );
228         SYSDEPS_InitErrno();
229     }
230 }
231
232 DECL_GLOBAL_CONSTRUCTOR(thread_init) { THREAD_Init(); }
233
234
235 /***********************************************************************
236  *           THREAD_Start
237  *
238  * Start execution of a newly created thread. Does not return.
239  */
240 static void THREAD_Start(void)
241 {
242     LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)NtCurrentTeb()->entry_point;
243
244     if (TRACE_ON(relay))
245         DPRINTF("%04lx:Starting thread (entryproc=%p)\n", GetCurrentThreadId(), func );
246
247     PROCESS_CallUserSignalProc( USIG_THREAD_INIT, 0 );
248     MODULE_DllThreadAttach( NULL );
249     ExitThread( func( NtCurrentTeb()->entry_arg ) );
250 }
251
252
253 /***********************************************************************
254  *           CreateThread   (KERNEL32.@)
255  */
256 HANDLE WINAPI CreateThread( SECURITY_ATTRIBUTES *sa, SIZE_T stack,
257                             LPTHREAD_START_ROUTINE start, LPVOID param,
258                             DWORD flags, LPDWORD id )
259 {
260     HANDLE handle = 0;
261     TEB *teb;
262     DWORD tid = 0;
263     int request_pipe[2];
264
265     if (pipe( request_pipe ) == -1)
266     {
267         SetLastError( ERROR_TOO_MANY_OPEN_FILES );
268         return 0;
269     }
270     fcntl( request_pipe[1], F_SETFD, 1 ); /* set close on exec flag */
271     wine_server_send_fd( request_pipe[0] );
272
273     SERVER_START_REQ( new_thread )
274     {
275         req->suspend    = ((flags & CREATE_SUSPENDED) != 0);
276         req->inherit    = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
277         req->request_fd = request_pipe[0];
278         if (!wine_server_call_err( req ))
279         {
280             handle = reply->handle;
281             tid = reply->tid;
282         }
283         close( request_pipe[0] );
284     }
285     SERVER_END_REQ;
286
287     if (!handle || !(teb = THREAD_InitStack( NULL, stack )))
288     {
289         close( request_pipe[1] );
290         return 0;
291     }
292
293     teb->process     = NtCurrentTeb()->process;
294     teb->tid         = tid;
295     teb->request_fd  = request_pipe[1];
296     teb->entry_point = start;
297     teb->entry_arg   = param;
298     teb->startup     = THREAD_Start;
299     teb->htask16     = GetCurrentTask();
300
301     if (id) *id = tid;
302     if (SYSDEPS_SpawnThread( teb ) == -1)
303     {
304         CloseHandle( handle );
305         close( request_pipe[1] );
306         THREAD_FreeTEB( teb );
307         return 0;
308     }
309     return handle;
310 }
311
312 /***********************************************************************
313  * ExitThread [KERNEL32.@]  Ends a thread
314  *
315  * RETURNS
316  *    None
317  */
318 void WINAPI ExitThread( DWORD code ) /* [in] Exit code for this thread */
319 {
320     BOOL last;
321     SERVER_START_REQ( terminate_thread )
322     {
323         /* send the exit code to the server */
324         req->handle    = GetCurrentThread();
325         req->exit_code = code;
326         wine_server_call( req );
327         last = reply->last;
328     }
329     SERVER_END_REQ;
330
331     if (last)
332     {
333         LdrShutdownProcess();
334         exit( code );
335     }
336     else
337     {
338         LdrShutdownThread();
339         if (!(NtCurrentTeb()->tibflags & TEBF_WIN32)) TASK_ExitTask();
340         SYSDEPS_ExitThread( code );
341     }
342 }
343
344 /***********************************************************************
345  * OpenThread Retrieves a handle to a thread from its thread id
346  *
347  * RETURNS
348  *    None
349  */
350 HANDLE WINAPI OpenThread( DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId )
351 {
352     HANDLE ret = 0;
353     SERVER_START_REQ( open_thread )
354     {
355         req->tid     = dwThreadId;
356         req->access  = dwDesiredAccess;
357         req->inherit = bInheritHandle;
358         if (!wine_server_call_err( req )) ret = reply->handle;
359     }
360     SERVER_END_REQ;
361     return ret;
362 }
363
364 /***********************************************************************
365  * SetThreadContext [KERNEL32.@]  Sets context of thread.
366  *
367  * RETURNS
368  *    Success: TRUE
369  *    Failure: FALSE
370  */
371 BOOL WINAPI SetThreadContext( HANDLE handle,           /* [in]  Handle to thread with context */
372                               const CONTEXT *context ) /* [in] Address of context structure */
373 {
374     NTSTATUS status = NtSetContextThread( handle, context );
375     if (status) SetLastError( RtlNtStatusToDosError(status) );
376     return !status;
377 }
378
379
380 /***********************************************************************
381  * GetThreadContext [KERNEL32.@]  Retrieves context of thread.
382  *
383  * RETURNS
384  *    Success: TRUE
385  *    Failure: FALSE
386  */
387 BOOL WINAPI GetThreadContext( HANDLE handle,     /* [in]  Handle to thread with context */
388                               CONTEXT *context ) /* [out] Address of context structure */
389 {
390     NTSTATUS status = NtGetContextThread( handle, context );
391     if (status) SetLastError( RtlNtStatusToDosError(status) );
392     return !status;
393 }
394
395
396 /**********************************************************************
397  * GetThreadPriority [KERNEL32.@]  Returns priority for thread.
398  *
399  * RETURNS
400  *    Success: Thread's priority level.
401  *    Failure: THREAD_PRIORITY_ERROR_RETURN
402  */
403 INT WINAPI GetThreadPriority(
404     HANDLE hthread) /* [in] Handle to thread */
405 {
406     INT ret = THREAD_PRIORITY_ERROR_RETURN;
407     SERVER_START_REQ( get_thread_info )
408     {
409         req->handle = hthread;
410         req->tid_in = 0;
411         if (!wine_server_call_err( req )) ret = reply->priority;
412     }
413     SERVER_END_REQ;
414     return ret;
415 }
416
417
418 /**********************************************************************
419  * SetThreadPriority [KERNEL32.@]  Sets priority for thread.
420  *
421  * RETURNS
422  *    Success: TRUE
423  *    Failure: FALSE
424  */
425 BOOL WINAPI SetThreadPriority(
426     HANDLE hthread, /* [in] Handle to thread */
427     INT priority)   /* [in] Thread priority level */
428 {
429     BOOL ret;
430     SERVER_START_REQ( set_thread_info )
431     {
432         req->handle   = hthread;
433         req->priority = priority;
434         req->mask     = SET_THREAD_INFO_PRIORITY;
435         ret = !wine_server_call_err( req );
436     }
437     SERVER_END_REQ;
438     return ret;
439 }
440
441
442 /**********************************************************************
443  * GetThreadPriorityBoost [KERNEL32.@]  Returns priority boost for thread.
444  *
445  * Always reports that priority boost is disabled.
446  *
447  * RETURNS
448  *    Success: TRUE.
449  *    Failure: FALSE
450  */
451 BOOL WINAPI GetThreadPriorityBoost(
452     HANDLE hthread, /* [in] Handle to thread */
453     PBOOL pstate)   /* [out] pointer to var that receives the boost state */
454 {
455     if (pstate) *pstate = FALSE;
456     return NO_ERROR;
457 }
458
459
460 /**********************************************************************
461  * SetThreadPriorityBoost [KERNEL32.@]  Sets priority boost for thread.
462  *
463  * Priority boost is not implemented. Thsi function always returns
464  * FALSE and sets last error to ERROR_CALL_NOT_IMPLEMENTED
465  *
466  * RETURNS
467  *    Always returns FALSE to indicate a failure
468  */
469 BOOL WINAPI SetThreadPriorityBoost(
470     HANDLE hthread, /* [in] Handle to thread */
471     BOOL disable)   /* [in] TRUE to disable priority boost */
472 {
473     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
474     return FALSE;
475 }
476
477
478 /**********************************************************************
479  *           SetThreadAffinityMask   (KERNEL32.@)
480  */
481 DWORD WINAPI SetThreadAffinityMask( HANDLE hThread, DWORD dwThreadAffinityMask )
482 {
483     DWORD ret;
484     SERVER_START_REQ( set_thread_info )
485     {
486         req->handle   = hThread;
487         req->affinity = dwThreadAffinityMask;
488         req->mask     = SET_THREAD_INFO_AFFINITY;
489         ret = !wine_server_call_err( req );
490         /* FIXME: should return previous value */
491     }
492     SERVER_END_REQ;
493     return ret;
494 }
495
496 /**********************************************************************
497  * SetThreadIdealProcessor [KERNEL32.@]  Obtains timing information.
498  *
499  * RETURNS
500  *    Success: Value of last call to SetThreadIdealProcessor
501  *    Failure: -1
502  */
503 DWORD WINAPI SetThreadIdealProcessor(
504     HANDLE hThread,          /* [in] Specifies the thread of interest */
505     DWORD dwIdealProcessor)  /* [in] Specifies the new preferred processor */
506 {
507     FIXME("(%p): stub\n",hThread);
508     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
509     return -1L;
510 }
511
512 /**********************************************************************
513  * TerminateThread [KERNEL32.@]  Terminates a thread
514  *
515  * RETURNS
516  *    Success: TRUE
517  *    Failure: FALSE
518  */
519 BOOL WINAPI TerminateThread( HANDLE handle,    /* [in] Handle to thread */
520                              DWORD exit_code)  /* [in] Exit code for thread */
521 {
522     NTSTATUS status = NtTerminateThread( handle, exit_code );
523     if (status) SetLastError( RtlNtStatusToDosError(status) );
524     return !status;
525 }
526
527
528 /**********************************************************************
529  *              GetExitCodeThread (KERNEL32.@)
530  *
531  * Gets termination status of thread.
532  *
533  * RETURNS
534  *    Success: TRUE
535  *    Failure: FALSE
536  */
537 BOOL WINAPI GetExitCodeThread(
538     HANDLE hthread, /* [in]  Handle to thread */
539     LPDWORD exitcode) /* [out] Address to receive termination status */
540 {
541     BOOL ret;
542     SERVER_START_REQ( get_thread_info )
543     {
544         req->handle = hthread;
545         req->tid_in = 0;
546         ret = !wine_server_call_err( req );
547         if (ret && exitcode) *exitcode = reply->exit_code;
548     }
549     SERVER_END_REQ;
550     return ret;
551 }
552
553
554 /**********************************************************************
555  * ResumeThread [KERNEL32.@]  Resumes a thread.
556  *
557  * Decrements a thread's suspend count.  When count is zero, the
558  * execution of the thread is resumed.
559  *
560  * RETURNS
561  *    Success: Previous suspend count
562  *    Failure: 0xFFFFFFFF
563  *    Already running: 0
564  */
565 DWORD WINAPI ResumeThread( HANDLE hthread ) /* [in] Identifies thread to restart */
566 {
567     DWORD ret;
568     NTSTATUS status = NtResumeThread( hthread, &ret );
569
570     if (status)
571     {
572         ret = ~0U;
573         SetLastError( RtlNtStatusToDosError(status) );
574     }
575     return ret;
576 }
577
578
579 /**********************************************************************
580  * SuspendThread [KERNEL32.@]  Suspends a thread.
581  *
582  * RETURNS
583  *    Success: Previous suspend count
584  *    Failure: 0xFFFFFFFF
585  */
586 DWORD WINAPI SuspendThread( HANDLE hthread ) /* [in] Handle to the thread */
587 {
588     DWORD ret;
589     NTSTATUS status = NtSuspendThread( hthread, &ret );
590
591     if (status)
592     {
593         ret = ~0U;
594         SetLastError( RtlNtStatusToDosError(status) );
595     }
596     return ret;
597 }
598
599
600 /* callback for QueueUserAPC */
601 static void CALLBACK call_user_apc( ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3 )
602 {
603     PAPCFUNC func = (PAPCFUNC)arg1;
604     func( arg2 );
605 }
606
607 /***********************************************************************
608  *              QueueUserAPC  (KERNEL32.@)
609  */
610 DWORD WINAPI QueueUserAPC( PAPCFUNC func, HANDLE hthread, ULONG_PTR data )
611 {
612     NTSTATUS status = NtQueueApcThread( hthread, call_user_apc, (ULONG_PTR)func, data, 0 );
613
614     if (status) SetLastError( RtlNtStatusToDosError(status) );
615     return !status;
616 }
617
618
619 /**********************************************************************
620  * GetThreadTimes [KERNEL32.@]  Obtains timing information.
621  *
622  * RETURNS
623  *    Success: TRUE
624  *    Failure: FALSE
625  */
626 BOOL WINAPI GetThreadTimes(
627     HANDLE thread,         /* [in]  Specifies the thread of interest */
628     LPFILETIME creationtime, /* [out] When the thread was created */
629     LPFILETIME exittime,     /* [out] When the thread was destroyed */
630     LPFILETIME kerneltime,   /* [out] Time thread spent in kernel mode */
631     LPFILETIME usertime)     /* [out] Time thread spent in user mode */
632 {
633     BOOL ret = TRUE;
634
635     if (creationtime || exittime)
636     {
637         /* We need to do a server call to get the creation time or exit time */
638         /* This works on any thread */
639
640         SERVER_START_REQ( get_thread_info )
641         {
642             req->handle = thread;
643             req->tid_in = 0;
644             if ((ret = !wine_server_call_err( req )))
645             {
646                 if (creationtime)
647                     RtlSecondsSince1970ToTime( reply->creation_time, (LARGE_INTEGER*)creationtime );
648                 if (exittime)
649                     RtlSecondsSince1970ToTime( reply->exit_time, (LARGE_INTEGER*)exittime );
650             }
651         }
652         SERVER_END_REQ;
653     }
654     if (ret && (kerneltime || usertime))
655     {
656         /* We call times(2) for kernel time or user time */
657         /* We can only (portably) do this for the current thread */
658         if (thread == GetCurrentThread())
659         {
660             ULONGLONG time;
661             struct tms time_buf;
662             long clocks_per_sec = sysconf(_SC_CLK_TCK);
663
664             times(&time_buf);
665             if (kerneltime)
666             {
667                 time = (ULONGLONG)time_buf.tms_stime * 10000000 / clocks_per_sec;
668                 kerneltime->dwHighDateTime = time >> 32;
669                 kerneltime->dwLowDateTime = (DWORD)time;
670             }
671             if (usertime)
672             {
673                 time = (ULONGLONG)time_buf.tms_utime * 10000000 / clocks_per_sec;
674                 usertime->dwHighDateTime = time >> 32;
675                 usertime->dwLowDateTime = (DWORD)time;
676             }
677         }
678         else
679         {
680             if (kerneltime) kerneltime->dwHighDateTime = kerneltime->dwLowDateTime = 0;
681             if (usertime) usertime->dwHighDateTime = usertime->dwLowDateTime = 0;
682             FIXME("Cannot get kerneltime or usertime of other threads\n");
683         }
684     }
685     return ret;
686 }
687
688
689 /**********************************************************************
690  * VWin32_BoostThreadGroup [KERNEL.535]
691  */
692 VOID WINAPI VWin32_BoostThreadGroup( DWORD threadId, INT boost )
693 {
694     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
695 }
696
697 /**********************************************************************
698  * VWin32_BoostThreadStatic [KERNEL.536]
699  */
700 VOID WINAPI VWin32_BoostThreadStatic( DWORD threadId, INT boost )
701 {
702     FIXME("(0x%08lx,%d): stub\n", threadId, boost);
703 }
704
705
706 /***********************************************************************
707  * GetCurrentThread [KERNEL32.@]  Gets pseudohandle for current thread
708  *
709  * RETURNS
710  *    Pseudohandle for the current thread
711  */
712 #undef GetCurrentThread
713 HANDLE WINAPI GetCurrentThread(void)
714 {
715     return (HANDLE)0xfffffffe;
716 }
717
718
719 /***********************************************************************
720  * ProcessIdToSessionId   (KERNEL32.@)
721  * This function is available on Terminal Server 4SP4 and Windows 2000
722  */
723 BOOL WINAPI ProcessIdToSessionId( DWORD procid, DWORD *sessionid_ptr )
724 {
725         /* According to MSDN, if the calling process is not in a terminal
726          * services environment, then the sessionid returned is zero.
727          */
728         *sessionid_ptr = 0;
729         return TRUE;
730 }
731
732 /***********************************************************************
733  * SetThreadExecutionState (KERNEL32.@)
734  *
735  * Informs the system that activity is taking place for
736  * power management purposes.
737  */
738 EXECUTION_STATE WINAPI SetThreadExecutionState(EXECUTION_STATE flags)
739 {
740     static EXECUTION_STATE current =
741             ES_SYSTEM_REQUIRED|ES_DISPLAY_REQUIRED|ES_USER_PRESENT;
742     EXECUTION_STATE old = current;
743
744     if (!(current & ES_CONTINUOUS) || (flags & ES_CONTINUOUS))
745         current = flags;
746     FIXME("(0x%lx): stub, harmless (power management).\n", flags);
747     return old;
748 }
749
750
751 #ifdef __i386__
752
753 /***********************************************************************
754  *              SetLastError (KERNEL.147)
755  *              SetLastError (KERNEL32.@)
756  */
757 /* void WINAPI SetLastError( DWORD error ); */
758 __ASM_GLOBAL_FUNC( SetLastError,
759                    "movl 4(%esp),%eax\n\t"
760                    ".byte 0x64\n\t"
761                    "movl %eax,0x60\n\t"
762                    "ret $4" );
763
764 /***********************************************************************
765  *              GetLastError (KERNEL.148)
766  *              GetLastError (KERNEL32.@)
767  */
768 /* DWORD WINAPI GetLastError(void); */
769 __ASM_GLOBAL_FUNC( GetLastError, ".byte 0x64\n\tmovl 0x60,%eax\n\tret" );
770
771 /***********************************************************************
772  *              GetCurrentProcessId (KERNEL.471)
773  *              GetCurrentProcessId (KERNEL32.@)
774  */
775 /* DWORD WINAPI GetCurrentProcessId(void) */
776 __ASM_GLOBAL_FUNC( GetCurrentProcessId, ".byte 0x64\n\tmovl 0x20,%eax\n\tret" );
777
778 /***********************************************************************
779  *              GetCurrentThreadId (KERNEL.462)
780  *              GetCurrentThreadId (KERNEL32.@)
781  */
782 /* DWORD WINAPI GetCurrentThreadId(void) */
783 __ASM_GLOBAL_FUNC( GetCurrentThreadId, ".byte 0x64\n\tmovl 0x24,%eax\n\tret" );
784
785 #else  /* __i386__ */
786
787 /**********************************************************************
788  *              SetLastError (KERNEL.147)
789  *              SetLastError (KERNEL32.@)
790  *
791  * Sets the last-error code.
792  */
793 void WINAPI SetLastError( DWORD error ) /* [in] Per-thread error code */
794 {
795     NtCurrentTeb()->last_error = error;
796 }
797
798 /**********************************************************************
799  *              GetLastError (KERNEL.148)
800  *              GetLastError (KERNEL32.@)
801  *
802  * Returns last-error code.
803  */
804 DWORD WINAPI GetLastError(void)
805 {
806     return NtCurrentTeb()->last_error;
807 }
808
809 /***********************************************************************
810  *              GetCurrentProcessId (KERNEL.471)
811  *              GetCurrentProcessId (KERNEL32.@)
812  *
813  * Returns process identifier.
814  */
815 DWORD WINAPI GetCurrentProcessId(void)
816 {
817     return (DWORD)NtCurrentTeb()->pid;
818 }
819
820 /***********************************************************************
821  *              GetCurrentThreadId (KERNEL.462)
822  *              GetCurrentThreadId (KERNEL32.@)
823  *
824  * Returns thread identifier.
825  */
826 DWORD WINAPI GetCurrentThreadId(void)
827 {
828     return NtCurrentTeb()->tid;
829 }
830
831 #endif  /* __i386__ */