4 * Copyright 1995 Alexandre Julliard
12 #include "wine/winbase16.h"
27 #include "selectors.h"
28 #include "stackframe.h"
36 #include "debugtools.h"
41 DECLARE_DEBUG_CHANNEL(relay
)
42 DECLARE_DEBUG_CHANNEL(task
)
43 DECLARE_DEBUG_CHANNEL(toolhelp
)
45 /* Min. number of thunks allocated when creating a new segment */
48 /* Pointer to function to switch to a larger stack */
49 int (*IF1632_CallLargeStack
)( int (*func
)(), void *arg
) = NULL
;
51 static THHOOK DefaultThhook
= { 0 };
52 THHOOK
*pThhook
= &DefaultThhook
;
54 #define hCurrentTask (pThhook->CurTDB)
55 #define hFirstTask (pThhook->HeadTDB)
56 #define hLockedTask (pThhook->LockTDB)
58 static UINT16 nTaskCount
= 0;
61 /***********************************************************************
64 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
66 THHOOK
*pOldThhook
= pThhook
;
68 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
70 *pThhook
= *pOldThhook
;
73 /***********************************************************************
76 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
78 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
80 if (pTask
->hNext
) return pTask
->hNext
;
81 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
84 /***********************************************************************
87 static void TASK_LinkTask( HTASK16 hTask
)
92 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
93 prevTask
= &hFirstTask
;
96 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
97 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
98 prevTask
= &prevTaskPtr
->hNext
;
100 pTask
->hNext
= *prevTask
;
106 /***********************************************************************
109 static void TASK_UnlinkTask( HTASK16 hTask
)
114 prevTask
= &hFirstTask
;
115 while (*prevTask
&& (*prevTask
!= hTask
))
117 pTask
= (TDB
*)GlobalLock16( *prevTask
);
118 prevTask
= &pTask
->hNext
;
122 pTask
= (TDB
*)GlobalLock16( *prevTask
);
123 *prevTask
= pTask
->hNext
;
130 /***********************************************************************
133 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
134 * and containing 'count' entries.
136 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
142 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
144 pThunk
->magic
= THUNK_MAGIC
;
145 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
147 for (i
= 0; i
< count
-1; i
++)
149 free
+= 8; /* Offset of next thunk */
150 pThunk
->thunks
[4*i
] = free
;
152 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
156 /***********************************************************************
159 * Allocate a thunk for MakeProcInstance().
161 static SEGPTR
TASK_AllocThunk( HTASK16 hTask
)
167 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
168 sel
= pTask
->hCSAlias
;
169 pThunk
= &pTask
->thunks
;
170 base
= (int)pThunk
- (int)pTask
;
171 while (!pThunk
->free
)
174 if (!sel
) /* Allocate a new segment */
176 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
177 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
178 if (!sel
) return (SEGPTR
)0;
179 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
182 pThunk
= (THUNKS
*)GlobalLock16( sel
);
185 base
+= pThunk
->free
;
186 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
187 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
191 /***********************************************************************
194 * Free a MakeProcInstance() thunk.
196 static BOOL
TASK_FreeThunk( HTASK16 hTask
, SEGPTR thunk
)
202 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
203 sel
= pTask
->hCSAlias
;
204 pThunk
= &pTask
->thunks
;
205 base
= (int)pThunk
- (int)pTask
;
206 while (sel
&& (sel
!= HIWORD(thunk
)))
209 pThunk
= (THUNKS
*)GlobalLock16( sel
);
212 if (!sel
) return FALSE
;
213 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
214 pThunk
->free
= LOWORD(thunk
) - base
;
219 /***********************************************************************
222 * 32-bit entry point for a new task. This function is responsible for
223 * setting up the registers and jumping to the 16-bit entry point.
225 void TASK_CallToStart(void)
227 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
228 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
229 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
232 /* Add task to 16-bit scheduler pool */
235 /* Registers at initialization must be:
237 * bx stack size in bytes
238 * cx heap size in bytes
239 * si previous app instance
240 * di current app instance
242 * es selector to the PSP
243 * ds dgroup of the application
245 * sp top of the stack
248 memset( &context
, 0, sizeof(context
) );
249 CS_reg(&context
) = GlobalHandleToSel16(pSegTable
[pModule
->cs
- 1].hSeg
);
250 DS_reg(&context
) = GlobalHandleToSel16(pTask
->hInstance
);
251 ES_reg(&context
) = pTask
->hPDB
;
252 EIP_reg(&context
) = pModule
->ip
;
253 EBX_reg(&context
) = pModule
->stack_size
;
254 ECX_reg(&context
) = pModule
->heap_size
;
255 EDI_reg(&context
) = pTask
->hInstance
;
256 ESI_reg(&context
) = pTask
->hPrevInstance
;
258 TRACE_(task
)("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
259 CS_reg(&context
), EIP_reg(&context
), DS_reg(&context
),
260 SELECTOROF(pTask
->teb
->cur_stack
),
261 OFFSETOF(pTask
->teb
->cur_stack
) );
263 Callbacks
->CallRegisterShortProc( &context
, 0 );
267 /***********************************************************************
270 * NOTE: This routine might be called by a Win32 thread. Thus, we need
271 * to be careful to protect global data structures. We do this
272 * by entering the Win16Lock while linking the task into the
275 BOOL
TASK_Create( NE_MODULE
*pModule
, UINT16 cmdShow
)
281 PDB
*pdb32
= PROCESS_Current();
283 /* Allocate the task structure */
285 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
286 pModule
->self
, FALSE
, FALSE
, FALSE
);
287 if (!hTask
) return FALSE
;
288 pTask
= (TDB
*)GlobalLock16( hTask
);
290 /* Fill the task structure */
293 pTask
->hSelf
= hTask
;
296 if (pModule
->flags
& NE_FFLAGS_WIN32
)
297 pTask
->flags
|= TDBF_WIN32
;
298 if (pModule
->lpDosTask
)
299 pTask
->flags
|= TDBF_WINOLDAP
;
301 pTask
->hInstance
= pModule
->self
;
302 pTask
->hPrevInstance
= 0;
303 /* NOTE: for 16-bit tasks, the instance handles are updated later on
306 pTask
->version
= pModule
->expected_version
;
307 pTask
->hModule
= pModule
->self
;
308 pTask
->hParent
= GetCurrentTask();
309 pTask
->magic
= TDB_MAGIC
;
310 pTask
->nCmdShow
= cmdShow
;
311 pTask
->teb
= NtCurrentTeb();
312 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
313 strcpy( pTask
->curdir
, "\\" );
314 lstrcpynA( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
315 sizeof(pTask
->curdir
) - 1 );
317 /* Create the thunks block */
319 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
321 /* Copy the module name */
323 GetModuleName16( pModule
->self
, name
, sizeof(name
) );
324 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
326 /* Allocate a selector for the PDB */
328 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB16
),
329 pModule
->self
, FALSE
, FALSE
, FALSE
, NULL
);
333 pTask
->pdb
.int20
= 0x20cd;
334 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
335 PUT_DWORD(&pTask
->pdb
.dispatcher
[1], (DWORD
)NE_GetEntryPoint(
336 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
337 pTask
->pdb
.savedint22
= INT_GetPMHandler( 0x22 );
338 pTask
->pdb
.savedint23
= INT_GetPMHandler( 0x23 );
339 pTask
->pdb
.savedint24
= INT_GetPMHandler( 0x24 );
340 pTask
->pdb
.fileHandlesPtr
=
341 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(pTask
->hPDB
),
342 (int)&((PDB16
*)0)->fileHandles
);
343 pTask
->pdb
.hFileHandles
= 0;
344 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
345 pTask
->pdb
.environment
= pdb32
->env_db
->env_sel
;
346 pTask
->pdb
.nbFiles
= 20;
348 /* Fill the command line */
350 cmd_line
= pdb32
->env_db
->cmd_line
;
351 while (*cmd_line
&& (*cmd_line
!= ' ') && (*cmd_line
!= '\t')) cmd_line
++;
352 while ((*cmd_line
== ' ') || (*cmd_line
== '\t')) cmd_line
++;
353 lstrcpynA( pTask
->pdb
.cmdLine
+1, cmd_line
, sizeof(pTask
->pdb
.cmdLine
)-1);
354 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
356 /* Get the compatibility flags */
358 pTask
->compat_flags
= GetProfileIntA( "Compatibility", name
, 0 );
360 /* Allocate a code segment alias for the TDB */
362 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
363 sizeof(TDB
), pTask
->hPDB
, TRUE
,
364 FALSE
, FALSE
, NULL
);
366 /* Set the owner of the environment block */
368 FarSetOwner16( pTask
->pdb
.environment
, pTask
->hPDB
);
370 /* Default DTA overwrites command-line */
372 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
373 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
375 /* Create scheduler event for 16-bit tasks */
377 if ( !(pTask
->flags
& TDBF_WIN32
) )
379 pTask
->hEvent
= CreateEventA( NULL
, TRUE
, FALSE
, NULL
);
380 pTask
->hEvent
= ConvertToGlobalHandle( pTask
->hEvent
);
383 /* Enter task handle into thread and process */
385 pTask
->teb
->htask16
= pTask
->teb
->process
->task
= hTask
;
386 TRACE_(task
)("module='%s' cmdline='%s' task=%04x\n", name
, cmd_line
, hTask
);
388 /* Add the task to the linked list */
390 SYSLEVEL_EnterWin16Lock();
391 TASK_LinkTask( hTask
);
392 SYSLEVEL_LeaveWin16Lock();
397 /***********************************************************************
400 static void TASK_DeleteTask( HTASK16 hTask
)
405 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
408 pTask
->magic
= 0xdead; /* invalidate signature */
410 /* Delete the Win32 part of the task */
412 /* PROCESS_FreePDB( pTask->teb->process ); FIXME */
413 /* K32OBJ_DecCount( &pTask->teb->header ); FIXME */
415 /* Free the selector aliases */
417 GLOBAL_FreeBlock( pTask
->hCSAlias
);
418 GLOBAL_FreeBlock( pTask
->hPDB
);
420 /* Free the task module */
422 FreeModule16( pTask
->hModule
);
424 /* Free the task structure itself */
426 GlobalFree16( hTask
);
428 /* Free all memory used by this task (including the 32-bit stack, */
429 /* the environment block and the thunk segments). */
431 GlobalFreeAll16( hPDB
);
434 /***********************************************************************
437 void TASK_KillTask( HTASK16 hTask
)
441 /* Enter the Win16Lock to protect global data structures */
442 SYSLEVEL_EnterWin16Lock();
444 if ( !hTask
) hTask
= GetCurrentTask();
445 pTask
= (TDB
*)GlobalLock16( hTask
);
448 SYSLEVEL_LeaveWin16Lock();
452 TRACE_(task
)("Killing task %04x\n", hTask
);
454 /* Delete active sockets */
457 WINSOCK_DeleteTaskWSI( pTask
, pTask
->pwsi
);
461 /* Kill DOS VM task */
462 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
463 if ( pModule
->lpDosTask
)
464 MZ_KillModule( pModule
->lpDosTask
);
468 /* Perform USER cleanup */
470 if (pTask
->userhandler
)
471 pTask
->userhandler( hTask
, USIG16_TERMINATION
, 0,
472 pTask
->hInstance
, pTask
->hQueue
);
474 PROCESS_CallUserSignalProc( USIG_PROCESS_EXIT
, 0 );
475 PROCESS_CallUserSignalProc( USIG_THREAD_EXIT
, 0 ); /* FIXME */
476 PROCESS_CallUserSignalProc( USIG_PROCESS_DESTROY
, 0 );
480 TRACE_(task
)("this is the last task, exiting\n" );
484 /* FIXME: Hack! Send a message to the initial task so that
485 * the GetMessage wakes up and the initial task can check whether
486 * it is the only remaining one and terminate itself ...
487 * The initial task should probably install hooks or something
488 * to get informed about task termination :-/
490 Callout
.PostAppMessage16( PROCESS_Initial()->task
, WM_NULL
, 0, 0 );
492 /* Remove the task from the list to be sure we never switch back to it */
493 TASK_UnlinkTask( hTask
);
496 TDB
* p
= (TDB
*)GlobalLock16( hFirstTask
);
499 if( p
->hYieldTo
== hTask
) p
->hYieldTo
= 0;
500 p
= (TDB
*)GlobalLock16( p
->hNext
);
506 if ( hLockedTask
== hTask
)
509 TASK_DeleteTask( hTask
);
511 /* When deleting the current task ... */
512 if ( hTask
== hCurrentTask
)
516 /* ... schedule another one ... */
519 /* ... and completely release the Win16Lock, just in case. */
520 ReleaseThunkLock( &lockCount
);
525 SYSLEVEL_LeaveWin16Lock();
528 /***********************************************************************
531 * This is where all the magic of task-switching happens!
533 * 16-bit Windows performs non-preemptive (cooperative) multitasking.
534 * This means that each 16-bit task runs until it voluntarily yields
535 * control, at which point the scheduler gets active and selects the
538 * In Wine, all processes, even 16-bit ones, are scheduled preemptively
539 * by the standard scheduler of the underlying OS. As many 16-bit apps
540 * *rely* on the behaviour of the Windows scheduler, however, we have
541 * to simulate that behaviour.
543 * This is achieved as follows: every 16-bit task is at time (except
544 * during task creation and deletion) in one of two states: either it
545 * is the one currently running, then the global variable hCurrentTask
546 * contains its task handle, or it is not currently running, then it
547 * is blocked on a special scheduler event, a global handle to which
548 * is stored in the task struct.
550 * When the current task yields control, this routine gets called. Its
551 * purpose is to determine the next task to be active, signal the
552 * scheduler event of that task, and then put the current task to sleep
553 * waiting for *its* scheduler event to get signalled again.
555 * This routine can get called in a few other special situations as well:
557 * - On creation of a 16-bit task, the Unix process executing the task
558 * calls TASK_Reschedule once it has completed its initialization.
559 * At this point, the task needs to be blocked until its scheduler
560 * event is signalled the first time (this will be done by the parent
561 * process to get the task up and running).
563 * - When the task currently running terminates itself, this routine gets
564 * called and has to schedule another task, *without* blocking the
567 * - When a 32-bit thread posts an event for a 16-bit task, it might be
568 * the case that *no* 16-bit task is currently running. In this case
569 * the task that has now an event pending is to be scheduled.
572 void TASK_Reschedule(void)
574 TDB
*pOldTask
= NULL
, *pNewTask
= NULL
;
575 HTASK16 hOldTask
= 0, hNewTask
= 0;
576 enum { MODE_YIELD
, MODE_SLEEP
, MODE_WAKEUP
} mode
;
579 SYSLEVEL_EnterWin16Lock();
581 /* Check what we need to do */
582 hOldTask
= GetCurrentTask();
583 pOldTask
= (TDB
*)GlobalLock16( hOldTask
);
584 TRACE_(task
)( "entered with hCurrentTask %04x by hTask %04x (pid %ld)\n",
585 hCurrentTask
, hOldTask
, (long) getpid() );
587 if ( pOldTask
&& THREAD_IsWin16( NtCurrentTeb() ) )
589 /* We are called by an active (non-deleted) 16-bit task */
591 /* If we don't even have a current task, or else the current
592 task has yielded, we'll need to schedule a new task and
593 (possibly) put the calling task to sleep. Otherwise, we
594 only block the caller. */
596 if ( !hCurrentTask
|| hCurrentTask
== hOldTask
)
603 /* We are called by a deleted 16-bit task or a 32-bit thread */
605 /* The only situation where we need to do something is if we
606 now do not have a current task. Then, we'll need to wake up
607 some task that has events pending. */
609 if ( !hCurrentTask
|| hCurrentTask
== hOldTask
)
614 SYSLEVEL_LeaveWin16Lock();
619 /* Find a task to yield to: check for DirectedYield() */
620 if ( mode
== MODE_YIELD
&& pOldTask
&& pOldTask
->hYieldTo
)
622 hNewTask
= pOldTask
->hYieldTo
;
623 pNewTask
= (TDB
*)GlobalLock16( hNewTask
);
624 if( !pNewTask
|| !pNewTask
->nEvents
) hNewTask
= 0;
625 pOldTask
->hYieldTo
= 0;
628 /* Find a task to yield to: check for pending events */
629 if ( (mode
== MODE_YIELD
|| mode
== MODE_WAKEUP
) && !hNewTask
)
631 hNewTask
= hFirstTask
;
634 pNewTask
= (TDB
*)GlobalLock16( hNewTask
);
636 TRACE_(task
)( "\ttask = %04x, events = %i\n",
637 hNewTask
, pNewTask
->nEvents
);
639 if (pNewTask
->nEvents
) break;
640 hNewTask
= pNewTask
->hNext
;
642 if (hLockedTask
&& (hNewTask
!= hLockedTask
)) hNewTask
= 0;
645 /* If we are still the task with highest priority, just return ... */
646 if ( mode
== MODE_YIELD
&& hNewTask
== hCurrentTask
)
648 TRACE_(task
)("returning to the current task (%04x)\n", hCurrentTask
);
649 SYSLEVEL_LeaveWin16Lock();
651 /* Allow Win32 threads to thunk down even while a Win16 task is
652 in a tight PeekMessage() or Yield() loop ... */
653 ReleaseThunkLock( &lockCount
);
654 RestoreThunkLock( lockCount
);
658 /* If no task to yield to found, suspend 16-bit scheduler ... */
659 if ( mode
== MODE_YIELD
&& !hNewTask
)
661 TRACE_(task
)("No currently active task\n");
665 /* If we found a task to wake up, do it ... */
666 if ( (mode
== MODE_YIELD
|| mode
== MODE_WAKEUP
) && hNewTask
)
668 TRACE_(task
)("Switching to task %04x (%.8s)\n",
669 hNewTask
, pNewTask
->module_name
);
671 pNewTask
->priority
++;
672 TASK_UnlinkTask( hNewTask
);
673 TASK_LinkTask( hNewTask
);
674 pNewTask
->priority
--;
676 hCurrentTask
= hNewTask
;
677 SetEvent( pNewTask
->hEvent
);
679 /* This is set just in case some app reads it ... */
680 pNewTask
->ss_sp
= pNewTask
->teb
->cur_stack
;
683 /* If we need to put the current task to sleep, do it ... */
684 if ( (mode
== MODE_YIELD
|| mode
== MODE_SLEEP
) && hOldTask
!= hCurrentTask
)
686 ResetEvent( pOldTask
->hEvent
);
688 ReleaseThunkLock( &lockCount
);
689 SYSLEVEL_CheckNotLevel( 1 );
690 WaitForSingleObject( pOldTask
->hEvent
, INFINITE
);
691 RestoreThunkLock( lockCount
);
694 SYSLEVEL_LeaveWin16Lock();
697 /***********************************************************************
698 * InitTask (KERNEL.91)
700 * Called by the application startup code.
702 void WINAPI
InitTask16( CONTEXT86
*context
)
705 INSTANCEDATA
*pinstance
;
708 EAX_reg(context
) = 0;
709 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
711 /* Note: we need to trust that BX/CX contain the stack/heap sizes,
712 as some apps, notably Visual Basic apps, *modify* the heap/stack
713 size of the instance data segment before calling InitTask() */
715 /* Initialize the INSTANCEDATA structure */
716 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
717 pinstance
->stackmin
= OFFSETOF( pTask
->teb
->cur_stack
);
718 pinstance
->stackbottom
= pinstance
->stackmin
; /* yup, that's right. Confused me too. */
719 pinstance
->stacktop
= ( pinstance
->stackmin
> BX_reg(context
)?
720 pinstance
->stackmin
- BX_reg(context
) : 0 ) + 150;
722 /* Initialize the local heap */
723 if ( CX_reg(context
) )
724 LocalInit16( pTask
->hInstance
, 0, CX_reg(context
) );
726 /* Initialize implicitly loaded DLLs */
727 NE_InitializeDLLs( pTask
->hModule
);
729 /* Registers on return are:
730 * ax 1 if OK, 0 on error
731 * cx stack limit in bytes
732 * dx cmdShow parameter
733 * si instance handle of the previous instance
734 * di instance handle of the new task
735 * es:bx pointer to command-line inside PSP
737 * 0 (=%bp) is pushed on the stack
739 ptr
= stack16_push( sizeof(WORD
) );
740 *(WORD
*)PTR_SEG_TO_LIN(ptr
) = 0;
741 ESP_reg(context
) -= 2;
743 EAX_reg(context
) = 1;
745 if (!pTask
->pdb
.cmdLine
[0]) EBX_reg(context
) = 0x80;
748 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
749 while ((*p
== ' ') || (*p
== '\t')) p
++;
750 EBX_reg(context
) = 0x80 + (p
- pTask
->pdb
.cmdLine
);
752 ECX_reg(context
) = pinstance
->stacktop
;
753 EDX_reg(context
) = pTask
->nCmdShow
;
754 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
755 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
756 ES_reg (context
) = (WORD
)pTask
->hPDB
;
760 /***********************************************************************
761 * WaitEvent (KERNEL.30)
763 BOOL16 WINAPI
WaitEvent16( HTASK16 hTask
)
767 if (!hTask
) hTask
= GetCurrentTask();
768 pTask
= (TDB
*)GlobalLock16( hTask
);
770 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
772 FIXME_(task
)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
776 if (pTask
->nEvents
> 0)
783 /* When we get back here, we have an event */
785 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
790 /***********************************************************************
791 * PostEvent (KERNEL.31)
793 void WINAPI
PostEvent16( HTASK16 hTask
)
797 if (!hTask
) hTask
= GetCurrentTask();
798 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
800 if ( !THREAD_IsWin16( pTask
->teb
) )
802 FIXME_(task
)("called for Win32 thread (%04x)!\n", pTask
->teb
->teb_sel
);
808 /* If we are a 32-bit task, we might need to wake up the 16-bit scheduler */
809 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
814 /***********************************************************************
815 * SetPriority (KERNEL.32)
817 void WINAPI
SetPriority16( HTASK16 hTask
, INT16 delta
)
822 if (!hTask
) hTask
= GetCurrentTask();
823 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
824 newpriority
= pTask
->priority
+ delta
;
825 if (newpriority
< -32) newpriority
= -32;
826 else if (newpriority
> 15) newpriority
= 15;
828 pTask
->priority
= newpriority
+ 1;
829 TASK_UnlinkTask( hTask
);
830 TASK_LinkTask( hTask
);
835 /***********************************************************************
836 * LockCurrentTask (KERNEL.33)
838 HTASK16 WINAPI
LockCurrentTask16( BOOL16 bLock
)
840 if (bLock
) hLockedTask
= GetCurrentTask();
841 else hLockedTask
= 0;
846 /***********************************************************************
847 * IsTaskLocked (KERNEL.122)
849 HTASK16 WINAPI
IsTaskLocked16(void)
855 /***********************************************************************
856 * OldYield (KERNEL.117)
858 void WINAPI
OldYield16(void)
860 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
862 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
864 FIXME_(task
)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
868 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
870 if (pCurTask
) pCurTask
->nEvents
--;
873 /***********************************************************************
874 * WIN32_OldYield16 (KERNEL.447)
876 void WINAPI
WIN32_OldYield16(void)
880 ReleaseThunkLock(&count
);
881 RestoreThunkLock(count
);
884 /***********************************************************************
885 * DirectedYield (KERNEL.150)
887 void WINAPI
DirectedYield16( HTASK16 hTask
)
889 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
891 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
893 FIXME_(task
)("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
897 TRACE_(task
)("%04x: DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
899 pCurTask
->hYieldTo
= hTask
;
902 TRACE_(task
)("%04x: back from DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
905 /***********************************************************************
906 * Yield16 (KERNEL.29)
908 void WINAPI
Yield16(void)
910 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
912 if (pCurTask
) pCurTask
->hYieldTo
= 0;
913 if (pCurTask
&& pCurTask
->hQueue
) Callout
.UserYield16();
917 /***********************************************************************
918 * KERNEL_490 (KERNEL.490)
920 HTASK16 WINAPI
KERNEL_490( HTASK16 someTask
)
922 if ( !someTask
) return 0;
924 FIXME_(task
)("(%04x): stub\n", someTask
);
928 /***********************************************************************
929 * MakeProcInstance16 (KERNEL.51)
931 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
937 ERR_(task
)("Ouch ! MakeProcInstance called with func == NULL !\n");
938 return (FARPROC16
)0; /* Windows seems to do the same */
940 if (!hInstance
) hInstance
= CURRENT_DS
;
941 thunkaddr
= TASK_AllocThunk( GetCurrentTask() );
942 if (!thunkaddr
) return (FARPROC16
)0;
943 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
944 lfunc
= PTR_SEG_TO_LIN( func
);
946 TRACE_(task
)("(%08lx,%04x): got thunk %08lx\n",
947 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
948 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) ||
949 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58))
951 FIXME_(task
)("thunk would be useless for %p, overwriting with nop;nop;\n", func
);
952 lfunc
[0]=0x90; /* nop */
953 lfunc
[1]=0x90; /* nop */
956 *thunk
++ = 0xb8; /* movw instance, %ax */
957 *thunk
++ = (BYTE
)(hInstance
& 0xff);
958 *thunk
++ = (BYTE
)(hInstance
>> 8);
959 *thunk
++ = 0xea; /* ljmp func */
960 *(DWORD
*)thunk
= (DWORD
)func
;
961 return (FARPROC16
)thunkaddr
;
965 /***********************************************************************
966 * FreeProcInstance16 (KERNEL.52)
968 void WINAPI
FreeProcInstance16( FARPROC16 func
)
970 TRACE_(task
)("(%08lx)\n", (DWORD
)func
);
971 TASK_FreeThunk( GetCurrentTask(), (SEGPTR
)func
);
974 /**********************************************************************
975 * TASK_GetCodeSegment
977 * Helper function for GetCodeHandle/GetCodeInfo: Retrieve the module
978 * and logical segment number of a given code segment.
980 * 'proc' either *is* already a pair of module handle and segment number,
981 * in which case there's nothing to do. Otherwise, it is a pointer to
982 * a function, and we need to retrieve the code segment. If the pointer
983 * happens to point to a thunk, we'll retrieve info about the code segment
984 * where the function pointed to by the thunk resides, not the thunk itself.
986 * FIXME: if 'proc' is a SNOOP16 return stub, we should retrieve info about
987 * the function the snoop code will return to ...
990 static BOOL
TASK_GetCodeSegment( FARPROC16 proc
, NE_MODULE
**ppModule
,
991 SEGTABLEENTRY
**ppSeg
, int *pSegNr
)
993 NE_MODULE
*pModule
= NULL
;
994 SEGTABLEENTRY
*pSeg
= NULL
;
997 /* Try pair of module handle / segment number */
998 pModule
= (NE_MODULE
*) GlobalLock16( HIWORD( proc
) );
999 if ( pModule
&& pModule
->magic
== IMAGE_OS2_SIGNATURE
)
1001 segNr
= LOWORD( proc
);
1002 if ( segNr
&& segNr
<= pModule
->seg_count
)
1003 pSeg
= NE_SEG_TABLE( pModule
) + segNr
-1;
1006 /* Try thunk or function */
1009 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1012 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1013 selector
= thunk
[6] + (thunk
[7] << 8);
1015 selector
= HIWORD( proc
);
1017 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
1018 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
1021 for ( segNr
= 1; segNr
<= pModule
->seg_count
; segNr
++, pSeg
++ )
1022 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
1025 if ( pModule
&& segNr
> pModule
->seg_count
)
1029 /* Abort if segment not found */
1031 if ( !pModule
|| !pSeg
)
1034 /* Return segment data */
1036 if ( ppModule
) *ppModule
= pModule
;
1037 if ( ppSeg
) *ppSeg
= pSeg
;
1038 if ( pSegNr
) *pSegNr
= segNr
;
1043 /**********************************************************************
1044 * GetCodeHandle (KERNEL.93)
1046 HANDLE16 WINAPI
GetCodeHandle16( FARPROC16 proc
)
1048 SEGTABLEENTRY
*pSeg
;
1050 if ( !TASK_GetCodeSegment( proc
, NULL
, &pSeg
, NULL
) )
1056 /**********************************************************************
1057 * GetCodeInfo (KERNEL.104)
1059 BOOL16 WINAPI
GetCodeInfo16( FARPROC16 proc
, SEGINFO
*segInfo
)
1062 SEGTABLEENTRY
*pSeg
;
1065 if ( !TASK_GetCodeSegment( proc
, &pModule
, &pSeg
, &segNr
) )
1068 /* Fill in segment information */
1070 segInfo
->offSegment
= pSeg
->filepos
;
1071 segInfo
->cbSegment
= pSeg
->size
;
1072 segInfo
->flags
= pSeg
->flags
;
1073 segInfo
->cbAlloc
= pSeg
->minsize
;
1074 segInfo
->h
= pSeg
->hSeg
;
1075 segInfo
->alignShift
= pModule
->alignment
;
1077 if ( segNr
== pModule
->dgroup
)
1078 segInfo
->cbAlloc
+= pModule
->heap_size
+ pModule
->stack_size
;
1080 /* Return module handle in %es */
1082 CURRENT_STACK16
->es
= GlobalHandleToSel16( pModule
->self
);
1088 /**********************************************************************
1089 * DefineHandleTable16 (KERNEL.94)
1091 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
1093 return TRUE
; /* FIXME */
1097 /***********************************************************************
1098 * SetTaskQueue (KERNEL.34)
1100 HQUEUE16 WINAPI
SetTaskQueue16( HTASK16 hTask
, HQUEUE16 hQueue
)
1105 if (!hTask
) hTask
= GetCurrentTask();
1106 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1108 hPrev
= pTask
->hQueue
;
1109 pTask
->hQueue
= hQueue
;
1115 /***********************************************************************
1116 * GetTaskQueue (KERNEL.35)
1118 HQUEUE16 WINAPI
GetTaskQueue16( HTASK16 hTask
)
1122 if (!hTask
) hTask
= GetCurrentTask();
1123 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1124 return pTask
->hQueue
;
1127 /***********************************************************************
1128 * SetThreadQueue (KERNEL.463)
1130 HQUEUE16 WINAPI
SetThreadQueue16( DWORD thread
, HQUEUE16 hQueue
)
1132 TEB
*teb
= thread
? THREAD_IdToTEB( thread
) : NtCurrentTeb();
1133 HQUEUE16 oldQueue
= teb
? teb
->queue
: 0;
1137 teb
->queue
= hQueue
;
1139 if ( GetTaskQueue16( teb
->process
->task
) == oldQueue
)
1140 SetTaskQueue16( teb
->process
->task
, hQueue
);
1146 /***********************************************************************
1147 * GetThreadQueue (KERNEL.464)
1149 HQUEUE16 WINAPI
GetThreadQueue16( DWORD thread
)
1153 teb
= NtCurrentTeb();
1154 else if ( HIWORD(thread
) )
1155 teb
= THREAD_IdToTEB( thread
);
1156 else if ( IsTask16( (HTASK16
)thread
) )
1157 teb
= ((TDB
*)GlobalLock16( (HANDLE16
)thread
))->teb
;
1159 return (HQUEUE16
)(teb
? teb
->queue
: 0);
1162 /***********************************************************************
1163 * SetFastQueue (KERNEL.624)
1165 VOID WINAPI
SetFastQueue16( DWORD thread
, HANDLE hQueue
)
1169 teb
= NtCurrentTeb();
1170 else if ( HIWORD(thread
) )
1171 teb
= THREAD_IdToTEB( thread
);
1172 else if ( IsTask16( (HTASK16
)thread
) )
1173 teb
= ((TDB
*)GlobalLock16( (HANDLE16
)thread
))->teb
;
1175 if ( teb
) teb
->queue
= (HQUEUE16
) hQueue
;
1178 /***********************************************************************
1179 * GetFastQueue (KERNEL.625)
1181 HANDLE WINAPI
GetFastQueue16( void )
1183 TEB
*teb
= NtCurrentTeb();
1187 Callout
.InitThreadInput16( 0, THREAD_IsWin16(teb
)? 4 : 5 );
1190 FIXME_(task
)("(): should initialize thread-local queue, expect failure!\n" );
1192 return (HANDLE
)teb
->queue
;
1195 /***********************************************************************
1196 * SwitchStackTo (KERNEL.108)
1198 void WINAPI
SwitchStackTo16( WORD seg
, WORD ptr
, WORD top
)
1201 STACK16FRAME
*oldFrame
, *newFrame
;
1202 INSTANCEDATA
*pData
;
1205 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1206 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1207 TRACE_(task
)("old=%04x:%04x new=%04x:%04x\n",
1208 SELECTOROF( pTask
->teb
->cur_stack
),
1209 OFFSETOF( pTask
->teb
->cur_stack
), seg
, ptr
);
1211 /* Save the old stack */
1213 oldFrame
= THREAD_STACK16( pTask
->teb
);
1214 /* pop frame + args and push bp */
1215 pData
->old_ss_sp
= pTask
->teb
->cur_stack
+ sizeof(STACK16FRAME
)
1217 *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
) = oldFrame
->bp
;
1218 pData
->stacktop
= top
;
1219 pData
->stackmin
= ptr
;
1220 pData
->stackbottom
= ptr
;
1222 /* Switch to the new stack */
1224 /* Note: we need to take the 3 arguments into account; otherwise,
1225 * the stack will underflow upon return from this function.
1227 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1228 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1229 pTask
->teb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( seg
, ptr
- copySize
);
1230 newFrame
= THREAD_STACK16( pTask
->teb
);
1232 /* Copy the stack frame and the local variables to the new stack */
1234 memmove( newFrame
, oldFrame
, copySize
);
1236 *(WORD
*)PTR_SEG_OFF_TO_LIN( seg
, ptr
) = 0; /* clear previous bp */
1240 /***********************************************************************
1241 * SwitchStackBack (KERNEL.109)
1243 void WINAPI
SwitchStackBack16( CONTEXT86
*context
)
1245 STACK16FRAME
*oldFrame
, *newFrame
;
1246 INSTANCEDATA
*pData
;
1248 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(NtCurrentTeb()->cur_stack
))))
1250 if (!pData
->old_ss_sp
)
1252 WARN_(task
)("No previous SwitchStackTo\n" );
1255 TRACE_(task
)("restoring stack %04x:%04x\n",
1256 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1258 oldFrame
= CURRENT_STACK16
;
1260 /* Pop bp from the previous stack */
1262 BP_reg(context
) = *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
);
1263 pData
->old_ss_sp
+= sizeof(WORD
);
1265 /* Switch back to the old stack */
1267 NtCurrentTeb()->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1268 SS_reg(context
) = SELECTOROF(pData
->old_ss_sp
);
1269 ESP_reg(context
) = OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1270 pData
->old_ss_sp
= 0;
1272 /* Build a stack frame for the return */
1274 newFrame
= CURRENT_STACK16
;
1275 newFrame
->frame32
= oldFrame
->frame32
;
1276 newFrame
->module_cs
= oldFrame
->module_cs
;
1277 newFrame
->callfrom_ip
= oldFrame
->callfrom_ip
;
1278 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1282 /***********************************************************************
1283 * GetTaskQueueDS16 (KERNEL.118)
1285 void WINAPI
GetTaskQueueDS16(void)
1287 CURRENT_STACK16
->ds
= GlobalHandleToSel16( GetTaskQueue16(0) );
1291 /***********************************************************************
1292 * GetTaskQueueES16 (KERNEL.119)
1294 void WINAPI
GetTaskQueueES16(void)
1296 CURRENT_STACK16
->es
= GlobalHandleToSel16( GetTaskQueue16(0) );
1300 /***********************************************************************
1301 * GetCurrentTask (KERNEL.36)
1303 HTASK16 WINAPI
GetCurrentTask(void)
1305 return PROCESS_Current()->task
;
1308 DWORD WINAPI
WIN16_GetCurrentTask(void)
1310 /* This is the version used by relay code; the first task is */
1311 /* returned in the high word of the result */
1312 return MAKELONG( GetCurrentTask(), hFirstTask
);
1316 /***********************************************************************
1317 * GetCurrentPDB (KERNEL.37)
1319 * UNDOC: returns PSP of KERNEL in high word
1321 DWORD WINAPI
GetCurrentPDB16(void)
1325 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1326 return MAKELONG(pTask
->hPDB
, 0); /* FIXME */
1330 /***********************************************************************
1331 * GetCurPID16 (KERNEL.157)
1333 DWORD WINAPI
GetCurPID16( DWORD unused
)
1339 /***********************************************************************
1340 * GetInstanceData (KERNEL.54)
1342 INT16 WINAPI
GetInstanceData16( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1344 char *ptr
= (char *)GlobalLock16( instance
);
1345 if (!ptr
|| !len
) return 0;
1346 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1347 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1352 /***********************************************************************
1353 * GetExeVersion (KERNEL.105)
1355 WORD WINAPI
GetExeVersion16(void)
1359 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1360 return pTask
->version
;
1364 /***********************************************************************
1365 * SetErrorMode16 (KERNEL.107)
1367 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1370 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1371 pTask
->error_mode
= mode
;
1372 return SetErrorMode( mode
);
1376 /***********************************************************************
1377 * GetDOSEnvironment (KERNEL.131)
1379 SEGPTR WINAPI
GetDOSEnvironment16(void)
1383 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1384 return PTR_SEG_OFF_TO_SEGPTR( pTask
->pdb
.environment
, 0 );
1388 /***********************************************************************
1389 * GetNumTasks (KERNEL.152)
1391 UINT16 WINAPI
GetNumTasks16(void)
1397 /***********************************************************************
1398 * GetTaskDS (KERNEL.155)
1400 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1401 * I don't think we need to bother with this.
1403 HINSTANCE16 WINAPI
GetTaskDS16(void)
1407 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1408 return pTask
->hInstance
;
1411 /***********************************************************************
1412 * GetDummyModuleHandleDS (KERNEL.602)
1414 WORD WINAPI
GetDummyModuleHandleDS16(void)
1419 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1420 if (!(pTask
->flags
& TDBF_WIN32
)) return 0;
1421 selector
= GlobalHandleToSel16( pTask
->hModule
);
1422 CURRENT_DS
= selector
;
1426 /***********************************************************************
1427 * IsTask (KERNEL.320)
1429 BOOL16 WINAPI
IsTask16( HTASK16 hTask
)
1433 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1434 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1435 return (pTask
->magic
== TDB_MAGIC
);
1439 /***********************************************************************
1440 * IsWinOldApTask16 (KERNEL.158)
1442 BOOL16 WINAPI
IsWinOldApTask16( HTASK16 hTask
)
1444 /* should return bit 0 of byte 0x48 in PSP */
1448 /***********************************************************************
1449 * SetTaskSignalProc (KERNEL.38)
1451 * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1453 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1458 if (!hTask
) hTask
= GetCurrentTask();
1459 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1460 oldProc
= (FARPROC16
)pTask
->userhandler
;
1461 pTask
->userhandler
= (USERSIGNALPROC
)proc
;
1466 /***********************************************************************
1467 * SetSigHandler (KERNEL.140)
1469 WORD WINAPI
SetSigHandler16( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1470 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1472 FIXME_(task
)("(%p,%p,%p,%d,%d), unimplemented.\n",
1473 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1475 if (flag
!= 1) return 0;
1476 if (!newmode
) newhandler
= NULL
; /* Default handler */
1481 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1482 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1483 pTask
->signal_flags
= newmode
;
1484 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1485 pTask
->sighandler
= newhandler
;
1491 /***********************************************************************
1492 * GlobalNotify (KERNEL.154)
1494 * Note that GlobalNotify does _not_ return the old NotifyProc
1495 * -- contrary to LocalNotify !!
1497 VOID WINAPI
GlobalNotify16( FARPROC16 proc
)
1501 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1502 pTask
->discardhandler
= proc
;
1506 /***********************************************************************
1507 * GetExePtr (KERNEL.133)
1509 static inline HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1514 /* Check for module handle */
1516 if (!(ptr
= GlobalLock16( handle
))) return 0;
1517 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1519 /* Search for this handle inside all tasks */
1521 *hTask
= hFirstTask
;
1524 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1525 if ((*hTask
== handle
) ||
1526 (pTask
->hInstance
== handle
) ||
1527 (pTask
->hQueue
== handle
) ||
1528 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1529 *hTask
= pTask
->hNext
;
1532 /* Check the owner for module handle */
1534 owner
= FarGetOwner16( handle
);
1535 if (!(ptr
= GlobalLock16( owner
))) return 0;
1536 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1538 /* Search for the owner inside all tasks */
1540 *hTask
= hFirstTask
;
1543 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1544 if ((*hTask
== owner
) ||
1545 (pTask
->hInstance
== owner
) ||
1546 (pTask
->hQueue
== owner
) ||
1547 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1548 *hTask
= pTask
->hNext
;
1554 HMODULE16 WINAPI
WIN16_GetExePtr( HANDLE16 handle
)
1557 HMODULE16 hModule
= GetExePtrHelper( handle
, &hTask
);
1558 STACK16FRAME
*frame
= CURRENT_STACK16
;
1559 frame
->ecx
= hModule
;
1560 if (hTask
) frame
->es
= hTask
;
1564 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1567 return GetExePtrHelper( handle
, &hTask
);
1571 /***********************************************************************
1572 * TaskFirst (TOOLHELP.63)
1574 BOOL16 WINAPI
TaskFirst16( TASKENTRY
*lpte
)
1576 lpte
->hNext
= hFirstTask
;
1577 return TaskNext16( lpte
);
1581 /***********************************************************************
1582 * TaskNext (TOOLHELP.64)
1584 BOOL16 WINAPI
TaskNext16( TASKENTRY
*lpte
)
1587 INSTANCEDATA
*pInstData
;
1589 TRACE_(toolhelp
)("(%p): task=%04x\n", lpte
, lpte
->hNext
);
1590 if (!lpte
->hNext
) return FALSE
;
1591 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1592 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1593 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1594 lpte
->hTask
= lpte
->hNext
;
1595 lpte
->hTaskParent
= pTask
->hParent
;
1596 lpte
->hInst
= pTask
->hInstance
;
1597 lpte
->hModule
= pTask
->hModule
;
1598 lpte
->wSS
= SELECTOROF( pTask
->teb
->cur_stack
);
1599 lpte
->wSP
= OFFSETOF( pTask
->teb
->cur_stack
);
1600 lpte
->wStackTop
= pInstData
->stacktop
;
1601 lpte
->wStackMinimum
= pInstData
->stackmin
;
1602 lpte
->wStackBottom
= pInstData
->stackbottom
;
1603 lpte
->wcEvents
= pTask
->nEvents
;
1604 lpte
->hQueue
= pTask
->hQueue
;
1605 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1606 lpte
->szModule
[8] = '\0';
1607 lpte
->wPSPOffset
= 0x100; /*??*/
1608 lpte
->hNext
= pTask
->hNext
;
1613 /***********************************************************************
1614 * TaskFindHandle (TOOLHELP.65)
1616 BOOL16 WINAPI
TaskFindHandle16( TASKENTRY
*lpte
, HTASK16 hTask
)
1618 lpte
->hNext
= hTask
;
1619 return TaskNext16( lpte
);
1623 /***********************************************************************
1624 * GetAppCompatFlags16 (KERNEL.354)
1626 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1628 return GetAppCompatFlags( hTask
);
1632 /***********************************************************************
1633 * GetAppCompatFlags32 (USER32.206)
1635 DWORD WINAPI
GetAppCompatFlags( HTASK hTask
)
1639 if (!hTask
) hTask
= GetCurrentTask();
1640 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1641 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1642 return pTask
->compat_flags
;