4 * Copyright 1995 Alexandre Julliard
26 #include "selectors.h"
27 #include "stackframe.h"
36 /* Min. number of thunks allocated when creating a new segment */
39 extern INT32
WINSOCK_DeleteTaskWSI( TDB
* pTask
, struct _WSINFO
* );
40 extern BOOL32
MODULE_FreeModule( HMODULE16 hModule
, TDB
* ptaskContext
);
42 /* Pointer to function to switch to a larger stack */
43 int (*IF1632_CallLargeStack
)( int (*func
)(), void *arg
) = NULL
;
45 static HTASK16 hFirstTask
= 0;
46 static HTASK16 hCurrentTask
= 0;
47 static HTASK16 hTaskToKill
= 0;
48 static HTASK16 hLockedTask
= 0;
49 static UINT16 nTaskCount
= 0;
51 static void TASK_YieldToSystem(TDB
*);
54 /***********************************************************************
57 HTASK16
TASK_GetNextTask( HTASK16 hTask
)
59 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
61 if (pTask
->hNext
) return pTask
->hNext
;
62 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
66 /***********************************************************************
69 static void TASK_LinkTask( HTASK16 hTask
)
74 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
75 prevTask
= &hFirstTask
;
78 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
79 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
80 prevTask
= &prevTaskPtr
->hNext
;
82 pTask
->hNext
= *prevTask
;
88 /***********************************************************************
91 static void TASK_UnlinkTask( HTASK16 hTask
)
96 prevTask
= &hFirstTask
;
97 while (*prevTask
&& (*prevTask
!= hTask
))
99 pTask
= (TDB
*)GlobalLock16( *prevTask
);
100 prevTask
= &pTask
->hNext
;
104 pTask
= (TDB
*)GlobalLock16( *prevTask
);
105 *prevTask
= pTask
->hNext
;
112 /***********************************************************************
115 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
116 * and containing 'count' entries.
118 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
124 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
126 pThunk
->magic
= THUNK_MAGIC
;
127 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
129 for (i
= 0; i
< count
-1; i
++)
131 free
+= 8; /* Offset of next thunk */
132 pThunk
->thunks
[4*i
] = free
;
134 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
138 /***********************************************************************
141 * Allocate a thunk for MakeProcInstance().
143 static SEGPTR
TASK_AllocThunk( HTASK16 hTask
)
149 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
150 sel
= pTask
->hCSAlias
;
151 pThunk
= &pTask
->thunks
;
152 base
= (int)pThunk
- (int)pTask
;
153 while (!pThunk
->free
)
156 if (!sel
) /* Allocate a new segment */
158 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
159 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
160 if (!sel
) return (SEGPTR
)0;
161 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
164 pThunk
= (THUNKS
*)GlobalLock16( sel
);
167 base
+= pThunk
->free
;
168 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
169 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
173 /***********************************************************************
176 * Free a MakeProcInstance() thunk.
178 static BOOL32
TASK_FreeThunk( HTASK16 hTask
, SEGPTR thunk
)
184 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
185 sel
= pTask
->hCSAlias
;
186 pThunk
= &pTask
->thunks
;
187 base
= (int)pThunk
- (int)pTask
;
188 while (sel
&& (sel
!= HIWORD(thunk
)))
191 pThunk
= (THUNKS
*)GlobalLock16( sel
);
194 if (!sel
) return FALSE
;
195 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
196 pThunk
->free
= LOWORD(thunk
) - base
;
201 /***********************************************************************
204 * 32-bit entry point for a new task. This function is responsible for
205 * setting up the registers and jumping to the 16-bit entry point.
207 static void TASK_CallToStart(void)
210 TDB
*pTask
= (TDB
*)GlobalLock16( hCurrentTask
);
211 NE_MODULE
*pModule
= MODULE_GetPtr( pTask
->hModule
);
212 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
214 SET_CUR_THREAD( pTask
->thdb
);
215 /* Terminate the stack frame */
216 THREAD_STACK16(pTask
->thdb
)->frame32
= NULL
;
217 if (pModule
->flags
& NE_FFLAGS_WIN32
)
219 /* FIXME: all this is an ugly hack */
221 FARPROC32 entry
= (FARPROC32
)RVA_PTR( PROCESS_Current()->exe_modref
->module
, OptionalHeader
.AddressOfEntryPoint
);
223 pTask
->userhandler
= (USERSIGNALPROC
)&USER_SignalProc
;
224 if (pModule
->heap_size
)
225 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
227 InitApp( pTask
->hModule
);
228 PE_InitializeDLLs( PROCESS_Current(), DLL_PROCESS_ATTACH
, (LPVOID
)-1 );
229 TRACE(relay
, "(entryproc=%p)\n", entry
);
231 TASK_KillCurrentTask( exit_code
);
235 /* Registers at initialization must be:
237 * bx stack size in bytes
238 * cx heap size in bytes
239 * si previous app instance
240 * di current app instance
242 * es selector to the PSP
243 * ds dgroup of the application
245 * sp top of the stack
249 memset( &context
, 0, sizeof(context
) );
250 CS_reg(&context
) = pSegTable
[pModule
->cs
- 1].selector
;
251 DS_reg(&context
) = pSegTable
[pModule
->dgroup
- 1].selector
;
252 ES_reg(&context
) = pTask
->hPDB
;
253 EIP_reg(&context
) = pModule
->ip
;
254 EBX_reg(&context
) = pModule
->stack_size
;
255 ECX_reg(&context
) = pModule
->heap_size
;
256 EDI_reg(&context
) = context
.SegDs
;
258 TRACE(task
, "Starting main program: cs:ip=%04lx:%04x ds=%04lx ss:sp=%04x:%04x\n",
259 CS_reg(&context
), IP_reg(&context
), DS_reg(&context
),
260 SELECTOROF(pTask
->thdb
->cur_stack
),
261 OFFSETOF(pTask
->thdb
->cur_stack
) );
263 Callbacks
->CallRegisterShortProc( &context
, 0 );
264 /* This should never return */
265 fprintf( stderr
, "TASK_CallToStart: Main program returned!\n" );
266 TASK_KillCurrentTask( 1 );
271 /***********************************************************************
274 HTASK16
TASK_Create( THDB
*thdb
, NE_MODULE
*pModule
, HINSTANCE16 hInstance
,
275 HINSTANCE16 hPrevInstance
, UINT16 cmdShow
)
279 LPSTR name
, cmd_line
;
282 STACK16FRAME
*frame16
;
283 STACK32FRAME
*frame32
;
284 PDB32
*pdb32
= thdb
->process
;
285 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
287 /* Allocate the task structure */
289 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
290 pModule
->self
, FALSE
, FALSE
, FALSE
);
291 if (!hTask
) return 0;
292 pTask
= (TDB
*)GlobalLock16( hTask
);
294 /* Fill the task structure */
296 pTask
->nEvents
= 1; /* So the task can be started */
297 pTask
->hSelf
= hTask
;
300 if (pModule
->flags
& NE_FFLAGS_WIN32
)
301 pTask
->flags
|= TDBF_WIN32
;
303 pTask
->version
= pModule
->expected_version
;
304 pTask
->hInstance
= hInstance
;
305 pTask
->hPrevInstance
= hPrevInstance
;
306 pTask
->hModule
= pModule
->self
;
307 pTask
->hParent
= hCurrentTask
;
308 pTask
->magic
= TDB_MAGIC
;
309 pTask
->nCmdShow
= cmdShow
;
311 pTask
->curdrive
= DRIVE_GetCurrentDrive() | 0x80;
312 strcpy( pTask
->curdir
, "\\" );
313 lstrcpyn32A( pTask
->curdir
+ 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
314 sizeof(pTask
->curdir
) - 1 );
316 /* Create the thunks block */
318 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
320 /* Copy the module name */
322 name
= MODULE_GetModuleName( pModule
->self
);
323 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
325 /* Allocate a selector for the PDB */
327 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
328 pModule
->self
, FALSE
, FALSE
, FALSE
, NULL
);
332 pTask
->pdb
.int20
= 0x20cd;
333 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
334 PUT_DWORD(&pTask
->pdb
.dispatcher
[1], (DWORD
)MODULE_GetEntryPoint(
335 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
336 pTask
->pdb
.savedint22
= INT_GetHandler( 0x22 );
337 pTask
->pdb
.savedint23
= INT_GetHandler( 0x23 );
338 pTask
->pdb
.savedint24
= INT_GetHandler( 0x24 );
339 pTask
->pdb
.fileHandlesPtr
=
340 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask
->hPDB
),
341 (int)&((PDB
*)0)->fileHandles
);
342 pTask
->pdb
.hFileHandles
= 0;
343 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
344 pTask
->pdb
.environment
= pdb32
->env_db
->env_sel
;
345 pTask
->pdb
.nbFiles
= 20;
347 /* Fill the command line */
349 cmd_line
= pdb32
->env_db
->cmd_line
;
350 while (*cmd_line
&& (*cmd_line
!= ' ') && (*cmd_line
!= '\t')) cmd_line
++;
351 lstrcpyn32A( pTask
->pdb
.cmdLine
+1, cmd_line
, sizeof(pTask
->pdb
.cmdLine
)-1);
352 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
354 /* Get the compatibility flags */
356 pTask
->compat_flags
= GetProfileInt32A( "Compatibility", name
, 0 );
358 /* Allocate a code segment alias for the TDB */
360 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
361 sizeof(TDB
), pTask
->hPDB
, TRUE
,
362 FALSE
, FALSE
, NULL
);
364 /* Set the owner of the environment block */
366 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
368 /* Default DTA overwrites command-line */
370 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
371 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
373 /* Create the 16-bit stack frame */
375 if (!(sp
= pModule
->sp
))
376 sp
= pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
;
378 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hInstance
, sp
);
379 pTask
->thdb
->cur_stack
-= sizeof(STACK16FRAME
) + sizeof(STACK32FRAME
*);
380 frame16
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
381 frame16
->ebp
= sp
+ (int)&((STACK16FRAME
*)0)->bp
;
382 frame16
->bp
= LOWORD(frame16
->ebp
);
383 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
384 frame16
->entry_point
= 0;
385 frame16
->entry_cs
= 0;
386 /* The remaining fields will be initialized in TASK_Reschedule */
388 /* Create the 32-bit stack frame */
390 stack32Top
= (char*)pTask
->thdb
->teb
.stack_top
;
391 frame16
->frame32
= frame32
= (STACK32FRAME
*)stack32Top
- 1;
392 frame32
->frame16
= pTask
->thdb
->cur_stack
+ sizeof(STACK16FRAME
);
398 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
399 /* The remaining fields will be initialized in TASK_Reschedule */
401 if (!THREAD_Current()->cur_stack
)
402 THREAD_Current()->cur_stack
= pTask
->thdb
->cur_stack
;
404 /* Add the task to the linked list */
406 TASK_LinkTask( hTask
);
408 TRACE(task
, "module='%s' cmdline='%s' task=%04x\n",
409 name
, cmd_line
, hTask
);
415 /***********************************************************************
418 static void TASK_DeleteTask( HTASK16 hTask
)
423 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
426 pTask
->magic
= 0xdead; /* invalidate signature */
428 /* Delete the Win32 part of the task */
430 K32OBJ_DecCount( &pTask
->thdb
->process
->header
);
431 K32OBJ_DecCount( &pTask
->thdb
->header
);
433 /* Free the task module */
435 MODULE_FreeModule( pTask
->hModule
, pTask
);
437 /* Free the selector aliases */
439 GLOBAL_FreeBlock( pTask
->hCSAlias
);
440 GLOBAL_FreeBlock( pTask
->hPDB
);
442 /* Free the task structure itself */
444 GlobalFree16( hTask
);
446 /* Free all memory used by this task (including the 32-bit stack, */
447 /* the environment block and the thunk segments). */
449 GlobalFreeAll( hPDB
);
453 /***********************************************************************
454 * TASK_KillCurrentTask
456 * Kill the currently running task. As it's not possible to kill the
457 * current task like this, it is simply marked for destruction, and will
458 * be killed when either TASK_Reschedule or this function is called again
459 * in the context of another task.
461 void TASK_KillCurrentTask( INT16 exitCode
)
463 TDB
* pTask
= (TDB
*) GlobalLock16( hCurrentTask
);
464 if (!pTask
) USER_ExitWindows(); /* No current task yet */
466 TRACE(task
, "Killing task %04x\n", hCurrentTask
);
468 /* Delete active sockets */
471 WINSOCK_DeleteTaskWSI( pTask
, pTask
->pwsi
);
473 /* Perform USER cleanup */
475 if (pTask
->userhandler
)
476 pTask
->userhandler( hCurrentTask
, USIG_TERMINATION
, 0,
477 pTask
->hInstance
, pTask
->hQueue
);
479 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
481 /* If another task is already marked for destruction, */
482 /* we can kill it now, as we are in another context. */
483 TASK_DeleteTask( hTaskToKill
);
488 TRACE(task
, "this is the last task, exiting\n" );
492 /* Remove the task from the list to be sure we never switch back to it */
493 TASK_UnlinkTask( hCurrentTask
);
496 TDB
* p
= (TDB
*)GlobalLock16( hFirstTask
);
499 if( p
->hYieldTo
== hCurrentTask
) p
->hYieldTo
= 0;
500 p
= (TDB
*)GlobalLock16( p
->hNext
);
504 hTaskToKill
= hCurrentTask
;
508 TASK_YieldToSystem(pTask
);
510 /* We should never return from this Yield() */
512 fprintf(stderr
,"Return of the living dead %04x!!!\n", hCurrentTask
);
516 /***********************************************************************
519 * This is where all the magic of task-switching happens!
521 * Note: This function should only be called via the TASK_YieldToSystem()
522 * wrapper, to make sure that all the context is saved correctly.
524 * It must not call functions that may yield control.
526 void TASK_Reschedule(void)
528 TDB
*pOldTask
= NULL
, *pNewTask
;
530 STACK16FRAME
*newframe16
;
535 /* First check if there's a task to kill */
537 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
539 TASK_DeleteTask( hTaskToKill
);
543 /* Find a task to yield to */
545 pOldTask
= (TDB
*)GlobalLock16( hCurrentTask
);
546 if (pOldTask
&& pOldTask
->hYieldTo
)
548 /* check for DirectedYield() */
550 hTask
= pOldTask
->hYieldTo
;
551 pNewTask
= (TDB
*)GlobalLock16( hTask
);
552 if( !pNewTask
|| !pNewTask
->nEvents
) hTask
= 0;
553 pOldTask
->hYieldTo
= 0;
556 /* extract hardware events only! */
558 if (!hTask
) EVENT_WaitNetEvent( FALSE
, TRUE
);
562 /* Find a task that has an event pending */
567 pNewTask
= (TDB
*)GlobalLock16( hTask
);
569 TRACE(task
, "\ttask = %04x, events = %i\n", hTask
, pNewTask
->nEvents
);
571 if (pNewTask
->nEvents
) break;
572 hTask
= pNewTask
->hNext
;
574 if (hLockedTask
&& (hTask
!= hLockedTask
)) hTask
= 0;
577 /* No task found, wait for some events to come in */
579 EVENT_WaitNetEvent( TRUE
, TRUE
);
582 if (hTask
== hCurrentTask
)
584 TRACE(task
, "returning to the current task(%04x)\n", hTask
);
585 return; /* Nothing to do */
587 pNewTask
= (TDB
*)GlobalLock16( hTask
);
588 TRACE(task
, "Switching to task %04x (%.8s)\n",
589 hTask
, pNewTask
->module_name
);
591 /* Make the task the last in the linked list (round-robin scheduling) */
593 pNewTask
->priority
++;
594 TASK_UnlinkTask( hTask
);
595 TASK_LinkTask( hTask
);
596 pNewTask
->priority
--;
598 /* Finish initializing the new task stack if necessary */
600 newframe16
= THREAD_STACK16( pNewTask
->thdb
);
601 if (!newframe16
->entry_cs
)
603 STACK16FRAME
*oldframe16
= CURRENT_STACK16
;
604 STACK32FRAME
*oldframe32
= oldframe16
->frame32
;
605 STACK32FRAME
*newframe32
= newframe16
->frame32
;
606 newframe16
->entry_ip
= oldframe16
->entry_ip
;
607 newframe16
->entry_cs
= oldframe16
->entry_cs
;
608 newframe16
->ip
= oldframe16
->ip
;
609 newframe16
->cs
= oldframe16
->cs
;
610 newframe32
->ebp
= oldframe32
->ebp
;
611 newframe32
->restore_addr
= oldframe32
->restore_addr
;
612 newframe32
->codeselector
= oldframe32
->codeselector
;
615 /* Switch to the new stack */
617 hCurrentTask
= hTask
;
618 SET_CUR_THREAD( pNewTask
->thdb
);
619 pNewTask
->ss_sp
= pNewTask
->thdb
->cur_stack
;
623 /***********************************************************************
626 * Scheduler interface, this way we ensure that all "unsafe" events are
627 * processed outside the scheduler.
629 void TASK_YieldToSystem(TDB
* pTask
)
633 Callbacks
->CallTaskRescheduleProc();
637 pQ
= (MESSAGEQUEUE
*)GlobalLock16(pTask
->hQueue
);
638 if( pQ
&& pQ
->flags
& QUEUE_FLAG_XEVENT
&&
639 !(pQ
->wakeBits
& (QS_SENDMESSAGE
| QS_SMRESULT
)) )
641 pQ
->flags
&= ~QUEUE_FLAG_XEVENT
;
642 EVENT_WaitNetEvent( FALSE
, FALSE
);
648 /***********************************************************************
649 * InitTask (KERNEL.91)
651 * Called by the application startup code.
653 void WINAPI
InitTask( CONTEXT
*context
)
657 SEGTABLEENTRY
*pSegTable
;
658 INSTANCEDATA
*pinstance
;
659 LONG stacklow
, stackhi
;
661 if (context
) EAX_reg(context
) = 0;
662 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
663 if (!(pModule
= MODULE_GetPtr( pTask
->hModule
))) return;
665 /* This is a hack to install task USER signal handler before
666 * implicitly loaded DLLs are initialized (see windows/user.c) */
668 pTask
->userhandler
= (USERSIGNALPROC
)&USER_SignalProc
;
670 /* Initialize implicitly loaded DLLs */
671 NE_InitializeDLLs( pTask
->hModule
);
675 /* Registers on return are:
676 * ax 1 if OK, 0 on error
677 * cx stack limit in bytes
678 * dx cmdShow parameter
679 * si instance handle of the previous instance
680 * di instance handle of the new task
681 * es:bx pointer to command-line inside PSP
683 EAX_reg(context
) = 1;
684 EBX_reg(context
) = pTask
->pdb
.cmdLine
[0] ? 0x81 : 0x80;
686 if (!pTask
->pdb
.cmdLine
[0]) EBX_reg(context
) = 0x80;
689 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
690 while ((*p
== ' ') || (*p
== '\t')) p
++;
691 EBX_reg(context
) = 0x80 + (p
- pTask
->pdb
.cmdLine
);
693 ECX_reg(context
) = pModule
->stack_size
;
694 EDX_reg(context
) = pTask
->nCmdShow
;
695 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
696 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
697 ES_reg (context
) = (WORD
)pTask
->hPDB
;
700 /* Initialize the local heap */
701 if ( pModule
->heap_size
)
703 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
706 /* Initialize the INSTANCEDATA structure */
707 pSegTable
= NE_SEG_TABLE( pModule
);
708 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
709 stackhi
= stacklow
+ pModule
->stack_size
;
710 if (stackhi
> 0xffff) stackhi
= 0xffff;
711 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
712 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
713 pinstance
->stacktop
= stacklow
;
714 pinstance
->stackmin
= OFFSETOF( pTask
->thdb
->cur_stack
);
718 /***********************************************************************
719 * WaitEvent (KERNEL.30)
721 BOOL16 WINAPI
WaitEvent( HTASK16 hTask
)
725 if (!hTask
) hTask
= hCurrentTask
;
726 pTask
= (TDB
*)GlobalLock16( hTask
);
727 if (pTask
->nEvents
> 0)
732 TASK_YieldToSystem(pTask
);
734 /* When we get back here, we have an event */
736 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
741 /***********************************************************************
742 * PostEvent (KERNEL.31)
744 void WINAPI
PostEvent( HTASK16 hTask
)
748 if (!hTask
) hTask
= hCurrentTask
;
749 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
754 /***********************************************************************
755 * SetPriority (KERNEL.32)
757 void WINAPI
SetPriority( HTASK16 hTask
, INT16 delta
)
762 if (!hTask
) hTask
= hCurrentTask
;
763 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
764 newpriority
= pTask
->priority
+ delta
;
765 if (newpriority
< -32) newpriority
= -32;
766 else if (newpriority
> 15) newpriority
= 15;
768 pTask
->priority
= newpriority
+ 1;
769 TASK_UnlinkTask( hTask
);
770 TASK_LinkTask( hTask
);
775 /***********************************************************************
776 * LockCurrentTask (KERNEL.33)
778 HTASK16 WINAPI
LockCurrentTask( BOOL16 bLock
)
780 if (bLock
) hLockedTask
= hCurrentTask
;
781 else hLockedTask
= 0;
786 /***********************************************************************
787 * IsTaskLocked (KERNEL.122)
789 HTASK16 WINAPI
IsTaskLocked(void)
795 /***********************************************************************
796 * OldYield (KERNEL.117)
798 void WINAPI
OldYield(void)
802 pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
803 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
804 TASK_YieldToSystem(pCurTask
);
805 if (pCurTask
) pCurTask
->nEvents
--;
809 /***********************************************************************
810 * DirectedYield (KERNEL.150)
812 void WINAPI
DirectedYield( HTASK16 hTask
)
814 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
815 pCurTask
->hYieldTo
= hTask
;
820 /***********************************************************************
821 * UserYield (USER.332)
823 void WINAPI
UserYield(void)
825 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
826 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
827 /* Handle sent messages */
828 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
829 QUEUE_ReceiveMessage( queue
);
833 queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
834 while (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
835 QUEUE_ReceiveMessage( queue
);
839 /***********************************************************************
840 * Yield16 (KERNEL.29)
842 void WINAPI
Yield16(void)
844 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
845 if (pCurTask
) pCurTask
->hYieldTo
= 0;
846 if (pCurTask
&& pCurTask
->hQueue
) UserYield();
851 /***********************************************************************
852 * MakeProcInstance16 (KERNEL.51)
854 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
859 if (!hInstance
) return 0;
860 if (__winelib
) return func
; /* func can be called directly in Winelib */
861 thunkaddr
= TASK_AllocThunk( hCurrentTask
);
862 if (!thunkaddr
) return (FARPROC16
)0;
863 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
864 lfunc
= PTR_SEG_TO_LIN( func
);
866 TRACE(task
, "(%08lx,%04x): got thunk %08lx\n",
867 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
868 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) ||
869 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58))
871 fprintf(stderr
,"FIXME: MakeProcInstance16 thunk would be useless for %p, overwriting with nop;nop;\n", func
);
872 lfunc
[0]=0x90; /* nop */
873 lfunc
[1]=0x90; /* nop */
876 *thunk
++ = 0xb8; /* movw instance, %ax */
877 *thunk
++ = (BYTE
)(hInstance
& 0xff);
878 *thunk
++ = (BYTE
)(hInstance
>> 8);
879 *thunk
++ = 0xea; /* ljmp func */
880 *(DWORD
*)thunk
= (DWORD
)func
;
881 return (FARPROC16
)thunkaddr
;
885 /***********************************************************************
886 * FreeProcInstance16 (KERNEL.52)
888 void WINAPI
FreeProcInstance16( FARPROC16 func
)
890 TRACE(task
, "(%08lx)\n", (DWORD
)func
);
891 if (!__winelib
) TASK_FreeThunk( hCurrentTask
, (SEGPTR
)func
);
895 /**********************************************************************
896 * GetCodeHandle (KERNEL.93)
898 HANDLE16 WINAPI
GetCodeHandle( FARPROC16 proc
)
901 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
903 if (__winelib
) return 0;
905 /* Return the code segment containing 'proc'. */
906 /* Not sure if this is really correct (shouldn't matter that much). */
908 /* Check if it is really a thunk */
909 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
910 handle
= GlobalHandle16( thunk
[6] + (thunk
[7] << 8) );
912 handle
= GlobalHandle16( HIWORD(proc
) );
918 /**********************************************************************
919 * DefineHandleTable16 (KERNEL.94)
921 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
923 return TRUE
; /* FIXME */
927 /***********************************************************************
928 * SetTaskQueue (KERNEL.34)
930 HQUEUE16 WINAPI
SetTaskQueue( HTASK16 hTask
, HQUEUE16 hQueue
)
935 if (!hTask
) hTask
= hCurrentTask
;
936 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
938 hPrev
= pTask
->hQueue
;
939 pTask
->hQueue
= hQueue
;
941 TIMER_SwitchQueue( hPrev
, hQueue
);
947 /***********************************************************************
948 * GetTaskQueue (KERNEL.35)
950 HQUEUE16 WINAPI
GetTaskQueue( HTASK16 hTask
)
954 if (!hTask
) hTask
= hCurrentTask
;
955 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
956 return pTask
->hQueue
;
960 /***********************************************************************
961 * SwitchStackTo (KERNEL.108)
963 void WINAPI
SwitchStackTo( WORD seg
, WORD ptr
, WORD top
)
966 STACK16FRAME
*oldFrame
, *newFrame
;
970 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
971 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
972 TRACE(task
, "old=%04x:%04x new=%04x:%04x\n",
973 SELECTOROF( pTask
->thdb
->cur_stack
),
974 OFFSETOF( pTask
->thdb
->cur_stack
), seg
, ptr
);
976 /* Save the old stack */
978 pData
->old_ss_sp
= pTask
->thdb
->cur_stack
;
979 pData
->stacktop
= top
;
980 pData
->stackmin
= ptr
;
981 pData
->stackbottom
= ptr
;
983 /* Switch to the new stack */
985 /* Note: we need to take the 3 arguments into account; otherwise,
986 * the stack will underflow upon return from this function.
988 oldFrame
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
989 pTask
->thdb
->cur_stack
= PTR_SEG_OFF_TO_SEGPTR( seg
,
990 ptr
- sizeof(STACK16FRAME
) - 3 * sizeof(WORD
) );
991 newFrame
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
993 /* Copy the stack frame and the local variables to the new stack */
995 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
996 memmove( newFrame
, oldFrame
, MAX( copySize
, sizeof(STACK16FRAME
) ));
1000 /***********************************************************************
1001 * SwitchStackBack (KERNEL.109)
1003 * Note: the function is declared as 'register' in the spec file in order
1004 * to make sure all registers are preserved, but we don't use them in any
1005 * way, so we don't need a CONTEXT* argument.
1007 void WINAPI
SwitchStackBack(void)
1010 STACK16FRAME
*oldFrame
, *newFrame
;
1011 INSTANCEDATA
*pData
;
1013 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
1014 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(pTask
->thdb
->cur_stack
))))
1016 if (!pData
->old_ss_sp
)
1018 fprintf( stderr
, "SwitchStackBack: no previous SwitchStackTo\n" );
1021 TRACE(task
, "restoring stack %04x:%04x\n",
1022 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1024 oldFrame
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
1026 /* Switch back to the old stack */
1028 pTask
->thdb
->cur_stack
= pData
->old_ss_sp
;
1029 pData
->old_ss_sp
= 0;
1031 /* Build a stack frame for the return */
1033 newFrame
= (STACK16FRAME
*)PTR_SEG_TO_LIN( pTask
->thdb
->cur_stack
);
1034 newFrame
->frame32
= oldFrame
->frame32
;
1035 if (TRACE_ON(relay
))
1037 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1038 newFrame
->entry_cs
= oldFrame
->entry_cs
;
1043 /***********************************************************************
1044 * GetTaskQueueDS (KERNEL.118)
1046 void WINAPI
GetTaskQueueDS( CONTEXT
*context
)
1048 DS_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1052 /***********************************************************************
1053 * GetTaskQueueES (KERNEL.119)
1055 void WINAPI
GetTaskQueueES( CONTEXT
*context
)
1057 ES_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1061 /***********************************************************************
1062 * GetCurrentTask (KERNEL.36)
1064 HTASK16 WINAPI
GetCurrentTask(void)
1066 return hCurrentTask
;
1069 DWORD WINAPI
WIN16_GetCurrentTask(void)
1071 /* This is the version used by relay code; the first task is */
1072 /* returned in the high word of the result */
1073 return MAKELONG( hCurrentTask
, hFirstTask
);
1077 /***********************************************************************
1078 * GetCurrentPDB (KERNEL.37)
1080 HANDLE16 WINAPI
GetCurrentPDB(void)
1084 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1089 /***********************************************************************
1090 * GetInstanceData (KERNEL.54)
1092 INT16 WINAPI
GetInstanceData( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1094 char *ptr
= (char *)GlobalLock16( instance
);
1095 if (!ptr
|| !len
) return 0;
1096 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1097 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1102 /***********************************************************************
1103 * GetExeVersion (KERNEL.105)
1105 WORD WINAPI
GetExeVersion(void)
1109 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1110 return pTask
->version
;
1114 /***********************************************************************
1115 * SetErrorMode16 (KERNEL.107)
1117 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1122 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1123 oldMode
= pTask
->error_mode
;
1124 pTask
->error_mode
= mode
;
1125 pTask
->thdb
->process
->error_mode
= mode
;
1130 /***********************************************************************
1131 * SetErrorMode32 (KERNEL32.486)
1133 UINT32 WINAPI
SetErrorMode32( UINT32 mode
)
1135 return SetErrorMode16( (UINT16
)mode
);
1139 /***********************************************************************
1140 * GetDOSEnvironment (KERNEL.131)
1142 SEGPTR WINAPI
GetDOSEnvironment(void)
1146 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1147 return PTR_SEG_OFF_TO_SEGPTR( pTask
->pdb
.environment
, 0 );
1151 /***********************************************************************
1152 * GetNumTasks (KERNEL.152)
1154 UINT16 WINAPI
GetNumTasks(void)
1160 /***********************************************************************
1161 * GetTaskDS (KERNEL.155)
1163 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1164 * I don't think we need to bother with this.
1166 HINSTANCE16 WINAPI
GetTaskDS(void)
1170 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1171 return pTask
->hInstance
;
1175 /***********************************************************************
1176 * IsTask (KERNEL.320)
1178 BOOL16 WINAPI
IsTask( HTASK16 hTask
)
1182 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1183 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1184 return (pTask
->magic
== TDB_MAGIC
);
1188 /***********************************************************************
1189 * SetTaskSignalProc (KERNEL.38)
1191 * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1193 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1198 if (!hTask
) hTask
= hCurrentTask
;
1199 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1200 oldProc
= (FARPROC16
)pTask
->userhandler
;
1201 pTask
->userhandler
= (USERSIGNALPROC
)proc
;
1206 /***********************************************************************
1207 * SetSigHandler (KERNEL.140)
1209 WORD WINAPI
SetSigHandler( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1210 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1212 FIXME(task
,"(%p,%p,%p,%d,%d), unimplemented.\n",
1213 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1215 if (flag
!= 1) return 0;
1216 if (!newmode
) newhandler
= NULL
; /* Default handler */
1221 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1222 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1223 pTask
->signal_flags
= newmode
;
1224 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1225 pTask
->sighandler
= newhandler
;
1231 /***********************************************************************
1232 * GlobalNotify (KERNEL.154)
1234 VOID WINAPI
GlobalNotify( FARPROC16 proc
)
1238 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
1239 pTask
->discardhandler
= proc
;
1243 /***********************************************************************
1244 * GetExePtr (KERNEL.133)
1246 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1252 /* Check for module handle */
1254 if (!(ptr
= GlobalLock16( handle
))) return 0;
1255 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1257 /* Check the owner for module handle */
1259 owner
= FarGetOwner( handle
);
1260 if (!(ptr
= GlobalLock16( owner
))) return 0;
1261 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1263 /* Search for this handle and its owner inside all tasks */
1268 TDB
*pTask
= (TDB
*)GlobalLock16( hTask
);
1269 if ((hTask
== handle
) ||
1270 (pTask
->hInstance
== handle
) ||
1271 (pTask
->hQueue
== handle
) ||
1272 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1273 if ((hTask
== owner
) ||
1274 (pTask
->hInstance
== owner
) ||
1275 (pTask
->hQueue
== owner
) ||
1276 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1277 hTask
= pTask
->hNext
;
1282 /***********************************************************************
1283 * TaskFirst (TOOLHELP.63)
1285 BOOL16 WINAPI
TaskFirst( TASKENTRY
*lpte
)
1287 lpte
->hNext
= hFirstTask
;
1288 return TaskNext( lpte
);
1292 /***********************************************************************
1293 * TaskNext (TOOLHELP.64)
1295 BOOL16 WINAPI
TaskNext( TASKENTRY
*lpte
)
1298 INSTANCEDATA
*pInstData
;
1300 TRACE(toolhelp
, "(%p): task=%04x\n", lpte
, lpte
->hNext
);
1301 if (!lpte
->hNext
) return FALSE
;
1302 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1303 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1304 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1305 lpte
->hTask
= lpte
->hNext
;
1306 lpte
->hTaskParent
= pTask
->hParent
;
1307 lpte
->hInst
= pTask
->hInstance
;
1308 lpte
->hModule
= pTask
->hModule
;
1309 lpte
->wSS
= SELECTOROF( pTask
->thdb
->cur_stack
);
1310 lpte
->wSP
= OFFSETOF( pTask
->thdb
->cur_stack
);
1311 lpte
->wStackTop
= pInstData
->stacktop
;
1312 lpte
->wStackMinimum
= pInstData
->stackmin
;
1313 lpte
->wStackBottom
= pInstData
->stackbottom
;
1314 lpte
->wcEvents
= pTask
->nEvents
;
1315 lpte
->hQueue
= pTask
->hQueue
;
1316 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1317 lpte
->szModule
[8] = '\0';
1318 lpte
->wPSPOffset
= 0x100; /*??*/
1319 lpte
->hNext
= pTask
->hNext
;
1324 /***********************************************************************
1325 * TaskFindHandle (TOOLHELP.65)
1327 BOOL16 WINAPI
TaskFindHandle( TASKENTRY
*lpte
, HTASK16 hTask
)
1329 lpte
->hNext
= hTask
;
1330 return TaskNext( lpte
);
1334 /***********************************************************************
1335 * GetAppCompatFlags16 (KERNEL.354)
1337 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1339 return GetAppCompatFlags32( hTask
);
1343 /***********************************************************************
1344 * GetAppCompatFlags32 (USER32.206)
1346 DWORD WINAPI
GetAppCompatFlags32( HTASK32 hTask
)
1350 if (!hTask
) hTask
= GetCurrentTask();
1351 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1352 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1353 return pTask
->compat_flags
;