4 * Copyright 1995 Alexandre Julliard
14 #include "directory.h"
33 /* Min. number of thunks allocated when creating a new segment */
36 /* 32-bit stack size for each task */
37 /* Must not be greater than 64k, or MAKE_SEGPTR won't work */
38 #define STACK32_SIZE 0x10000
40 extern void USER_AppExit(HTASK
, HINSTANCE
, HQUEUE
);
41 /* ------ Internal variables ------ */
43 static HTASK hFirstTask
= 0;
44 static HTASK hCurrentTask
= 0;
45 static HTASK hTaskToKill
= 0;
46 static HTASK hLockedTask
= 0;
47 static WORD nTaskCount
= 0;
48 static HANDLE hDOSEnvironment
= 0;
50 /* ------ Internal declarations ------ */
52 /* TASK_Reschedule() 16-bit entry point */
53 static FARPROC TASK_RescheduleProc
;
56 #define TASK_SCHEDULE() TASK_Reschedule();
58 #define TASK_SCHEDULE() CallTo16_word_(TASK_RescheduleProc,0)
61 static HANDLE
TASK_CreateDOSEnvironment(void);
63 /***********************************************************************
68 TASK_RescheduleProc
= MODULE_GetWndProcEntry16( "TASK_Reschedule" );
69 if (!(hDOSEnvironment
= TASK_CreateDOSEnvironment()))
70 fprintf( stderr
, "Not enough memory for DOS Environment\n" );
71 return (hDOSEnvironment
!= 0);
75 /***********************************************************************
78 HTASK
TASK_GetNextTask( HTASK hTask
)
80 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
82 if (pTask
->hNext
) return pTask
->hNext
;
83 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
87 /***********************************************************************
88 * TASK_CreateDOSEnvironment
90 * Create the original DOS environment.
92 static HANDLE
TASK_CreateDOSEnvironment(void)
94 static const char program_name
[] = "KRNL386.EXE";
96 int initial_size
, size
, i
, winpathlen
, sysdirlen
;
99 extern char **environ
;
101 /* DOS environment format:
109 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
112 /* First compute the size of the fixed part of the environment */
114 for (i
= winpathlen
= 0; ; i
++)
116 int len
= DIR_GetDosPath( i
, NULL
, 0 );
118 winpathlen
+= len
+ 1;
120 if (!winpathlen
) winpathlen
= 1;
121 sysdirlen
= GetSystemDirectory32A( NULL
, 0 ) + 1;
122 initial_size
= 5 + winpathlen
+ /* PATH=xxxx */
123 1 + /* BYTE 0 at end */
124 sizeof(WORD
) + /* WORD 1 */
125 sysdirlen
+ /* program directory */
126 strlen(program_name
) + 1; /* program name */
128 /* Compute the total size of the Unix environment (except path) */
130 for (e
= environ
, size
= initial_size
; *e
; e
++)
132 if (lstrncmpi32A(*e
, "path=", 5))
134 int len
= strlen(*e
) + 1;
135 if (size
+ len
>= 32767)
137 fprintf( stderr
, "Warning: environment larger than 32k.\n" );
145 /* Now allocate the environment */
147 if (!(handle
= GlobalAlloc16( GMEM_FIXED
, size
))) return 0;
148 p
= (char *)GlobalLock16( handle
);
150 /* And fill it with the Unix environment */
152 for (e
= environ
, size
= initial_size
; *e
; e
++)
154 if (lstrncmpi32A(*e
, "path=", 5))
156 int len
= strlen(*e
) + 1;
157 if (size
+ len
>= 32767) break;
164 /* Now add the path */
166 strcpy( p
, "PATH=" );
167 for (i
= 0, p
+= 5; ; i
++)
169 if (!DIR_GetDosPath( i
, p
, winpathlen
)) break;
173 if (p
[-1] == ';') p
[-1] = '\0';
176 /* Now add the program name */
181 GetSystemDirectory32A( p
, sysdirlen
);
183 strcat( p
, program_name
);
187 p
= (char *) GlobalLock16( handle
);
188 dprintf_task(stddeb
, "Master DOS environment at %p\n", p
);
189 for (; *p
; p
+= strlen(p
) + 1) dprintf_task(stddeb
, " %s\n", p
);
190 dprintf_task( stddeb
, "Progname: %s\n", p
+3 );
196 /***********************************************************************
199 static void TASK_LinkTask( HTASK hTask
)
204 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
205 prevTask
= &hFirstTask
;
208 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
209 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
210 prevTask
= &prevTaskPtr
->hNext
;
212 pTask
->hNext
= *prevTask
;
218 /***********************************************************************
221 static void TASK_UnlinkTask( HTASK hTask
)
226 prevTask
= &hFirstTask
;
227 while (*prevTask
&& (*prevTask
!= hTask
))
229 pTask
= (TDB
*)GlobalLock16( *prevTask
);
230 prevTask
= &pTask
->hNext
;
234 pTask
= (TDB
*)GlobalLock16( *prevTask
);
235 *prevTask
= pTask
->hNext
;
242 /***********************************************************************
245 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
246 * and containing 'count' entries.
248 static void TASK_CreateThunks( HGLOBAL handle
, WORD offset
, WORD count
)
254 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
256 pThunk
->magic
= THUNK_MAGIC
;
257 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
259 for (i
= 0; i
< count
-1; i
++)
261 free
+= 8; /* Offset of next thunk */
262 pThunk
->thunks
[4*i
] = free
;
264 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
268 /***********************************************************************
271 * Allocate a thunk for MakeProcInstance().
274 static SEGPTR
TASK_AllocThunk( HTASK hTask
)
280 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
281 sel
= pTask
->hCSAlias
;
282 pThunk
= &pTask
->thunks
;
283 base
= (int)pThunk
- (int)pTask
;
284 while (!pThunk
->free
)
287 if (!sel
) /* Allocate a new segment */
289 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
290 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
291 if (!sel
) return (SEGPTR
)0;
292 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
295 pThunk
= (THUNKS
*)GlobalLock16( sel
);
298 base
+= pThunk
->free
;
299 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
300 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
305 /***********************************************************************
308 * Free a MakeProcInstance() thunk.
311 static BOOL
TASK_FreeThunk( HTASK hTask
, SEGPTR thunk
)
317 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
318 sel
= pTask
->hCSAlias
;
319 pThunk
= &pTask
->thunks
;
320 base
= (int)pThunk
- (int)pTask
;
321 while (sel
&& (sel
!= HIWORD(thunk
)))
324 pThunk
= (THUNKS
*)GlobalLock16( sel
);
327 if (!sel
) return FALSE
;
328 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
329 pThunk
->free
= LOWORD(thunk
) - base
;
335 /***********************************************************************
338 * 32-bit entry point for a new task. This function is responsible for
339 * setting up the registers and jumping to the 16-bit entry point.
342 static void TASK_CallToStart(void)
344 int cs_reg
, ds_reg
, ip_reg
;
345 TDB
*pTask
= (TDB
*)GlobalLock16( hCurrentTask
);
346 NE_MODULE
*pModule
= MODULE_GetPtr( pTask
->hModule
);
347 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
349 /* Registers at initialization must be:
351 * bx stack size in bytes
352 * cx heap size in bytes
353 * si previous app instance
354 * di current app instance
356 * es selector to the PSP
357 * ds dgroup of the application
359 * sp top of the stack
362 cs_reg
= pSegTable
[pModule
->cs
- 1].selector
;
363 ip_reg
= pModule
->ip
;
364 ds_reg
= pSegTable
[pModule
->dgroup
- 1].selector
;
366 IF1632_Saved16_ss
= pTask
->ss
;
367 IF1632_Saved16_sp
= pTask
->sp
;
368 dprintf_task( stddeb
, "Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
369 cs_reg
, ip_reg
, ds_reg
,
370 IF1632_Saved16_ss
, IF1632_Saved16_sp
);
372 CallTo16_regs_( (FARPROC
)(cs_reg
<< 16 | ip_reg
), ds_reg
,
373 pTask
->hPDB
/*es*/, 0 /*bp*/, 0 /*ax*/,
374 pModule
->stack_size
/*bx*/, pModule
->heap_size
/*cx*/,
375 0 /*dx*/, 0 /*si*/, ds_reg
/*di*/ );
377 /* This should never return */
378 fprintf( stderr
, "TASK_CallToStart: Main program returned!\n" );
379 TASK_KillCurrentTask( 1 );
384 /***********************************************************************
387 HTASK
TASK_CreateTask( HMODULE hModule
, HANDLE hInstance
, HANDLE hPrevInstance
,
388 HANDLE hEnvironment
, char *cmdLine
, WORD cmdShow
)
394 SEGTABLEENTRY
*pSegTable
;
398 char *stack16Top
, *stack32Top
;
399 STACK16FRAME
*frame16
;
400 STACK32FRAME
*frame32
;
401 extern DWORD CALLTO16_RetAddr_word
;
404 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
405 pSegTable
= NE_SEG_TABLE( pModule
);
407 /* Allocate the task structure */
409 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
410 hModule
, FALSE
, FALSE
, FALSE
);
411 if (!hTask
) return 0;
412 pTask
= (TDB
*)GlobalLock16( hTask
);
414 /* Allocate the new environment block */
416 if (!(hParentEnv
= hEnvironment
))
418 TDB
*pParent
= (TDB
*)GlobalLock16( hCurrentTask
);
419 hParentEnv
= pParent
? pParent
->pdb
.environment
: hDOSEnvironment
;
421 /* FIXME: do we really need to make a copy also when */
422 /* we don't use the parent environment? */
423 if (!(hEnvironment
= GlobalAlloc16( GMEM_FIXED
, GlobalSize16(hParentEnv
))))
425 GlobalFree16( hTask
);
428 memcpy( GlobalLock16( hEnvironment
), GlobalLock16( hParentEnv
),
429 GlobalSize16( hParentEnv
) );
431 /* Get current directory */
433 GetModuleFileName( hModule
, filename
, sizeof(filename
) );
434 name
= strrchr(filename
, '\\');
435 if (name
) *(name
+1) = 0;
437 /* Fill the task structure */
439 pTask
->nEvents
= 1; /* So the task can be started */
440 pTask
->hSelf
= hTask
;
442 pTask
->version
= pModule
->expected_version
;
443 pTask
->hInstance
= hInstance
;
444 pTask
->hPrevInstance
= hPrevInstance
;
445 pTask
->hModule
= hModule
;
446 pTask
->hParent
= hCurrentTask
;
447 pTask
->curdrive
= filename
[0] - 'A' + 0x80;
448 strcpy( pTask
->curdir
, filename
+2 );
449 pTask
->magic
= TDB_MAGIC
;
450 pTask
->nCmdShow
= cmdShow
;
452 /* Create the thunks block */
454 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
456 /* Copy the module name */
458 name
= MODULE_GetModuleName( hModule
);
459 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
461 /* Allocate a selector for the PDB */
463 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
464 hModule
, FALSE
, FALSE
, FALSE
, NULL
);
468 pTask
->pdb
.int20
= 0x20cd;
470 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
471 *(FARPROC16
*)&pTask
->pdb
.dispatcher
[1] = MODULE_GetEntryPoint( GetModuleHandle("KERNEL"), 102 ); /* KERNEL.102 is DOS3Call() */
472 pTask
->pdb
.savedint22
= INT_GetHandler( 0x22 );
473 pTask
->pdb
.savedint23
= INT_GetHandler( 0x23 );
474 pTask
->pdb
.savedint24
= INT_GetHandler( 0x24 );
475 pTask
->pdb
.fileHandlesPtr
= (SEGPTR
)MAKELONG( 0x18,
476 GlobalHandleToSel(pTask
->hPDB
) );
478 pTask
->pdb
.fileHandlesPtr
= pTask
->pdb
.fileHandles
;
480 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
481 pTask
->pdb
.environment
= hEnvironment
;
482 pTask
->pdb
.nbFiles
= 20;
483 lstrcpyn32A( pTask
->pdb
.cmdLine
+ 1, cmdLine
, 127 );
484 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
486 /* Get the compatibility flags */
488 pTask
->compat_flags
= GetProfileInt( name
, "Compatibility", 0 );
490 /* Allocate a code segment alias for the TDB */
492 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
493 sizeof(TDB
), pTask
->hPDB
, TRUE
,
494 FALSE
, FALSE
, NULL
);
496 /* Set the owner of the environment block */
498 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
500 /* Default DTA overwrites command-line */
502 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
503 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
505 /* Allocate the 32-bit stack */
508 pTask
->hStack32
= GLOBAL_Alloc( GMEM_FIXED
, STACK32_SIZE
, pTask
->hPDB
,
509 FALSE
, FALSE
, FALSE
);
511 /* Create the 32-bit stack frame */
513 *(DWORD
*)GlobalLock16(pTask
->hStack32
) = 0xDEADBEEF;
514 stack32Top
= (char*)GlobalLock16(pTask
->hStack32
) + STACK32_SIZE
;
515 frame32
= (STACK32FRAME
*)stack32Top
- 1;
516 frame32
->saved_esp
= (DWORD
)stack32Top
;
523 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
524 frame32
->codeselector
= WINE_CODE_SELECTOR
;
525 pTask
->esp
= (DWORD
)frame32
;
527 /* Create the 16-bit stack frame */
529 pTask
->ss
= hInstance
;
530 pTask
->sp
= ((pModule
->sp
!= 0) ? pModule
->sp
:
531 pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
) & ~1;
532 stack16Top
= (char *)PTR_SEG_OFF_TO_LIN( pTask
->ss
, pTask
->sp
);
533 frame16
= (STACK16FRAME
*)stack16Top
- 1;
534 frame16
->saved_ss
= 0; /*pTask->ss;*/
535 frame16
->saved_sp
= 0; /*pTask->sp;*/
536 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
537 frame16
->entry_point
= 0;
538 frame16
->entry_ip
= OFFSETOF(TASK_RescheduleProc
) + 14;
539 frame16
->entry_cs
= SELECTOROF(TASK_RescheduleProc
);
541 frame16
->ip
= LOWORD( CALLTO16_RetAddr_word
);
542 frame16
->cs
= HIWORD( CALLTO16_RetAddr_word
);
543 pTask
->sp
-= sizeof(STACK16FRAME
);
545 /* If there's no 16-bit stack yet, use a part of the new task stack */
546 /* This is only needed to have a stack to switch from on the first */
547 /* call to DirectedYield(). */
549 if (!IF1632_Saved16_ss
)
551 IF1632_Saved16_ss
= pTask
->ss
;
552 IF1632_Saved16_sp
= pTask
->sp
;
555 /* Add a breakpoint at the start of the task */
559 if (pModule
->flags
& NE_FFLAGS_WIN32
)
561 DBG_ADDR addr
= { 0, pModule
->pe_module
->load_addr
+
562 pModule
->pe_module
->pe_header
->opt_coff
.AddressOfEntryPoint
};
563 fprintf( stderr
, "Win32 task '%s': ", name
);
564 DEBUG_AddBreakpoint( &addr
);
568 DBG_ADDR addr
= { pSegTable
[pModule
->cs
-1].selector
, pModule
->ip
};
569 fprintf( stderr
, "Win16 task '%s': ", name
);
570 DEBUG_AddBreakpoint( &addr
);
575 /* Add the task to the linked list */
577 TASK_LinkTask( hTask
);
579 dprintf_task( stddeb
, "CreateTask: module='%s' cmdline='%s' task=%04x\n",
580 name
, cmdLine
, hTask
);
586 /***********************************************************************
589 static void TASK_DeleteTask( HTASK hTask
)
594 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
597 /* Free the task module */
599 FreeModule16( pTask
->hModule
);
601 /* Close all open files of this task */
603 FILE_CloseAllFiles( pTask
->hPDB
);
605 /* Free the selector aliases */
607 GLOBAL_FreeBlock( pTask
->hCSAlias
);
608 GLOBAL_FreeBlock( pTask
->hPDB
);
610 /* Free the task structure itself */
612 GlobalFree16( hTask
);
614 /* Free all memory used by this task (including the 32-bit stack, */
615 /* the environment block and the thunk segments). */
617 GlobalFreeAll( hPDB
);
621 /***********************************************************************
622 * TASK_KillCurrentTask
624 * Kill the currently running task. As it's not possible to kill the
625 * current task like this, it is simply marked for destruction, and will
626 * be killed when either TASK_Reschedule or this function is called again
627 * in the context of another task.
629 void TASK_KillCurrentTask( int exitCode
)
631 extern void EXEC_ExitWindows( int retCode
);
633 TDB
* pTask
= (TDB
*) GlobalLock16( hCurrentTask
);
634 if (!pTask
) EXEC_ExitWindows(0); /* No current task yet */
636 /* Perform USER cleanup */
638 USER_AppExit( hCurrentTask
, pTask
->hInstance
, pTask
->hQueue
);
640 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
642 /* If another task is already marked for destruction, */
643 /* we can kill it now, as we are in another context. */
644 TASK_DeleteTask( hTaskToKill
);
649 dprintf_task( stddeb
, "Killing the last task, exiting\n" );
650 EXEC_ExitWindows( 0 );
653 /* Remove the task from the list to be sure we never switch back to it */
654 TASK_UnlinkTask( hCurrentTask
);
656 hTaskToKill
= hCurrentTask
;
660 /* We should never return from this Yield() */
662 fprintf(stderr
,"It's alive! Alive!!!\n");
667 /***********************************************************************
670 * This is where all the magic of task-switching happens!
672 * This function should only be called via the TASK_SCHEDULE() macro, to make
673 * sure that all the context is saved correctly.
675 void TASK_Reschedule(void)
677 TDB
*pOldTask
= NULL
, *pNewTask
;
683 /* First check if there's a task to kill */
685 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
687 TASK_DeleteTask( hTaskToKill
);
691 /* Flush any X events that happened in the meantime */
693 EVENT_WaitXEvent( FALSE
);
695 /* Find a task to yield to */
697 pOldTask
= (TDB
*)GlobalLock16( hCurrentTask
);
698 if (pOldTask
&& pOldTask
->hYieldTo
)
700 /* If a task is stored in hYieldTo of the current task (put there */
701 /* by DirectedYield), yield to it only if it has events pending. */
702 hTask
= pOldTask
->hYieldTo
;
703 if (!(pNewTask
= (TDB
*)GlobalLock16( hTask
)) || !pNewTask
->nEvents
)
709 /* Find a task that has an event pending */
714 pNewTask
= (TDB
*)GlobalLock16( hTask
);
715 if (pNewTask
->nEvents
) break;
716 hTask
= pNewTask
->hNext
;
718 if (hLockedTask
&& (hTask
!= hLockedTask
)) hTask
= 0;
721 /* No task found, wait for some events to come in */
723 EVENT_WaitXEvent( TRUE
);
726 if (hTask
== hCurrentTask
) return; /* Nothing to do */
728 pNewTask
= (TDB
*)GlobalLock16( hTask
);
729 dprintf_task( stddeb
, "Switching to task %04x (%.8s)\n",
730 hTask
, pNewTask
->module_name
);
732 /* Save the stacks of the previous task (if any) */
734 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
737 pOldTask
->ss
= IF1632_Saved16_ss
;
738 pOldTask
->sp
= IF1632_Saved16_sp
;
739 pOldTask
->esp
= IF1632_Saved32_esp
;
741 else IF1632_Original32_esp
= IF1632_Saved32_esp
;
744 /* Make the task the last in the linked list (round-robin scheduling) */
746 pNewTask
->priority
++;
747 TASK_UnlinkTask( hTask
);
748 TASK_LinkTask( hTask
);
749 pNewTask
->priority
--;
751 /* Switch to the new stack */
753 hCurrentTask
= hTask
;
754 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
755 IF1632_Saved16_ss
= pNewTask
->ss
;
756 IF1632_Saved16_sp
= pNewTask
->sp
;
757 IF1632_Saved32_esp
= pNewTask
->esp
;
758 IF1632_Stack32_base
= WIN16_GlobalLock16( pNewTask
->hStack32
);
763 /***********************************************************************
764 * InitTask (KERNEL.91)
769 void InitTask( SIGCONTEXT
*context
)
774 SEGTABLEENTRY
*pSegTable
;
775 INSTANCEDATA
*pinstance
;
776 LONG stacklow
, stackhi
;
779 EAX_reg(context
) = 0;
781 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
782 if (!(pModule
= MODULE_GetPtr( pTask
->hModule
))) return;
785 NE_InitializeDLLs( pTask
->hModule
);
787 /* Registers on return are:
788 * ax 1 if OK, 0 on error
789 * cx stack limit in bytes
790 * dx cmdShow parameter
791 * si instance handle of the previous instance
792 * di instance handle of the new task
793 * es:bx pointer to command-line inside PSP
795 EAX_reg(context
) = 1;
796 EBX_reg(context
) = 0x81;
797 ECX_reg(context
) = pModule
->stack_size
;
798 EDX_reg(context
) = pTask
->nCmdShow
;
799 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
800 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
801 ES_reg (context
) = (WORD
)pTask
->hPDB
;
803 /* Initialize the local heap */
804 if ( pModule
->heap_size
)
806 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
810 /* Initialize the INSTANCEDATA structure */
811 pSegTable
= NE_SEG_TABLE( pModule
);
812 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
813 stackhi
= stacklow
+ pModule
->stack_size
;
814 if (stackhi
> 0xffff) stackhi
= 0xffff;
815 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
816 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
817 pinstance
->stacktop
= stacklow
;
819 pinstance
->stackmin
= IF1632_Saved16_sp
;
824 /***********************************************************************
825 * WaitEvent (KERNEL.30)
827 BOOL
WaitEvent( HTASK hTask
)
831 if (!hTask
) hTask
= hCurrentTask
;
832 pTask
= (TDB
*)GlobalLock16( hTask
);
833 if (pTask
->nEvents
> 0)
839 /* When we get back here, we have an event */
840 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
841 else fprintf( stderr
, "WaitEvent: reschedule returned without event\n" );
846 /***********************************************************************
847 * PostEvent (KERNEL.31)
849 void PostEvent( HTASK hTask
)
853 if (!hTask
) hTask
= hCurrentTask
;
854 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
859 /***********************************************************************
860 * SetPriority (KERNEL.32)
862 void SetPriority( HTASK hTask
, int delta
)
867 if (!hTask
) hTask
= hCurrentTask
;
868 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
869 newpriority
= pTask
->priority
+ delta
;
870 if (newpriority
< -32) newpriority
= -32;
871 else if (newpriority
> 15) newpriority
= 15;
873 pTask
->priority
= newpriority
+ 1;
874 TASK_UnlinkTask( hTask
);
875 TASK_LinkTask( hTask
);
880 /***********************************************************************
881 * LockCurrentTask (KERNEL.33)
883 HTASK
LockCurrentTask( BOOL bLock
)
885 if (bLock
) hLockedTask
= hCurrentTask
;
886 else hLockedTask
= 0;
891 /***********************************************************************
892 * IsTaskLocked (KERNEL.122)
894 HTASK
IsTaskLocked(void)
900 /***********************************************************************
901 * OldYield (KERNEL.117)
907 pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
908 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
910 if (pCurTask
) pCurTask
->nEvents
--;
914 /***********************************************************************
915 * DirectedYield (KERNEL.150)
917 void DirectedYield( HTASK hTask
)
919 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
920 pCurTask
->hYieldTo
= hTask
;
925 /***********************************************************************
926 * UserYield (USER.332)
930 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
931 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
932 /* Handle sent messages */
933 if (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
934 QUEUE_ReceiveMessage( queue
);
938 queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
939 if (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
940 QUEUE_ReceiveMessage( queue
);
944 /***********************************************************************
949 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
950 if (pCurTask
) pCurTask
->hYieldTo
= 0;
951 if (pCurTask
&& pCurTask
->hQueue
) UserYield();
956 /***********************************************************************
957 * MakeProcInstance16 (KERNEL.51)
959 FARPROC16
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
962 return func
; /* func can be called directly in Winelib */
967 thunkaddr
= TASK_AllocThunk( hCurrentTask
);
968 if (!thunkaddr
) return (FARPROC
)0;
969 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
971 dprintf_task( stddeb
, "MakeProcInstance(%08lx,%04x): got thunk %08lx\n",
972 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
974 *thunk
++ = 0xb8; /* movw instance, %ax */
975 *thunk
++ = (BYTE
)(hInstance
& 0xff);
976 *thunk
++ = (BYTE
)(hInstance
>> 8);
977 *thunk
++ = 0xea; /* ljmp func */
978 *(DWORD
*)thunk
= (DWORD
)func
;
979 return (FARPROC
)thunkaddr
;
984 /***********************************************************************
985 * FreeProcInstance16 (KERNEL.52)
987 void FreeProcInstance16( FARPROC16 func
)
990 dprintf_task( stddeb
, "FreeProcInstance(%08lx)\n", (DWORD
)func
);
991 TASK_FreeThunk( hCurrentTask
, (SEGPTR
)func
);
996 /**********************************************************************
997 * GetCodeHandle (KERNEL.93)
999 HANDLE
GetCodeHandle( FARPROC proc
)
1003 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1005 /* Return the code segment containing 'proc'. */
1006 /* Not sure if this is really correct (shouldn't matter that much). */
1008 /* Check if it is really a thunk */
1009 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1010 handle
= GlobalHandle16( thunk
[6] + (thunk
[7] << 8) );
1012 handle
= GlobalHandle16( HIWORD(proc
) );
1016 return (HANDLE
)proc
;
1021 /***********************************************************************
1022 * SetTaskQueue (KERNEL.34)
1024 HQUEUE
SetTaskQueue( HANDLE hTask
, HQUEUE hQueue
)
1029 if (!hTask
) hTask
= hCurrentTask
;
1030 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1032 hPrev
= pTask
->hQueue
;
1033 pTask
->hQueue
= hQueue
;
1035 TIMER_SwitchQueue( hPrev
, hQueue
);
1041 /***********************************************************************
1042 * GetTaskQueue (KERNEL.35)
1044 HQUEUE16
GetTaskQueue( HTASK16 hTask
)
1048 if (!hTask
) hTask
= hCurrentTask
;
1049 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1050 return pTask
->hQueue
;
1054 /***********************************************************************
1055 * GetTaskQueueDS (KERNEL.118)
1058 void GetTaskQueueDS( SIGCONTEXT
*context
)
1060 DS_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1062 #endif /* WINELIB */
1065 /***********************************************************************
1066 * GetTaskQueueES (KERNEL.119)
1069 void GetTaskQueueES( SIGCONTEXT
*context
)
1071 ES_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1073 #endif /* WINELIB */
1076 /***********************************************************************
1077 * GetCurrentTask (KERNEL.36)
1079 HTASK16
GetCurrentTask(void)
1081 return hCurrentTask
;
1084 DWORD
WIN16_GetCurrentTask(void)
1086 /* This is the version used by relay code; the first task is */
1087 /* returned in the high word of the result */
1088 return MAKELONG( hCurrentTask
, hFirstTask
);
1092 /***********************************************************************
1093 * GetCurrentPDB (KERNEL.37)
1095 HANDLE
GetCurrentPDB(void)
1099 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1104 /***********************************************************************
1105 * GetInstanceData (KERNEL.54)
1107 int GetInstanceData( HANDLE instance
, WORD buffer
, int len
)
1109 char *ptr
= (char *)GlobalLock16( instance
);
1110 if (!ptr
|| !len
) return 0;
1111 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1112 memcpy( ptr
+ buffer
, (char *)GlobalLock16( CURRENT_DS
) + buffer
, len
);
1117 /***********************************************************************
1118 * SetErrorMode (KERNEL.107)
1120 UINT
SetErrorMode( UINT mode
)
1125 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1126 oldMode
= pTask
->error_mode
;
1127 pTask
->error_mode
= mode
;
1132 /***********************************************************************
1133 * GetDOSEnvironment (KERNEL.131)
1135 SEGPTR
GetDOSEnvironment(void)
1139 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1140 return (SEGPTR
)WIN16_GlobalLock16( pTask
->pdb
.environment
);
1144 /***********************************************************************
1145 * GetNumTasks (KERNEL.152)
1147 WORD
GetNumTasks(void)
1153 /***********************************************************************
1154 * GetTaskDS (KERNEL.155)
1156 HINSTANCE16
GetTaskDS(void)
1160 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1161 return pTask
->hInstance
;
1165 /***********************************************************************
1166 * IsTask (KERNEL.320)
1168 BOOL
IsTask( HTASK hTask
)
1172 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1173 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1174 return (pTask
->magic
== TDB_MAGIC
);
1178 /***********************************************************************
1179 * GetExePtr (KERNEL.133)
1181 HMODULE
GetExePtr( HANDLE handle
)
1187 /* Check for module handle */
1189 if (!(ptr
= GlobalLock16( handle
))) return 0;
1190 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return handle
;
1192 /* Check the owner for module handle */
1194 owner
= FarGetOwner( handle
);
1195 if (!(ptr
= GlobalLock16( owner
))) return 0;
1196 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return owner
;
1198 /* Search for this handle and its owner inside all tasks */
1203 TDB
*pTask
= (TDB
*)GlobalLock16( hTask
);
1204 if ((hTask
== handle
) ||
1205 (pTask
->hInstance
== handle
) ||
1206 (pTask
->hQueue
== handle
) ||
1207 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1208 if ((hTask
== owner
) ||
1209 (pTask
->hInstance
== owner
) ||
1210 (pTask
->hQueue
== owner
) ||
1211 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1212 hTask
= pTask
->hNext
;
1218 /***********************************************************************
1219 * TaskFirst (TOOLHELP.63)
1221 BOOL16
TaskFirst( TASKENTRY
*lpte
)
1223 lpte
->hNext
= hFirstTask
;
1224 return TaskNext( lpte
);
1228 /***********************************************************************
1229 * TaskNext (TOOLHELP.64)
1231 BOOL16
TaskNext( TASKENTRY
*lpte
)
1234 INSTANCEDATA
*pInstData
;
1236 dprintf_toolhelp( stddeb
, "TaskNext(%p): task=%04x\n", lpte
, lpte
->hNext
);
1237 if (!lpte
->hNext
) return FALSE
;
1238 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1239 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1240 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1241 lpte
->hTask
= lpte
->hNext
;
1242 lpte
->hTaskParent
= pTask
->hParent
;
1243 lpte
->hInst
= pTask
->hInstance
;
1244 lpte
->hModule
= pTask
->hModule
;
1245 lpte
->wSS
= pTask
->ss
;
1246 lpte
->wSP
= pTask
->sp
;
1247 lpte
->wStackTop
= pInstData
->stacktop
;
1248 lpte
->wStackMinimum
= pInstData
->stackmin
;
1249 lpte
->wStackBottom
= pInstData
->stackbottom
;
1250 lpte
->wcEvents
= pTask
->nEvents
;
1251 lpte
->hQueue
= pTask
->hQueue
;
1252 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1253 lpte
->szModule
[8] = '\0';
1254 lpte
->wPSPOffset
= 0x100; /*??*/
1255 lpte
->hNext
= pTask
->hNext
;
1260 /***********************************************************************
1261 * TaskFindHandle (TOOLHELP.65)
1263 BOOL16
TaskFindHandle( TASKENTRY
*lpte
, HTASK16 hTask
)
1265 lpte
->hNext
= hTask
;
1266 return TaskNext( lpte
);
1270 /***********************************************************************
1271 * GetAppCompatFlags (KERNEL.354) (USER32.205)
1273 DWORD
GetAppCompatFlags( HTASK32 hTask
)
1277 if (!hTask
) hTask
= GetCurrentTask();
1278 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1279 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1280 return pTask
->compat_flags
;