4 * Copyright 1995 Alexandre Julliard
21 #include "selectors.h"
27 /* Min. number of thunks allocated when creating a new segment */
30 /* 32-bit stack size for each task */
31 /* Must not be greater than 64k, or MAKE_SEGPTR won't work */
32 #define STACK32_SIZE 0x10000
35 static HTASK hFirstTask
= 0;
36 static HTASK hCurrentTask
= 0;
37 static HTASK hTaskToKill
= 0;
38 static HTASK hLockedTask
= 0;
39 static WORD nTaskCount
= 0;
40 static HANDLE hDOSEnvironment
= 0;
42 /* TASK_Reschedule() 16-bit entry point */
43 static FARPROC TASK_RescheduleProc
;
46 #define TASK_SCHEDULE() TASK_Reschedule();
48 #define TASK_SCHEDULE() CallTo16_word_(TASK_RescheduleProc,0)
52 static HANDLE
TASK_CreateDOSEnvironment(void);
54 /***********************************************************************
59 TASK_RescheduleProc
= (FARPROC
)GetWndProcEntry16( "TASK_Reschedule" );
60 if (!(hDOSEnvironment
= TASK_CreateDOSEnvironment()))
61 fprintf( stderr
, "Not enough memory for DOS Environment\n" );
62 return (hDOSEnvironment
!= 0);
66 /***********************************************************************
67 * TASK_CreateDOSEnvironment
69 * Create the original DOS environment.
71 static HANDLE
TASK_CreateDOSEnvironment(void)
73 static const char program_name
[] = "KRNL386.EXE";
75 int initial_size
, size
;
78 extern char **environ
;
79 extern char WindowsDirectory
[], SystemDirectory
[];
81 /* DOS environment format:
90 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
93 /* First compute the size of the fixed part of the environment */
95 initial_size
= 5 + /* PATH= */
96 strlen(WindowsPath
) + 1 + /* path value */
98 strlen(WindowsDirectory
) + 1 + /* windir value */
99 1 + /* BYTE 0 at end */
100 sizeof(WORD
) + /* WORD 1 */
101 strlen(SystemDirectory
) + 1 + /* program directory */
102 strlen(program_name
) + 1; /* program name */
104 /* Compute the total size of the Unix environment (except path) */
106 for (e
= environ
, size
= initial_size
; *e
; e
++)
108 if (strncasecmp(*e
, "path=", 5))
110 int len
= strlen(*e
) + 1;
111 if (size
+ len
>= 32767)
113 fprintf( stderr
, "Warning: environment larger than 32k.\n" );
121 /* Now allocate the environment */
123 if (!(handle
= GlobalAlloc( GMEM_FIXED
, size
))) return 0;
124 p
= (char *)GlobalLock( handle
);
126 /* And fill it with the Unix environment */
128 for (e
= environ
, size
= initial_size
; *e
; e
++)
130 if (strncasecmp(*e
, "path=", 5))
132 int len
= strlen(*e
) + 1;
133 if (size
+ len
>= 32767) break;
140 /* Now add the path and Windows directory */
142 strcpy( p
, "PATH=" );
143 strcat( p
, WindowsPath
);
146 strcpy( p
, "windir=" );
147 strcat( p
, WindowsDirectory
);
150 /* Now add the program name */
155 strcpy( p
, SystemDirectory
);
157 strcat( p
, program_name
);
161 p
= (char *) GlobalLock( handle
);
162 dprintf_task(stddeb
, "Master DOS environment at %p\n", p
);
163 for (; *p
; p
+= strlen(p
) + 1) dprintf_task(stddeb
, " %s\n", p
);
164 dprintf_task( stddeb
, "Progname: %s\n", p
+3 );
170 /***********************************************************************
173 static void TASK_LinkTask( HTASK hTask
)
178 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
179 prevTask
= &hFirstTask
;
182 TDB
*prevTaskPtr
= (TDB
*)GlobalLock( *prevTask
);
183 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
184 prevTask
= &prevTaskPtr
->hNext
;
186 pTask
->hNext
= *prevTask
;
192 /***********************************************************************
195 static void TASK_UnlinkTask( HTASK hTask
)
200 prevTask
= &hFirstTask
;
201 while (*prevTask
&& (*prevTask
!= hTask
))
203 pTask
= (TDB
*)GlobalLock( *prevTask
);
204 prevTask
= &pTask
->hNext
;
208 pTask
= (TDB
*)GlobalLock( *prevTask
);
209 *prevTask
= pTask
->hNext
;
216 /***********************************************************************
219 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
220 * and containing 'count' entries.
222 static void TASK_CreateThunks( HGLOBAL handle
, WORD offset
, WORD count
)
228 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock( handle
) + offset
);
230 pThunk
->magic
= THUNK_MAGIC
;
231 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
233 for (i
= 0; i
< count
-1; i
++)
235 free
+= 8; /* Offset of next thunk */
236 pThunk
->thunks
[4*i
] = free
;
238 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
242 /***********************************************************************
245 * Allocate a thunk for MakeProcInstance().
247 static SEGPTR
TASK_AllocThunk( HTASK hTask
)
253 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
254 sel
= pTask
->hCSAlias
;
255 pThunk
= &pTask
->thunks
;
256 base
= (int)pThunk
- (int)pTask
;
257 while (!pThunk
->free
)
260 if (!sel
) /* Allocate a new segment */
262 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
263 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
264 if (!sel
) return (SEGPTR
)0;
265 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
268 pThunk
= (THUNKS
*)GlobalLock( sel
);
271 base
+= pThunk
->free
;
272 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
273 return MAKELONG( base
, sel
);
277 /***********************************************************************
280 * Free a MakeProcInstance() thunk.
282 static BOOL
TASK_FreeThunk( HTASK hTask
, SEGPTR thunk
)
288 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
289 sel
= pTask
->hCSAlias
;
290 pThunk
= &pTask
->thunks
;
291 base
= (int)pThunk
- (int)pTask
;
292 while (sel
&& (sel
!= HIWORD(thunk
)))
295 pThunk
= (THUNKS
*)GlobalLock( sel
);
298 if (!sel
) return FALSE
;
299 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
300 pThunk
->free
= LOWORD(thunk
) - base
;
305 /***********************************************************************
308 * 32-bit entry point for a new task. This function is responsible for
309 * setting up the registers and jumping to the 16-bit entry point.
311 static void TASK_CallToStart(void)
313 int cs_reg
, ds_reg
, ip_reg
;
314 TDB
*pTask
= (TDB
*)GlobalLock( hCurrentTask
);
315 NE_MODULE
*pModule
= (NE_MODULE
*)GlobalLock( pTask
->hModule
);
316 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
318 /* Registers at initialization must be:
320 * bx stack size in bytes
321 * cx heap size in bytes
322 * si previous app instance
323 * di current app instance
325 * es selector to the PSP
326 * ds dgroup of the application
328 * sp top of the stack
331 cs_reg
= pSegTable
[pModule
->cs
- 1].selector
;
332 ip_reg
= pModule
->ip
;
333 ds_reg
= pSegTable
[pModule
->dgroup
- 1].selector
;
335 /* JBP: I doubt a CallTo16_regs_ is possible in libwine.a, and IF1632 is not
338 IF1632_Saved16_ss
= pTask
->ss
;
339 IF1632_Saved16_sp
= pTask
->sp
;
340 dprintf_task( stddeb
, "Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
341 cs_reg
, ip_reg
, ds_reg
,
342 IF1632_Saved16_ss
, IF1632_Saved16_sp
);
344 CallTo16_regs_( (FARPROC
)(cs_reg
<< 16 | ip_reg
), ds_reg
,
345 pTask
->hPDB
/*es*/, 0 /*bp*/, 0 /*ax*/,
346 pModule
->stack_size
/*bx*/, pModule
->heap_size
/*cx*/,
347 0 /*dx*/, 0 /*si*/, ds_reg
/*di*/ );
349 fprintf(stderr
, "JBP: Ignoring main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
350 cs_reg
, ip_reg
, ds_reg
,
351 pTask
->ss
, pTask
->sp
);
353 /* This should never return */
354 fprintf( stderr
, "TASK_CallToStart: Main program returned!\n" );
355 TASK_KillCurrentTask( 1 );
359 /***********************************************************************
362 HTASK
TASK_CreateTask( HMODULE hModule
, HANDLE hInstance
, HANDLE hPrevInstance
,
363 HANDLE hEnvironment
, char *cmdLine
, WORD cmdShow
)
369 SEGTABLEENTRY
*pSegTable
;
373 char *stack16Top
, *stack32Top
;
374 STACK16FRAME
*frame16
;
375 STACK32FRAME
*frame32
;
376 extern DWORD CALL16_RetAddr_word
;
379 if (!(pModule
= (NE_MODULE
*)GlobalLock( hModule
))) return 0;
380 pSegTable
= NE_SEG_TABLE( pModule
);
382 /* Allocate the task structure */
384 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
385 hModule
, FALSE
, FALSE
, FALSE
);
386 if (!hTask
) return 0;
387 pTask
= (TDB
*)GlobalLock( hTask
);
389 /* Allocate the new environment block */
391 if (!(hParentEnv
= hEnvironment
))
393 TDB
*pParent
= (TDB
*)GlobalLock( hCurrentTask
);
394 hParentEnv
= pParent
? pParent
->pdb
.environment
: hDOSEnvironment
;
396 /* FIXME: do we really need to make a copy also when */
397 /* we don't use the parent environment? */
398 if (!(hEnvironment
= GlobalAlloc( GMEM_FIXED
, GlobalSize( hParentEnv
) )))
403 memcpy( GlobalLock( hEnvironment
), GlobalLock( hParentEnv
),
404 GlobalSize( hParentEnv
) );
406 /* Get current directory */
408 GetModuleFileName( hModule
, filename
, sizeof(filename
) );
409 name
= strrchr(filename
, '\\');
410 if (name
) *(name
+1) = 0;
412 /* Fill the task structure */
414 pTask
->nEvents
= 1; /* So the task can be started */
415 pTask
->hSelf
= hTask
;
417 pTask
->version
= pModule
->expected_version
;
418 pTask
->hInstance
= hInstance
;
419 pTask
->hPrevInstance
= hPrevInstance
;
420 pTask
->hModule
= hModule
;
421 pTask
->hParent
= hCurrentTask
;
423 pTask
->curdrive
= 'C' - 'A' + 0x80;
425 pTask
->curdrive
= filename
[0] - 'A' + 0x80;
427 pTask
->magic
= TDB_MAGIC
;
428 pTask
->nCmdShow
= cmdShow
;
429 strcpy( pTask
->curdir
, filename
+2 );
431 /* Create the thunks block */
433 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
435 /* Copy the module name */
437 name
= MODULE_GetModuleName( hModule
);
438 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
442 pTask
->pdb
.int20
= 0x20cd;
443 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
444 *(DWORD
*)&pTask
->pdb
.dispatcher
[1] = MODULE_GetEntryPoint( GetModuleHandle("KERNEL"), 102 ); /* KERNEL.102 is DOS3Call() */
446 pTask
->pdb
.savedint22
= INT_GetHandler( 0x22 );
447 pTask
->pdb
.savedint23
= INT_GetHandler( 0x23 );
448 pTask
->pdb
.savedint24
= INT_GetHandler( 0x24 );
450 pTask
->pdb
.environment
= hEnvironment
;
451 strncpy( pTask
->pdb
.cmdLine
+ 1, cmdLine
, 126 );
452 pTask
->pdb
.cmdLine
[127] = '\0';
453 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
455 /* Get the compatibility flags */
457 pTask
->compat_flags
= GetProfileInt( name
, "Compatibility", 0 );
459 /* Allocate a selector for the PDB */
461 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
462 hModule
, FALSE
, FALSE
, FALSE
, NULL
);
464 /* Allocate a code segment alias for the TDB */
466 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
467 sizeof(TDB
), pTask
->hPDB
, TRUE
,
468 FALSE
, FALSE
, NULL
);
470 /* Set the owner of the environment block */
472 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
474 /* Default DTA overwrites command-line */
476 pTask
->dta
= MAKELONG( (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
,
479 /* Allocate the 32-bit stack */
482 pTask
->hStack32
= GLOBAL_Alloc( GMEM_FIXED
, STACK32_SIZE
, pTask
->hPDB
,
483 FALSE
, FALSE
, FALSE
);
485 /* Create the 32-bit stack frame */
487 *(DWORD
*)GlobalLock(pTask
->hStack32
) = 0xDEADBEEF;
488 stack32Top
= (char*)GlobalLock(pTask
->hStack32
) + STACK32_SIZE
;
489 frame32
= (STACK32FRAME
*)stack32Top
- 1;
490 frame32
->saved_esp
= (DWORD
)stack32Top
;
497 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
498 frame32
->codeselector
= WINE_CODE_SELECTOR
;
499 pTask
->esp
= (DWORD
)frame32
;
501 /* Create the 16-bit stack frame */
503 pTask
->ss
= hInstance
;
504 pTask
->sp
= ((pModule
->sp
!= 0) ? pModule
->sp
:
505 pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
) & ~1;
506 stack16Top
= (char *)PTR_SEG_OFF_TO_LIN( pTask
->ss
, pTask
->sp
);
507 frame16
= (STACK16FRAME
*)stack16Top
- 1;
508 frame16
->saved_ss
= 0; /*pTask->ss;*/
509 frame16
->saved_sp
= 0; /*pTask->sp;*/
510 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
511 frame16
->entry_point
= 0;
512 frame16
->ordinal_number
= 24; /* WINPROCS.24 is TASK_Reschedule */
513 frame16
->dll_id
= 24; /* WINPROCS */
515 frame16
->ip
= LOWORD( CALL16_RetAddr_word
);
516 frame16
->cs
= HIWORD( CALL16_RetAddr_word
);
517 pTask
->sp
-= sizeof(STACK16FRAME
);
519 /* If there's no 16-bit stack yet, use a part of the new task stack */
520 /* This is only needed to have a stack to switch from on the first */
521 /* call to DirectedYield(). */
523 if (!IF1632_Saved16_ss
)
525 IF1632_Saved16_ss
= pTask
->ss
;
526 IF1632_Saved16_sp
= pTask
->sp
;
529 /* Add a breakpoint at the start of the task */
533 DBG_ADDR addr
= { pSegTable
[pModule
->cs
-1].selector
, pModule
->ip
};
534 fprintf( stderr
, "Task '%s': ", name
);
535 DEBUG_AddBreakpoint( &addr
);
539 /* Add the task to the linked list */
541 TASK_LinkTask( hTask
);
543 dprintf_task( stddeb
, "CreateTask: module='%s' cmdline='%s' task="NPFMT
"\n",
544 name
, cmdLine
, hTask
);
550 /***********************************************************************
553 static void TASK_DeleteTask( HTASK hTask
)
557 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
559 /* Free the task module */
561 FreeModule( pTask
->hModule
);
563 /* Free all memory used by this task (including the 32-bit stack, */
564 /* the environment block and the thunk segments). */
566 GlobalFreeAll( pTask
->hPDB
);
568 /* Free the selector aliases */
570 GLOBAL_FreeBlock( pTask
->hCSAlias
);
571 GLOBAL_FreeBlock( pTask
->hPDB
);
573 /* Free the task structure itself */
579 /***********************************************************************
580 * TASK_KillCurrentTask
582 * Kill the currently running task. As it's not possible to kill the
583 * current task like this, it is simply marked for destruction, and will
584 * be killed when either TASK_Reschedule or this function is called again
585 * in the context of another task.
587 void TASK_KillCurrentTask( int exitCode
)
589 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
591 /* If another task is already marked for destruction, */
592 /* we call kill it now, as we are in another context. */
593 TASK_DeleteTask( hTaskToKill
);
598 dprintf_task( stddeb
, "Killing the last task, exiting\n" );
602 /* Remove the task from the list to be sure we never switch back to it */
603 TASK_UnlinkTask( hCurrentTask
);
605 hTaskToKill
= hCurrentTask
;
608 /* We never return from Yield() */
612 /***********************************************************************
615 * This is where all the magic of task-switching happens!
617 * This function should only be called via the TASK_SCHEDULE() macro, to make
618 * sure that all the context is saved correctly.
620 void TASK_Reschedule(void)
622 TDB
*pOldTask
= NULL
, *pNewTask
;
628 /* First check if there's a task to kill */
630 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
632 TASK_DeleteTask( hTaskToKill
);
636 /* If current task is locked, simply return */
638 if (hLockedTask
) return;
640 /* Find a task to yield to */
642 pOldTask
= (TDB
*)GlobalLock( hCurrentTask
);
643 if (pOldTask
&& pOldTask
->hYieldTo
)
645 /* If a task is stored in hYieldTo of the current task (put there */
646 /* by DirectedYield), yield to it only if it has events pending. */
647 hTask
= pOldTask
->hYieldTo
;
648 if (!(pNewTask
= (TDB
*)GlobalLock( hTask
)) || !pNewTask
->nEvents
)
657 pNewTask
= (TDB
*)GlobalLock( hTask
);
658 if (pNewTask
->nEvents
&& (hTask
!= hCurrentTask
)) break;
659 hTask
= pNewTask
->hNext
;
663 /* If there's a task to kill, switch to any other task, */
664 /* even if it doesn't have events pending. */
666 if (!hTask
&& hTaskToKill
) hTask
= hFirstTask
;
668 if (!hTask
) return; /* Do nothing */
670 pNewTask
= (TDB
*)GlobalLock( hTask
);
671 dprintf_task( stddeb
, "Switching to task "NPFMT
" (%.8s)\n",
672 hTask
, pNewTask
->module_name
);
674 /* Save the stacks of the previous task (if any) */
676 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
679 pOldTask
->ss
= IF1632_Saved16_ss
;
680 pOldTask
->sp
= IF1632_Saved16_sp
;
681 pOldTask
->esp
= IF1632_Saved32_esp
;
683 else IF1632_Original32_esp
= IF1632_Saved32_esp
;
686 /* Make the task the last in the linked list (round-robin scheduling) */
688 pNewTask
->priority
++;
689 TASK_UnlinkTask( hTask
);
690 TASK_LinkTask( hTask
);
691 pNewTask
->priority
--;
693 /* Switch to the new stack */
695 hCurrentTask
= hTask
;
696 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
697 IF1632_Saved16_ss
= pNewTask
->ss
;
698 IF1632_Saved16_sp
= pNewTask
->sp
;
699 IF1632_Saved32_esp
= pNewTask
->esp
;
700 IF1632_Stack32_base
= WIN16_GlobalLock( pNewTask
->hStack32
);
705 /***********************************************************************
706 * InitTask (KERNEL.91)
708 void InitTask( struct sigcontext_struct context
)
710 static int firstTask
= 1;
713 SEGTABLEENTRY
*pSegTable
;
714 INSTANCEDATA
*pinstance
;
715 LONG stacklow
, stackhi
;
717 EAX_reg(&context
) = 0;
718 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return;
719 if (!(pModule
= (NE_MODULE
*)GlobalLock( pTask
->hModule
))) return;
723 extern BOOL
WIDGETS_Init(void);
724 extern BOOL
WIN_CreateDesktopWindow(void);
726 /* Perform global initialisations that need a task context */
728 /* Initialize built-in window classes */
729 if (!WIDGETS_Init()) return;
731 /* Create desktop window */
732 if (!WIN_CreateDesktopWindow()) return;
738 NE_InitializeDLLs( pTask
->hModule
);
741 /* Registers on return are:
742 * ax 1 if OK, 0 on error
743 * cx stack limit in bytes
744 * dx cmdShow parameter
745 * si instance handle of the previous instance
746 * di instance handle of the new task
747 * es:bx pointer to command-line inside PSP
749 EAX_reg(&context
) = 1;
750 EBX_reg(&context
) = 0x81;
751 ECX_reg(&context
) = pModule
->stack_size
;
752 EDX_reg(&context
) = pTask
->nCmdShow
;
753 ESI_reg(&context
) = (DWORD
)pTask
->hPrevInstance
;
754 EDI_reg(&context
) = (DWORD
)pTask
->hInstance
;
755 ES_reg (&context
) = (WORD
)pTask
->hPDB
;
757 /* Initialize the local heap */
758 if ( pModule
->heap_size
)
760 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
764 /* Initialize the INSTANCEDATA structure */
765 pSegTable
= NE_SEG_TABLE( pModule
);
766 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
767 stackhi
= stacklow
+ pModule
->stack_size
;
768 if (stackhi
> 0xffff) stackhi
= 0xffff;
769 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
770 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
771 pinstance
->stacktop
= stacklow
;
772 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
773 pinstance
->stackmin
= IF1632_Saved16_sp
;
778 /***********************************************************************
779 * WaitEvent (KERNEL.30)
781 BOOL
WaitEvent( HTASK hTask
)
785 if (!hTask
) hTask
= hCurrentTask
;
786 pTask
= (TDB
*)GlobalLock( hTask
);
787 if (pTask
->nEvents
> 0)
793 /* When we get back here, we have an event (or the task is the only one) */
794 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
799 /***********************************************************************
800 * PostEvent (KERNEL.31)
802 void PostEvent( HTASK hTask
)
806 if (!hTask
) hTask
= hCurrentTask
;
807 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
812 /***********************************************************************
813 * SetPriority (KERNEL.32)
815 void SetPriority( HTASK hTask
, int delta
)
820 if (!hTask
) hTask
= hCurrentTask
;
821 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
822 newpriority
= pTask
->priority
+ delta
;
823 if (newpriority
< -32) newpriority
= -32;
824 else if (newpriority
> 15) newpriority
= 15;
826 pTask
->priority
= newpriority
+ 1;
827 TASK_UnlinkTask( hTask
);
828 TASK_LinkTask( hTask
);
833 /***********************************************************************
834 * LockCurrentTask (KERNEL.33)
836 HTASK
LockCurrentTask( BOOL bLock
)
838 if (bLock
) hLockedTask
= hCurrentTask
;
839 else hLockedTask
= 0;
844 /***********************************************************************
845 * IsTaskLocked (KERNEL.122)
847 WORD
IsTaskLocked(void)
853 /***********************************************************************
854 * OldYield (KERNEL.117)
860 pCurTask
= (TDB
*)GlobalLock( hCurrentTask
);
861 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
863 if (pCurTask
) pCurTask
->nEvents
--;
867 /***********************************************************************
868 * DirectedYield (KERNEL.150)
870 void DirectedYield( HTASK hTask
)
874 if ((pCurTask
= (TDB
*)GlobalLock( hCurrentTask
)) != NULL
)
875 pCurTask
->hYieldTo
= hTask
;
881 /***********************************************************************
890 /***********************************************************************
891 * MakeProcInstance (KERNEL.51)
893 FARPROC
MakeProcInstance( FARPROC func
, HANDLE hInstance
)
898 thunkaddr
= TASK_AllocThunk( hCurrentTask
);
899 if (!thunkaddr
) return (FARPROC
)0;
900 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
902 dprintf_task( stddeb
, "MakeProcInstance(%08lx,"NPFMT
"): got thunk %08lx\n",
903 (SEGPTR
)func
, hInstance
, (SEGPTR
)thunkaddr
);
905 *thunk
++ = 0xb8; /* movw instance, %ax */
907 *thunk
++ = (BYTE
)(hInstance
& 0xff);
908 *thunk
++ = (BYTE
)(hInstance
>> 8);
910 *thunk
++ = 0xea; /* ljmp func */
911 *(DWORD
*)thunk
= (DWORD
)func
;
912 return (FARPROC
)thunkaddr
;
916 /***********************************************************************
917 * FreeProcInstance (KERNEL.52)
919 void FreeProcInstance( FARPROC func
)
921 dprintf_task( stddeb
, "FreeProcInstance(%08lx)\n", (SEGPTR
)func
);
922 TASK_FreeThunk( hCurrentTask
, (SEGPTR
)func
);
926 /**********************************************************************
927 * GetCodeHandle (KERNEL.93)
929 HANDLE
GetCodeHandle( FARPROC proc
)
932 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
934 /* Return the code segment containing 'proc'. */
935 /* Not sure if this is really correct (shouldn't matter that much). */
937 /* Check if it is really a thunk */
938 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
939 handle
= GlobalHandle( thunk
[6] + (thunk
[7] << 8) );
941 handle
= GlobalHandle( HIWORD(proc
) );
943 printf( "STUB: GetCodeHandle(%08lx) returning "NPFMT
"\n",
944 (DWORD
)proc
, handle
);
949 /***********************************************************************
950 * SetTaskQueue (KERNEL.34)
952 HGLOBAL
SetTaskQueue( HANDLE hTask
, HGLOBAL hQueue
)
957 if (!hTask
) hTask
= hCurrentTask
;
958 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
959 hPrev
= pTask
->hQueue
;
960 pTask
->hQueue
= hQueue
;
965 /***********************************************************************
966 * GetTaskQueue (KERNEL.35)
968 HGLOBAL
GetTaskQueue( HANDLE hTask
)
972 if (!hTask
) hTask
= hCurrentTask
;
973 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
974 return pTask
->hQueue
;
978 /***********************************************************************
979 * GetTaskQueueDS (KERNEL.118)
982 void GetTaskQueueDS( struct sigcontext_struct context
)
984 DS_reg(&context
) = GlobalHandleToSel( GetTaskQueue(0) );
989 /***********************************************************************
990 * GetTaskQueueES (KERNEL.119)
993 void GetTaskQueueES( struct sigcontext_struct context
)
995 ES_reg(&context
) = GlobalHandleToSel( GetTaskQueue(0) );
1000 /***********************************************************************
1001 * GetCurrentTask (KERNEL.36)
1003 HTASK
GetCurrentTask(void)
1005 /* Undocumented: first task is returned in high word */
1007 return hCurrentTask
;
1009 return MAKELONG( hCurrentTask
, hFirstTask
);
1014 /***********************************************************************
1015 * GetCurrentPDB (KERNEL.37)
1017 HANDLE
GetCurrentPDB(void)
1021 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1026 /***********************************************************************
1027 * GetInstanceData (KERNEL.54)
1029 int GetInstanceData( HANDLE instance
, WORD buffer
, int len
)
1031 char *ptr
= (char *)GlobalLock( instance
);
1032 if (!ptr
|| !len
) return 0;
1033 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1034 memcpy( ptr
+ buffer
, (char *)GlobalLock( CURRENT_DS
) + buffer
, len
);
1039 /***********************************************************************
1040 * GetDOSEnvironment (KERNEL.131)
1042 SEGPTR
GetDOSEnvironment(void)
1046 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1047 return (SEGPTR
)WIN16_GlobalLock( pTask
->pdb
.environment
);
1051 /***********************************************************************
1052 * GetNumTasks (KERNEL.152)
1054 WORD
GetNumTasks(void)
1060 /***********************************************************************
1061 * GetTaskDS (KERNEL.155)
1063 HINSTANCE
GetTaskDS(void)
1067 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1068 return pTask
->hInstance
;
1072 /***********************************************************************
1073 * IsTask (KERNEL.320)
1075 BOOL
IsTask( HTASK hTask
)
1079 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return FALSE
;
1080 if (GlobalSize( hTask
) < sizeof(TDB
)) return FALSE
;
1081 return (pTask
->magic
== TDB_MAGIC
);
1085 /***********************************************************************
1086 * GetExePtr (KERNEL.133)
1088 HMODULE
GetExePtr( HANDLE handle
)
1094 /* Check for module handle */
1096 if (!(ptr
= GlobalLock( handle
))) return 0;
1097 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return handle
;
1099 /* Check the owner for module handle */
1102 owner
= FarGetOwner( handle
);
1105 fprintf(stderr
,"JBP: FarGetOwner() ignored.\n");
1107 if (!(ptr
= GlobalLock( owner
))) return 0;
1108 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return owner
;
1110 /* Search for this handle and its owner inside all tasks */
1115 TDB
*pTask
= (TDB
*)GlobalLock( hTask
);
1116 if ((hTask
== handle
) ||
1117 (pTask
->hInstance
== handle
) ||
1118 (pTask
->hQueue
== handle
) ||
1119 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1120 if ((hTask
== owner
) ||
1121 (pTask
->hInstance
== owner
) ||
1122 (pTask
->hQueue
== owner
) ||
1123 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1124 hTask
= pTask
->hNext
;
1130 /***********************************************************************
1131 * TaskFirst (TOOLHELP.63)
1133 BOOL
TaskFirst( TASKENTRY
*lpte
)
1135 lpte
->hNext
= hFirstTask
;
1136 return TaskNext( lpte
);
1140 /***********************************************************************
1141 * TaskNext (TOOLHELP.64)
1143 BOOL
TaskNext( TASKENTRY
*lpte
)
1146 INSTANCEDATA
*pInstData
;
1148 dprintf_toolhelp( stddeb
, "TaskNext(%p): task="NPFMT
"\n", lpte
, lpte
->hNext
);
1149 if (!lpte
->hNext
) return FALSE
;
1150 pTask
= (TDB
*)GlobalLock( lpte
->hNext
);
1151 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1152 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1153 lpte
->hTask
= lpte
->hNext
;
1154 lpte
->hTaskParent
= pTask
->hParent
;
1155 lpte
->hInst
= pTask
->hInstance
;
1156 lpte
->hModule
= pTask
->hModule
;
1157 lpte
->wSS
= pTask
->ss
;
1158 lpte
->wSP
= pTask
->sp
;
1159 lpte
->wStackTop
= pInstData
->stacktop
;
1160 lpte
->wStackMinimum
= pInstData
->stackmin
;
1161 lpte
->wStackBottom
= pInstData
->stackbottom
;
1162 lpte
->wcEvents
= pTask
->nEvents
;
1163 lpte
->hQueue
= pTask
->hQueue
;
1164 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1165 lpte
->szModule
[8] = '\0';
1166 lpte
->wPSPOffset
= 0x100; /*??*/
1167 lpte
->hNext
= pTask
->hNext
;
1172 /***********************************************************************
1173 * TaskFindHandle (TOOLHELP.65)
1175 BOOL
TaskFindHandle( TASKENTRY
*lpte
, HTASK hTask
)
1177 lpte
->hNext
= hTask
;
1178 return TaskNext( lpte
);