4 * Copyright 1995 Alexandre Julliard
12 #include "wine/winbase16.h"
25 #include "selectors.h"
26 #include "stackframe.h"
33 #include "debugtools.h"
38 DEFAULT_DEBUG_CHANNEL(task
)
39 DECLARE_DEBUG_CHANNEL(relay
)
40 DECLARE_DEBUG_CHANNEL(toolhelp
)
42 /* Min. number of thunks allocated when creating a new segment */
46 static THHOOK DefaultThhook
= { 0 };
47 THHOOK
*pThhook
= &DefaultThhook
;
49 #define hCurrentTask (pThhook->CurTDB)
50 #define hFirstTask (pThhook->HeadTDB)
51 #define hLockedTask (pThhook->LockTDB)
53 static UINT16 nTaskCount
= 0;
55 static HTASK initial_task
;
57 /***********************************************************************
60 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
62 THHOOK
*pOldThhook
= pThhook
;
64 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
66 *pThhook
= *pOldThhook
;
69 /***********************************************************************
72 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
74 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
76 if (pTask
->hNext
) return pTask
->hNext
;
77 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
80 /***********************************************************************
83 static void TASK_LinkTask( HTASK16 hTask
)
88 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
89 prevTask
= &hFirstTask
;
92 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
93 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
94 prevTask
= &prevTaskPtr
->hNext
;
96 pTask
->hNext
= *prevTask
;
102 /***********************************************************************
105 static void TASK_UnlinkTask( HTASK16 hTask
)
110 prevTask
= &hFirstTask
;
111 while (*prevTask
&& (*prevTask
!= hTask
))
113 pTask
= (TDB
*)GlobalLock16( *prevTask
);
114 prevTask
= &pTask
->hNext
;
118 pTask
= (TDB
*)GlobalLock16( *prevTask
);
119 *prevTask
= pTask
->hNext
;
126 /***********************************************************************
129 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
130 * and containing 'count' entries.
132 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
138 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
140 pThunk
->magic
= THUNK_MAGIC
;
141 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
143 for (i
= 0; i
< count
-1; i
++)
145 free
+= 8; /* Offset of next thunk */
146 pThunk
->thunks
[4*i
] = free
;
148 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
152 /***********************************************************************
155 * Allocate a thunk for MakeProcInstance().
157 static SEGPTR
TASK_AllocThunk( HTASK16 hTask
)
163 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
164 sel
= pTask
->hCSAlias
;
165 pThunk
= &pTask
->thunks
;
166 base
= (int)pThunk
- (int)pTask
;
167 while (!pThunk
->free
)
170 if (!sel
) /* Allocate a new segment */
172 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
173 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
174 if (!sel
) return (SEGPTR
)0;
175 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
178 pThunk
= (THUNKS
*)GlobalLock16( sel
);
181 base
+= pThunk
->free
;
182 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
183 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
187 /***********************************************************************
190 * Free a MakeProcInstance() thunk.
192 static BOOL
TASK_FreeThunk( HTASK16 hTask
, SEGPTR thunk
)
198 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
199 sel
= pTask
->hCSAlias
;
200 pThunk
= &pTask
->thunks
;
201 base
= (int)pThunk
- (int)pTask
;
202 while (sel
&& (sel
!= HIWORD(thunk
)))
205 pThunk
= (THUNKS
*)GlobalLock16( sel
);
208 if (!sel
) return FALSE
;
209 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
210 pThunk
->free
= LOWORD(thunk
) - base
;
215 /***********************************************************************
218 * 32-bit entry point for a new task. This function is responsible for
219 * setting up the registers and jumping to the 16-bit entry point.
221 void TASK_CallToStart(void)
223 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
224 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
225 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
228 SYSLEVEL_EnterWin16Lock();
230 /* Add task to 16-bit scheduler pool if necessary */
231 if ( hCurrentTask
!= GetCurrentTask() )
234 /* Registers at initialization must be:
236 * bx stack size in bytes
237 * cx heap size in bytes
238 * si previous app instance
239 * di current app instance
241 * es selector to the PSP
242 * ds dgroup of the application
244 * sp top of the stack
247 memset( &context
, 0, sizeof(context
) );
248 CS_reg(&context
) = GlobalHandleToSel16(pSegTable
[pModule
->cs
- 1].hSeg
);
249 DS_reg(&context
) = GlobalHandleToSel16(pTask
->hInstance
);
250 ES_reg(&context
) = pTask
->hPDB
;
251 EIP_reg(&context
) = pModule
->ip
;
252 EBX_reg(&context
) = pModule
->stack_size
;
253 ECX_reg(&context
) = pModule
->heap_size
;
254 EDI_reg(&context
) = pTask
->hInstance
;
255 ESI_reg(&context
) = pTask
->hPrevInstance
;
257 TRACE("Starting main program: cs:ip=%04lx:%04lx ds=%04lx ss:sp=%04x:%04x\n",
258 CS_reg(&context
), EIP_reg(&context
), DS_reg(&context
),
259 SELECTOROF(pTask
->teb
->cur_stack
),
260 OFFSETOF(pTask
->teb
->cur_stack
) );
262 Callbacks
->CallRegisterShortProc( &context
, 0 );
266 /***********************************************************************
269 * NOTE: This routine might be called by a Win32 thread. Thus, we need
270 * to be careful to protect global data structures. We do this
271 * by entering the Win16Lock while linking the task into the
274 BOOL
TASK_Create( NE_MODULE
*pModule
, UINT16 cmdShow
, TEB
*teb
, LPCSTR cmdline
, BYTE len
)
279 PDB
*pdb32
= PROCESS_Current();
281 /* Allocate the task structure */
283 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
284 pModule
->self
, FALSE
, FALSE
, FALSE
);
285 if (!hTask
) return FALSE
;
286 pTask
= (TDB
*)GlobalLock16( hTask
);
288 /* Fill the task structure */
291 pTask
->hSelf
= hTask
;
294 if (teb
->tibflags
& TEBF_WIN32
) pTask
->flags
|= TDBF_WIN32
;
295 if (pModule
->lpDosTask
) pTask
->flags
|= TDBF_WINOLDAP
;
297 pTask
->hInstance
= pModule
->self
;
298 pTask
->hPrevInstance
= 0;
299 /* NOTE: for 16-bit tasks, the instance handles are updated later on
302 pTask
->version
= pModule
->expected_version
;
303 pTask
->hModule
= pModule
->self
;
304 pTask
->hParent
= GetCurrentTask();
305 pTask
->magic
= TDB_MAGIC
;
306 pTask
->nCmdShow
= cmdShow
;
308 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
309 strcpy( pTask
->curdir
, "\\" );
310 lstrcpynA( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
311 sizeof(pTask
->curdir
) - 1 );
313 /* Create the thunks block */
315 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
317 /* Copy the module name */
319 GetModuleName16( pModule
->self
, name
, sizeof(name
) );
320 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
322 /* Allocate a selector for the PDB */
324 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB16
),
325 pModule
->self
, FALSE
, FALSE
, FALSE
, NULL
);
329 pTask
->pdb
.int20
= 0x20cd;
330 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
331 PUT_DWORD(&pTask
->pdb
.dispatcher
[1], (DWORD
)NE_GetEntryPoint(
332 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
333 pTask
->pdb
.savedint22
= INT_GetPMHandler( 0x22 );
334 pTask
->pdb
.savedint23
= INT_GetPMHandler( 0x23 );
335 pTask
->pdb
.savedint24
= INT_GetPMHandler( 0x24 );
336 pTask
->pdb
.fileHandlesPtr
=
337 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(pTask
->hPDB
),
338 (int)&((PDB16
*)0)->fileHandles
);
339 pTask
->pdb
.hFileHandles
= 0;
340 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
341 pTask
->pdb
.environment
= pdb32
->env_db
->env_sel
;
342 pTask
->pdb
.nbFiles
= 20;
344 /* Fill the command line */
348 cmdline
= pdb32
->env_db
->cmd_line
;
349 while (*cmdline
&& (*cmdline
!= ' ') && (*cmdline
!= '\t')) cmdline
++;
350 while ((*cmdline
== ' ') || (*cmdline
== '\t')) cmdline
++;
351 len
= strlen(cmdline
);
353 if (len
>= sizeof(pTask
->pdb
.cmdLine
)) len
= sizeof(pTask
->pdb
.cmdLine
)-1;
354 pTask
->pdb
.cmdLine
[0] = len
;
355 memcpy( pTask
->pdb
.cmdLine
+ 1, cmdline
, len
);
356 /* pTask->pdb.cmdLine[len+1] = 0; */
358 /* Get the compatibility flags */
360 pTask
->compat_flags
= GetProfileIntA( "Compatibility", name
, 0 );
362 /* Allocate a code segment alias for the TDB */
364 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
365 sizeof(TDB
), pTask
->hPDB
, TRUE
,
366 FALSE
, FALSE
, NULL
);
368 /* Set the owner of the environment block */
370 FarSetOwner16( pTask
->pdb
.environment
, pTask
->hPDB
);
372 /* Default DTA overwrites command line */
374 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
375 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
377 /* Create scheduler event for 16-bit tasks */
379 if ( !(pTask
->flags
& TDBF_WIN32
) )
381 pTask
->hEvent
= CreateEventA( NULL
, TRUE
, FALSE
, NULL
);
382 pTask
->hEvent
= ConvertToGlobalHandle( pTask
->hEvent
);
385 /* Enter task handle into thread and process */
387 teb
->htask16
= hTask
;
388 if (!initial_task
) initial_task
= hTask
;
390 TRACE("module='%s' cmdline='%.*s' task=%04x\n", name
, *cmdline
, cmdline
+1, hTask
);
392 /* Add the task to the linked list */
394 SYSLEVEL_EnterWin16Lock();
395 TASK_LinkTask( hTask
);
396 SYSLEVEL_LeaveWin16Lock();
401 /***********************************************************************
404 static void TASK_DeleteTask( HTASK16 hTask
)
409 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
412 pTask
->magic
= 0xdead; /* invalidate signature */
414 /* Free the selector aliases */
416 GLOBAL_FreeBlock( pTask
->hCSAlias
);
417 GLOBAL_FreeBlock( pTask
->hPDB
);
419 /* Free the task module */
421 FreeModule16( pTask
->hModule
);
423 /* Free the task structure itself */
425 GlobalFree16( hTask
);
427 /* Free all memory used by this task (including the 32-bit stack, */
428 /* the environment block and the thunk segments). */
430 GlobalFreeAll16( hPDB
);
433 /***********************************************************************
436 void TASK_KillTask( HTASK16 hTask
)
440 /* Enter the Win16Lock to protect global data structures */
441 SYSLEVEL_EnterWin16Lock();
443 if ( !hTask
) hTask
= GetCurrentTask();
444 pTask
= (TDB
*)GlobalLock16( hTask
);
447 SYSLEVEL_LeaveWin16Lock();
451 TRACE("Killing task %04x\n", hTask
);
455 /* Kill DOS VM task */
456 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
457 if ( pModule
->lpDosTask
)
458 MZ_KillModule( pModule
->lpDosTask
);
462 /* Perform USER cleanup */
464 TASK_CallTaskSignalProc( USIG16_TERMINATION
, hTask
);
465 PROCESS_CallUserSignalProc( USIG_PROCESS_EXIT
, 0 );
466 PROCESS_CallUserSignalProc( USIG_THREAD_EXIT
, 0 );
467 PROCESS_CallUserSignalProc( USIG_PROCESS_DESTROY
, 0 );
471 TRACE("this is the last task, exiting\n" );
475 /* FIXME: Hack! Send a message to the initial task so that
476 * the GetMessage wakes up and the initial task can check whether
477 * it is the only remaining one and terminate itself ...
478 * The initial task should probably install hooks or something
479 * to get informed about task termination :-/
481 Callout
.PostAppMessage16( initial_task
, WM_NULL
, 0, 0 );
483 /* Remove the task from the list to be sure we never switch back to it */
484 TASK_UnlinkTask( hTask
);
487 TDB
* p
= (TDB
*)GlobalLock16( hFirstTask
);
490 if( p
->hYieldTo
== hTask
) p
->hYieldTo
= 0;
491 p
= (TDB
*)GlobalLock16( p
->hNext
);
497 if ( hLockedTask
== hTask
)
500 TASK_DeleteTask( hTask
);
502 /* When deleting the current task ... */
503 if ( hTask
== hCurrentTask
)
507 /* ... schedule another one ... */
510 /* ... and completely release the Win16Lock, just in case. */
511 ReleaseThunkLock( &lockCount
);
516 SYSLEVEL_LeaveWin16Lock();
519 /***********************************************************************
522 * This is where all the magic of task-switching happens!
524 * 16-bit Windows performs non-preemptive (cooperative) multitasking.
525 * This means that each 16-bit task runs until it voluntarily yields
526 * control, at which point the scheduler gets active and selects the
529 * In Wine, all processes, even 16-bit ones, are scheduled preemptively
530 * by the standard scheduler of the underlying OS. As many 16-bit apps
531 * *rely* on the behaviour of the Windows scheduler, however, we have
532 * to simulate that behaviour.
534 * This is achieved as follows: every 16-bit task is at time (except
535 * during task creation and deletion) in one of two states: either it
536 * is the one currently running, then the global variable hCurrentTask
537 * contains its task handle, or it is not currently running, then it
538 * is blocked on a special scheduler event, a global handle to which
539 * is stored in the task struct.
541 * When the current task yields control, this routine gets called. Its
542 * purpose is to determine the next task to be active, signal the
543 * scheduler event of that task, and then put the current task to sleep
544 * waiting for *its* scheduler event to get signalled again.
546 * This routine can get called in a few other special situations as well:
548 * - On creation of a 16-bit task, the Unix process executing the task
549 * calls TASK_Reschedule once it has completed its initialization.
550 * At this point, the task needs to be blocked until its scheduler
551 * event is signalled the first time (this will be done by the parent
552 * process to get the task up and running).
554 * - When the task currently running terminates itself, this routine gets
555 * called and has to schedule another task, *without* blocking the
558 * - When a 32-bit thread posts an event for a 16-bit task, it might be
559 * the case that *no* 16-bit task is currently running. In this case
560 * the task that has now an event pending is to be scheduled.
563 void TASK_Reschedule(void)
565 TDB
*pOldTask
= NULL
, *pNewTask
= NULL
;
566 HTASK16 hOldTask
= 0, hNewTask
= 0;
567 enum { MODE_YIELD
, MODE_SLEEP
, MODE_WAKEUP
} mode
;
570 SYSLEVEL_EnterWin16Lock();
572 /* Check what we need to do */
573 hOldTask
= GetCurrentTask();
574 pOldTask
= (TDB
*)GlobalLock16( hOldTask
);
575 TRACE( "entered with hCurrentTask %04x by hTask %04x (pid %ld)\n",
576 hCurrentTask
, hOldTask
, (long) getpid() );
578 if ( pOldTask
&& THREAD_IsWin16( NtCurrentTeb() ) )
580 /* We are called by an active (non-deleted) 16-bit task */
582 /* If we don't even have a current task, or else the current
583 task has yielded, we'll need to schedule a new task and
584 (possibly) put the calling task to sleep. Otherwise, we
585 only block the caller. */
587 if ( !hCurrentTask
|| hCurrentTask
== hOldTask
)
594 /* We are called by a deleted 16-bit task or a 32-bit thread */
596 /* The only situation where we need to do something is if we
597 now do not have a current task. Then, we'll need to wake up
598 some task that has events pending. */
600 if ( !hCurrentTask
|| hCurrentTask
== hOldTask
)
605 SYSLEVEL_LeaveWin16Lock();
610 /* Find a task to yield to: check for DirectedYield() */
611 if ( mode
== MODE_YIELD
&& pOldTask
&& pOldTask
->hYieldTo
)
613 hNewTask
= pOldTask
->hYieldTo
;
614 pNewTask
= (TDB
*)GlobalLock16( hNewTask
);
615 if( !pNewTask
|| !pNewTask
->nEvents
) hNewTask
= 0;
616 pOldTask
->hYieldTo
= 0;
619 /* Find a task to yield to: check for pending events */
620 if ( (mode
== MODE_YIELD
|| mode
== MODE_WAKEUP
) && !hNewTask
)
622 hNewTask
= hFirstTask
;
625 pNewTask
= (TDB
*)GlobalLock16( hNewTask
);
627 TRACE( "\ttask = %04x, events = %i\n", hNewTask
, pNewTask
->nEvents
);
629 if (pNewTask
->nEvents
) break;
630 hNewTask
= pNewTask
->hNext
;
632 if (hLockedTask
&& (hNewTask
!= hLockedTask
)) hNewTask
= 0;
635 /* If we are still the task with highest priority, just return ... */
636 if ( mode
== MODE_YIELD
&& hNewTask
&& hNewTask
== hCurrentTask
)
638 TRACE("returning to the current task (%04x)\n", hCurrentTask
);
639 SYSLEVEL_LeaveWin16Lock();
641 /* Allow Win32 threads to thunk down even while a Win16 task is
642 in a tight PeekMessage() or Yield() loop ... */
643 ReleaseThunkLock( &lockCount
);
644 RestoreThunkLock( lockCount
);
648 /* If no task to yield to found, suspend 16-bit scheduler ... */
649 if ( mode
== MODE_YIELD
&& !hNewTask
)
651 TRACE("No currently active task\n");
655 /* If we found a task to wake up, do it ... */
656 if ( (mode
== MODE_YIELD
|| mode
== MODE_WAKEUP
) && hNewTask
)
658 TRACE("Switching to task %04x (%.8s)\n",
659 hNewTask
, pNewTask
->module_name
);
661 pNewTask
->priority
++;
662 TASK_UnlinkTask( hNewTask
);
663 TASK_LinkTask( hNewTask
);
664 pNewTask
->priority
--;
666 hCurrentTask
= hNewTask
;
667 SetEvent( pNewTask
->hEvent
);
669 /* This is set just in case some app reads it ... */
670 pNewTask
->ss_sp
= pNewTask
->teb
->cur_stack
;
673 /* If we need to put the current task to sleep, do it ... */
674 if ( (mode
== MODE_YIELD
|| mode
== MODE_SLEEP
) && hOldTask
!= hCurrentTask
)
676 ResetEvent( pOldTask
->hEvent
);
678 ReleaseThunkLock( &lockCount
);
679 SYSLEVEL_CheckNotLevel( 1 );
680 WaitForSingleObject( pOldTask
->hEvent
, INFINITE
);
681 RestoreThunkLock( lockCount
);
684 SYSLEVEL_LeaveWin16Lock();
687 /***********************************************************************
688 * InitTask (KERNEL.91)
690 * Called by the application startup code.
692 void WINAPI
InitTask16( CONTEXT86
*context
)
695 INSTANCEDATA
*pinstance
;
698 EAX_reg(context
) = 0;
699 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
701 /* Note: we need to trust that BX/CX contain the stack/heap sizes,
702 as some apps, notably Visual Basic apps, *modify* the heap/stack
703 size of the instance data segment before calling InitTask() */
705 /* Initialize the INSTANCEDATA structure */
706 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
707 pinstance
->stackmin
= OFFSETOF( pTask
->teb
->cur_stack
) + sizeof( STACK16FRAME
);
708 pinstance
->stackbottom
= pinstance
->stackmin
; /* yup, that's right. Confused me too. */
709 pinstance
->stacktop
= ( pinstance
->stackmin
> BX_reg(context
)?
710 pinstance
->stackmin
- BX_reg(context
) : 0 ) + 150;
712 /* Initialize the local heap */
713 if ( CX_reg(context
) )
714 LocalInit16( GlobalHandleToSel16(pTask
->hInstance
), 0, CX_reg(context
) );
716 /* Initialize implicitly loaded DLLs */
717 NE_InitializeDLLs( pTask
->hModule
);
718 NE_DllProcessAttach( pTask
->hModule
);
720 /* Registers on return are:
721 * ax 1 if OK, 0 on error
722 * cx stack limit in bytes
723 * dx cmdShow parameter
724 * si instance handle of the previous instance
725 * di instance handle of the new task
726 * es:bx pointer to command line inside PSP
728 * 0 (=%bp) is pushed on the stack
730 ptr
= stack16_push( sizeof(WORD
) );
731 *(WORD
*)PTR_SEG_TO_LIN(ptr
) = 0;
732 ESP_reg(context
) -= 2;
734 EAX_reg(context
) = 1;
736 if (!pTask
->pdb
.cmdLine
[0]) EBX_reg(context
) = 0x80;
739 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
740 while ((*p
== ' ') || (*p
== '\t')) p
++;
741 EBX_reg(context
) = 0x80 + (p
- pTask
->pdb
.cmdLine
);
743 ECX_reg(context
) = pinstance
->stacktop
;
744 EDX_reg(context
) = pTask
->nCmdShow
;
745 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
746 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
747 ES_reg (context
) = (WORD
)pTask
->hPDB
;
751 /***********************************************************************
752 * WaitEvent (KERNEL.30)
754 BOOL16 WINAPI
WaitEvent16( HTASK16 hTask
)
758 if (!hTask
) hTask
= GetCurrentTask();
759 pTask
= (TDB
*)GlobalLock16( hTask
);
761 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
763 FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
767 if (pTask
->nEvents
> 0)
774 /* When we get back here, we have an event */
776 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
781 /***********************************************************************
782 * PostEvent (KERNEL.31)
784 void WINAPI
PostEvent16( HTASK16 hTask
)
788 if (!hTask
) hTask
= GetCurrentTask();
789 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
791 if ( !THREAD_IsWin16( pTask
->teb
) )
793 FIXME("called for Win32 thread (%04x)!\n", pTask
->teb
->teb_sel
);
799 /* If we are a 32-bit task, we might need to wake up the 16-bit scheduler */
800 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
805 /***********************************************************************
806 * SetPriority (KERNEL.32)
808 void WINAPI
SetPriority16( HTASK16 hTask
, INT16 delta
)
813 if (!hTask
) hTask
= GetCurrentTask();
814 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
815 newpriority
= pTask
->priority
+ delta
;
816 if (newpriority
< -32) newpriority
= -32;
817 else if (newpriority
> 15) newpriority
= 15;
819 pTask
->priority
= newpriority
+ 1;
820 TASK_UnlinkTask( hTask
);
821 TASK_LinkTask( hTask
);
826 /***********************************************************************
827 * LockCurrentTask (KERNEL.33)
829 HTASK16 WINAPI
LockCurrentTask16( BOOL16 bLock
)
831 if (bLock
) hLockedTask
= GetCurrentTask();
832 else hLockedTask
= 0;
837 /***********************************************************************
838 * IsTaskLocked (KERNEL.122)
840 HTASK16 WINAPI
IsTaskLocked16(void)
846 /***********************************************************************
847 * OldYield (KERNEL.117)
849 void WINAPI
OldYield16(void)
851 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
853 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
855 FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
859 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
861 if (pCurTask
) pCurTask
->nEvents
--;
864 /***********************************************************************
865 * WIN32_OldYield16 (KERNEL.447)
867 void WINAPI
WIN32_OldYield16(void)
871 ReleaseThunkLock(&count
);
872 RestoreThunkLock(count
);
875 /***********************************************************************
876 * DirectedYield (KERNEL.150)
878 void WINAPI
DirectedYield16( HTASK16 hTask
)
880 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
882 if ( !THREAD_IsWin16( NtCurrentTeb() ) )
884 FIXME("called for Win32 thread (%04x)!\n", NtCurrentTeb()->teb_sel
);
888 TRACE("%04x: DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
890 pCurTask
->hYieldTo
= hTask
;
893 TRACE("%04x: back from DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
896 /***********************************************************************
897 * Yield16 (KERNEL.29)
899 void WINAPI
Yield16(void)
901 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
903 if (pCurTask
) pCurTask
->hYieldTo
= 0;
904 if (pCurTask
&& pCurTask
->hQueue
) Callout
.UserYield16();
908 /***********************************************************************
909 * KERNEL_490 (KERNEL.490)
911 HTASK16 WINAPI
KERNEL_490( HTASK16 someTask
)
913 if ( !someTask
) return 0;
915 FIXME("(%04x): stub\n", someTask
);
919 /***********************************************************************
920 * MakeProcInstance16 (KERNEL.51)
922 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
926 WORD hInstanceSelector
;
928 hInstanceSelector
= GlobalHandleToSel16(hInstance
);
930 TRACE("(%08lx, %04x);\n", (DWORD
)func
, hInstance
);
933 /* Win95 actually protects via SEH, but this is better for debugging */
934 ERR("Ouch ! Called with invalid func 0x%08lx !\n", (DWORD
)func
);
940 if ( (!(hInstance
& 4)) ||
941 ((hInstance
!= 0xffff) && IS_SELECTOR_FREE(hInstance
|7)) )
943 ERR("Invalid hInstance (%04x) passed to MakeProcInstance !\n",
949 if ( (CURRENT_DS
!= hInstanceSelector
)
951 && (hInstance
!= 0xffff) )
953 /* calling MPI with a foreign DSEG is invalid ! */
954 ERR("Problem with hInstance? Got %04x, using %04x instead\n",
955 hInstance
,CURRENT_DS
);
958 /* Always use the DSEG that MPI was entered with.
959 * We used to set hInstance to GetTaskDS16(), but this should be wrong
960 * as CURRENT_DS provides the DSEG value we need.
961 * ("calling" DS, *not* "task" DS !) */
962 hInstanceSelector
= CURRENT_DS
;
963 hInstance
= GlobalHandle16(hInstanceSelector
);
965 /* no thunking for DLLs */
966 if (NE_GetPtr(FarGetOwner16(hInstance
))->flags
& NE_FFLAGS_LIBMODULE
)
969 thunkaddr
= TASK_AllocThunk( GetCurrentTask() );
970 if (!thunkaddr
) return (FARPROC16
)0;
971 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
972 lfunc
= PTR_SEG_TO_LIN( func
);
974 TRACE("(%08lx,%04x): got thunk %08lx\n",
975 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
976 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) || /* movw %ds, %ax */
977 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58)) /* pushw %ds, popw %ax */
979 FIXME("This was the (in)famous \"thunk useless\" warning. We thought we have to overwrite with nop;nop;, but this isn't true.\n");
982 *thunk
++ = 0xb8; /* movw instance, %ax */
983 *thunk
++ = (BYTE
)(hInstanceSelector
& 0xff);
984 *thunk
++ = (BYTE
)(hInstanceSelector
>> 8);
985 *thunk
++ = 0xea; /* ljmp func */
986 *(DWORD
*)thunk
= (DWORD
)func
;
987 return (FARPROC16
)thunkaddr
;
988 /* CX reg indicates if thunkaddr != NULL, implement if needed */
992 /***********************************************************************
993 * FreeProcInstance16 (KERNEL.52)
995 void WINAPI
FreeProcInstance16( FARPROC16 func
)
997 TRACE("(%08lx)\n", (DWORD
)func
);
998 TASK_FreeThunk( GetCurrentTask(), (SEGPTR
)func
);
1001 /**********************************************************************
1002 * TASK_GetCodeSegment
1004 * Helper function for GetCodeHandle/GetCodeInfo: Retrieve the module
1005 * and logical segment number of a given code segment.
1007 * 'proc' either *is* already a pair of module handle and segment number,
1008 * in which case there's nothing to do. Otherwise, it is a pointer to
1009 * a function, and we need to retrieve the code segment. If the pointer
1010 * happens to point to a thunk, we'll retrieve info about the code segment
1011 * where the function pointed to by the thunk resides, not the thunk itself.
1013 * FIXME: if 'proc' is a SNOOP16 return stub, we should retrieve info about
1014 * the function the snoop code will return to ...
1017 static BOOL
TASK_GetCodeSegment( FARPROC16 proc
, NE_MODULE
**ppModule
,
1018 SEGTABLEENTRY
**ppSeg
, int *pSegNr
)
1020 NE_MODULE
*pModule
= NULL
;
1021 SEGTABLEENTRY
*pSeg
= NULL
;
1024 /* Try pair of module handle / segment number */
1025 pModule
= (NE_MODULE
*) GlobalLock16( HIWORD( proc
) );
1026 if ( pModule
&& pModule
->magic
== IMAGE_OS2_SIGNATURE
)
1028 segNr
= LOWORD( proc
);
1029 if ( segNr
&& segNr
<= pModule
->seg_count
)
1030 pSeg
= NE_SEG_TABLE( pModule
) + segNr
-1;
1033 /* Try thunk or function */
1036 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1039 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1040 selector
= thunk
[6] + (thunk
[7] << 8);
1042 selector
= HIWORD( proc
);
1044 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
1045 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
1048 for ( segNr
= 1; segNr
<= pModule
->seg_count
; segNr
++, pSeg
++ )
1049 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
1052 if ( pModule
&& segNr
> pModule
->seg_count
)
1056 /* Abort if segment not found */
1058 if ( !pModule
|| !pSeg
)
1061 /* Return segment data */
1063 if ( ppModule
) *ppModule
= pModule
;
1064 if ( ppSeg
) *ppSeg
= pSeg
;
1065 if ( pSegNr
) *pSegNr
= segNr
;
1070 /**********************************************************************
1071 * GetCodeHandle (KERNEL.93)
1073 HANDLE16 WINAPI
GetCodeHandle16( FARPROC16 proc
)
1075 SEGTABLEENTRY
*pSeg
;
1077 if ( !TASK_GetCodeSegment( proc
, NULL
, &pSeg
, NULL
) )
1083 /**********************************************************************
1084 * GetCodeInfo (KERNEL.104)
1086 BOOL16 WINAPI
GetCodeInfo16( FARPROC16 proc
, SEGINFO
*segInfo
)
1089 SEGTABLEENTRY
*pSeg
;
1092 if ( !TASK_GetCodeSegment( proc
, &pModule
, &pSeg
, &segNr
) )
1095 /* Fill in segment information */
1097 segInfo
->offSegment
= pSeg
->filepos
;
1098 segInfo
->cbSegment
= pSeg
->size
;
1099 segInfo
->flags
= pSeg
->flags
;
1100 segInfo
->cbAlloc
= pSeg
->minsize
;
1101 segInfo
->h
= pSeg
->hSeg
;
1102 segInfo
->alignShift
= pModule
->alignment
;
1104 if ( segNr
== pModule
->dgroup
)
1105 segInfo
->cbAlloc
+= pModule
->heap_size
+ pModule
->stack_size
;
1107 /* Return module handle in %es */
1109 CURRENT_STACK16
->es
= GlobalHandleToSel16( pModule
->self
);
1115 /**********************************************************************
1116 * DefineHandleTable16 (KERNEL.94)
1118 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
1120 FIXME("(%04x): stub ?\n", wOffset
);
1125 /***********************************************************************
1126 * SetTaskQueue (KERNEL.34)
1128 HQUEUE16 WINAPI
SetTaskQueue16( HTASK16 hTask
, HQUEUE16 hQueue
)
1133 if (!hTask
) hTask
= GetCurrentTask();
1134 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1136 hPrev
= pTask
->hQueue
;
1137 pTask
->hQueue
= hQueue
;
1143 /***********************************************************************
1144 * GetTaskQueue (KERNEL.35)
1146 HQUEUE16 WINAPI
GetTaskQueue16( HTASK16 hTask
)
1150 if (!hTask
) hTask
= GetCurrentTask();
1151 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1152 return pTask
->hQueue
;
1155 /***********************************************************************
1156 * SetThreadQueue (KERNEL.463)
1158 HQUEUE16 WINAPI
SetThreadQueue16( DWORD thread
, HQUEUE16 hQueue
)
1160 TEB
*teb
= thread
? THREAD_IdToTEB( thread
) : NtCurrentTeb();
1161 HQUEUE16 oldQueue
= teb
? teb
->queue
: 0;
1165 teb
->queue
= hQueue
;
1167 if ( GetTaskQueue16( teb
->htask16
) == oldQueue
)
1168 SetTaskQueue16( teb
->htask16
, hQueue
);
1174 /***********************************************************************
1175 * GetThreadQueue (KERNEL.464)
1177 HQUEUE16 WINAPI
GetThreadQueue16( DWORD thread
)
1181 teb
= NtCurrentTeb();
1182 else if ( HIWORD(thread
) )
1183 teb
= THREAD_IdToTEB( thread
);
1184 else if ( IsTask16( (HTASK16
)thread
) )
1185 teb
= ((TDB
*)GlobalLock16( (HANDLE16
)thread
))->teb
;
1187 return (HQUEUE16
)(teb
? teb
->queue
: 0);
1190 /***********************************************************************
1191 * SetFastQueue (KERNEL.624)
1193 VOID WINAPI
SetFastQueue16( DWORD thread
, HANDLE hQueue
)
1197 teb
= NtCurrentTeb();
1198 else if ( HIWORD(thread
) )
1199 teb
= THREAD_IdToTEB( thread
);
1200 else if ( IsTask16( (HTASK16
)thread
) )
1201 teb
= ((TDB
*)GlobalLock16( (HANDLE16
)thread
))->teb
;
1203 if ( teb
) teb
->queue
= (HQUEUE16
) hQueue
;
1206 /***********************************************************************
1207 * GetFastQueue (KERNEL.625)
1209 HANDLE WINAPI
GetFastQueue16( void )
1211 TEB
*teb
= NtCurrentTeb();
1215 Callout
.InitThreadInput16( 0, THREAD_IsWin16(teb
)? 4 : 5 );
1218 FIXME("(): should initialize thread-local queue, expect failure!\n" );
1220 return (HANDLE
)teb
->queue
;
1223 /***********************************************************************
1224 * SwitchStackTo (KERNEL.108)
1226 void WINAPI
SwitchStackTo16( WORD seg
, WORD ptr
, WORD top
)
1229 STACK16FRAME
*oldFrame
, *newFrame
;
1230 INSTANCEDATA
*pData
;
1233 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1234 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1235 TRACE("old=%04x:%04x new=%04x:%04x\n",
1236 SELECTOROF( pTask
->teb
->cur_stack
),
1237 OFFSETOF( pTask
->teb
->cur_stack
), seg
, ptr
);
1239 /* Save the old stack */
1241 oldFrame
= THREAD_STACK16( pTask
->teb
);
1242 /* pop frame + args and push bp */
1243 pData
->old_ss_sp
= pTask
->teb
->cur_stack
+ sizeof(STACK16FRAME
)
1245 *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
) = oldFrame
->bp
;
1246 pData
->stacktop
= top
;
1247 pData
->stackmin
= ptr
;
1248 pData
->stackbottom
= ptr
;
1250 /* Switch to the new stack */
1252 /* Note: we need to take the 3 arguments into account; otherwise,
1253 * the stack will underflow upon return from this function.
1255 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1256 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1257 pTask
->teb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( seg
, ptr
- copySize
);
1258 newFrame
= THREAD_STACK16( pTask
->teb
);
1260 /* Copy the stack frame and the local variables to the new stack */
1262 memmove( newFrame
, oldFrame
, copySize
);
1264 *(WORD
*)PTR_SEG_OFF_TO_LIN( seg
, ptr
) = 0; /* clear previous bp */
1268 /***********************************************************************
1269 * SwitchStackBack (KERNEL.109)
1271 void WINAPI
SwitchStackBack16( CONTEXT86
*context
)
1273 STACK16FRAME
*oldFrame
, *newFrame
;
1274 INSTANCEDATA
*pData
;
1276 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(NtCurrentTeb()->cur_stack
))))
1278 if (!pData
->old_ss_sp
)
1280 WARN("No previous SwitchStackTo\n" );
1283 TRACE("restoring stack %04x:%04x\n",
1284 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1286 oldFrame
= CURRENT_STACK16
;
1288 /* Pop bp from the previous stack */
1290 BP_reg(context
) = *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
);
1291 pData
->old_ss_sp
+= sizeof(WORD
);
1293 /* Switch back to the old stack */
1295 NtCurrentTeb()->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1296 SS_reg(context
) = SELECTOROF(pData
->old_ss_sp
);
1297 ESP_reg(context
) = OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1298 pData
->old_ss_sp
= 0;
1300 /* Build a stack frame for the return */
1302 newFrame
= CURRENT_STACK16
;
1303 newFrame
->frame32
= oldFrame
->frame32
;
1304 newFrame
->module_cs
= oldFrame
->module_cs
;
1305 newFrame
->callfrom_ip
= oldFrame
->callfrom_ip
;
1306 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1310 /***********************************************************************
1311 * GetTaskQueueDS16 (KERNEL.118)
1313 void WINAPI
GetTaskQueueDS16(void)
1315 CURRENT_STACK16
->ds
= GlobalHandleToSel16( GetTaskQueue16(0) );
1319 /***********************************************************************
1320 * GetTaskQueueES16 (KERNEL.119)
1322 void WINAPI
GetTaskQueueES16(void)
1324 CURRENT_STACK16
->es
= GlobalHandleToSel16( GetTaskQueue16(0) );
1328 /***********************************************************************
1329 * GetCurrentTask (KERNEL.36)
1331 HTASK16 WINAPI
GetCurrentTask(void)
1333 return NtCurrentTeb()->htask16
;
1336 DWORD WINAPI
WIN16_GetCurrentTask(void)
1338 /* This is the version used by relay code; the first task is */
1339 /* returned in the high word of the result */
1340 return MAKELONG( GetCurrentTask(), hFirstTask
);
1344 /***********************************************************************
1345 * GetCurrentPDB (KERNEL.37)
1347 * UNDOC: returns PSP of KERNEL in high word
1349 DWORD WINAPI
GetCurrentPDB16(void)
1353 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1354 return MAKELONG(pTask
->hPDB
, 0); /* FIXME */
1358 /***********************************************************************
1359 * GetCurPID16 (KERNEL.157)
1361 DWORD WINAPI
GetCurPID16( DWORD unused
)
1367 /***********************************************************************
1368 * GetInstanceData (KERNEL.54)
1370 INT16 WINAPI
GetInstanceData16( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1372 char *ptr
= (char *)GlobalLock16( instance
);
1373 if (!ptr
|| !len
) return 0;
1374 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1375 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1380 /***********************************************************************
1381 * GetExeVersion (KERNEL.105)
1383 WORD WINAPI
GetExeVersion16(void)
1387 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1388 return pTask
->version
;
1392 /***********************************************************************
1393 * SetErrorMode16 (KERNEL.107)
1395 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1398 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1399 pTask
->error_mode
= mode
;
1400 return SetErrorMode( mode
);
1404 /***********************************************************************
1405 * GetDOSEnvironment (KERNEL.131)
1407 SEGPTR WINAPI
GetDOSEnvironment16(void)
1411 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1412 return PTR_SEG_OFF_TO_SEGPTR( pTask
->pdb
.environment
, 0 );
1416 /***********************************************************************
1417 * GetNumTasks (KERNEL.152)
1419 UINT16 WINAPI
GetNumTasks16(void)
1425 /***********************************************************************
1426 * GetTaskDS (KERNEL.155)
1428 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1429 * I don't think we need to bother with this.
1431 HINSTANCE16 WINAPI
GetTaskDS16(void)
1435 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1436 return GlobalHandleToSel16(pTask
->hInstance
);
1439 /***********************************************************************
1440 * GetDummyModuleHandleDS (KERNEL.602)
1442 WORD WINAPI
GetDummyModuleHandleDS16(void)
1447 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1448 if (!(pTask
->flags
& TDBF_WIN32
)) return 0;
1449 selector
= GlobalHandleToSel16( pTask
->hModule
);
1450 CURRENT_DS
= selector
;
1454 /***********************************************************************
1455 * IsTask (KERNEL.320)
1457 BOOL16 WINAPI
IsTask16( HTASK16 hTask
)
1461 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1462 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1463 return (pTask
->magic
== TDB_MAGIC
);
1467 /***********************************************************************
1468 * IsWinOldApTask16 (KERNEL.158)
1470 BOOL16 WINAPI
IsWinOldApTask16( HTASK16 hTask
)
1472 /* should return bit 0 of byte 0x48 in PSP */
1476 /***********************************************************************
1477 * SetTaskSignalProc (KERNEL.38)
1479 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1484 if (!hTask
) hTask
= GetCurrentTask();
1485 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1486 oldProc
= pTask
->userhandler
;
1487 pTask
->userhandler
= proc
;
1491 /***********************************************************************
1492 * TASK_CallTaskSignalProc
1494 /* ### start build ### */
1495 extern WORD CALLBACK
TASK_CallTo16_word_wwwww(FARPROC16
,WORD
,WORD
,WORD
,WORD
,WORD
);
1496 /* ### stop build ### */
1497 void TASK_CallTaskSignalProc( UINT16 uCode
, HANDLE16 hTaskOrModule
)
1499 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1500 if ( !pTask
|| !pTask
->userhandler
) return;
1502 TASK_CallTo16_word_wwwww( pTask
->userhandler
,
1503 hTaskOrModule
, uCode
, 0,
1504 pTask
->hInstance
, pTask
->hQueue
);
1507 /***********************************************************************
1508 * SetSigHandler (KERNEL.140)
1510 WORD WINAPI
SetSigHandler16( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1511 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1513 FIXME("(%p,%p,%p,%d,%d), unimplemented.\n",
1514 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1516 if (flag
!= 1) return 0;
1517 if (!newmode
) newhandler
= NULL
; /* Default handler */
1522 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1523 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1524 pTask
->signal_flags
= newmode
;
1525 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1526 pTask
->sighandler
= newhandler
;
1532 /***********************************************************************
1533 * GlobalNotify (KERNEL.154)
1535 * Note that GlobalNotify does _not_ return the old NotifyProc
1536 * -- contrary to LocalNotify !!
1538 VOID WINAPI
GlobalNotify16( FARPROC16 proc
)
1542 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1543 pTask
->discardhandler
= proc
;
1547 /***********************************************************************
1548 * GetExePtr (KERNEL.133)
1550 static inline HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1555 /* Check for module handle */
1557 if (!(ptr
= GlobalLock16( handle
))) return 0;
1558 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1560 /* Search for this handle inside all tasks */
1562 *hTask
= hFirstTask
;
1565 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1566 if ((*hTask
== handle
) ||
1567 (pTask
->hInstance
== handle
) ||
1568 (pTask
->hQueue
== handle
) ||
1569 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1570 *hTask
= pTask
->hNext
;
1573 /* Check the owner for module handle */
1575 owner
= FarGetOwner16( handle
);
1576 if (!(ptr
= GlobalLock16( owner
))) return 0;
1577 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1579 /* Search for the owner inside all tasks */
1581 *hTask
= hFirstTask
;
1584 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1585 if ((*hTask
== owner
) ||
1586 (pTask
->hInstance
== owner
) ||
1587 (pTask
->hQueue
== owner
) ||
1588 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1589 *hTask
= pTask
->hNext
;
1595 HMODULE16 WINAPI
WIN16_GetExePtr( HANDLE16 handle
)
1598 HMODULE16 hModule
= GetExePtrHelper( handle
, &hTask
);
1599 STACK16FRAME
*frame
= CURRENT_STACK16
;
1600 frame
->ecx
= hModule
;
1601 if (hTask
) frame
->es
= hTask
;
1605 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1608 return GetExePtrHelper( handle
, &hTask
);
1612 /***********************************************************************
1613 * TaskFirst (TOOLHELP.63)
1615 BOOL16 WINAPI
TaskFirst16( TASKENTRY
*lpte
)
1617 lpte
->hNext
= hFirstTask
;
1618 return TaskNext16( lpte
);
1622 /***********************************************************************
1623 * TaskNext (TOOLHELP.64)
1625 BOOL16 WINAPI
TaskNext16( TASKENTRY
*lpte
)
1628 INSTANCEDATA
*pInstData
;
1630 TRACE_(toolhelp
)("(%p): task=%04x\n", lpte
, lpte
->hNext
);
1631 if (!lpte
->hNext
) return FALSE
;
1632 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1633 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1634 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( GlobalHandleToSel16(pTask
->hInstance
), 0 );
1635 lpte
->hTask
= lpte
->hNext
;
1636 lpte
->hTaskParent
= pTask
->hParent
;
1637 lpte
->hInst
= pTask
->hInstance
;
1638 lpte
->hModule
= pTask
->hModule
;
1639 lpte
->wSS
= SELECTOROF( pTask
->teb
->cur_stack
);
1640 lpte
->wSP
= OFFSETOF( pTask
->teb
->cur_stack
);
1641 lpte
->wStackTop
= pInstData
->stacktop
;
1642 lpte
->wStackMinimum
= pInstData
->stackmin
;
1643 lpte
->wStackBottom
= pInstData
->stackbottom
;
1644 lpte
->wcEvents
= pTask
->nEvents
;
1645 lpte
->hQueue
= pTask
->hQueue
;
1646 lstrcpynA( lpte
->szModule
, pTask
->module_name
, sizeof(lpte
->szModule
) );
1647 lpte
->wPSPOffset
= 0x100; /*??*/
1648 lpte
->hNext
= pTask
->hNext
;
1653 /***********************************************************************
1654 * TaskFindHandle (TOOLHELP.65)
1656 BOOL16 WINAPI
TaskFindHandle16( TASKENTRY
*lpte
, HTASK16 hTask
)
1658 lpte
->hNext
= hTask
;
1659 return TaskNext16( lpte
);
1663 /***********************************************************************
1664 * GetAppCompatFlags16 (KERNEL.354)
1666 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1668 return GetAppCompatFlags( hTask
);
1672 /***********************************************************************
1673 * GetAppCompatFlags (USER32.206)
1675 DWORD WINAPI
GetAppCompatFlags( HTASK hTask
)
1679 if (!hTask
) hTask
= GetCurrentTask();
1680 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1681 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1682 return pTask
->compat_flags
;