4 * Copyright 1995 Alexandre Julliard
26 #include "selectors.h"
27 #include "stackframe.h"
40 /* Min. number of thunks allocated when creating a new segment */
43 /* Pointer to function to switch to a larger stack */
44 int (*IF1632_CallLargeStack
)( int (*func
)(), void *arg
) = NULL
;
47 static THHOOK DefaultThhook
= { 0 };
48 THHOOK
*pThhook
= &DefaultThhook
;
50 #define hCurrentTask (pThhook->CurTDB)
51 #define hFirstTask (pThhook->HeadTDB)
52 #define hLockedTask (pThhook->LockTDB)
54 static HTASK16 hTaskToKill
= 0;
55 static UINT16 nTaskCount
= 0;
57 static void TASK_YieldToSystem(TDB
*);
59 extern BOOL32 THREAD_InitDone
;
62 /***********************************************************************
65 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
67 THHOOK
*pOldThhook
= pThhook
;
69 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
71 *pThhook
= *pOldThhook
;
74 /***********************************************************************
77 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
79 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
81 if (pTask
->hNext
) return pTask
->hNext
;
82 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
85 /***********************************************************************
88 static void TASK_LinkTask( HTASK16 hTask
)
93 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
94 prevTask
= &hFirstTask
;
97 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
98 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
99 prevTask
= &prevTaskPtr
->hNext
;
101 pTask
->hNext
= *prevTask
;
107 /***********************************************************************
110 static void TASK_UnlinkTask( HTASK16 hTask
)
115 prevTask
= &hFirstTask
;
116 while (*prevTask
&& (*prevTask
!= hTask
))
118 pTask
= (TDB
*)GlobalLock16( *prevTask
);
119 prevTask
= &pTask
->hNext
;
123 pTask
= (TDB
*)GlobalLock16( *prevTask
);
124 *prevTask
= pTask
->hNext
;
131 /***********************************************************************
134 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
135 * and containing 'count' entries.
137 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
143 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
145 pThunk
->magic
= THUNK_MAGIC
;
146 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
148 for (i
= 0; i
< count
-1; i
++)
150 free
+= 8; /* Offset of next thunk */
151 pThunk
->thunks
[4*i
] = free
;
153 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
157 /***********************************************************************
160 * Allocate a thunk for MakeProcInstance().
162 static SEGPTR
TASK_AllocThunk( HTASK16 hTask
)
168 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
169 sel
= pTask
->hCSAlias
;
170 pThunk
= &pTask
->thunks
;
171 base
= (int)pThunk
- (int)pTask
;
172 while (!pThunk
->free
)
175 if (!sel
) /* Allocate a new segment */
177 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
178 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
179 if (!sel
) return (SEGPTR
)0;
180 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
183 pThunk
= (THUNKS
*)GlobalLock16( sel
);
186 base
+= pThunk
->free
;
187 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
188 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
192 /***********************************************************************
195 * Free a MakeProcInstance() thunk.
197 static BOOL32
TASK_FreeThunk( HTASK16 hTask
, SEGPTR thunk
)
203 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
204 sel
= pTask
->hCSAlias
;
205 pThunk
= &pTask
->thunks
;
206 base
= (int)pThunk
- (int)pTask
;
207 while (sel
&& (sel
!= HIWORD(thunk
)))
210 pThunk
= (THUNKS
*)GlobalLock16( sel
);
213 if (!sel
) return FALSE
;
214 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
215 pThunk
->free
= LOWORD(thunk
) - base
;
220 /***********************************************************************
223 * 32-bit entry point for a new task. This function is responsible for
224 * setting up the registers and jumping to the 16-bit entry point.
226 static void TASK_CallToStart(void)
228 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
229 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
230 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
232 SET_CUR_THREAD( pTask
->thdb
);
235 /* Terminate the stack frame chain */
236 memset(THREAD_STACK16( pTask
->thdb
), '\0', sizeof(STACK16FRAME
));
238 if (pModule
->flags
& NE_FFLAGS_WIN32
)
240 /* FIXME: all this is an ugly hack */
242 LPTHREAD_START_ROUTINE entry
= (LPTHREAD_START_ROUTINE
)
243 RVA_PTR(pModule
->module32
, OptionalHeader
.AddressOfEntryPoint
);
244 DWORD size
= PE_HEADER(pModule
->module32
)->OptionalHeader
.SizeOfStackReserve
;
248 pTask
->userhandler
= (USERSIGNALPROC
)&USER_SignalProc
;
249 if (pModule
->heap_size
)
250 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
252 InitApp( pTask
->hModule
);
253 MODULE_InitializeDLLs( PROCESS_Current(), 0, DLL_PROCESS_ATTACH
, (LPVOID
)-1 );
254 TRACE(relay
, "(entryproc=%p)\n", entry
);
257 ExitProcess( entry(NULL
) );
259 CreateThread( NULL
, size
, entry
, NULL
, 0, &id
);
260 thdb
= THREAD_ID_TO_THDB( id
);
262 while ( thdb
->exit_code
== 0x103 )
265 QUEUE_Signal( pTask
->hSelf
);
268 ExitProcess( thdb
->exit_code
);
271 else if (pModule
->dos_image
)
278 /* Registers at initialization must be:
280 * bx stack size in bytes
281 * cx heap size in bytes
282 * si previous app instance
283 * di current app instance
285 * es selector to the PSP
286 * ds dgroup of the application
288 * sp top of the stack
292 memset( &context
, 0, sizeof(context
) );
293 CS_reg(&context
) = GlobalHandleToSel(pSegTable
[pModule
->cs
- 1].hSeg
);
294 DS_reg(&context
) = GlobalHandleToSel(pSegTable
[pModule
->dgroup
- 1].hSeg
);
295 ES_reg(&context
) = pTask
->hPDB
;
296 EIP_reg(&context
) = pModule
->ip
;
297 EBX_reg(&context
) = pModule
->stack_size
;
298 ECX_reg(&context
) = pModule
->heap_size
;
299 EDI_reg(&context
) = context
.SegDs
;
301 TRACE(task
, "Starting main program: cs:ip=%04lx:%04x ds=%04lx ss:sp=%04x:%04x\n",
302 CS_reg(&context
), IP_reg(&context
), DS_reg(&context
),
303 SELECTOROF(pTask
->thdb
->cur_stack
),
304 OFFSETOF(pTask
->thdb
->cur_stack
) );
306 Callbacks
->CallRegisterShortProc( &context
, 0 );
307 /* This should never return */
308 ERR( task
, "Main program returned! (should never happen)\n" );
314 /***********************************************************************
317 * NOTE: This routine might be called by a Win32 thread. We don't have
318 * any real problems with that, since we operated merely on a private
319 * TDB structure that is not yet linked into the task list.
321 HTASK16
TASK_Create( THDB
*thdb
, NE_MODULE
*pModule
, HINSTANCE16 hInstance
,
322 HINSTANCE16 hPrevInstance
, UINT16 cmdShow
)
330 STACK16FRAME
*frame16
;
331 STACK32FRAME
*frame32
;
332 PDB32
*pdb32
= thdb
->process
;
333 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
335 /* Allocate the task structure */
337 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
338 pModule
->self
, FALSE
, FALSE
, FALSE
);
339 if (!hTask
) return 0;
340 pTask
= (TDB
*)GlobalLock16( hTask
);
342 /* Fill the task structure */
344 pTask
->nEvents
= 1; /* So the task can be started */
345 pTask
->hSelf
= hTask
;
348 if (pModule
->flags
& NE_FFLAGS_WIN32
)
349 pTask
->flags
|= TDBF_WIN32
;
350 if (pModule
->lpDosTask
)
351 pTask
->flags
|= TDBF_WINOLDAP
;
353 pTask
->version
= pModule
->expected_version
;
354 pTask
->hInstance
= hInstance
;
355 pTask
->hPrevInstance
= hPrevInstance
;
356 pTask
->hModule
= pModule
->self
;
357 pTask
->hParent
= GetCurrentTask();
358 pTask
->magic
= TDB_MAGIC
;
359 pTask
->nCmdShow
= cmdShow
;
361 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
362 strcpy( pTask
->curdir
, "\\" );
363 lstrcpyn32A( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
364 sizeof(pTask
->curdir
) - 1 );
366 /* Create the thunks block */
368 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
370 /* Copy the module name */
372 GetModuleName( pModule
->self
, name
, sizeof(name
) );
373 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
375 /* Allocate a selector for the PDB */
377 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
378 pModule
->self
, FALSE
, FALSE
, FALSE
, NULL
);
382 pTask
->pdb
.int20
= 0x20cd;
383 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
384 PUT_DWORD(&pTask
->pdb
.dispatcher
[1], (DWORD
)NE_GetEntryPoint(
385 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
386 pTask
->pdb
.savedint22
= INT_GetPMHandler( 0x22 );
387 pTask
->pdb
.savedint23
= INT_GetPMHandler( 0x23 );
388 pTask
->pdb
.savedint24
= INT_GetPMHandler( 0x24 );
389 pTask
->pdb
.fileHandlesPtr
=
390 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask
->hPDB
),
391 (int)&((PDB
*)0)->fileHandles
);
392 pTask
->pdb
.hFileHandles
= 0;
393 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
394 pTask
->pdb
.environment
= pdb32
->env_db
->env_sel
;
395 pTask
->pdb
.nbFiles
= 20;
397 /* Fill the command line */
399 cmd_line
= pdb32
->env_db
->cmd_line
;
400 while (*cmd_line
&& (*cmd_line
!= ' ') && (*cmd_line
!= '\t')) cmd_line
++;
401 while ((*cmd_line
== ' ') || (*cmd_line
== '\t')) cmd_line
++;
402 lstrcpyn32A( pTask
->pdb
.cmdLine
+1, cmd_line
, sizeof(pTask
->pdb
.cmdLine
)-1);
403 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
405 /* Get the compatibility flags */
407 pTask
->compat_flags
= GetProfileInt32A( "Compatibility", name
, 0 );
409 /* Allocate a code segment alias for the TDB */
411 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
412 sizeof(TDB
), pTask
->hPDB
, TRUE
,
413 FALSE
, FALSE
, NULL
);
415 /* Set the owner of the environment block */
417 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
419 /* Default DTA overwrites command-line */
421 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
422 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
424 /* Create the 16-bit stack frame */
426 if (!(sp
= pModule
->sp
))
427 sp
= pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
;
428 sp
&= ~1; sp
-= 2*sizeof(STACK16FRAME
);
429 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hInstance
, sp
);
430 frame16
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
431 frame16
->ebp
= sp
+ (int)&((STACK16FRAME
*)0)->bp
;
432 frame16
->bp
= LOWORD(frame16
->ebp
);
433 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
435 frame16
->entry_point
= 0;
436 frame16
->entry_cs
= 0;
437 frame16
->mutex_count
= 1; /* TASK_Reschedule is called from 16-bit code */
438 /* The remaining fields will be initialized in TASK_Reschedule */
440 /* Create the 32-bit stack frame */
442 stack32Top
= (char*)pTask
->thdb
->teb
.stack_top
;
443 frame16
->frame32
= frame32
= (STACK32FRAME
*)stack32Top
- 1;
444 frame32
->frame16
= pTask
->thdb
->cur_stack
+ sizeof(STACK16FRAME
);
450 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
451 /* The remaining fields will be initialized in TASK_Reschedule */
454 TRACE(task
, "module='%s' cmdline='%s' task=%04x\n",
455 name
, cmd_line
, hTask
);
460 /***********************************************************************
463 * NOTE: This routine might be called by a Win32 thread. Thus, we need
464 * to be careful to protect global data structures. We do this
465 * by entering the Win16Lock while linking the task into the
468 void TASK_StartTask( HTASK16 hTask
)
470 /* Add the task to the linked list */
472 SYSLEVEL_EnterWin16Lock();
473 TASK_LinkTask( hTask
);
474 SYSLEVEL_LeaveWin16Lock();
476 TRACE(task
, "linked task %04x\n", hTask
);
478 /* Get the task up and running. If we ourselves are a 16-bit task,
479 we simply Yield(). If we are 32-bit however, we need to signal
480 the main process somehow (NOT YET IMPLEMENTED!) */
482 if ( THREAD_IsWin16( THREAD_Current() ) )
485 FIXME(task
, "Don't know how to start 16-bit task from 32-bit thread. Move the mouse!\n");
489 /***********************************************************************
492 static void TASK_DeleteTask( HTASK16 hTask
)
497 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
500 pTask
->magic
= 0xdead; /* invalidate signature */
502 /* Delete the Win32 part of the task */
504 K32OBJ_DecCount( &pTask
->thdb
->process
->header
);
505 K32OBJ_DecCount( &pTask
->thdb
->header
);
507 /* Free the task module */
509 FreeModule16( pTask
->hModule
);
511 /* Free the selector aliases */
513 GLOBAL_FreeBlock( pTask
->hCSAlias
);
514 GLOBAL_FreeBlock( pTask
->hPDB
);
516 /* Free the task structure itself */
518 GlobalFree16( hTask
);
520 /* Free all memory used by this task (including the 32-bit stack, */
521 /* the environment block and the thunk segments). */
523 GlobalFreeAll( hPDB
);
527 /***********************************************************************
528 * TASK_KillCurrentTask
530 * Kill the currently running task. As it's not possible to kill the
531 * current task like this, it is simply marked for destruction, and will
532 * be killed when either TASK_Reschedule or this function is called again
533 * in the context of another task.
535 void TASK_KillCurrentTask( INT16 exitCode
)
537 TDB
* pTask
= (TDB
*) GlobalLock16( GetCurrentTask() );
538 NE_MODULE
* pModule
= NE_GetPtr( pTask
->hModule
);
539 if (!pTask
) USER_ExitWindows(); /* No current task yet */
541 if ( !THREAD_IsWin16( THREAD_Current() ) )
543 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
547 /* Enter the Win16Lock to protect global data structures
548 NOTE: We never explicitly leave it again. This shouldn't matter
549 though, as it will be released in TASK_Reschedule and this
550 task won't ever get scheduled again ... */
552 SYSLEVEL_EnterWin16Lock();
554 assert(hCurrentTask
== GetCurrentTask());
556 TRACE(task
, "Killing task %04x\n", hCurrentTask
);
558 /* Delete active sockets */
561 WINSOCK_DeleteTaskWSI( pTask
, pTask
->pwsi
);
564 /* Kill DOS VM task */
565 if ( pModule
->lpDosTask
)
566 MZ_KillModule( pModule
->lpDosTask
);
569 /* Perform USER cleanup */
571 if (pTask
->userhandler
)
572 pTask
->userhandler( hCurrentTask
, USIG_TERMINATION
, 0,
573 pTask
->hInstance
, pTask
->hQueue
);
575 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
577 /* If another task is already marked for destruction, */
578 /* we can kill it now, as we are in another context. */
579 TASK_DeleteTask( hTaskToKill
);
582 if (nTaskCount
<= 2) /* FIXME */
584 TRACE(task
, "this is the last task, exiting\n" );
588 /* Remove the task from the list to be sure we never switch back to it */
589 TASK_UnlinkTask( hCurrentTask
);
592 TDB
* p
= (TDB
*)GlobalLock16( hFirstTask
);
595 if( p
->hYieldTo
== hCurrentTask
) p
->hYieldTo
= 0;
596 p
= (TDB
*)GlobalLock16( p
->hNext
);
600 hTaskToKill
= hCurrentTask
;
604 TASK_YieldToSystem(pTask
);
606 /* We should never return from this Yield() */
608 ERR(task
,"Return of the living dead %04x!!!\n", hCurrentTask
);
612 /***********************************************************************
615 * This is where all the magic of task-switching happens!
617 * Note: This function should only be called via the TASK_YieldToSystem()
618 * wrapper, to make sure that all the context is saved correctly.
620 * It must not call functions that may yield control.
622 void TASK_Reschedule(void)
624 TDB
*pOldTask
= NULL
, *pNewTask
;
626 STACK16FRAME
*newframe16
;
628 /* Get the initial task up and running */
629 if (!hCurrentTask
&& GetCurrentTask())
631 /* We need to remove one pair of stackframes (exept for Winelib) */
632 STACK16FRAME
*oldframe16
= CURRENT_STACK16
;
633 STACK32FRAME
*oldframe32
= oldframe16
->frame32
;
634 STACK16FRAME
*newframe16
= PTR_SEG_TO_LIN( oldframe32
->frame16
);
635 STACK32FRAME
*newframe32
= newframe16
->frame32
;
638 newframe16
->entry_ip
= oldframe16
->entry_ip
;
639 newframe16
->entry_cs
= oldframe16
->entry_cs
;
640 newframe16
->ip
= oldframe16
->ip
;
641 newframe16
->cs
= oldframe16
->cs
;
642 newframe32
->ebp
= oldframe32
->ebp
;
643 newframe32
->restore_addr
= oldframe32
->restore_addr
;
644 newframe32
->codeselector
= oldframe32
->codeselector
;
646 THREAD_Current()->cur_stack
= oldframe32
->frame16
;
649 hCurrentTask
= GetCurrentTask();
650 pNewTask
= (TDB
*)GlobalLock16( hCurrentTask
);
651 pNewTask
->ss_sp
= pNewTask
->thdb
->cur_stack
;
655 /* NOTE: As we are entered from 16-bit code, we hold the Win16Lock.
656 We hang onto it thoughout most of this routine, so that accesses
657 to global variables (most notably the task list) are protected. */
658 assert(hCurrentTask
== GetCurrentTask());
660 TRACE(task
, "entered with hTask %04x (pid %d)\n", hCurrentTask
, getpid());
663 /* FIXME: What about the Win16Lock ??? */
666 /* First check if there's a task to kill */
668 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
670 TASK_DeleteTask( hTaskToKill
);
674 /* Find a task to yield to */
676 pOldTask
= (TDB
*)GlobalLock16( hCurrentTask
);
677 if (pOldTask
&& pOldTask
->hYieldTo
)
679 /* check for DirectedYield() */
681 hTask
= pOldTask
->hYieldTo
;
682 pNewTask
= (TDB
*)GlobalLock16( hTask
);
683 if( !pNewTask
|| !pNewTask
->nEvents
) hTask
= 0;
684 pOldTask
->hYieldTo
= 0;
687 /* extract hardware events only! */
689 if (!hTask
) EVENT_WaitNetEvent( FALSE
, TRUE
);
693 /* Find a task that has an event pending */
698 pNewTask
= (TDB
*)GlobalLock16( hTask
);
700 TRACE(task
, "\ttask = %04x, events = %i\n", hTask
, pNewTask
->nEvents
);
702 if (pNewTask
->nEvents
) break;
703 hTask
= pNewTask
->hNext
;
705 if (hLockedTask
&& (hTask
!= hLockedTask
)) hTask
= 0;
708 /* No task found, wait for some events to come in */
710 /* NOTE: We release the Win16Lock while waiting for events. This is to enable
711 Win32 threads to thunk down to 16-bit temporarily. Since Win16
712 tasks won't execute and Win32 threads are not allowed to enter
713 TASK_Reschedule anyway, there should be no re-entrancy problem ... */
715 SYSLEVEL_ReleaseWin16Lock();
716 EVENT_WaitNetEvent( TRUE
, TRUE
);
717 SYSLEVEL_RestoreWin16Lock();
720 if (hTask
== hCurrentTask
)
722 TRACE(task
, "returning to the current task(%04x)\n", hTask
);
723 return; /* Nothing to do */
725 pNewTask
= (TDB
*)GlobalLock16( hTask
);
726 TRACE(task
, "Switching to task %04x (%.8s)\n",
727 hTask
, pNewTask
->module_name
);
729 /* Make the task the last in the linked list (round-robin scheduling) */
731 pNewTask
->priority
++;
732 TASK_UnlinkTask( hTask
);
733 TASK_LinkTask( hTask
);
734 pNewTask
->priority
--;
736 /* Finish initializing the new task stack if necessary */
738 newframe16
= THREAD_STACK16( pNewTask
->thdb
);
739 if (!newframe16
->entry_cs
)
741 STACK16FRAME
*oldframe16
= CURRENT_STACK16
;
742 STACK32FRAME
*oldframe32
= oldframe16
->frame32
;
743 STACK32FRAME
*newframe32
= newframe16
->frame32
;
744 newframe16
->entry_ip
= oldframe16
->entry_ip
;
745 newframe16
->entry_cs
= oldframe16
->entry_cs
;
746 newframe16
->ip
= oldframe16
->ip
;
747 newframe16
->cs
= oldframe16
->cs
;
748 newframe32
->ebp
= oldframe32
->ebp
;
749 newframe32
->restore_addr
= oldframe32
->restore_addr
;
750 newframe32
->codeselector
= oldframe32
->codeselector
;
753 /* Switch to the new stack */
755 /* NOTE: We need to release/restore the Win16Lock, as the task
756 switched to might be at another recursion level than
759 SYSLEVEL_ReleaseWin16Lock();
761 hCurrentTask
= hTask
;
762 SET_CUR_THREAD( pNewTask
->thdb
);
763 pNewTask
->ss_sp
= pNewTask
->thdb
->cur_stack
;
765 SYSLEVEL_RestoreWin16Lock();
769 /***********************************************************************
772 * Scheduler interface, this way we ensure that all "unsafe" events are
773 * processed outside the scheduler.
775 void TASK_YieldToSystem(TDB
* pTask
)
779 if ( !THREAD_IsWin16( THREAD_Current() ) )
781 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
785 Callbacks
->CallTaskRescheduleProc();
789 pQ
= (MESSAGEQUEUE
*)GlobalLock16(pTask
->hQueue
);
790 if( pQ
&& pQ
->flags
& QUEUE_FLAG_XEVENT
&&
791 !(pQ
->wakeBits
& (QS_SENDMESSAGE
| QS_SMRESULT
)) )
793 pQ
->flags
&= ~QUEUE_FLAG_XEVENT
;
794 EVENT_WaitNetEvent( FALSE
, FALSE
);
800 /***********************************************************************
801 * InitTask (KERNEL.91)
803 * Called by the application startup code.
805 void WINAPI
InitTask( CONTEXT
*context
)
809 SEGTABLEENTRY
*pSegTable
;
810 INSTANCEDATA
*pinstance
;
811 LONG stacklow
, stackhi
;
813 if (context
) EAX_reg(context
) = 0;
814 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
815 if (!(pModule
= NE_GetPtr( pTask
->hModule
))) return;
817 /* This is a hack to install task USER signal handler before
818 * implicitly loaded DLLs are initialized (see windows/user.c) */
820 pTask
->userhandler
= (USERSIGNALPROC
)&USER_SignalProc
;
822 /* Initialize implicitly loaded DLLs */
823 NE_InitializeDLLs( pTask
->hModule
);
827 /* Registers on return are:
828 * ax 1 if OK, 0 on error
829 * cx stack limit in bytes
830 * dx cmdShow parameter
831 * si instance handle of the previous instance
832 * di instance handle of the new task
833 * es:bx pointer to command-line inside PSP
835 * 0 (=%bp) is pushed on the stack
837 SEGPTR ptr
= STACK16_PUSH( pTask
->thdb
, sizeof(WORD
) );
838 *(WORD
*)PTR_SEG_TO_LIN(ptr
) = 0;
839 SP_reg(context
) -= 2;
841 EAX_reg(context
) = 1;
843 if (!pTask
->pdb
.cmdLine
[0]) EBX_reg(context
) = 0x80;
846 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
847 while ((*p
== ' ') || (*p
== '\t')) p
++;
848 EBX_reg(context
) = 0x80 + (p
- pTask
->pdb
.cmdLine
);
850 ECX_reg(context
) = pModule
->stack_size
;
851 EDX_reg(context
) = pTask
->nCmdShow
;
852 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
853 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
854 ES_reg (context
) = (WORD
)pTask
->hPDB
;
857 /* Initialize the local heap */
858 if ( pModule
->heap_size
)
860 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
863 /* Initialize the INSTANCEDATA structure */
864 pSegTable
= NE_SEG_TABLE( pModule
);
865 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
866 stackhi
= stacklow
+ pModule
->stack_size
;
867 if (stackhi
> 0xffff) stackhi
= 0xffff;
868 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
869 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
870 pinstance
->stacktop
= stacklow
;
871 pinstance
->stackmin
= OFFSETOF( pTask
->thdb
->cur_stack
);
875 /***********************************************************************
876 * WaitEvent (KERNEL.30)
878 BOOL16 WINAPI
WaitEvent( HTASK16 hTask
)
882 if (!hTask
) hTask
= GetCurrentTask();
883 pTask
= (TDB
*)GlobalLock16( hTask
);
885 if ( !THREAD_IsWin16( THREAD_Current() ) )
887 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
891 if (pTask
->nEvents
> 0)
896 TASK_YieldToSystem(pTask
);
898 /* When we get back here, we have an event */
900 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
905 /***********************************************************************
906 * PostEvent (KERNEL.31)
908 void WINAPI
PostEvent( HTASK16 hTask
)
912 if (!hTask
) hTask
= GetCurrentTask();
913 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
915 if ( !THREAD_IsWin16( THREAD_Current() ) )
917 WARN(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
925 /***********************************************************************
926 * SetPriority (KERNEL.32)
928 void WINAPI
SetPriority( HTASK16 hTask
, INT16 delta
)
933 if (!hTask
) hTask
= GetCurrentTask();
934 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
935 newpriority
= pTask
->priority
+ delta
;
936 if (newpriority
< -32) newpriority
= -32;
937 else if (newpriority
> 15) newpriority
= 15;
939 pTask
->priority
= newpriority
+ 1;
940 TASK_UnlinkTask( hTask
);
941 TASK_LinkTask( hTask
);
946 /***********************************************************************
947 * LockCurrentTask (KERNEL.33)
949 HTASK16 WINAPI
LockCurrentTask( BOOL16 bLock
)
951 if (bLock
) hLockedTask
= GetCurrentTask();
952 else hLockedTask
= 0;
957 /***********************************************************************
958 * IsTaskLocked (KERNEL.122)
960 HTASK16 WINAPI
IsTaskLocked(void)
966 /***********************************************************************
967 * OldYield (KERNEL.117)
969 void WINAPI
OldYield(void)
971 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
973 if ( !THREAD_IsWin16( THREAD_Current() ) )
975 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
979 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
980 TASK_YieldToSystem(pCurTask
);
981 if (pCurTask
) pCurTask
->nEvents
--;
985 /***********************************************************************
986 * DirectedYield (KERNEL.150)
988 void WINAPI
DirectedYield( HTASK16 hTask
)
990 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
992 if ( !THREAD_IsWin16( THREAD_Current() ) )
994 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
998 TRACE(task
, "%04x: DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
1000 pCurTask
->hYieldTo
= hTask
;
1003 TRACE(task
, "%04x: back from DirectedYield(%04x)\n", pCurTask
->hSelf
, hTask
);
1007 /***********************************************************************
1008 * UserYield (USER.332)
1010 void WINAPI
UserYield(void)
1012 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1013 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
1015 if ( !THREAD_IsWin16( THREAD_Current() ) )
1017 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1021 /* Handle sent messages */
1022 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
1023 QUEUE_ReceiveMessage( queue
);
1027 queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
1028 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
1029 QUEUE_ReceiveMessage( queue
);
1033 /***********************************************************************
1034 * Yield16 (KERNEL.29)
1036 void WINAPI
Yield16(void)
1038 TDB
*pCurTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
1040 if ( !THREAD_IsWin16( THREAD_Current() ) )
1042 FIXME(task
, "called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel
);
1046 if (pCurTask
) pCurTask
->hYieldTo
= 0;
1047 if (pCurTask
&& pCurTask
->hQueue
) UserYield();
1052 /***********************************************************************
1053 * MakeProcInstance16 (KERNEL.51)
1055 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
1061 ERR(task
, "Ouch ! MakeProcInstance called with func == NULL !\n");
1062 return (FARPROC16
)0; /* Windows seems to do the same */
1064 if (!hInstance
) hInstance
= CURRENT_DS
;
1065 thunkaddr
= TASK_AllocThunk( GetCurrentTask() );
1066 if (!thunkaddr
) return (FARPROC16
)0;
1067 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
1068 lfunc
= PTR_SEG_TO_LIN( func
);
1070 TRACE(task
, "(%08lx,%04x): got thunk %08lx\n",
1071 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
1072 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) ||
1073 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58))
1075 FIXME(task
,"thunk would be useless for %p, overwriting with nop;nop;\n", func
);
1076 lfunc
[0]=0x90; /* nop */
1077 lfunc
[1]=0x90; /* nop */
1080 *thunk
++ = 0xb8; /* movw instance, %ax */
1081 *thunk
++ = (BYTE
)(hInstance
& 0xff);
1082 *thunk
++ = (BYTE
)(hInstance
>> 8);
1083 *thunk
++ = 0xea; /* ljmp func */
1084 *(DWORD
*)thunk
= (DWORD
)func
;
1085 return (FARPROC16
)thunkaddr
;
1089 /***********************************************************************
1090 * FreeProcInstance16 (KERNEL.52)
1092 void WINAPI
FreeProcInstance16( FARPROC16 func
)
1094 TRACE(task
, "(%08lx)\n", (DWORD
)func
);
1095 TASK_FreeThunk( GetCurrentTask(), (SEGPTR
)func
);
1099 /**********************************************************************
1100 * GetCodeHandle (KERNEL.93)
1102 HANDLE16 WINAPI
GetCodeHandle( FARPROC16 proc
)
1105 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1107 /* Return the code segment containing 'proc'. */
1108 /* Not sure if this is really correct (shouldn't matter that much). */
1110 /* Check if it is really a thunk */
1111 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1112 handle
= GlobalHandle16( thunk
[6] + (thunk
[7] << 8) );
1114 handle
= GlobalHandle16( HIWORD(proc
) );
1119 /**********************************************************************
1120 * GetCodeInfo (KERNEL.104)
1122 VOID WINAPI
GetCodeInfo( FARPROC16 proc
, SEGINFO
*segInfo
)
1124 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1125 NE_MODULE
*pModule
= NULL
;
1126 SEGTABLEENTRY
*pSeg
= NULL
;
1129 /* proc is either a thunk, or else a pair of module handle
1130 and segment number. In the first case, we also need to
1131 extract module and segment number. */
1133 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1135 WORD selector
= thunk
[6] + (thunk
[7] << 8);
1136 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
1137 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
1140 for ( segNr
= 0; segNr
< pModule
->seg_count
; segNr
++, pSeg
++ )
1141 if ( GlobalHandleToSel(pSeg
->hSeg
) == selector
)
1144 if ( pModule
&& segNr
>= pModule
->seg_count
)
1149 pModule
= NE_GetPtr( HIWORD( proc
) );
1150 segNr
= LOWORD( proc
);
1152 if ( pModule
&& segNr
< pModule
->seg_count
)
1153 pSeg
= NE_SEG_TABLE( pModule
) + segNr
;
1156 /* fill in segment information */
1158 segInfo
->offSegment
= pSeg
? pSeg
->filepos
: 0;
1159 segInfo
->cbSegment
= pSeg
? pSeg
->size
: 0;
1160 segInfo
->flags
= pSeg
? pSeg
->flags
: 0;
1161 segInfo
->cbAlloc
= pSeg
? pSeg
->minsize
: 0;
1162 segInfo
->h
= pSeg
? pSeg
->hSeg
: 0;
1163 segInfo
->alignShift
= pModule
? pModule
->alignment
: 0;
1167 /**********************************************************************
1168 * DefineHandleTable16 (KERNEL.94)
1170 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
1172 return TRUE
; /* FIXME */
1176 /***********************************************************************
1177 * SetTaskQueue (KERNEL.34)
1179 HQUEUE16 WINAPI
SetTaskQueue( HTASK16 hTask
, HQUEUE16 hQueue
)
1184 if (!hTask
) hTask
= GetCurrentTask();
1185 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1187 hPrev
= pTask
->hQueue
;
1188 pTask
->hQueue
= hQueue
;
1190 TIMER_SwitchQueue( hPrev
, hQueue
);
1196 /***********************************************************************
1197 * GetTaskQueue (KERNEL.35)
1199 HQUEUE16 WINAPI
GetTaskQueue( HTASK16 hTask
)
1203 if (!hTask
) hTask
= GetCurrentTask();
1204 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1205 return pTask
->hQueue
;
1208 /***********************************************************************
1209 * SetThreadQueue (KERNEL.463)
1211 HQUEUE16 WINAPI
SetThreadQueue( DWORD thread
, HQUEUE16 hQueue
)
1213 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1214 HQUEUE16 oldQueue
= thdb
? thdb
->teb
.queue
: 0;
1218 thdb
->teb
.queue
= hQueue
;
1220 if ( GetTaskQueue( thdb
->process
->task
) == oldQueue
)
1221 SetTaskQueue( thdb
->process
->task
, hQueue
);
1227 /***********************************************************************
1228 * GetThreadQueue (KERNEL.464)
1230 HQUEUE16 WINAPI
GetThreadQueue( DWORD thread
)
1232 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1233 return (HQUEUE16
)(thdb
? thdb
->teb
.queue
: 0);
1236 /***********************************************************************
1237 * SetFastQueue (KERNEL.624)
1239 VOID WINAPI
SetFastQueue( DWORD thread
, HANDLE32 hQueue
)
1241 THDB
*thdb
= THREAD_IdToTHDB( thread
);
1242 if ( thdb
) thdb
->teb
.queue
= (HQUEUE16
) hQueue
;
1245 /***********************************************************************
1246 * GetFastQueue (KERNEL.625)
1248 HANDLE32 WINAPI
GetFastQueue( void )
1250 THDB
*thdb
= THREAD_Current();
1251 if (!thdb
) return 0;
1253 if (!(thdb
->teb
.queue
))
1255 HMODULE16 hModule
= GetModuleHandle16( "USER" );
1256 FARPROC16 proc
= WIN32_GetProcAddress16( hModule
, "InitThreadInput" );
1257 Callbacks
->CallBootAppProc( proc
, 0, 4 ); /* FIXME! */
1260 if (!(thdb
->teb
.queue
))
1261 FIXME( task
, "(): should initialize thread-local queue, expect failure!\n" );
1263 return (HANDLE32
)thdb
->teb
.queue
;
1266 /***********************************************************************
1267 * SwitchStackTo (KERNEL.108)
1269 void WINAPI
SwitchStackTo( WORD seg
, WORD ptr
, WORD top
)
1272 STACK16FRAME
*oldFrame
, *newFrame
;
1273 INSTANCEDATA
*pData
;
1276 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1277 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1278 TRACE(task
, "old=%04x:%04x new=%04x:%04x\n",
1279 SELECTOROF( pTask
->thdb
->cur_stack
),
1280 OFFSETOF( pTask
->thdb
->cur_stack
), seg
, ptr
);
1282 /* Save the old stack */
1284 oldFrame
= THREAD_STACK16( pTask
->thdb
);
1285 /* pop frame + args and push bp */
1286 pData
->old_ss_sp
= pTask
->thdb
->cur_stack
+ sizeof(STACK16FRAME
)
1288 *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
) = oldFrame
->bp
;
1289 pData
->stacktop
= top
;
1290 pData
->stackmin
= ptr
;
1291 pData
->stackbottom
= ptr
;
1293 /* Switch to the new stack */
1295 /* Note: we need to take the 3 arguments into account; otherwise,
1296 * the stack will underflow upon return from this function.
1298 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1299 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1300 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( seg
, ptr
- copySize
);
1301 newFrame
= THREAD_STACK16( pTask
->thdb
);
1303 /* Copy the stack frame and the local variables to the new stack */
1305 memmove( newFrame
, oldFrame
, copySize
);
1307 *(WORD
*)PTR_SEG_OFF_TO_LIN( seg
, ptr
) = 0; /* clear previous bp */
1311 /***********************************************************************
1312 * SwitchStackBack (KERNEL.109)
1314 void WINAPI
SwitchStackBack( CONTEXT
*context
)
1317 STACK16FRAME
*oldFrame
, *newFrame
;
1318 INSTANCEDATA
*pData
;
1320 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1321 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(pTask
->thdb
->cur_stack
))))
1323 if (!pData
->old_ss_sp
)
1325 WARN( task
, "No previous SwitchStackTo\n" );
1328 TRACE(task
, "restoring stack %04x:%04x\n",
1329 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1331 oldFrame
= THREAD_STACK16( pTask
->thdb
);
1333 /* Pop bp from the previous stack */
1335 BP_reg(context
) = *(WORD
*)PTR_SEG_TO_LIN(pData
->old_ss_sp
);
1336 pData
->old_ss_sp
+= sizeof(WORD
);
1338 /* Switch back to the old stack */
1340 pTask
->thdb
->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1341 SS_reg(context
) = SELECTOROF(pData
->old_ss_sp
);
1342 ESP_reg(context
) = OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1343 pData
->old_ss_sp
= 0;
1345 /* Build a stack frame for the return */
1347 newFrame
= THREAD_STACK16( pTask
->thdb
);
1348 newFrame
->frame32
= oldFrame
->frame32
;
1349 if (TRACE_ON(relay
))
1351 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1352 newFrame
->entry_cs
= oldFrame
->entry_cs
;
1357 /***********************************************************************
1358 * GetTaskQueueDS (KERNEL.118)
1360 void WINAPI
GetTaskQueueDS( CONTEXT
*context
)
1362 DS_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1366 /***********************************************************************
1367 * GetTaskQueueES (KERNEL.119)
1369 void WINAPI
GetTaskQueueES( CONTEXT
*context
)
1371 ES_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1375 /***********************************************************************
1376 * GetCurrentTask (KERNEL.36)
1378 HTASK16 WINAPI
GetCurrentTask(void)
1380 return THREAD_InitDone
? PROCESS_Current()->task
: 0;
1383 DWORD WINAPI
WIN16_GetCurrentTask(void)
1385 /* This is the version used by relay code; the first task is */
1386 /* returned in the high word of the result */
1387 return MAKELONG( GetCurrentTask(), hFirstTask
);
1391 /***********************************************************************
1392 * GetCurrentPDB (KERNEL.37)
1394 HANDLE16 WINAPI
GetCurrentPDB(void)
1398 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1403 /***********************************************************************
1404 * GetInstanceData (KERNEL.54)
1406 INT16 WINAPI
GetInstanceData( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1408 char *ptr
= (char *)GlobalLock16( instance
);
1409 if (!ptr
|| !len
) return 0;
1410 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1411 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1416 /***********************************************************************
1417 * GetExeVersion (KERNEL.105)
1419 WORD WINAPI
GetExeVersion(void)
1423 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1424 return pTask
->version
;
1428 /***********************************************************************
1429 * SetErrorMode16 (KERNEL.107)
1431 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1436 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1437 oldMode
= pTask
->error_mode
;
1438 pTask
->error_mode
= mode
;
1439 pTask
->thdb
->process
->error_mode
= mode
;
1444 /***********************************************************************
1445 * SetErrorMode32 (KERNEL32.486)
1447 UINT32 WINAPI
SetErrorMode32( UINT32 mode
)
1449 return SetErrorMode16( (UINT16
)mode
);
1453 /***********************************************************************
1454 * GetDOSEnvironment (KERNEL.131)
1456 SEGPTR WINAPI
GetDOSEnvironment(void)
1460 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1461 return PTR_SEG_OFF_TO_SEGPTR( pTask
->pdb
.environment
, 0 );
1465 /***********************************************************************
1466 * GetNumTasks (KERNEL.152)
1468 UINT16 WINAPI
GetNumTasks(void)
1474 /***********************************************************************
1475 * GetTaskDS (KERNEL.155)
1477 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1478 * I don't think we need to bother with this.
1480 HINSTANCE16 WINAPI
GetTaskDS(void)
1484 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1485 return pTask
->hInstance
;
1489 /***********************************************************************
1490 * IsTask (KERNEL.320)
1492 BOOL16 WINAPI
IsTask( HTASK16 hTask
)
1496 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1497 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1498 return (pTask
->magic
== TDB_MAGIC
);
1502 /***********************************************************************
1503 * SetTaskSignalProc (KERNEL.38)
1505 * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1507 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1512 if (!hTask
) hTask
= GetCurrentTask();
1513 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1514 oldProc
= (FARPROC16
)pTask
->userhandler
;
1515 pTask
->userhandler
= (USERSIGNALPROC
)proc
;
1520 /***********************************************************************
1521 * SetSigHandler (KERNEL.140)
1523 WORD WINAPI
SetSigHandler( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1524 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1526 FIXME(task
,"(%p,%p,%p,%d,%d), unimplemented.\n",
1527 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1529 if (flag
!= 1) return 0;
1530 if (!newmode
) newhandler
= NULL
; /* Default handler */
1535 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return 0;
1536 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1537 pTask
->signal_flags
= newmode
;
1538 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1539 pTask
->sighandler
= newhandler
;
1545 /***********************************************************************
1546 * GlobalNotify (KERNEL.154)
1548 VOID WINAPI
GlobalNotify( FARPROC16 proc
)
1552 if (!(pTask
= (TDB
*)GlobalLock16( GetCurrentTask() ))) return;
1553 pTask
->discardhandler
= proc
;
1557 /***********************************************************************
1558 * GetExePtr (KERNEL.133)
1560 static HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1565 /* Check for module handle */
1567 if (!(ptr
= GlobalLock16( handle
))) return 0;
1568 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1570 /* Search for this handle inside all tasks */
1572 *hTask
= hFirstTask
;
1575 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1576 if ((*hTask
== handle
) ||
1577 (pTask
->hInstance
== handle
) ||
1578 (pTask
->hQueue
== handle
) ||
1579 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1580 *hTask
= pTask
->hNext
;
1583 /* Check the owner for module handle */
1585 owner
= FarGetOwner( handle
);
1586 if (!(ptr
= GlobalLock16( owner
))) return 0;
1587 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1589 /* Search for the owner inside all tasks */
1591 *hTask
= hFirstTask
;
1594 TDB
*pTask
= (TDB
*)GlobalLock16( *hTask
);
1595 if ((*hTask
== owner
) ||
1596 (pTask
->hInstance
== owner
) ||
1597 (pTask
->hQueue
== owner
) ||
1598 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1599 *hTask
= pTask
->hNext
;
1605 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1608 return GetExePtrHelper( handle
, &dummy
);
1611 void WINAPI
WIN16_GetExePtr( CONTEXT
*context
)
1613 WORD
*stack
= PTR_SEG_OFF_TO_LIN(SS_reg(context
), SP_reg(context
));
1614 HANDLE16 handle
= (HANDLE16
)stack
[2];
1618 hModule
= GetExePtrHelper( handle
, &hTask
);
1620 AX_reg(context
) = CX_reg(context
) = hModule
;
1621 if (hTask
) ES_reg(context
) = hTask
;
1624 /***********************************************************************
1625 * TaskFirst (TOOLHELP.63)
1627 BOOL16 WINAPI
TaskFirst( TASKENTRY
*lpte
)
1629 lpte
->hNext
= hFirstTask
;
1630 return TaskNext( lpte
);
1634 /***********************************************************************
1635 * TaskNext (TOOLHELP.64)
1637 BOOL16 WINAPI
TaskNext( TASKENTRY
*lpte
)
1640 INSTANCEDATA
*pInstData
;
1642 TRACE(toolhelp
, "(%p): task=%04x\n", lpte
, lpte
->hNext
);
1643 if (!lpte
->hNext
) return FALSE
;
1644 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1645 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1646 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1647 lpte
->hTask
= lpte
->hNext
;
1648 lpte
->hTaskParent
= pTask
->hParent
;
1649 lpte
->hInst
= pTask
->hInstance
;
1650 lpte
->hModule
= pTask
->hModule
;
1651 lpte
->wSS
= SELECTOROF( pTask
->thdb
->cur_stack
);
1652 lpte
->wSP
= OFFSETOF( pTask
->thdb
->cur_stack
);
1653 lpte
->wStackTop
= pInstData
->stacktop
;
1654 lpte
->wStackMinimum
= pInstData
->stackmin
;
1655 lpte
->wStackBottom
= pInstData
->stackbottom
;
1656 lpte
->wcEvents
= pTask
->nEvents
;
1657 lpte
->hQueue
= pTask
->hQueue
;
1658 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1659 lpte
->szModule
[8] = '\0';
1660 lpte
->wPSPOffset
= 0x100; /*??*/
1661 lpte
->hNext
= pTask
->hNext
;
1666 /***********************************************************************
1667 * TaskFindHandle (TOOLHELP.65)
1669 BOOL16 WINAPI
TaskFindHandle( TASKENTRY
*lpte
, HTASK16 hTask
)
1671 lpte
->hNext
= hTask
;
1672 return TaskNext( lpte
);
1676 /***********************************************************************
1677 * GetAppCompatFlags16 (KERNEL.354)
1679 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1681 return GetAppCompatFlags32( hTask
);
1685 /***********************************************************************
1686 * GetAppCompatFlags32 (USER32.206)
1688 DWORD WINAPI
GetAppCompatFlags32( HTASK32 hTask
)
1692 if (!hTask
) hTask
= GetCurrentTask();
1693 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1694 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1695 return pTask
->compat_flags
;