4 * Copyright 1995 Alexandre Julliard
27 #include "selectors.h"
28 #include "stackframe.h"
41 /* Min. number of thunks allocated when creating a new segment */
44 /* Pointer to function to switch to a larger stack */
45 int (*IF1632_CallLargeStack
)( int (*func
)(), void *arg
) = NULL
;
47 /* Pointer to debugger callback routine */
48 void (*TASK_AddTaskEntryBreakpoint
)( HTASK16 hTask
) = NULL
;
50 static THHOOK DefaultThhook
= { 0 };
51 THHOOK
*pThhook
= &DefaultThhook
;
53 #define hCurrentTask (pThhook->CurTDB)
54 #define hFirstTask (pThhook->HeadTDB)
55 #define hLockedTask (pThhook->LockTDB)
57 static HTASK16 hTaskToKill
= 0;
58 static UINT16 nTaskCount
= 0;
60 static void TASK_YieldToSystem(TDB
*);
62 extern BOOL32 THREAD_InitDone
;
65 /***********************************************************************
68 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
70 THHOOK
*pOldThhook
= pThhook
;
72 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
74 *pThhook
= *pOldThhook
;
77 /***********************************************************************
80 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
82 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
84 if (pTask
->hNext
) return pTask
->hNext
;
85 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
88 /***********************************************************************
91 static void TASK_LinkTask( HTASK16 hTask
)
96 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
97 prevTask
= &hFirstTask
;
100 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
101 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
102 prevTask
= &prevTaskPtr
->hNext
;
104 pTask
->hNext
= *prevTask
;
110 /***********************************************************************
113 static void TASK_UnlinkTask( HTASK16 hTask
)
118 prevTask
= &hFirstTask
;
119 while (*prevTask
&& (*prevTask
!= hTask
))
121 pTask
= (TDB
*)GlobalLock16( *prevTask
);
122 prevTask
= &pTask
->hNext
;
126 pTask
= (TDB
*)GlobalLock16( *prevTask
);
127 *prevTask
= pTask
->hNext
;
134 /***********************************************************************
137 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
138 * and containing 'count' entries.
140 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
146 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
148 pThunk
->magic
= THUNK_MAGIC
;
149 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
151 for (i
= 0; i
< count
-1; i
++)
153 free
+= 8; /* Offset of next thunk */
154 pThunk
->thunks
[4*i
] = free
;
156 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
160 /***********************************************************************
163 * Allocate a thunk for MakeProcInstance().
165 static SEGPTR
TASK_AllocThunk( HTASK16 hTask
)
171 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
172 sel
= pTask
->hCSAlias
;
173 pThunk
= &pTask
->thunks
;
174 base
= (int)pThunk
- (int)pTask
;
175 while (!pThunk
->free
)
178 if (!sel
) /* Allocate a new segment */
180 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
181 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
182 if (!sel
) return (SEGPTR
)0;
183 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
186 pThunk
= (THUNKS
*)GlobalLock16( sel
);
189 base
+= pThunk
->free
;
190 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
191 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
195 /***********************************************************************
198 * Free a MakeProcInstance() thunk.
200 static BOOL32
TASK_FreeThunk( HTASK16 hTask
, SEGPTR thunk
)
206 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
207 sel
= pTask
->hCSAlias
;
208 pThunk
= &pTask
->thunks
;
209 base
= (int)pThunk
- (int)pTask
;
210 while (sel
&& (sel
!= HIWORD(thunk
)))
213 pThunk
= (THUNKS
*)GlobalLock16( sel
);
216 if (!sel
) return FALSE
;
217 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
218 pThunk
->free
= LOWORD(thunk
) - base
;
223 /***********************************************************************
226 * 32-bit entry point for a new task. This function is responsible for
227 * setting up the registers and jumping to the 16-bit entry point.
229 static void TASK_CallToStart(void)
231 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
232 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
233 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
235 SET_CUR_THREAD( pTask
->thdb
);
238 /* Terminate the stack frame chain */
239 memset(THREAD_STACK16( pTask
->thdb
), '\0', sizeof(STACK16FRAME
));
241 if (pModule
->flags
& NE_FFLAGS_WIN32
)
243 /* FIXME: all this is an ugly hack */
245 LPTHREAD_START_ROUTINE entry
= (LPTHREAD_START_ROUTINE
)
246 RVA_PTR(pModule
->module32
, OptionalHeader
.AddressOfEntryPoint
);
248 if (pModule
->heap_size
)
249 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
251 InitApp( pTask
->hModule
);
252 MODULE_InitializeDLLs( PROCESS_Current(), 0, DLL_PROCESS_ATTACH
, (LPVOID
)-1 );
253 TRACE(relay
, "(entryproc=%p)\n", entry
);
256 ExitProcess( entry(NULL
) );
259 DWORD size
= PE_HEADER(pModule
->module32
)->OptionalHeader
.SizeOfStackReserve
;
263 CreateThread( NULL
, size
, entry
, NULL
, 0, &id
);
264 thdb
= THREAD_ID_TO_THDB( id
);
266 while ( thdb
->exit_code
== 0x103 )
269 QUEUE_Signal( pTask
->hSelf
);
272 ExitProcess( thdb
->exit_code
);
276 else if (pModule
->dos_image
)
283 /* Registers at initialization must be:
285 * bx stack size in bytes
286 * cx heap size in bytes
287 * si previous app instance
288 * di current app instance
290 * es selector to the PSP
291 * ds dgroup of the application
293 * sp top of the stack
297 memset( &context
, 0, sizeof(context
) );
298 CS_reg(&context
) = GlobalHandleToSel(pSegTable
[pModule
->cs
- 1].hSeg
);
299 DS_reg(&context
) = GlobalHandleToSel(pSegTable
[pModule
->dgroup
- 1].hSeg
);
300 ES_reg(&context
) = pTask
->hPDB
;
301 EIP_reg(&context
) = pModule
->ip
;
302 EBX_reg(&context
) = pModule
->stack_size
;
303 ECX_reg(&context
) = pModule
->heap_size
;
304 EDI_reg(&context
) = context
.SegDs
;
306 TRACE(task
, "Starting main program: cs:ip=%04lx:%04x ds=%04lx ss:sp=%04x:%04x\n",
307 CS_reg(&context
), IP_reg(&context
), DS_reg(&context
),
308 SELECTOROF(pTask
->thdb
->cur_stack
),
309 OFFSETOF(pTask
->thdb
->cur_stack
) );
311 Callbacks
->CallRegisterShortProc( &context
, 0 );
312 /* This should never return */
313 ERR( task
, "Main program returned! (should never happen)\n" );
319 /***********************************************************************
322 * NOTE: This routine might be called by a Win32 thread. We don't have
323 * any real problems with that, since we operated merely on a private
324 * TDB structure that is not yet linked into the task list.
326 HTASK16
TASK_Create( THDB
*thdb
, NE_MODULE
*pModule
, HINSTANCE16 hInstance
,
327 HINSTANCE16 hPrevInstance
, UINT16 cmdShow
)
330 TDB
*pTask
, *pInitialTask
;
335 STACK16FRAME
*frame16
;
336 STACK32FRAME
*frame32
;
337 PDB32
*pdb32
= thdb
->process
;
338 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
340 /* Allocate the task structure */
342 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
343 pModule
->self
, FALSE
, FALSE
, FALSE
);
344 if (!hTask
) return 0;
345 pTask
= (TDB
*)GlobalLock16( hTask
);
347 /* Fill the task structure */
349 pTask
->nEvents
= 1; /* So the task can be started */
350 pTask
->hSelf
= hTask
;
353 if (pModule
->flags
& NE_FFLAGS_WIN32
)
354 pTask
->flags
|= TDBF_WIN32
;
355 if (pModule
->lpDosTask
)
356 pTask
->flags
|= TDBF_WINOLDAP
;
358 pTask
->version
= pModule
->expected_version
;
359 pTask
->hInstance
= hInstance
;
360 pTask
->hPrevInstance
= hPrevInstance
;
361 pTask
->hModule
= pModule
->self
;
362 pTask
->hParent
= GetCurrentTask();
363 pTask
->magic
= TDB_MAGIC
;
364 pTask
->nCmdShow
= cmdShow
;
366 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
367 strcpy( pTask
->curdir
, "\\" );
368 lstrcpyn32A( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
369 sizeof(pTask
->curdir
) - 1 );
371 /* Create the thunks block */
373 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
375 /* Copy the module name */
377 GetModuleName( pModule
->self
, name
, sizeof(name
) );
378 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
380 /* Allocate a selector for the PDB */
382 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
383 pModule
->self
, FALSE
, FALSE
, FALSE
, NULL
);
387 pTask
->pdb
.int20
= 0x20cd;
388 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
389 PUT_DWORD(&pTask
->pdb
.dispatcher
[1], (DWORD
)NE_GetEntryPoint(
390 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
391 pTask
->pdb
.savedint22
= INT_GetPMHandler( 0x22 );
392 pTask
->pdb
.savedint23
= INT_GetPMHandler( 0x23 );
393 pTask
->pdb
.savedint24
= INT_GetPMHandler( 0x24 );
394 pTask
->pdb
.fileHandlesPtr
=
395 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask
->hPDB
),
396 (int)&((PDB
*)0)->fileHandles
);
397 pTask
->pdb
.hFileHandles
= 0;
398 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
399 pTask
->pdb
.environment
= pdb32
->env_db
->env_sel
;
400 pTask
->pdb
.nbFiles
= 20;
402 /* Fill the command line */
404 cmd_line
= pdb32
->env_db
->cmd_line
;
405 while (*cmd_line
&& (*cmd_line
!= ' ') && (*cmd_line
!= '\t')) cmd_line
++;
406 while ((*cmd_line
== ' ') || (*cmd_line
== '\t')) cmd_line
++;
407 lstrcpyn32A( pTask
->pdb
.cmdLine
+1, cmd_line
, sizeof(pTask
->pdb
.cmdLine
)-1);
408 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
410 /* Get the compatibility flags */
412 pTask
->compat_flags
= GetProfileInt32A( "Compatibility", name
, 0 );
414 /* Allocate a code segment alias for the TDB */
416 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
417 sizeof(TDB
), pTask
->hPDB
, TRUE
,
418 FALSE
, FALSE
, NULL
);
420 /* Set the owner of the environment block */
422 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
424 /* Default DTA overwrites command-line */
426 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
427 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
429 /* Inherit default UserSignalHandler from initial process */
431 pInitialTask
= (TDB
*)GlobalLock16( PROCESS_Initial()->task
);
433 pTask
->userhandler
= pInitialTask
->userhandler
;
435 /* Create the 16-bit stack frame */
437 if (!(sp
= pModule
->sp
))
438 sp
= pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
;
439 sp
&= ~1; sp
-= 2*sizeof(STACK16FRAME
);
440 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hInstance
, sp
);
441 frame16
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
442 frame16
->ebp
= sp
+ (int)&((STACK16FRAME
*)0)->bp
;
443 frame16
->bp
= LOWORD(frame16
->ebp
);
444 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
446 frame16
->entry_point
= 0;
447 frame16
->entry_cs
= 0;
448 frame16
->mutex_count
= 1; /* TASK_Reschedule is called from 16-bit code */
449 /* The remaining fields will be initialized in TASK_Reschedule */
451 /* Create the 32-bit stack frame */
453 stack32Top
= (char*)pTask
->thdb
->teb
.stack_top
;
454 frame16
->frame32
= frame32
= (STACK32FRAME
*)stack32Top
- 1;
455 frame32
->frame16
= pTask
->thdb
->cur_stack
+ sizeof(STACK16FRAME
);
461 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
462 /* The remaining fields will be initialized in TASK_Reschedule */
465 TRACE(task
, "module='%s' cmdline='%s' task=%04x\n",
466 name
, cmd_line
, hTask
);
471 /***********************************************************************
474 * NOTE: This routine might be called by a Win32 thread. Thus, we need
475 * to be careful to protect global data structures. We do this
476 * by entering the Win16Lock while linking the task into the
479 void TASK_StartTask( HTASK16 hTask
)
481 /* Add the task to the linked list */
483 SYSLEVEL_EnterWin16Lock();
484 TASK_LinkTask( hTask
);
485 SYSLEVEL_LeaveWin16Lock();
487 TRACE(task
, "linked task %04x\n", hTask
);
489 /* If requested, add entry point breakpoint */
491 if ( TASK_AddTaskEntryBreakpoint
)
492 TASK_AddTaskEntryBreakpoint( hTask
);
494 /* Get the task up and running. If we ourselves are a 16-bit task,
495 we simply Yield(). If we are 32-bit however, we need to signal
496 the main process somehow (NOT YET IMPLEMENTED!) */
498 if ( THREAD_IsWin16( THREAD_Current() ) )
501 FIXME(task
, "Don't know how to start 16-bit task from 32-bit thread. Move the mouse!\n");
505 /***********************************************************************
508 static void TASK_DeleteTask( HTASK16 hTask
)
513 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
516 pTask
->magic
= 0xdead; /* invalidate signature */
518 /* Delete the Win32 part of the task */
520 K32OBJ_DecCount( &pTask
->thdb
->process
->header
);
521 K32OBJ_DecCount( &pTask
->thdb
->header
);
523 /* Free the selector aliases */
525 GLOBAL_FreeBlock( pTask
->hCSAlias
);
526 GLOBAL_FreeBlock( pTask
->hPDB
);
528 /* Free the task module */
530 FreeModule16( pTask
->hModule
);
532 /* Free the task structure itself */
534 GlobalFree16( hTask
);
536 /* Free all memory used by this task (including the 32-bit stack, */
537 /* the environment block and the thunk segments). */
539 GlobalFreeAll( hPDB
);
543 /***********************************************************************
544 * TASK_KillCurrentTask
546 * Kill the currently running task. As it's not possible to kill the
547 * current task like this, it is simply marked for destruction, and will
548 * be killed when either TASK_Reschedule or this function is called again
549 * in the context of another task.
551 void TASK_KillCurrentTask( INT16 exitCode
)
553 TDB
* pTask
= (TDB
*) GlobalLock16( GetCurrentTask() );
554 NE_MODULE
* pModule
= NE_GetPtr( pTask
->hModule
);
555 if (!pTask
) USER_ExitWindows(); /* No current task yet */
557 if ( !THREAD_IsWin16( THREAD_Current() ) )
559 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
563 /* Enter the Win16Lock to protect global data structures
564 NOTE: We never explicitly leave it again. This shouldn't matter
565 though, as it will be released in TASK_Reschedule and this
566 task won't ever get scheduled again ... */
568 SYSLEVEL_EnterWin16Lock();
570 assert(hCurrentTask
== GetCurrentTask());
572 TRACE(task
, "Killing task %04x\n", hCurrentTask
);
574 /* Delete active sockets */
577 WINSOCK_DeleteTaskWSI( pTask
, pTask
->pwsi
);
580 /* Kill DOS VM task */
581 if ( pModule
->lpDosTask
)
582 MZ_KillModule( pModule
->lpDosTask
);
585 /* Perform USER cleanup */
587 if (pTask
->userhandler
)
588 pTask
->userhandler( hCurrentTask
, USIG_TERMINATION
, 0,
589 pTask
->hInstance
, pTask
->hQueue
);
591 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
593 /* If another task is already marked for destruction, */
594 /* we can kill it now, as we are in another context. */
595 TASK_DeleteTask( hTaskToKill
);
600 TRACE(task
, "this is the last task, exiting\n" );
606 /* FIXME: Hack! Send a message to the initial task so that
607 * the GetMessage wakes up and the initial task can check whether
608 * it is the only remaining one and terminate itself ...
609 * The initial task should probably install hooks or something
610 * to get informed about task termination :-/
612 HTASK16 hTask
= PROCESS_Initial()->task
;
613 HMODULE16 hModule
= GetModuleHandle16( "USER" );
614 FARPROC16 postFunc
= WIN32_GetProcAddress16( hModule
, "PostAppMessage" );
616 Callbacks
->CallPostAppMessageProc( postFunc
, hTask
, WM_NULL
, 0, 0 );
619 /* Remove the task from the list to be sure we never switch back to it */
620 TASK_UnlinkTask( hCurrentTask
);
623 TDB
* p
= (TDB
*)GlobalLock16( hFirstTask
);
626 if( p
->hYieldTo
== hCurrentTask
) p
->hYieldTo
= 0;
627 p
= (TDB
*)GlobalLock16( p
->hNext
);
631 hTaskToKill
= hCurrentTask
;
635 TASK_YieldToSystem(pTask
);
637 /* We should never return from this Yield() */
639 ERR(task
,"Return of the living dead %04x!!!\n", hCurrentTask
);
643 /***********************************************************************
646 * This is where all the magic of task-switching happens!
648 * Note: This function should only be called via the TASK_YieldToSystem()
649 * wrapper, to make sure that all the context is saved correctly.
651 * It must not call functions that may yield control.
653 void TASK_Reschedule(void)
655 TDB
*pOldTask
= NULL
, *pNewTask
;
657 STACK16FRAME
*newframe16
;
659 /* Get the initial task up and running */
660 if (!hCurrentTask
&& GetCurrentTask())
662 /* We need to remove one pair of stackframes (exept for Winelib) */
663 STACK16FRAME
*oldframe16
= CURRENT_STACK16
;
664 STACK32FRAME
*oldframe32
= oldframe16
->frame32
;
665 STACK16FRAME
*newframe16
= PTR_SEG_TO_LIN( oldframe32
->frame16
);
666 STACK32FRAME
*newframe32
= newframe16
->frame32
;
669 newframe16
->entry_ip
= oldframe16
->entry_ip
;
670 newframe16
->entry_cs
= oldframe16
->entry_cs
;
671 newframe16
->ip
= oldframe16
->ip
;
672 newframe16
->cs
= oldframe16
->cs
;
673 newframe32
->ebp
= oldframe32
->ebp
;
674 newframe32
->restore_addr
= oldframe32
->restore_addr
;
675 newframe32
->codeselector
= oldframe32
->codeselector
;
677 THREAD_Current()->cur_stack
= oldframe32
->frame16
;
680 hCurrentTask
= GetCurrentTask();
681 pNewTask
= (TDB
*)GlobalLock16( hCurrentTask
);
682 pNewTask
->ss_sp
= pNewTask
->thdb
->cur_stack
;
686 /* NOTE: As we are entered from 16-bit code, we hold the Win16Lock.
687 We hang onto it thoughout most of this routine, so that accesses
688 to global variables (most notably the task list) are protected. */
689 assert(hCurrentTask
== GetCurrentTask());
691 TRACE(task
, "entered with hTask %04x (pid %d)\n", hCurrentTask
, getpid());
694 /* FIXME: What about the Win16Lock ??? */
697 /* First check if there's a task to kill */
699 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
701 TASK_DeleteTask( hTaskToKill
);
705 /* Find a task to yield to */
707 pOldTask
= (TDB
*)GlobalLock16( hCurrentTask
);
708 if (pOldTask
&& pOldTask
->hYieldTo
)
710 /* check for DirectedYield() */
712 hTask
= pOldTask
->hYieldTo
;
713 pNewTask
= (TDB
*)GlobalLock16( hTask
);
714 if( !pNewTask
|| !pNewTask
->nEvents
) hTask
= 0;
715 pOldTask
->hYieldTo
= 0;
718 /* extract hardware events only! */
720 if (!hTask
) EVENT_WaitNetEvent( FALSE
, TRUE
);
724 /* Find a task that has an event pending */
729 pNewTask
= (TDB
*)GlobalLock16( hTask
);
731 TRACE(task
, "\ttask = %04x, events = %i\n", hTask
, pNewTask
->nEvents
);
733 if (pNewTask
->nEvents
) break;
734 hTask
= pNewTask
->hNext
;
736 if (hLockedTask
&& (hTask
!= hLockedTask
)) hTask
= 0;
739 /* No task found, wait for some events to come in */
741 /* NOTE: We release the Win16Lock while waiting for events. This is to enable
742 Win32 threads to thunk down to 16-bit temporarily. Since Win16
743 tasks won't execute and Win32 threads are not allowed to enter
744 TASK_Reschedule anyway, there should be no re-entrancy problem ... */
746 SYSLEVEL_ReleaseWin16Lock();
747 EVENT_WaitNetEvent( TRUE
, TRUE
);
748 SYSLEVEL_RestoreWin16Lock();
751 if (hTask
== hCurrentTask
)
753 TRACE(task
, "returning to the current task(%04x)\n", hTask
);
754 return; /* Nothing to do */
756 pNewTask
= (TDB
*)GlobalLock16( hTask
);
757 TRACE(task
, "Switching to task %04x (%.8s)\n",
758 hTask
, pNewTask
->module_name
);
760 /* Make the task the last in the linked list (round-robin scheduling) */
762 pNewTask
->priority
++;
763 TASK_UnlinkTask( hTask
);
764 TASK_LinkTask( hTask
);
765 pNewTask
->priority
--;
767 /* Finish initializing the new task stack if necessary */
769 newframe16
= THREAD_STACK16( pNewTask
->thdb
);
770 if (!newframe16
->entry_cs
)
772 STACK16FRAME
*oldframe16
= CURRENT_STACK16
;
773 STACK32FRAME
*oldframe32
= oldframe16
->frame32
;
774 STACK32FRAME
*newframe32
= newframe16
->frame32
;
775 newframe16
->entry_ip
= oldframe16
->entry_ip
;
776 newframe16
->entry_cs
= oldframe16
->entry_cs
;
777 newframe16
->ip
= oldframe16
->ip
;
778 newframe16
->cs
= oldframe16
->cs
;
779 newframe32
->ebp
= oldframe32
->ebp
;
780 newframe32
->restore_addr
= oldframe32
->restore_addr
;
781 newframe32
->codeselector
= oldframe32
->codeselector
;
784 /* Switch to the new stack */
786 /* NOTE: We need to release/restore the Win16Lock, as the task
787 switched to might be at another recursion level than
790 SYSLEVEL_ReleaseWin16Lock();
792 hCurrentTask
= hTask
;
793 SET_CUR_THREAD( pNewTask
->thdb
);
794 pNewTask
->ss_sp
= pNewTask
->thdb
->cur_stack
;
796 SYSLEVEL_RestoreWin16Lock();
800 /***********************************************************************
803 * Scheduler interface, this way we ensure that all "unsafe" events are
804 * processed outside the scheduler.
806 void TASK_YieldToSystem(TDB
* pTask
)
810 if ( !THREAD_IsWin16( THREAD_Current() ) )
812 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
816 Callbacks
->CallTaskRescheduleProc();
820 pQ
= (MESSAGEQUEUE
*)GlobalLock16(pTask
->hQueue
);
821 if( pQ
&& pQ
->flags
& QUEUE_FLAG_XEVENT
&&
822 !(pQ
->wakeBits
& (QS_SENDMESSAGE
| QS_SMRESULT
)) )
824 pQ
->flags
&= ~QUEUE_FLAG_XEVENT
;
825 EVENT_WaitNetEvent( FALSE
, FALSE
);
831 /***********************************************************************
832 * InitTask (KERNEL.91)
834 * Called by the application startup code.
836 void WINAPI
InitTask( CONTEXT
*context
)
840 SEGTABLEENTRY
*pSegTable
;
841 INSTANCEDATA
*pinstance
;
842 LONG stacklow
, stackhi
;
844 if (context
) EAX_reg(context
) = 0;
845 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
846 if (!(pModule
= NE_GetPtr( pTask
->hModule
))) return;
848 /* Initialize implicitly loaded DLLs */
849 NE_InitializeDLLs( pTask
->hModule
);
853 /* Registers on return are:
854 * ax 1 if OK, 0 on error
855 * cx stack limit in bytes
856 * dx cmdShow parameter
857 * si instance handle of the previous instance
858 * di instance handle of the new task
859 * es:bx pointer to command-line inside PSP
861 * 0 (=%bp) is pushed on the stack
863 SEGPTR ptr
= STACK16_PUSH( pTask
->thdb
, sizeof(WORD
) );
864 *(WORD
*)PTR_SEG_TO_LIN(ptr
) = 0;
865 SP_reg(context
) -= 2;
867 EAX_reg(context
) = 1;
869 if (!pTask
->pdb
.cmdLine
[0]) EBX_reg(context
) = 0x80;
872 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
873 while ((*p
== ' ') || (*p
== '\t')) p
++;
874 EBX_reg(context
) = 0x80 + (p
- pTask
->pdb
.cmdLine
);
876 ECX_reg(context
) = pModule
->stack_size
;
877 EDX_reg(context
) = pTask
->nCmdShow
;
878 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
879 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
880 ES_reg (context
) = (WORD
)pTask
->hPDB
;
883 /* Initialize the local heap */
884 if ( pModule
->heap_size
)
886 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
889 /* Initialize the INSTANCEDATA structure */
890 pSegTable
= NE_SEG_TABLE( pModule
);
891 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
892 stackhi
= stacklow
+ pModule
->stack_size
;
893 if (stackhi
> 0xffff) stackhi
= 0xffff;
894 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
895 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
896 pinstance
->stacktop
= stacklow
;
897 pinstance
->stackmin
= OFFSETOF( pTask
->thdb
->cur_stack
);
901 /***********************************************************************
902 * WaitEvent (KERNEL.30)
904 BOOL16 WINAPI
WaitEvent( HTASK16 hTask
)
908 if (!hTask
) hTask
= GetCurrentTask();
909 pTask
= (TDB
*)GlobalLock16( hTask
);
911 if ( !THREAD_IsWin16( THREAD_Current() ) )
913 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
917 if (pTask
->nEvents
> 0)
922 TASK_YieldToSystem(pTask
);
924 /* When we get back here, we have an event */
926 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
931 /***********************************************************************
932 * PostEvent (KERNEL.31)
934 void WINAPI
PostEvent( HTASK16 hTask
)
938 if (!hTask
) hTask
= GetCurrentTask();
939 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
941 if ( !THREAD_IsWin16( THREAD_Current() ) )
943 WARN(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
951 /***********************************************************************
952 * SetPriority (KERNEL.32)
954 void WINAPI
SetPriority( HTASK16 hTask
, INT16 delta
)
959 if (!hTask
) hTask
= GetCurrentTask();
960 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
961 newpriority
= pTask
->priority
+ delta
;
962 if (newpriority
< -32) newpriority
= -32;
963 else if (newpriority
> 15) newpriority
= 15;
965 pTask
->priority
= newpriority
+ 1;
966 TASK_UnlinkTask( hTask
);
967 TASK_LinkTask( hTask
);
972 /***********************************************************************
973 * LockCurrentTask (KERNEL.33)
975 HTASK16 WINAPI
LockCurrentTask( BOOL16 bLock
)
977 if (bLock
) hLockedTask
= GetCurrentTask();
978 else hLockedTask
= 0;
983 /***********************************************************************
984 * IsTaskLocked (KERNEL.122)
986 HTASK16 WINAPI
IsTaskLocked(void)
992 /***********************************************************************
993 * OldYield (KERNEL.117)
995 void WINAPI
OldYield(void)
997 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
999 if ( !THREAD_IsWin16( THREAD_Current() ) )
1001 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1005 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
1006 TASK_YieldToSystem(pCurTask
);
1007 if (pCurTask
) pCurTask
->nEvents
--;
1011 /***********************************************************************
1012 * DirectedYield (KERNEL.150)
1014 void WINAPI
DirectedYield( HTASK16 hTask
)
1016 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1018 if ( !THREAD_IsWin16( THREAD_Current() ) )
1020 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1024 TRACE(task
, "%04x: DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
1026 pCurTask
->hYieldTo
= hTask
;
1029 TRACE(task
, "%04x: back from DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
1033 /***********************************************************************
1034 * UserYield (USER.332)
1036 void WINAPI
UserYield(void)
1038 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1039 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
1041 if ( !THREAD_IsWin16( THREAD_Current() ) )
1043 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1047 /* Handle sent messages */
1048 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
1049 QUEUE_ReceiveMessage( queue
);
1053 queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
1054 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
1055 QUEUE_ReceiveMessage( queue
);
1059 /***********************************************************************
1060 * Yield16 (KERNEL.29)
1062 void WINAPI
Yield16(void)
1064 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1066 if ( !THREAD_IsWin16( THREAD_Current() ) )
1068 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1072 if (pCurTask
) pCurTask
->hYieldTo
= 0;
1073 if (pCurTask
&& pCurTask
->hQueue
) UserYield();
1077 /***********************************************************************
1078 * KERNEL_490 (KERNEL.490)
1080 HTASK16 WINAPI
KERNEL_490( HTASK16 someTask
)
1082 if ( !someTask
) return 0;
1084 FIXME( task
, "(%04x): stub\n", someTask
);
1088 /***********************************************************************
1089 * MakeProcInstance16 (KERNEL.51)
1091 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
1097 ERR(task
, "Ouch ! MakeProcInstance called with func == NULL !\n");
1098 return (FARPROC16
)0; /* Windows seems to do the same */
1100 if (!hInstance
) hInstance
= CURRENT_DS
;
1101 thunkaddr
= TASK_AllocThunk( GetCurrentTask() );
1102 if (!thunkaddr
) return (FARPROC16
)0;
1103 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
1104 lfunc
= PTR_SEG_TO_LIN( func
);
1106 TRACE(task
, "(%08lx,%04x): got thunk %08lx\n",
1107 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
1108 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) ||
1109 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58))
1111 FIXME(task
,"thunk would be useless for %p, overwriting with nop;nop;\n", func
);
1112 lfunc
[0]=0x90; /* nop */
1113 lfunc
[1]=0x90; /* nop */
1116 *thunk
++ = 0xb8; /* movw instance, %ax */
1117 *thunk
++ = (BYTE
)(hInstance
& 0xff);
1118 *thunk
++ = (BYTE
)(hInstance
>> 8);
1119 *thunk
++ = 0xea; /* ljmp func */
1120 *(DWORD
*)thunk
= (DWORD
)func
;
1121 return (FARPROC16
)thunkaddr
;
1125 /***********************************************************************
1126 * FreeProcInstance16 (KERNEL.52)
1128 void WINAPI
FreeProcInstance16( FARPROC16 func
)
1130 TRACE(task
, "(%08lx)\n", (DWORD
)func
);
1131 TASK_FreeThunk( GetCurrentTask(), (SEGPTR
)func
);
1135 /**********************************************************************
1136 * GetCodeHandle (KERNEL.93)
1138 HANDLE16 WINAPI
GetCodeHandle( FARPROC16 proc
)
1141 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1143 /* Return the code segment containing 'proc'. */
1144 /* Not sure if this is really correct (shouldn't matter that much). */
1146 /* Check if it is really a thunk */
1147 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1148 handle
= GlobalHandle16( thunk
[6] + (thunk
[7] << 8) );
1150 handle
= GlobalHandle16( HIWORD(proc
) );
1155 /**********************************************************************
1156 * GetCodeInfo (KERNEL.104)
1158 VOID WINAPI
GetCodeInfo( FARPROC16 proc
, SEGINFO
*segInfo
)
1160 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1161 NE_MODULE
*pModule
= NULL
;
1162 SEGTABLEENTRY
*pSeg
= NULL
;
1165 /* proc is either a thunk, or else a pair of module handle
1166 and segment number. In the first case, we also need to
1167 extract module and segment number. */
1169 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1171 WORD selector
= thunk
[6] + (thunk
[7] << 8);
1172 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
1173 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
1176 for ( segNr
= 0; segNr
< pModule
->seg_count
; segNr
++, pSeg
++ )
1177 if ( GlobalHandleToSel(pSeg
->hSeg
) == selector
)
1180 if ( pModule
&& segNr
>= pModule
->seg_count
)
1185 pModule
= NE_GetPtr( HIWORD( proc
) );
1186 segNr
= LOWORD( proc
);
1188 if ( pModule
&& segNr
< pModule
->seg_count
)
1189 pSeg
= NE_SEG_TABLE( pModule
) + segNr
;
1192 /* fill in segment information */
1194 segInfo
->offSegment
= pSeg
? pSeg
->filepos
: 0;
1195 segInfo
->cbSegment
= pSeg
? pSeg
->size
: 0;
1196 segInfo
->flags
= pSeg
? pSeg
->flags
: 0;
1197 segInfo
->cbAlloc
= pSeg
? pSeg
->minsize
: 0;
1198 segInfo
->h
= pSeg
? pSeg
->hSeg
: 0;
1199 segInfo
->alignShift
= pModule
? pModule
->alignment
: 0;
1203 /**********************************************************************
1204 * DefineHandleTable16 (KERNEL.94)
1206 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
1208 return TRUE
; /* FIXME */
1212 /***********************************************************************
1213 * SetTaskQueue (KERNEL.34)
1215 HQUEUE16 WINAPI
SetTaskQueue( HTASK16 hTask
, HQUEUE16 hQueue
)
1220 if (!hTask
) hTask
= GetCurrentTask();
1221 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1223 hPrev
= pTask
->hQueue
;
1224 pTask
->hQueue
= hQueue
;
1226 TIMER_SwitchQueue( hPrev
, hQueue
);
1232 /***********************************************************************
1233 * GetTaskQueue (KERNEL.35)
1235 HQUEUE16 WINAPI
GetTaskQueue( HTASK16 hTask
)
1239 if (!hTask
) hTask
= GetCurrentTask();
1240 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1241 return pTask
->hQueue
;
1244 /***********************************************************************
1245 * SetThreadQueue (KERNEL.463)
1247 HQUEUE16 WINAPI
SetThreadQueue( DWORD thread
, HQUEUE16 hQueue
)
1249 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1250 HQUEUE16 oldQueue
= thdb
? thdb
->teb
.queue
: 0;
1254 thdb
->teb
.queue
= hQueue
;
1256 if ( GetTaskQueue( thdb
->process
->task
) == oldQueue
)
1257 SetTaskQueue( thdb
->process
->task
, hQueue
);
1263 /***********************************************************************
1264 * GetThreadQueue (KERNEL.464)
1266 HQUEUE16 WINAPI
GetThreadQueue( DWORD thread
)
1268 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1269 return (HQUEUE16
)(thdb
? thdb
->teb
.queue
: 0);
1272 /***********************************************************************
1273 * SetFastQueue (KERNEL.624)
1275 VOID WINAPI
SetFastQueue( DWORD thread
, HANDLE32 hQueue
)
1277 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1278 if ( thdb
) thdb
->teb
.queue
= (HQUEUE16
) hQueue
;
1281 /***********************************************************************
1282 * GetFastQueue (KERNEL.625)
1284 HANDLE32 WINAPI
GetFastQueue( void )
1286 THDB
*thdb
= THREAD_Current();
1287 if (!thdb
) return 0;
1289 if (!(thdb
->teb
.queue
))
1291 HMODULE16 hModule
= GetModuleHandle16( "USER" );
1292 FARPROC16 proc
= WIN32_GetProcAddress16( hModule
, "InitThreadInput" );
1293 Callbacks
->CallBootAppProc( proc
, 0, THREAD_IsWin16(thdb
)? 4 : 5 ); /* FIXME! */
1296 if (!(thdb
->teb
.queue
))
1297 FIXME( task
, "(): should initialize thread-local queue, expect failure!\n" );
1299 return (HANDLE32
)thdb
->teb
.queue
;
1302 /***********************************************************************
1303 * SwitchStackTo (KERNEL.108)
1305 void WINAPI
SwitchStackTo( WORD seg
, WORD ptr
, WORD top
)
1308 STACK16FRAME
*oldFrame
, *newFrame
;
1309 INSTANCEDATA
*pData
;
1312 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1313 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1314 TRACE(task
, "old=%04x:%04x new=%04x:%04x\n",
1315 SELECTOROF( pTask
->thdb
->cur_stack
),
1316 OFFSETOF( pTask
->thdb
->cur_stack
), seg
, ptr
);
1318 /* Save the old stack */
1320 oldFrame
= THREAD_STACK16( pTask
->thdb
);
1321 /* pop frame + args and push bp */
1322 pData
->old_ss_sp
= pTask
->thdb
->cur_stack
+ sizeof(STACK16FRAME
)
1324 *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
) = oldFrame
->bp
;
1325 pData
->stacktop
= top
;
1326 pData
->stackmin
= ptr
;
1327 pData
->stackbottom
= ptr
;
1329 /* Switch to the new stack */
1331 /* Note: we need to take the 3 arguments into account; otherwise,
1332 * the stack will underflow upon return from this function.
1334 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1335 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1336 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( seg
, ptr
- copySize
);
1337 newFrame
= THREAD_STACK16( pTask
->thdb
);
1339 /* Copy the stack frame and the local variables to the new stack */
1341 memmove( newFrame
, oldFrame
, copySize
);
1343 *(WORD
*)PTR_SEG_OFF_TO_LIN( seg
, ptr
) = 0; /* clear previous bp */
1347 /***********************************************************************
1348 * SwitchStackBack (KERNEL.109)
1350 void WINAPI
SwitchStackBack( CONTEXT
*context
)
1353 STACK16FRAME
*oldFrame
, *newFrame
;
1354 INSTANCEDATA
*pData
;
1356 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1357 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(pTask
->thdb
->cur_stack
))))
1359 if (!pData
->old_ss_sp
)
1361 WARN( task
, "No previous SwitchStackTo\n" );
1364 TRACE(task
, "restoring stack %04x:%04x\n",
1365 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1367 oldFrame
= THREAD_STACK16( pTask
->thdb
);
1369 /* Pop bp from the previous stack */
1371 BP_reg(context
) = *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
);
1372 pData
->old_ss_sp
+= sizeof(WORD
);
1374 /* Switch back to the old stack */
1376 pTask
->thdb
->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1377 SS_reg(context
) = SELECTOROF(pData
->old_ss_sp
);
1378 ESP_reg(context
) = OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1379 pData
->old_ss_sp
= 0;
1381 /* Build a stack frame for the return */
1383 newFrame
= THREAD_STACK16( pTask
->thdb
);
1384 newFrame
->frame32
= oldFrame
->frame32
;
1385 if (TRACE_ON(relay
))
1387 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1388 newFrame
->entry_cs
= oldFrame
->entry_cs
;
1393 /***********************************************************************
1394 * GetTaskQueueDS (KERNEL.118)
1396 void WINAPI
GetTaskQueueDS( CONTEXT
*context
)
1398 DS_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1402 /***********************************************************************
1403 * GetTaskQueueES (KERNEL.119)
1405 void WINAPI
GetTaskQueueES( CONTEXT
*context
)
1407 ES_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1411 /***********************************************************************
1412 * GetCurrentTask (KERNEL.36)
1414 HTASK16 WINAPI
GetCurrentTask(void)
1416 return THREAD_InitDone
? PROCESS_Current()->task
: 0;
1419 DWORD WINAPI
WIN16_GetCurrentTask(void)
1421 /* This is the version used by relay code; the first task is */
1422 /* returned in the high word of the result */
1423 return MAKELONG( GetCurrentTask(), hFirstTask
);
1427 /***********************************************************************
1428 * GetCurrentPDB (KERNEL.37)
1430 * UNDOC: returns PSP of KERNEL in high word
1432 DWORD WINAPI
GetCurrentPDB(void)
1436 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1437 return MAKELONG(pTask
->hPDB
, 0); /* FIXME */
1441 /***********************************************************************
1442 * GetInstanceData (KERNEL.54)
1444 INT16 WINAPI
GetInstanceData( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1446 char *ptr
= (char *)GlobalLock16( instance
);
1447 if (!ptr
|| !len
) return 0;
1448 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1449 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1454 /***********************************************************************
1455 * GetExeVersion (KERNEL.105)
1457 WORD WINAPI
GetExeVersion(void)
1461 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1462 return pTask
->version
;
1466 /***********************************************************************
1467 * SetErrorMode16 (KERNEL.107)
1469 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1474 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1475 oldMode
= pTask
->error_mode
;
1476 pTask
->error_mode
= mode
;
1477 pTask
->thdb
->process
->error_mode
= mode
;
1482 /***********************************************************************
1483 * SetErrorMode32 (KERNEL32.486)
1485 UINT32 WINAPI
SetErrorMode32( UINT32 mode
)
1487 return SetErrorMode16( (UINT16
)mode
);
1491 /***********************************************************************
1492 * GetDOSEnvironment (KERNEL.131)
1494 SEGPTR WINAPI
GetDOSEnvironment(void)
1498 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1499 return PTR_SEG_OFF_TO_SEGPTR( pTask
->pdb
.environment
, 0 );
1503 /***********************************************************************
1504 * GetNumTasks (KERNEL.152)
1506 UINT16 WINAPI
GetNumTasks(void)
1512 /***********************************************************************
1513 * GetTaskDS (KERNEL.155)
1515 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1516 * I don't think we need to bother with this.
1518 HINSTANCE16 WINAPI
GetTaskDS(void)
1522 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1523 return pTask
->hInstance
;
1526 /***********************************************************************
1527 * GetDummyModuleHandleDS (KERNEL.602)
1529 VOID WINAPI
GetDummyModuleHandleDS( CONTEXT
*context
)
1534 AX_reg( context
) = 0;
1535 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1536 if (!(pTask
->flags
& TDBF_WIN32
)) return;
1538 selector
= GlobalHandleToSel( pTask
->hModule
);
1539 DS_reg( context
) = selector
;
1540 AX_reg( context
) = selector
;
1543 /***********************************************************************
1544 * IsTask (KERNEL.320)
1546 BOOL16 WINAPI
IsTask( HTASK16 hTask
)
1550 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1551 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1552 return (pTask
->magic
== TDB_MAGIC
);
1556 /***********************************************************************
1557 * SetTaskSignalProc (KERNEL.38)
1559 * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1561 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1566 if (!hTask
) hTask
= GetCurrentTask();
1567 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1568 oldProc
= (FARPROC16
)pTask
->userhandler
;
1569 pTask
->userhandler
= (USERSIGNALPROC
)proc
;
1574 /***********************************************************************
1575 * SetSigHandler (KERNEL.140)
1577 WORD WINAPI
SetSigHandler( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1578 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1580 FIXME(task
,"(%p,%p,%p,%d,%d), unimplemented.\n",
1581 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1583 if (flag
!= 1) return 0;
1584 if (!newmode
) newhandler
= NULL
; /* Default handler */
1589 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1590 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1591 pTask
->signal_flags
= newmode
;
1592 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1593 pTask
->sighandler
= newhandler
;
1599 /***********************************************************************
1600 * GlobalNotify (KERNEL.154)
1602 * Note that GlobalNotify does _not_ return the old NotifyProc
1603 * -- contrary to LocalNotify !!
1605 VOID WINAPI
GlobalNotify( FARPROC16 proc
)
1609 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1610 pTask
->discardhandler
= proc
;
1614 /***********************************************************************
1615 * GetExePtr (KERNEL.133)
1617 static HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1622 /* Check for module handle */
1624 if (!(ptr
= GlobalLock16( handle
))) return 0;
1625 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1627 /* Search for this handle inside all tasks */
1629 *hTask
= hFirstTask
;
1632 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1633 if ((*hTask
== handle
) ||
1634 (pTask
->hInstance
== handle
) ||
1635 (pTask
->hQueue
== handle
) ||
1636 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1637 *hTask
= pTask
->hNext
;
1640 /* Check the owner for module handle */
1642 owner
= FarGetOwner( handle
);
1643 if (!(ptr
= GlobalLock16( owner
))) return 0;
1644 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1646 /* Search for the owner inside all tasks */
1648 *hTask
= hFirstTask
;
1651 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1652 if ((*hTask
== owner
) ||
1653 (pTask
->hInstance
== owner
) ||
1654 (pTask
->hQueue
== owner
) ||
1655 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1656 *hTask
= pTask
->hNext
;
1662 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1665 return GetExePtrHelper( handle
, &dummy
);
1668 void WINAPI
WIN16_GetExePtr( CONTEXT
*context
)
1670 WORD
*stack
= PTR_SEG_OFF_TO_LIN(SS_reg(context
), SP_reg(context
));
1671 HANDLE16 handle
= (HANDLE16
)stack
[2];
1675 hModule
= GetExePtrHelper( handle
, &hTask
);
1677 AX_reg(context
) = CX_reg(context
) = hModule
;
1678 if (hTask
) ES_reg(context
) = hTask
;
1681 /***********************************************************************
1682 * TaskFirst (TOOLHELP.63)
1684 BOOL16 WINAPI
TaskFirst( TASKENTRY
*lpte
)
1686 lpte
->hNext
= hFirstTask
;
1687 return TaskNext( lpte
);
1691 /***********************************************************************
1692 * TaskNext (TOOLHELP.64)
1694 BOOL16 WINAPI
TaskNext( TASKENTRY
*lpte
)
1697 INSTANCEDATA
*pInstData
;
1699 TRACE(toolhelp
, "(%p): task=%04x\n", lpte
, lpte
->hNext
);
1700 if (!lpte
->hNext
) return FALSE
;
1701 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1702 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1703 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1704 lpte
->hTask
= lpte
->hNext
;
1705 lpte
->hTaskParent
= pTask
->hParent
;
1706 lpte
->hInst
= pTask
->hInstance
;
1707 lpte
->hModule
= pTask
->hModule
;
1708 lpte
->wSS
= SELECTOROF( pTask
->thdb
->cur_stack
);
1709 lpte
->wSP
= OFFSETOF( pTask
->thdb
->cur_stack
);
1710 lpte
->wStackTop
= pInstData
->stacktop
;
1711 lpte
->wStackMinimum
= pInstData
->stackmin
;
1712 lpte
->wStackBottom
= pInstData
->stackbottom
;
1713 lpte
->wcEvents
= pTask
->nEvents
;
1714 lpte
->hQueue
= pTask
->hQueue
;
1715 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1716 lpte
->szModule
[8] = '\0';
1717 lpte
->wPSPOffset
= 0x100; /*??*/
1718 lpte
->hNext
= pTask
->hNext
;
1723 /***********************************************************************
1724 * TaskFindHandle (TOOLHELP.65)
1726 BOOL16 WINAPI
TaskFindHandle( TASKENTRY
*lpte
, HTASK16 hTask
)
1728 lpte
->hNext
= hTask
;
1729 return TaskNext( lpte
);
1733 /***********************************************************************
1734 * GetAppCompatFlags16 (KERNEL.354)
1736 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1738 return GetAppCompatFlags32( hTask
);
1742 /***********************************************************************
1743 * GetAppCompatFlags32 (USER32.206)
1745 DWORD WINAPI
GetAppCompatFlags32( HTASK32 hTask
)
1749 if (!hTask
) hTask
= GetCurrentTask();
1750 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1751 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1752 return pTask
->compat_flags
;