4 * Copyright 1995 Alexandre Julliard
12 #include "wine/port.h"
13 #include "wine/winbase16.h"
22 #include "selectors.h"
23 #include "stackframe.h"
30 #include "debugtools.h"
35 DEFAULT_DEBUG_CHANNEL(task
);
36 DECLARE_DEBUG_CHANNEL(relay
);
37 DECLARE_DEBUG_CHANNEL(toolhelp
);
39 /* Min. number of thunks allocated when creating a new segment */
43 static THHOOK DefaultThhook
;
44 THHOOK
*pThhook
= &DefaultThhook
;
46 #define hCurrentTask (pThhook->CurTDB)
47 #define hFirstTask (pThhook->HeadTDB)
48 #define hLockedTask (pThhook->LockTDB)
50 static UINT16 nTaskCount
= 0;
52 static HTASK initial_task
;
54 /***********************************************************************
57 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
59 THHOOK
*pOldThhook
= pThhook
;
61 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
63 *pThhook
= *pOldThhook
;
66 /***********************************************************************
69 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
71 TDB
* pTask
= TASK_GetPtr( hTask
);
73 if (pTask
->hNext
) return pTask
->hNext
;
74 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
78 /***********************************************************************
81 TDB
*TASK_GetPtr( HTASK16 hTask
)
83 return GlobalLock16( hTask
);
87 /***********************************************************************
90 TDB
*TASK_GetCurrent(void)
92 return TASK_GetPtr( GetCurrentTask() );
96 /***********************************************************************
99 static void TASK_LinkTask( HTASK16 hTask
)
104 if (!(pTask
= TASK_GetPtr( hTask
))) return;
105 prevTask
= &hFirstTask
;
108 TDB
*prevTaskPtr
= TASK_GetPtr( *prevTask
);
109 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
110 prevTask
= &prevTaskPtr
->hNext
;
112 pTask
->hNext
= *prevTask
;
118 /***********************************************************************
121 static void TASK_UnlinkTask( HTASK16 hTask
)
126 prevTask
= &hFirstTask
;
127 while (*prevTask
&& (*prevTask
!= hTask
))
129 pTask
= TASK_GetPtr( *prevTask
);
130 prevTask
= &pTask
->hNext
;
134 pTask
= TASK_GetPtr( *prevTask
);
135 *prevTask
= pTask
->hNext
;
142 /***********************************************************************
145 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
146 * and containing 'count' entries.
148 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
154 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
156 pThunk
->magic
= THUNK_MAGIC
;
157 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
159 for (i
= 0; i
< count
-1; i
++)
161 free
+= 8; /* Offset of next thunk */
162 pThunk
->thunks
[4*i
] = free
;
164 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
168 /***********************************************************************
171 * Allocate a thunk for MakeProcInstance().
173 static SEGPTR
TASK_AllocThunk(void)
179 if (!(pTask
= TASK_GetCurrent())) return 0;
180 sel
= pTask
->hCSAlias
;
181 pThunk
= &pTask
->thunks
;
182 base
= (int)pThunk
- (int)pTask
;
183 while (!pThunk
->free
)
186 if (!sel
) /* Allocate a new segment */
188 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
189 pTask
->hPDB
, WINE_LDT_FLAGS_CODE
);
190 if (!sel
) return (SEGPTR
)0;
191 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
194 pThunk
= (THUNKS
*)GlobalLock16( sel
);
197 base
+= pThunk
->free
;
198 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
199 return MAKESEGPTR( sel
, base
);
203 /***********************************************************************
206 * Free a MakeProcInstance() thunk.
208 static BOOL
TASK_FreeThunk( SEGPTR thunk
)
214 if (!(pTask
= TASK_GetCurrent())) return 0;
215 sel
= pTask
->hCSAlias
;
216 pThunk
= &pTask
->thunks
;
217 base
= (int)pThunk
- (int)pTask
;
218 while (sel
&& (sel
!= HIWORD(thunk
)))
221 pThunk
= (THUNKS
*)GlobalLock16( sel
);
224 if (!sel
) return FALSE
;
225 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
226 pThunk
->free
= LOWORD(thunk
) - base
;
231 /***********************************************************************
234 * NOTE: This routine might be called by a Win32 thread. Thus, we need
235 * to be careful to protect global data structures. We do this
236 * by entering the Win16Lock while linking the task into the
239 static TDB
*TASK_Create( NE_MODULE
*pModule
, UINT16 cmdShow
, TEB
*teb
, LPCSTR cmdline
, BYTE len
)
245 /* Allocate the task structure */
247 hTask
= GlobalAlloc16( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
) );
248 if (!hTask
) return NULL
;
249 pTask
= TASK_GetPtr( hTask
);
250 FarSetOwner16( hTask
, pModule
->self
);
252 /* Fill the task structure */
254 pTask
->hSelf
= hTask
;
256 if (teb
&& teb
->tibflags
& TEBF_WIN32
)
258 pTask
->flags
|= TDBF_WIN32
;
259 pTask
->hInstance
= pModule
->self
;
260 pTask
->hPrevInstance
= 0;
261 /* NOTE: for 16-bit tasks, the instance handles are updated later on
265 pTask
->version
= pModule
->expected_version
;
266 pTask
->hModule
= pModule
->self
;
267 pTask
->hParent
= GetCurrentTask();
268 pTask
->magic
= TDB_MAGIC
;
269 pTask
->nCmdShow
= cmdShow
;
271 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
272 strcpy( pTask
->curdir
, "\\" );
273 lstrcpynA( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
274 sizeof(pTask
->curdir
) - 1 );
276 /* Create the thunks block */
278 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
280 /* Copy the module name */
282 GetModuleName16( pModule
->self
, name
, sizeof(name
) );
283 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
285 /* Allocate a selector for the PDB */
287 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB16
),
288 pModule
->self
, WINE_LDT_FLAGS_DATA
);
292 pTask
->pdb
.int20
= 0x20cd;
293 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
294 PUT_UA_DWORD(&pTask
->pdb
.dispatcher
[1],
295 (DWORD
)GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" ));
296 pTask
->pdb
.savedint22
= INT_GetPMHandler( 0x22 );
297 pTask
->pdb
.savedint23
= INT_GetPMHandler( 0x23 );
298 pTask
->pdb
.savedint24
= INT_GetPMHandler( 0x24 );
299 pTask
->pdb
.fileHandlesPtr
=
300 MAKESEGPTR( GlobalHandleToSel16(pTask
->hPDB
), (int)&((PDB16
*)0)->fileHandles
);
301 pTask
->pdb
.hFileHandles
= 0;
302 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
303 /* FIXME: should we make a copy of the environment? */
304 pTask
->pdb
.environment
= SELECTOROF(GetDOSEnvironment16());
305 pTask
->pdb
.nbFiles
= 20;
307 /* Fill the command line */
311 cmdline
= GetCommandLineA();
312 /* remove the first word (program name) */
314 if (!(cmdline
= strchr( cmdline
+1, '"' ))) cmdline
= GetCommandLineA();
315 while (*cmdline
&& (*cmdline
!= ' ') && (*cmdline
!= '\t')) cmdline
++;
316 while ((*cmdline
== ' ') || (*cmdline
== '\t')) cmdline
++;
317 len
= strlen(cmdline
);
319 if (len
>= sizeof(pTask
->pdb
.cmdLine
)) len
= sizeof(pTask
->pdb
.cmdLine
)-1;
320 pTask
->pdb
.cmdLine
[0] = len
;
321 memcpy( pTask
->pdb
.cmdLine
+ 1, cmdline
, len
);
322 /* pTask->pdb.cmdLine[len+1] = 0; */
324 TRACE("module='%s' cmdline='%.*s' task=%04x\n", name
, len
, cmdline
, hTask
);
326 /* Get the compatibility flags */
328 pTask
->compat_flags
= GetProfileIntA( "Compatibility", name
, 0 );
330 /* Allocate a code segment alias for the TDB */
332 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
333 sizeof(TDB
), pTask
->hPDB
, WINE_LDT_FLAGS_CODE
);
335 /* Default DTA overwrites command line */
337 pTask
->dta
= MAKESEGPTR( pTask
->hPDB
, (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
339 /* Create scheduler event for 16-bit tasks */
341 if ( !(pTask
->flags
& TDBF_WIN32
) )
342 NtCreateEvent( &pTask
->hEvent
, EVENT_ALL_ACCESS
, NULL
, TRUE
, FALSE
);
344 /* Enter task handle into thread */
346 if (teb
) teb
->htask16
= hTask
;
347 if (!initial_task
) initial_task
= hTask
;
353 /***********************************************************************
356 static void TASK_DeleteTask( HTASK16 hTask
)
361 if (!(pTask
= TASK_GetPtr( hTask
))) return;
364 pTask
->magic
= 0xdead; /* invalidate signature */
366 /* Free the selector aliases */
368 GLOBAL_FreeBlock( pTask
->hCSAlias
);
369 GLOBAL_FreeBlock( pTask
->hPDB
);
371 /* Free the task module */
373 FreeModule16( pTask
->hModule
);
375 /* Free the task structure itself */
377 GlobalFree16( hTask
);
379 /* Free all memory used by this task (including the 32-bit stack, */
380 /* the environment block and the thunk segments). */
382 GlobalFreeAll16( hPDB
);
386 /***********************************************************************
387 * TASK_CreateMainTask
389 * Create a task for the main (32-bit) process.
391 void TASK_CreateMainTask(void)
394 STARTUPINFOA startup_info
;
395 UINT cmdShow
= 1; /* SW_SHOWNORMAL but we don't want to include winuser.h here */
397 GetStartupInfoA( &startup_info
);
398 if (startup_info
.dwFlags
& STARTF_USESHOWWINDOW
) cmdShow
= startup_info
.wShowWindow
;
399 pTask
= TASK_Create( (NE_MODULE
*)GlobalLock16( MapHModuleLS(GetModuleHandleA(0)) ),
400 cmdShow
, NtCurrentTeb(), NULL
, 0 );
403 ERR("could not create task for main process\n");
407 /* Add the task to the linked list */
408 /* (no need to get the win16 lock, we are the only thread at this point) */
409 TASK_LinkTask( pTask
->hSelf
);
413 /* startup routine for a new 16-bit thread */
414 static DWORD CALLBACK
task_start( TDB
*pTask
)
418 NtCurrentTeb()->tibflags
&= ~TEBF_WIN32
;
419 NtCurrentTeb()->htask16
= pTask
->hSelf
;
422 TASK_LinkTask( pTask
->hSelf
);
423 pTask
->teb
= NtCurrentTeb();
424 ret
= NE_StartTask();
430 /***********************************************************************
433 * Spawn a new 16-bit task.
435 HTASK
TASK_SpawnTask( NE_MODULE
*pModule
, WORD cmdShow
, LPCSTR cmdline
, BYTE len
, HANDLE
*hThread
)
439 if (!(pTask
= TASK_Create( pModule
, cmdShow
, NULL
, cmdline
, len
))) return 0;
440 if (!(*hThread
= CreateThread( NULL
, 0, (LPTHREAD_START_ROUTINE
)task_start
, pTask
, 0, NULL
)))
442 TASK_DeleteTask( pTask
->hSelf
);
449 /***********************************************************************
452 void TASK_ExitTask(void)
457 /* Enter the Win16Lock to protect global data structures */
460 pTask
= TASK_GetCurrent();
467 TRACE("Killing task %04x\n", pTask
->hSelf
);
469 /* Perform USER cleanup */
471 TASK_CallTaskSignalProc( USIG16_TERMINATION
, pTask
->hSelf
);
472 PROCESS_CallUserSignalProc( USIG_PROCESS_EXIT
, 0 );
473 PROCESS_CallUserSignalProc( USIG_THREAD_EXIT
, 0 );
474 PROCESS_CallUserSignalProc( USIG_PROCESS_DESTROY
, 0 );
476 /* Remove the task from the list to be sure we never switch back to it */
477 TASK_UnlinkTask( pTask
->hSelf
);
479 if (!nTaskCount
|| (nTaskCount
== 1 && hFirstTask
== initial_task
))
481 TRACE("this is the last task, exiting\n" );
487 TDB
* p
= TASK_GetPtr( hFirstTask
);
490 if( p
->hYieldTo
== pTask
->hSelf
) p
->hYieldTo
= 0;
491 p
= TASK_GetPtr( p
->hNext
);
497 if ( hLockedTask
== pTask
->hSelf
)
500 TASK_DeleteTask( pTask
->hSelf
);
502 /* ... and completely release the Win16Lock, just in case. */
503 ReleaseThunkLock( &lockCount
);
507 /***********************************************************************
508 * InitTask (KERNEL.91)
510 * Called by the application startup code.
512 void WINAPI
InitTask16( CONTEXT86
*context
)
515 INSTANCEDATA
*pinstance
;
519 if (!(pTask
= TASK_GetCurrent())) return;
521 /* Note: we need to trust that BX/CX contain the stack/heap sizes,
522 as some apps, notably Visual Basic apps, *modify* the heap/stack
523 size of the instance data segment before calling InitTask() */
525 /* Initialize the INSTANCEDATA structure */
526 pinstance
= MapSL( MAKESEGPTR(CURRENT_DS
, 0) );
527 pinstance
->stackmin
= OFFSETOF( pTask
->teb
->cur_stack
) + sizeof( STACK16FRAME
);
528 pinstance
->stackbottom
= pinstance
->stackmin
; /* yup, that's right. Confused me too. */
529 pinstance
->stacktop
= ( pinstance
->stackmin
> LOWORD(context
->Ebx
) ?
530 pinstance
->stackmin
- LOWORD(context
->Ebx
) : 0 ) + 150;
532 /* Initialize the local heap */
533 if (LOWORD(context
->Ecx
))
534 LocalInit16( GlobalHandleToSel16(pTask
->hInstance
), 0, LOWORD(context
->Ecx
) );
536 /* Initialize implicitly loaded DLLs */
537 NE_InitializeDLLs( pTask
->hModule
);
538 NE_DllProcessAttach( pTask
->hModule
);
540 /* Registers on return are:
541 * ax 1 if OK, 0 on error
542 * cx stack limit in bytes
543 * dx cmdShow parameter
544 * si instance handle of the previous instance
545 * di instance handle of the new task
546 * es:bx pointer to command line inside PSP
548 * 0 (=%bp) is pushed on the stack
550 ptr
= stack16_push( sizeof(WORD
) );
551 *(WORD
*)MapSL(ptr
) = 0;
556 if (!pTask
->pdb
.cmdLine
[0]) context
->Ebx
= 0x80;
559 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
560 while ((*p
== ' ') || (*p
== '\t')) p
++;
561 context
->Ebx
= 0x80 + (p
- pTask
->pdb
.cmdLine
);
563 context
->Ecx
= pinstance
->stacktop
;
564 context
->Edx
= pTask
->nCmdShow
;
565 context
->Esi
= (DWORD
)pTask
->hPrevInstance
;
566 context
->Edi
= (DWORD
)pTask
->hInstance
;
567 context
->SegEs
= (WORD
)pTask
->hPDB
;
571 /***********************************************************************
572 * WaitEvent (KERNEL.30)
574 BOOL16 WINAPI
WaitEvent16( HTASK16 hTask
)
578 if (!hTask
) hTask
= GetCurrentTask();
579 pTask
= TASK_GetPtr( hTask
);
581 if (pTask
->flags
& TDBF_WIN32
)
583 FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
587 if (pTask
->nEvents
> 0)
593 if (pTask
->teb
== NtCurrentTeb())
597 NtResetEvent( pTask
->hEvent
, NULL
);
598 ReleaseThunkLock( &lockCount
);
599 SYSLEVEL_CheckNotLevel( 1 );
600 WaitForSingleObject( pTask
->hEvent
, INFINITE
);
601 RestoreThunkLock( lockCount
);
602 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
604 else FIXME("for other task %04x cur=%04x\n",pTask
->hSelf
,GetCurrentTask());
610 /***********************************************************************
611 * PostEvent (KERNEL.31)
613 void WINAPI
PostEvent16( HTASK16 hTask
)
617 if (!hTask
) hTask
= GetCurrentTask();
618 if (!(pTask
= TASK_GetPtr( hTask
))) return;
620 if (pTask
->flags
& TDBF_WIN32
)
622 FIXME("called for Win32 thread (%04x)!\n", pTask
->teb
->teb_sel
);
628 if (pTask
->nEvents
== 1) NtSetEvent( pTask
->hEvent
, NULL
);
632 /***********************************************************************
633 * SetPriority (KERNEL.32)
635 void WINAPI
SetPriority16( HTASK16 hTask
, INT16 delta
)
640 if (!hTask
) hTask
= GetCurrentTask();
641 if (!(pTask
= TASK_GetPtr( hTask
))) return;
642 newpriority
= pTask
->priority
+ delta
;
643 if (newpriority
< -32) newpriority
= -32;
644 else if (newpriority
> 15) newpriority
= 15;
646 pTask
->priority
= newpriority
+ 1;
647 TASK_UnlinkTask( pTask
->hSelf
);
648 TASK_LinkTask( pTask
->hSelf
);
653 /***********************************************************************
654 * LockCurrentTask (KERNEL.33)
656 HTASK16 WINAPI
LockCurrentTask16( BOOL16 bLock
)
658 if (bLock
) hLockedTask
= GetCurrentTask();
659 else hLockedTask
= 0;
664 /***********************************************************************
665 * IsTaskLocked (KERNEL.122)
667 HTASK16 WINAPI
IsTaskLocked16(void)
673 /***********************************************************************
674 * OldYield (KERNEL.117)
676 void WINAPI
OldYield16(void)
680 ReleaseThunkLock(&count
);
681 RestoreThunkLock(count
);
684 /***********************************************************************
685 * WIN32_OldYield16 (KERNEL.447)
687 void WINAPI
WIN32_OldYield16(void)
691 ReleaseThunkLock(&count
);
692 RestoreThunkLock(count
);
695 /***********************************************************************
696 * DirectedYield (KERNEL.150)
698 void WINAPI
DirectedYield16( HTASK16 hTask
)
700 TDB
*pCurTask
= TASK_GetCurrent();
702 if (pCurTask
->flags
& TDBF_WIN32
)
704 FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
708 TRACE("%04x: DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
710 pCurTask
->hYieldTo
= hTask
;
713 TRACE("%04x: back from DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
716 /***********************************************************************
717 * Yield16 (KERNEL.29)
719 void WINAPI
Yield16(void)
721 TDB
*pCurTask
= TASK_GetCurrent();
723 if (pCurTask
) pCurTask
->hYieldTo
= 0;
724 if (pCurTask
&& pCurTask
->hQueue
&& Callout
.UserYield16
) Callout
.UserYield16();
728 /***********************************************************************
729 * KERNEL_490 (KERNEL.490)
731 HTASK16 WINAPI
KERNEL_490( HTASK16 someTask
)
733 if ( !someTask
) return 0;
735 FIXME("(%04x): stub\n", someTask
);
739 /***********************************************************************
740 * MakeProcInstance16 (KERNEL.51)
742 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
746 WORD hInstanceSelector
;
748 hInstanceSelector
= GlobalHandleToSel16(hInstance
);
750 TRACE("(%08lx, %04x);\n", (DWORD
)func
, hInstance
);
753 /* Win95 actually protects via SEH, but this is better for debugging */
754 WARN("Ouch ! Called with invalid func 0x%08lx !\n", (DWORD
)func
);
760 if ( (!(hInstance
& 4)) ||
761 ((hInstance
!= 0xffff) && IS_SELECTOR_FREE(hInstance
|7)) )
763 WARN("Invalid hInstance (%04x) passed to MakeProcInstance !\n",
769 if ( (GlobalHandleToSel16(CURRENT_DS
) != hInstanceSelector
)
771 && (hInstance
!= 0xffff) )
773 /* calling MPI with a foreign DSEG is invalid ! */
774 WARN("Problem with hInstance? Got %04x, using %04x instead\n",
775 hInstance
,CURRENT_DS
);
778 /* Always use the DSEG that MPI was entered with.
779 * We used to set hInstance to GetTaskDS16(), but this should be wrong
780 * as CURRENT_DS provides the DSEG value we need.
781 * ("calling" DS, *not* "task" DS !) */
782 hInstanceSelector
= CURRENT_DS
;
783 hInstance
= GlobalHandle16(hInstanceSelector
);
785 /* no thunking for DLLs */
786 if (NE_GetPtr(FarGetOwner16(hInstance
))->flags
& NE_FFLAGS_LIBMODULE
)
789 thunkaddr
= TASK_AllocThunk();
790 if (!thunkaddr
) return (FARPROC16
)0;
791 thunk
= MapSL( thunkaddr
);
792 lfunc
= MapSL( (SEGPTR
)func
);
794 TRACE("(%08lx,%04x): got thunk %08lx\n",
795 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
796 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) || /* movw %ds, %ax */
797 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58)) /* pushw %ds, popw %ax */
799 WARN("This was the (in)famous \"thunk useless\" warning. We thought we have to overwrite with nop;nop;, but this isn't true.\n");
802 *thunk
++ = 0xb8; /* movw instance, %ax */
803 *thunk
++ = (BYTE
)(hInstanceSelector
& 0xff);
804 *thunk
++ = (BYTE
)(hInstanceSelector
>> 8);
805 *thunk
++ = 0xea; /* ljmp func */
806 *(DWORD
*)thunk
= (DWORD
)func
;
807 return (FARPROC16
)thunkaddr
;
808 /* CX reg indicates if thunkaddr != NULL, implement if needed */
812 /***********************************************************************
813 * FreeProcInstance16 (KERNEL.52)
815 void WINAPI
FreeProcInstance16( FARPROC16 func
)
817 TRACE("(%08lx)\n", (DWORD
)func
);
818 TASK_FreeThunk( (SEGPTR
)func
);
821 /**********************************************************************
822 * TASK_GetCodeSegment
824 * Helper function for GetCodeHandle/GetCodeInfo: Retrieve the module
825 * and logical segment number of a given code segment.
827 * 'proc' either *is* already a pair of module handle and segment number,
828 * in which case there's nothing to do. Otherwise, it is a pointer to
829 * a function, and we need to retrieve the code segment. If the pointer
830 * happens to point to a thunk, we'll retrieve info about the code segment
831 * where the function pointed to by the thunk resides, not the thunk itself.
833 * FIXME: if 'proc' is a SNOOP16 return stub, we should retrieve info about
834 * the function the snoop code will return to ...
837 static BOOL
TASK_GetCodeSegment( FARPROC16 proc
, NE_MODULE
**ppModule
,
838 SEGTABLEENTRY
**ppSeg
, int *pSegNr
)
840 NE_MODULE
*pModule
= NULL
;
841 SEGTABLEENTRY
*pSeg
= NULL
;
844 /* Try pair of module handle / segment number */
845 pModule
= (NE_MODULE
*) GlobalLock16( HIWORD( proc
) );
846 if ( pModule
&& pModule
->magic
== IMAGE_OS2_SIGNATURE
)
848 segNr
= LOWORD( proc
);
849 if ( segNr
&& segNr
<= pModule
->seg_count
)
850 pSeg
= NE_SEG_TABLE( pModule
) + segNr
-1;
853 /* Try thunk or function */
856 BYTE
*thunk
= MapSL( (SEGPTR
)proc
);
859 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
860 selector
= thunk
[6] + (thunk
[7] << 8);
862 selector
= HIWORD( proc
);
864 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
865 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
868 for ( segNr
= 1; segNr
<= pModule
->seg_count
; segNr
++, pSeg
++ )
869 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
872 if ( pModule
&& segNr
> pModule
->seg_count
)
876 /* Abort if segment not found */
878 if ( !pModule
|| !pSeg
)
881 /* Return segment data */
883 if ( ppModule
) *ppModule
= pModule
;
884 if ( ppSeg
) *ppSeg
= pSeg
;
885 if ( pSegNr
) *pSegNr
= segNr
;
890 /**********************************************************************
891 * GetCodeHandle (KERNEL.93)
893 HANDLE16 WINAPI
GetCodeHandle16( FARPROC16 proc
)
897 if ( !TASK_GetCodeSegment( proc
, NULL
, &pSeg
, NULL
) )
903 /**********************************************************************
904 * GetCodeInfo (KERNEL.104)
906 BOOL16 WINAPI
GetCodeInfo16( FARPROC16 proc
, SEGINFO
*segInfo
)
912 if ( !TASK_GetCodeSegment( proc
, &pModule
, &pSeg
, &segNr
) )
915 /* Fill in segment information */
917 segInfo
->offSegment
= pSeg
->filepos
;
918 segInfo
->cbSegment
= pSeg
->size
;
919 segInfo
->flags
= pSeg
->flags
;
920 segInfo
->cbAlloc
= pSeg
->minsize
;
921 segInfo
->h
= pSeg
->hSeg
;
922 segInfo
->alignShift
= pModule
->alignment
;
924 if ( segNr
== pModule
->dgroup
)
925 segInfo
->cbAlloc
+= pModule
->heap_size
+ pModule
->stack_size
;
927 /* Return module handle in %es */
929 CURRENT_STACK16
->es
= GlobalHandleToSel16( pModule
->self
);
935 /**********************************************************************
936 * DefineHandleTable16 (KERNEL.94)
938 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
940 FIXME("(%04x): stub ?\n", wOffset
);
945 /***********************************************************************
946 * SetTaskQueue (KERNEL.34)
948 HQUEUE16 WINAPI
SetTaskQueue16( HTASK16 hTask
, HQUEUE16 hQueue
)
953 if (!hTask
) hTask
= GetCurrentTask();
954 if (!(pTask
= TASK_GetPtr( hTask
))) return 0;
956 hPrev
= pTask
->hQueue
;
957 pTask
->hQueue
= hQueue
;
963 /***********************************************************************
964 * GetTaskQueue (KERNEL.35)
966 HQUEUE16 WINAPI
GetTaskQueue16( HTASK16 hTask
)
970 if (!hTask
) hTask
= GetCurrentTask();
971 if (!(pTask
= TASK_GetPtr( hTask
))) return 0;
972 return pTask
->hQueue
;
975 /***********************************************************************
976 * SetThreadQueue (KERNEL.463)
978 HQUEUE16 WINAPI
SetThreadQueue16( DWORD thread
, HQUEUE16 hQueue
)
980 TEB
*teb
= thread
? THREAD_IdToTEB( thread
) : NtCurrentTeb();
981 HQUEUE16 oldQueue
= teb
? teb
->queue
: 0;
987 if ( GetTaskQueue16( teb
->htask16
) == oldQueue
)
988 SetTaskQueue16( teb
->htask16
, hQueue
);
994 /***********************************************************************
995 * GetThreadQueue (KERNEL.464)
997 HQUEUE16 WINAPI
GetThreadQueue16( DWORD thread
)
1001 teb
= NtCurrentTeb();
1002 else if ( HIWORD(thread
) )
1003 teb
= THREAD_IdToTEB( thread
);
1004 else if ( IsTask16( (HTASK16
)thread
) )
1005 teb
= (TASK_GetPtr( (HANDLE16
)thread
))->teb
;
1007 return (HQUEUE16
)(teb
? teb
->queue
: 0);
1010 /***********************************************************************
1011 * SetFastQueue (KERNEL.624)
1013 VOID WINAPI
SetFastQueue16( DWORD thread
, HANDLE hQueue
)
1017 teb
= NtCurrentTeb();
1018 else if ( HIWORD(thread
) )
1019 teb
= THREAD_IdToTEB( thread
);
1020 else if ( IsTask16( (HTASK16
)thread
) )
1021 teb
= (TASK_GetPtr( (HANDLE16
)thread
))->teb
;
1023 if ( teb
) teb
->queue
= (HQUEUE16
) hQueue
;
1026 /***********************************************************************
1027 * GetFastQueue (KERNEL.625)
1029 HANDLE WINAPI
GetFastQueue16( void )
1031 TEB
*teb
= NtCurrentTeb();
1036 if (!Callout
.InitThreadInput16
)
1038 THUNK_InitCallout();
1039 if (!Callout
.InitThreadInput16
)
1041 FIXME("InitThreadInput16 callout not found, trouble ahead\n");
1045 Callout
.InitThreadInput16( 0, (teb
->tibflags
& TEBF_WIN32
) ? 5 : 4 );
1048 FIXME("(): should initialize thread-local queue, expect failure!\n" );
1051 return (HANDLE
)teb
->queue
;
1054 /***********************************************************************
1055 * SwitchStackTo (KERNEL.108)
1057 void WINAPI
SwitchStackTo16( WORD seg
, WORD ptr
, WORD top
)
1060 STACK16FRAME
*oldFrame
, *newFrame
;
1061 INSTANCEDATA
*pData
;
1064 if (!(pTask
= TASK_GetCurrent())) return;
1065 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1066 TRACE("old=%04x:%04x new=%04x:%04x\n",
1067 SELECTOROF( pTask
->teb
->cur_stack
),
1068 OFFSETOF( pTask
->teb
->cur_stack
), seg
, ptr
);
1070 /* Save the old stack */
1072 oldFrame
= THREAD_STACK16( pTask
->teb
);
1073 /* pop frame + args and push bp */
1074 pData
->old_ss_sp
= pTask
->teb
->cur_stack
+ sizeof(STACK16FRAME
)
1076 *(WORD
*)MapSL(pData
->old_ss_sp
) = oldFrame
->bp
;
1077 pData
->stacktop
= top
;
1078 pData
->stackmin
= ptr
;
1079 pData
->stackbottom
= ptr
;
1081 /* Switch to the new stack */
1083 /* Note: we need to take the 3 arguments into account; otherwise,
1084 * the stack will underflow upon return from this function.
1086 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1087 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1088 pTask
->teb
->cur_stack
= MAKESEGPTR( seg
, ptr
- copySize
);
1089 newFrame
= THREAD_STACK16( pTask
->teb
);
1091 /* Copy the stack frame and the local variables to the new stack */
1093 memmove( newFrame
, oldFrame
, copySize
);
1095 *(WORD
*)MapSL( MAKESEGPTR( seg
, ptr
) ) = 0; /* clear previous bp */
1099 /***********************************************************************
1100 * SwitchStackBack (KERNEL.109)
1102 void WINAPI
SwitchStackBack16( CONTEXT86
*context
)
1104 STACK16FRAME
*oldFrame
, *newFrame
;
1105 INSTANCEDATA
*pData
;
1107 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(NtCurrentTeb()->cur_stack
))))
1109 if (!pData
->old_ss_sp
)
1111 WARN("No previous SwitchStackTo\n" );
1114 TRACE("restoring stack %04x:%04x\n",
1115 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1117 oldFrame
= CURRENT_STACK16
;
1119 /* Pop bp from the previous stack */
1121 BP_reg(context
) = *(WORD
*)MapSL(pData
->old_ss_sp
);
1122 pData
->old_ss_sp
+= sizeof(WORD
);
1124 /* Switch back to the old stack */
1126 NtCurrentTeb()->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1127 context
->SegSs
= SELECTOROF(pData
->old_ss_sp
);
1128 context
->Esp
= OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1129 pData
->old_ss_sp
= 0;
1131 /* Build a stack frame for the return */
1133 newFrame
= CURRENT_STACK16
;
1134 newFrame
->frame32
= oldFrame
->frame32
;
1135 newFrame
->module_cs
= oldFrame
->module_cs
;
1136 newFrame
->callfrom_ip
= oldFrame
->callfrom_ip
;
1137 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1141 /***********************************************************************
1142 * GetTaskQueueDS16 (KERNEL.118)
1144 void WINAPI
GetTaskQueueDS16(void)
1146 CURRENT_STACK16
->ds
= GlobalHandleToSel16( GetTaskQueue16(0) );
1150 /***********************************************************************
1151 * GetTaskQueueES16 (KERNEL.119)
1153 void WINAPI
GetTaskQueueES16(void)
1155 CURRENT_STACK16
->es
= GlobalHandleToSel16( GetTaskQueue16(0) );
1159 /***********************************************************************
1160 * GetCurrentTask (KERNEL.36)
1162 HTASK16 WINAPI
GetCurrentTask(void)
1164 return NtCurrentTeb()->htask16
;
1167 DWORD WINAPI
WIN16_GetCurrentTask(void)
1169 /* This is the version used by relay code; the first task is */
1170 /* returned in the high word of the result */
1171 return MAKELONG( GetCurrentTask(), hFirstTask
);
1175 /***********************************************************************
1176 * GetCurrentPDB (KERNEL.37)
1178 * UNDOC: returns PSP of KERNEL in high word
1180 DWORD WINAPI
GetCurrentPDB16(void)
1184 if (!(pTask
= TASK_GetCurrent())) return 0;
1185 return MAKELONG(pTask
->hPDB
, 0); /* FIXME */
1189 /***********************************************************************
1190 * GetCurPID16 (KERNEL.157)
1192 DWORD WINAPI
GetCurPID16( DWORD unused
)
1198 /***********************************************************************
1199 * GetInstanceData (KERNEL.54)
1201 INT16 WINAPI
GetInstanceData16( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1203 char *ptr
= (char *)GlobalLock16( instance
);
1204 if (!ptr
|| !len
) return 0;
1205 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1206 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1211 /***********************************************************************
1212 * GetExeVersion (KERNEL.105)
1214 WORD WINAPI
GetExeVersion16(void)
1218 if (!(pTask
= TASK_GetCurrent())) return 0;
1219 return pTask
->version
;
1223 /***********************************************************************
1224 * SetErrorMode16 (KERNEL.107)
1226 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1229 if (!(pTask
= TASK_GetCurrent())) return 0;
1230 pTask
->error_mode
= mode
;
1231 return SetErrorMode( mode
);
1235 /***********************************************************************
1236 * GetNumTasks (KERNEL.152)
1238 UINT16 WINAPI
GetNumTasks16(void)
1244 /***********************************************************************
1245 * GetTaskDS (KERNEL.155)
1247 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1248 * I don't think we need to bother with this.
1250 HINSTANCE16 WINAPI
GetTaskDS16(void)
1254 if (!(pTask
= TASK_GetCurrent())) return 0;
1255 return GlobalHandleToSel16(pTask
->hInstance
);
1258 /***********************************************************************
1259 * GetDummyModuleHandleDS (KERNEL.602)
1261 WORD WINAPI
GetDummyModuleHandleDS16(void)
1266 if (!(pTask
= TASK_GetCurrent())) return 0;
1267 if (!(pTask
->flags
& TDBF_WIN32
)) return 0;
1268 selector
= GlobalHandleToSel16( pTask
->hModule
);
1269 CURRENT_DS
= selector
;
1273 /***********************************************************************
1274 * IsTask (KERNEL.320)
1275 * IsTask16 (KERNEL32.@)
1277 BOOL16 WINAPI
IsTask16( HTASK16 hTask
)
1281 if (!(pTask
= TASK_GetPtr( hTask
))) return FALSE
;
1282 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1283 return (pTask
->magic
== TDB_MAGIC
);
1287 /***********************************************************************
1288 * IsWinOldApTask16 (KERNEL.158)
1290 BOOL16 WINAPI
IsWinOldApTask16( HTASK16 hTask
)
1292 /* should return bit 0 of byte 0x48 in PSP */
1296 /***********************************************************************
1297 * SetTaskSignalProc (KERNEL.38)
1299 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1304 if (!hTask
) hTask
= GetCurrentTask();
1305 if (!(pTask
= TASK_GetPtr( hTask
))) return NULL
;
1306 oldProc
= pTask
->userhandler
;
1307 pTask
->userhandler
= proc
;
1311 /***********************************************************************
1312 * TASK_CallTaskSignalProc
1314 /* ### start build ### */
1315 extern WORD CALLBACK
TASK_CallTo16_word_wwwww(FARPROC16
,WORD
,WORD
,WORD
,WORD
,WORD
);
1316 /* ### stop build ### */
1317 void TASK_CallTaskSignalProc( UINT16 uCode
, HANDLE16 hTaskOrModule
)
1319 TDB
*pTask
= TASK_GetCurrent();
1320 if ( !pTask
|| !pTask
->userhandler
) return;
1322 TASK_CallTo16_word_wwwww( pTask
->userhandler
,
1323 hTaskOrModule
, uCode
, 0,
1324 pTask
->hInstance
, pTask
->hQueue
);
1327 /***********************************************************************
1328 * SetSigHandler (KERNEL.140)
1330 WORD WINAPI
SetSigHandler16( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1331 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1333 FIXME("(%p,%p,%p,%d,%d), unimplemented.\n",
1334 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1336 if (flag
!= 1) return 0;
1337 if (!newmode
) newhandler
= NULL
; /* Default handler */
1342 if (!(pTask
= TASK_GetCurrent())) return 0;
1343 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1344 pTask
->signal_flags
= newmode
;
1345 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1346 pTask
->sighandler
= newhandler
;
1352 /***********************************************************************
1353 * GlobalNotify (KERNEL.154)
1355 * Note that GlobalNotify does _not_ return the old NotifyProc
1356 * -- contrary to LocalNotify !!
1358 VOID WINAPI
GlobalNotify16( FARPROC16 proc
)
1362 if (!(pTask
= TASK_GetCurrent())) return;
1363 pTask
->discardhandler
= proc
;
1367 /***********************************************************************
1368 * GetExePtr (KERNEL.133)
1370 static inline HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1375 /* Check for module handle */
1377 if (!(ptr
= GlobalLock16( handle
))) return 0;
1378 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1380 /* Search for this handle inside all tasks */
1382 *hTask
= hFirstTask
;
1385 TDB
*pTask
= TASK_GetPtr( *hTask
);
1386 if ((*hTask
== handle
) ||
1387 (pTask
->hInstance
== handle
) ||
1388 (pTask
->hQueue
== handle
) ||
1389 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1390 *hTask
= pTask
->hNext
;
1393 /* Check the owner for module handle */
1395 owner
= FarGetOwner16( handle
);
1396 if (!(ptr
= GlobalLock16( owner
))) return 0;
1397 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1399 /* Search for the owner inside all tasks */
1401 *hTask
= hFirstTask
;
1404 TDB
*pTask
= TASK_GetPtr( *hTask
);
1405 if ((*hTask
== owner
) ||
1406 (pTask
->hInstance
== owner
) ||
1407 (pTask
->hQueue
== owner
) ||
1408 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1409 *hTask
= pTask
->hNext
;
1415 /**********************************************************************/
1417 HMODULE16 WINAPI
WIN16_GetExePtr( HANDLE16 handle
)
1420 HMODULE16 hModule
= GetExePtrHelper( handle
, &hTask
);
1421 STACK16FRAME
*frame
= CURRENT_STACK16
;
1422 frame
->ecx
= hModule
;
1423 if (hTask
) frame
->es
= hTask
;
1427 /**********************************************************************/
1429 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1432 return GetExePtrHelper( handle
, &hTask
);
1436 /***********************************************************************
1437 * TaskFirst (TOOLHELP.63)
1439 BOOL16 WINAPI
TaskFirst16( TASKENTRY
*lpte
)
1441 lpte
->hNext
= hFirstTask
;
1442 return TaskNext16( lpte
);
1446 /***********************************************************************
1447 * TaskNext (TOOLHELP.64)
1449 BOOL16 WINAPI
TaskNext16( TASKENTRY
*lpte
)
1452 INSTANCEDATA
*pInstData
;
1454 TRACE_(toolhelp
)("(%p): task=%04x\n", lpte
, lpte
->hNext
);
1455 if (!lpte
->hNext
) return FALSE
;
1457 /* make sure that task and hInstance are valid (skip initial Wine task !) */
1459 pTask
= TASK_GetPtr( lpte
->hNext
);
1460 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1461 if (pTask
->hInstance
)
1463 lpte
->hNext
= pTask
->hNext
;
1465 pInstData
= MapSL( MAKESEGPTR( GlobalHandleToSel16(pTask
->hInstance
), 0 ) );
1466 lpte
->hTask
= lpte
->hNext
;
1467 lpte
->hTaskParent
= pTask
->hParent
;
1468 lpte
->hInst
= pTask
->hInstance
;
1469 lpte
->hModule
= pTask
->hModule
;
1470 lpte
->wSS
= SELECTOROF( pTask
->teb
->cur_stack
);
1471 lpte
->wSP
= OFFSETOF( pTask
->teb
->cur_stack
);
1472 lpte
->wStackTop
= pInstData
->stacktop
;
1473 lpte
->wStackMinimum
= pInstData
->stackmin
;
1474 lpte
->wStackBottom
= pInstData
->stackbottom
;
1475 lpte
->wcEvents
= pTask
->nEvents
;
1476 lpte
->hQueue
= pTask
->hQueue
;
1477 lstrcpynA( lpte
->szModule
, pTask
->module_name
, sizeof(lpte
->szModule
) );
1478 lpte
->wPSPOffset
= 0x100; /*??*/
1479 lpte
->hNext
= pTask
->hNext
;
1484 /***********************************************************************
1485 * TaskFindHandle (TOOLHELP.65)
1487 BOOL16 WINAPI
TaskFindHandle16( TASKENTRY
*lpte
, HTASK16 hTask
)
1489 lpte
->hNext
= hTask
;
1490 return TaskNext16( lpte
);
1494 typedef INT (WINAPI
*MessageBoxA_funcptr
)(HWND hWnd
, LPCSTR text
, LPCSTR title
, UINT type
);
1496 /**************************************************************************
1497 * FatalAppExit16 (KERNEL.137)
1499 void WINAPI
FatalAppExit16( UINT16 action
, LPCSTR str
)
1501 TDB
*pTask
= TASK_GetCurrent();
1503 if (!pTask
|| !(pTask
->error_mode
& SEM_NOGPFAULTERRORBOX
))
1505 HMODULE mod
= GetModuleHandleA( "user32.dll" );
1508 MessageBoxA_funcptr pMessageBoxA
= (MessageBoxA_funcptr
)GetProcAddress( mod
, "MessageBoxA" );
1511 pMessageBoxA( 0, str
, NULL
, MB_SYSTEMMODAL
| MB_OK
);
1515 ERR( "%s\n", debugstr_a(str
) );
1522 /***********************************************************************
1523 * TerminateApp16 (TOOLHELP.77)
1525 * See "Undocumented Windows".
1527 void WINAPI
TerminateApp16(HTASK16 hTask
, WORD wFlags
)
1529 if (hTask
&& hTask
!= GetCurrentTask())
1531 FIXME("cannot terminate task %x\n", hTask
);
1535 if (wFlags
& NO_UAE_BOX
)
1538 old_mode
= SetErrorMode16(0);
1539 SetErrorMode16(old_mode
|SEM_NOGPFAULTERRORBOX
);
1541 FatalAppExit16( 0, NULL
);
1543 /* hmm, we're still alive ?? */
1545 /* check undocumented flag */
1546 if (!(wFlags
& 0x8000))
1547 TASK_CallTaskSignalProc( USIG16_TERMINATION
, hTask
);
1549 /* UndocWin says to call int 0x21/0x4c exit=0xff here,
1550 but let's just call ExitThread */
1555 /***********************************************************************
1556 * GetAppCompatFlags16 (KERNEL.354)
1558 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1560 return GetAppCompatFlags( hTask
);
1564 /***********************************************************************
1565 * GetAppCompatFlags (USER32.@)
1567 DWORD WINAPI
GetAppCompatFlags( HTASK hTask
)
1571 if (!hTask
) hTask
= GetCurrentTask();
1572 if (!(pTask
=TASK_GetPtr( (HTASK16
)hTask
))) return 0;
1573 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1574 return pTask
->compat_flags
;