4 * Copyright 1995 Alexandre Julliard
14 #include "directory.h"
28 #include "stackframe.h"
34 /* Min. number of thunks allocated when creating a new segment */
37 /* 32-bit stack size for each task */
38 /* Must not be greater than 64k, or MAKE_SEGPTR won't work */
39 #define STACK32_SIZE 0x10000
41 extern void USER_AppExit(HTASK
, HINSTANCE
, HQUEUE
);
43 /* Saved 16-bit stack for current process (Win16 only) */
44 WORD IF1632_Saved16_ss
= 0;
45 WORD IF1632_Saved16_sp
= 0;
47 /* Saved 32-bit stack for current process (Win16 only) */
48 DWORD IF1632_Saved32_esp
= 0;
49 SEGPTR IF1632_Stack32_base
= 0;
51 /* Original Unix stack */
52 DWORD IF1632_Original32_esp
;
54 static HTASK16 hFirstTask
= 0;
55 static HTASK16 hCurrentTask
= 0;
56 static HTASK16 hTaskToKill
= 0;
57 static HTASK16 hLockedTask
= 0;
58 static WORD nTaskCount
= 0;
59 static HANDLE hDOSEnvironment
= 0;
61 /* TASK_Reschedule() 16-bit entry point */
62 static FARPROC16 TASK_RescheduleProc
;
65 #define TASK_SCHEDULE() TASK_Reschedule()
67 #define TASK_SCHEDULE() CallTo16_word_(TASK_RescheduleProc)
70 static HANDLE
TASK_CreateDOSEnvironment(void);
72 /***********************************************************************
75 BOOL32
TASK_Init(void)
77 TASK_RescheduleProc
= MODULE_GetWndProcEntry16( "TASK_Reschedule" );
78 if (!(hDOSEnvironment
= TASK_CreateDOSEnvironment()))
79 fprintf( stderr
, "Not enough memory for DOS Environment\n" );
80 return (hDOSEnvironment
!= 0);
84 /***********************************************************************
87 HTASK
TASK_GetNextTask( HTASK hTask
)
89 TDB
* pTask
= (TDB
*)GlobalLock16(hTask
);
91 if (pTask
->hNext
) return pTask
->hNext
;
92 return (hFirstTask
!= hTask
) ? hFirstTask
: 0;
96 /***********************************************************************
97 * TASK_CreateDOSEnvironment
99 * Create the original DOS environment.
101 static HANDLE
TASK_CreateDOSEnvironment(void)
103 static const char program_name
[] = "KRNL386.EXE";
105 int initial_size
, size
, i
, winpathlen
, sysdirlen
;
108 extern char **environ
;
110 /* DOS environment format:
118 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
121 /* First compute the size of the fixed part of the environment */
123 for (i
= winpathlen
= 0; ; i
++)
125 int len
= DIR_GetDosPath( i
, NULL
, 0 );
127 winpathlen
+= len
+ 1;
129 if (!winpathlen
) winpathlen
= 1;
130 sysdirlen
= GetSystemDirectory32A( NULL
, 0 ) + 1;
131 initial_size
= 5 + winpathlen
+ /* PATH=xxxx */
132 1 + /* BYTE 0 at end */
133 sizeof(WORD
) + /* WORD 1 */
134 sysdirlen
+ /* program directory */
135 strlen(program_name
) + 1; /* program name */
137 /* Compute the total size of the Unix environment (except path) */
139 for (e
= environ
, size
= initial_size
; *e
; e
++)
141 if (lstrncmpi32A(*e
, "path=", 5))
143 int len
= strlen(*e
) + 1;
144 if (size
+ len
>= 32767)
146 fprintf( stderr
, "Warning: environment larger than 32k.\n" );
154 /* Now allocate the environment */
156 if (!(handle
= GlobalAlloc16( GMEM_FIXED
, size
))) return 0;
157 p
= (char *)GlobalLock16( handle
);
159 /* And fill it with the Unix environment */
161 for (e
= environ
, size
= initial_size
; *e
; e
++)
163 if (lstrncmpi32A(*e
, "path=", 5))
165 int len
= strlen(*e
) + 1;
166 if (size
+ len
>= 32767) break;
173 /* Now add the path */
175 strcpy( p
, "PATH=" );
176 for (i
= 0, p
+= 5; ; i
++)
178 if (!DIR_GetDosPath( i
, p
, winpathlen
)) break;
182 if (p
[-1] == ';') p
[-1] = '\0';
185 /* Now add the program name */
190 GetSystemDirectory32A( p
, sysdirlen
);
192 strcat( p
, program_name
);
196 p
= (char *) GlobalLock16( handle
);
197 dprintf_task(stddeb
, "Master DOS environment at %p\n", p
);
198 for (; *p
; p
+= strlen(p
) + 1) dprintf_task(stddeb
, " %s\n", p
);
199 dprintf_task( stddeb
, "Progname: %s\n", p
+3 );
205 /***********************************************************************
208 static void TASK_LinkTask( HTASK16 hTask
)
213 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
214 prevTask
= &hFirstTask
;
217 TDB
*prevTaskPtr
= (TDB
*)GlobalLock16( *prevTask
);
218 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
219 prevTask
= &prevTaskPtr
->hNext
;
221 pTask
->hNext
= *prevTask
;
227 /***********************************************************************
230 static void TASK_UnlinkTask( HTASK16 hTask
)
235 prevTask
= &hFirstTask
;
236 while (*prevTask
&& (*prevTask
!= hTask
))
238 pTask
= (TDB
*)GlobalLock16( *prevTask
);
239 prevTask
= &pTask
->hNext
;
243 pTask
= (TDB
*)GlobalLock16( *prevTask
);
244 *prevTask
= pTask
->hNext
;
251 /***********************************************************************
254 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
255 * and containing 'count' entries.
257 static void TASK_CreateThunks( HGLOBAL handle
, WORD offset
, WORD count
)
263 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
265 pThunk
->magic
= THUNK_MAGIC
;
266 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
268 for (i
= 0; i
< count
-1; i
++)
270 free
+= 8; /* Offset of next thunk */
271 pThunk
->thunks
[4*i
] = free
;
273 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
277 /***********************************************************************
280 * Allocate a thunk for MakeProcInstance().
283 static SEGPTR
TASK_AllocThunk( HTASK hTask
)
289 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
290 sel
= pTask
->hCSAlias
;
291 pThunk
= &pTask
->thunks
;
292 base
= (int)pThunk
- (int)pTask
;
293 while (!pThunk
->free
)
296 if (!sel
) /* Allocate a new segment */
298 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
299 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
300 if (!sel
) return (SEGPTR
)0;
301 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
304 pThunk
= (THUNKS
*)GlobalLock16( sel
);
307 base
+= pThunk
->free
;
308 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
309 return PTR_SEG_OFF_TO_SEGPTR( sel
, base
);
314 /***********************************************************************
317 * Free a MakeProcInstance() thunk.
320 static BOOL
TASK_FreeThunk( HTASK hTask
, SEGPTR thunk
)
326 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
327 sel
= pTask
->hCSAlias
;
328 pThunk
= &pTask
->thunks
;
329 base
= (int)pThunk
- (int)pTask
;
330 while (sel
&& (sel
!= HIWORD(thunk
)))
333 pThunk
= (THUNKS
*)GlobalLock16( sel
);
336 if (!sel
) return FALSE
;
337 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
338 pThunk
->free
= LOWORD(thunk
) - base
;
344 /***********************************************************************
347 * 32-bit entry point for a new task. This function is responsible for
348 * setting up the registers and jumping to the 16-bit entry point.
351 static void TASK_CallToStart(void)
353 int cs_reg
, ds_reg
, ip_reg
;
354 TDB
*pTask
= (TDB
*)GlobalLock16( hCurrentTask
);
355 NE_MODULE
*pModule
= MODULE_GetPtr( pTask
->hModule
);
356 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
358 /* Registers at initialization must be:
360 * bx stack size in bytes
361 * cx heap size in bytes
362 * si previous app instance
363 * di current app instance
365 * es selector to the PSP
366 * ds dgroup of the application
368 * sp top of the stack
371 cs_reg
= pSegTable
[pModule
->cs
- 1].selector
;
372 ip_reg
= pModule
->ip
;
373 ds_reg
= pSegTable
[pModule
->dgroup
- 1].selector
;
375 IF1632_Saved16_ss
= pTask
->ss
;
376 IF1632_Saved16_sp
= pTask
->sp
;
377 dprintf_task( stddeb
, "Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
378 cs_reg
, ip_reg
, ds_reg
,
379 IF1632_Saved16_ss
, IF1632_Saved16_sp
);
381 CallTo16_regs_( (FARPROC16
)(cs_reg
<< 16 | ip_reg
), ds_reg
,
382 pTask
->hPDB
/*es*/, 0 /*bp*/, 0 /*ax*/,
383 pModule
->stack_size
/*bx*/, pModule
->heap_size
/*cx*/,
384 0 /*dx*/, 0 /*si*/, ds_reg
/*di*/ );
386 /* This should never return */
387 fprintf( stderr
, "TASK_CallToStart: Main program returned!\n" );
388 TASK_KillCurrentTask( 1 );
393 /***********************************************************************
396 HTASK16
TASK_CreateTask( HMODULE16 hModule
, HINSTANCE16 hInstance
,
397 HINSTANCE16 hPrevInstance
, HANDLE16 hEnvironment
,
398 LPCSTR cmdLine
, UINT16 cmdShow
)
404 SEGTABLEENTRY
*pSegTable
;
407 char *stack16Top
, *stack32Top
;
408 STACK16FRAME
*frame16
;
409 STACK32FRAME
*frame32
;
411 extern DWORD CALLTO16_RetAddr_word
;
414 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
415 pSegTable
= NE_SEG_TABLE( pModule
);
417 /* Allocate the task structure */
419 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
420 hModule
, FALSE
, FALSE
, FALSE
);
421 if (!hTask
) return 0;
422 pTask
= (TDB
*)GlobalLock16( hTask
);
424 /* Allocate the new environment block */
426 if (!(hParentEnv
= hEnvironment
))
428 TDB
*pParent
= (TDB
*)GlobalLock16( hCurrentTask
);
429 hParentEnv
= pParent
? pParent
->pdb
.environment
: hDOSEnvironment
;
431 /* FIXME: do we really need to make a copy also when */
432 /* we don't use the parent environment? */
433 if (!(hEnvironment
= GlobalAlloc16( GMEM_FIXED
, GlobalSize16(hParentEnv
))))
435 GlobalFree16( hTask
);
438 memcpy( GlobalLock16( hEnvironment
), GlobalLock16( hParentEnv
),
439 GlobalSize16( hParentEnv
) );
441 /* Get current directory */
443 GetModuleFileName( hModule
, filename
, sizeof(filename
) );
444 name
= strrchr(filename
, '\\');
445 if (name
) *(name
+1) = 0;
447 /* Fill the task structure */
449 pTask
->nEvents
= 1; /* So the task can be started */
450 pTask
->hSelf
= hTask
;
452 pTask
->version
= pModule
->expected_version
;
453 pTask
->hInstance
= hInstance
;
454 pTask
->hPrevInstance
= hPrevInstance
;
455 pTask
->hModule
= hModule
;
456 pTask
->hParent
= hCurrentTask
;
457 pTask
->curdrive
= filename
[0] - 'A' + 0x80;
458 strcpy( pTask
->curdir
, filename
+2 );
459 pTask
->magic
= TDB_MAGIC
;
460 pTask
->nCmdShow
= cmdShow
;
462 /* Create the thunks block */
464 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
466 /* Copy the module name */
468 name
= MODULE_GetModuleName( hModule
);
469 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
471 /* Allocate a selector for the PDB */
473 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
474 hModule
, FALSE
, FALSE
, FALSE
, NULL
);
478 pTask
->pdb
.int20
= 0x20cd;
479 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
481 *(FARPROC16
*)&pTask
->pdb
.dispatcher
[1] = MODULE_GetEntryPoint( GetModuleHandle("KERNEL"), 102 ); /* KERNEL.102 is DOS3Call() */
482 pTask
->pdb
.savedint22
= INT_GetHandler( 0x22 );
483 pTask
->pdb
.savedint23
= INT_GetHandler( 0x23 );
484 pTask
->pdb
.savedint24
= INT_GetHandler( 0x24 );
486 pTask
->pdb
.fileHandlesPtr
=
487 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask
->hPDB
),
488 (int)&((PDB
*)0)->fileHandles
);
489 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
490 pTask
->pdb
.environment
= hEnvironment
;
491 pTask
->pdb
.nbFiles
= 20;
492 lstrcpyn32A( pTask
->pdb
.cmdLine
+ 1, cmdLine
, 127 );
493 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
495 /* Get the compatibility flags */
497 pTask
->compat_flags
= GetProfileInt( name
, "Compatibility", 0 );
499 /* Allocate a code segment alias for the TDB */
501 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
502 sizeof(TDB
), pTask
->hPDB
, TRUE
,
503 FALSE
, FALSE
, NULL
);
505 /* Set the owner of the environment block */
507 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
509 /* Default DTA overwrites command-line */
511 pTask
->dta
= PTR_SEG_OFF_TO_SEGPTR( pTask
->hPDB
,
512 (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
514 /* Allocate the 32-bit stack */
516 pTask
->hStack32
= GLOBAL_Alloc( GMEM_FIXED
, STACK32_SIZE
, pTask
->hPDB
,
517 FALSE
, FALSE
, FALSE
);
519 /* Create the 32-bit stack frame */
521 *(DWORD
*)GlobalLock16(pTask
->hStack32
) = 0xDEADBEEF;
522 stack32Top
= (char*)GlobalLock16(pTask
->hStack32
) + STACK32_SIZE
;
523 frame32
= (STACK32FRAME
*)stack32Top
- 1;
524 frame32
->saved_esp
= (DWORD
)stack32Top
;
532 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
533 frame32
->codeselector
= WINE_CODE_SELECTOR
;
535 pTask
->esp
= (DWORD
)frame32
;
537 /* Create the 16-bit stack frame */
539 pTask
->ss
= hInstance
;
540 pTask
->sp
= ((pModule
->sp
!= 0) ? pModule
->sp
:
541 pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
) & ~1;
542 stack16Top
= (char *)PTR_SEG_OFF_TO_LIN( pTask
->ss
, pTask
->sp
);
543 frame16
= (STACK16FRAME
*)stack16Top
- 1;
544 frame16
->saved_ss
= 0;
545 frame16
->saved_sp
= 0;
546 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
547 frame16
->entry_point
= 0;
548 frame16
->entry_ip
= OFFSETOF(TASK_RescheduleProc
) + 14;
549 frame16
->entry_cs
= SELECTOROF(TASK_RescheduleProc
);
552 frame16
->ip
= LOWORD( CALLTO16_RetAddr_word
);
553 frame16
->cs
= HIWORD( CALLTO16_RetAddr_word
);
555 pTask
->sp
-= sizeof(STACK16FRAME
);
557 /* If there's no 16-bit stack yet, use a part of the new task stack */
558 /* This is only needed to have a stack to switch from on the first */
559 /* call to DirectedYield(). */
561 if (!IF1632_Saved16_ss
)
563 IF1632_Saved16_ss
= pTask
->ss
;
564 IF1632_Saved16_sp
= pTask
->sp
;
567 /* Add a breakpoint at the start of the task */
572 if (pModule
->flags
& NE_FFLAGS_WIN32
)
574 DBG_ADDR addr
= { 0, pModule
->pe_module
->load_addr
+
575 pModule
->pe_module
->pe_header
->opt_coff
.AddressOfEntryPoint
};
576 fprintf( stderr
, "Win32 task '%s': ", name
);
577 DEBUG_AddBreakpoint( &addr
);
581 DBG_ADDR addr
= { pSegTable
[pModule
->cs
-1].selector
, pModule
->ip
};
582 fprintf( stderr
, "Win16 task '%s': ", name
);
583 DEBUG_AddBreakpoint( &addr
);
588 /* Add the task to the linked list */
590 TASK_LinkTask( hTask
);
592 dprintf_task( stddeb
, "CreateTask: module='%s' cmdline='%s' task=%04x\n",
593 name
, cmdLine
, hTask
);
599 /***********************************************************************
602 static void TASK_DeleteTask( HTASK hTask
)
607 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
610 /* Free the task module */
612 FreeModule16( pTask
->hModule
);
614 /* Close all open files of this task */
616 FILE_CloseAllFiles( pTask
->hPDB
);
618 /* Free the selector aliases */
620 GLOBAL_FreeBlock( pTask
->hCSAlias
);
621 GLOBAL_FreeBlock( pTask
->hPDB
);
623 /* Free the task structure itself */
625 GlobalFree16( hTask
);
627 /* Free all memory used by this task (including the 32-bit stack, */
628 /* the environment block and the thunk segments). */
630 GlobalFreeAll( hPDB
);
634 /***********************************************************************
635 * TASK_KillCurrentTask
637 * Kill the currently running task. As it's not possible to kill the
638 * current task like this, it is simply marked for destruction, and will
639 * be killed when either TASK_Reschedule or this function is called again
640 * in the context of another task.
642 void TASK_KillCurrentTask( INT16 exitCode
)
644 extern void EXEC_ExitWindows( int retCode
);
646 TDB
* pTask
= (TDB
*) GlobalLock16( hCurrentTask
);
647 if (!pTask
) EXEC_ExitWindows(0); /* No current task yet */
649 /* Perform USER cleanup */
651 USER_AppExit( hCurrentTask
, pTask
->hInstance
, pTask
->hQueue
);
653 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
655 /* If another task is already marked for destruction, */
656 /* we can kill it now, as we are in another context. */
657 TASK_DeleteTask( hTaskToKill
);
662 dprintf_task( stddeb
, "Killing the last task, exiting\n" );
663 EXEC_ExitWindows( 0 );
666 /* Remove the task from the list to be sure we never switch back to it */
667 TASK_UnlinkTask( hCurrentTask
);
669 hTaskToKill
= hCurrentTask
;
673 /* We should never return from this Yield() */
675 fprintf(stderr
,"It's alive! Alive!!!\n");
680 /***********************************************************************
683 * This is where all the magic of task-switching happens!
685 * This function should only be called via the TASK_SCHEDULE() macro, to make
686 * sure that all the context is saved correctly.
688 void TASK_Reschedule(void)
690 TDB
*pOldTask
= NULL
, *pNewTask
;
696 /* First check if there's a task to kill */
698 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
700 TASK_DeleteTask( hTaskToKill
);
704 /* Flush any X events that happened in the meantime */
706 EVENT_WaitXEvent( FALSE
);
708 /* Find a task to yield to */
710 pOldTask
= (TDB
*)GlobalLock16( hCurrentTask
);
711 if (pOldTask
&& pOldTask
->hYieldTo
)
713 /* If a task is stored in hYieldTo of the current task (put there */
714 /* by DirectedYield), yield to it only if it has events pending. */
715 hTask
= pOldTask
->hYieldTo
;
716 if (!(pNewTask
= (TDB
*)GlobalLock16( hTask
)) || !pNewTask
->nEvents
)
722 /* Find a task that has an event pending */
727 pNewTask
= (TDB
*)GlobalLock16( hTask
);
728 if (pNewTask
->nEvents
) break;
729 hTask
= pNewTask
->hNext
;
731 if (hLockedTask
&& (hTask
!= hLockedTask
)) hTask
= 0;
734 /* No task found, wait for some events to come in */
736 EVENT_WaitXEvent( TRUE
);
739 if (hTask
== hCurrentTask
) return; /* Nothing to do */
741 pNewTask
= (TDB
*)GlobalLock16( hTask
);
742 dprintf_task( stddeb
, "Switching to task %04x (%.8s)\n",
743 hTask
, pNewTask
->module_name
);
745 /* Save the stacks of the previous task (if any) */
749 pOldTask
->ss
= IF1632_Saved16_ss
;
750 pOldTask
->sp
= IF1632_Saved16_sp
;
751 pOldTask
->esp
= IF1632_Saved32_esp
;
753 else IF1632_Original32_esp
= IF1632_Saved32_esp
;
755 /* Make the task the last in the linked list (round-robin scheduling) */
757 pNewTask
->priority
++;
758 TASK_UnlinkTask( hTask
);
759 TASK_LinkTask( hTask
);
760 pNewTask
->priority
--;
762 /* Switch to the new stack */
764 hCurrentTask
= hTask
;
765 IF1632_Saved16_ss
= pNewTask
->ss
;
766 IF1632_Saved16_sp
= pNewTask
->sp
;
767 IF1632_Saved32_esp
= pNewTask
->esp
;
768 IF1632_Stack32_base
= WIN16_GlobalLock16( pNewTask
->hStack32
);
772 /***********************************************************************
773 * InitTask (KERNEL.91)
778 void InitTask( SIGCONTEXT
*context
)
783 SEGTABLEENTRY
*pSegTable
;
784 INSTANCEDATA
*pinstance
;
785 LONG stacklow
, stackhi
;
788 EAX_reg(context
) = 0;
790 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
791 if (!(pModule
= MODULE_GetPtr( pTask
->hModule
))) return;
794 NE_InitializeDLLs( pTask
->hModule
);
796 /* Registers on return are:
797 * ax 1 if OK, 0 on error
798 * cx stack limit in bytes
799 * dx cmdShow parameter
800 * si instance handle of the previous instance
801 * di instance handle of the new task
802 * es:bx pointer to command-line inside PSP
804 EAX_reg(context
) = 1;
805 EBX_reg(context
) = 0x81;
806 ECX_reg(context
) = pModule
->stack_size
;
807 EDX_reg(context
) = pTask
->nCmdShow
;
808 ESI_reg(context
) = (DWORD
)pTask
->hPrevInstance
;
809 EDI_reg(context
) = (DWORD
)pTask
->hInstance
;
810 ES_reg (context
) = (WORD
)pTask
->hPDB
;
812 /* Initialize the local heap */
813 if ( pModule
->heap_size
)
815 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
819 /* Initialize the INSTANCEDATA structure */
820 pSegTable
= NE_SEG_TABLE( pModule
);
821 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
822 stackhi
= stacklow
+ pModule
->stack_size
;
823 if (stackhi
> 0xffff) stackhi
= 0xffff;
824 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
825 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
826 pinstance
->stacktop
= stacklow
;
828 pinstance
->stackmin
= IF1632_Saved16_sp
;
833 /***********************************************************************
834 * WaitEvent (KERNEL.30)
836 BOOL
WaitEvent( HTASK hTask
)
840 if (!hTask
) hTask
= hCurrentTask
;
841 pTask
= (TDB
*)GlobalLock16( hTask
);
842 if (pTask
->nEvents
> 0)
848 /* When we get back here, we have an event */
849 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
850 else fprintf( stderr
, "WaitEvent: reschedule returned without event\n" );
855 /***********************************************************************
856 * PostEvent (KERNEL.31)
858 void PostEvent( HTASK hTask
)
862 if (!hTask
) hTask
= hCurrentTask
;
863 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
868 /***********************************************************************
869 * SetPriority (KERNEL.32)
871 void SetPriority( HTASK hTask
, int delta
)
876 if (!hTask
) hTask
= hCurrentTask
;
877 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return;
878 newpriority
= pTask
->priority
+ delta
;
879 if (newpriority
< -32) newpriority
= -32;
880 else if (newpriority
> 15) newpriority
= 15;
882 pTask
->priority
= newpriority
+ 1;
883 TASK_UnlinkTask( hTask
);
884 TASK_LinkTask( hTask
);
889 /***********************************************************************
890 * LockCurrentTask (KERNEL.33)
892 HTASK
LockCurrentTask( BOOL bLock
)
894 if (bLock
) hLockedTask
= hCurrentTask
;
895 else hLockedTask
= 0;
900 /***********************************************************************
901 * IsTaskLocked (KERNEL.122)
903 HTASK
IsTaskLocked(void)
909 /***********************************************************************
910 * OldYield (KERNEL.117)
916 pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
917 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
919 if (pCurTask
) pCurTask
->nEvents
--;
923 /***********************************************************************
924 * DirectedYield (KERNEL.150)
926 void DirectedYield( HTASK hTask
)
928 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
929 pCurTask
->hYieldTo
= hTask
;
934 /***********************************************************************
935 * UserYield (USER.332)
939 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
940 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
941 /* Handle sent messages */
942 if (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
943 QUEUE_ReceiveMessage( queue
);
947 queue
= (MESSAGEQUEUE
*)GlobalLock16( pCurTask
->hQueue
);
948 if (queue
&& (queue
->wakeBits
& QS_SENDMESSAGE
))
949 QUEUE_ReceiveMessage( queue
);
953 /***********************************************************************
958 TDB
*pCurTask
= (TDB
*)GlobalLock16( hCurrentTask
);
959 if (pCurTask
) pCurTask
->hYieldTo
= 0;
960 if (pCurTask
&& pCurTask
->hQueue
) UserYield();
965 /***********************************************************************
966 * MakeProcInstance16 (KERNEL.51)
968 FARPROC16
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
971 return func
; /* func can be called directly in Winelib */
976 thunkaddr
= TASK_AllocThunk( hCurrentTask
);
977 if (!thunkaddr
) return (FARPROC16
)0;
978 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
980 dprintf_task( stddeb
, "MakeProcInstance(%08lx,%04x): got thunk %08lx\n",
981 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
983 *thunk
++ = 0xb8; /* movw instance, %ax */
984 *thunk
++ = (BYTE
)(hInstance
& 0xff);
985 *thunk
++ = (BYTE
)(hInstance
>> 8);
986 *thunk
++ = 0xea; /* ljmp func */
987 *(DWORD
*)thunk
= (DWORD
)func
;
988 return (FARPROC16
)thunkaddr
;
993 /***********************************************************************
994 * FreeProcInstance16 (KERNEL.52)
996 void FreeProcInstance16( FARPROC16 func
)
999 dprintf_task( stddeb
, "FreeProcInstance(%08lx)\n", (DWORD
)func
);
1000 TASK_FreeThunk( hCurrentTask
, (SEGPTR
)func
);
1005 /**********************************************************************
1006 * GetCodeHandle (KERNEL.93)
1008 HANDLE
GetCodeHandle( FARPROC16 proc
)
1012 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
1014 /* Return the code segment containing 'proc'. */
1015 /* Not sure if this is really correct (shouldn't matter that much). */
1017 /* Check if it is really a thunk */
1018 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
1019 handle
= GlobalHandle16( thunk
[6] + (thunk
[7] << 8) );
1021 handle
= GlobalHandle16( HIWORD(proc
) );
1025 return (HANDLE
)proc
;
1030 /***********************************************************************
1031 * SetTaskQueue (KERNEL.34)
1033 HQUEUE
SetTaskQueue( HANDLE hTask
, HQUEUE hQueue
)
1038 if (!hTask
) hTask
= hCurrentTask
;
1039 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1041 hPrev
= pTask
->hQueue
;
1042 pTask
->hQueue
= hQueue
;
1044 TIMER_SwitchQueue( hPrev
, hQueue
);
1050 /***********************************************************************
1051 * GetTaskQueue (KERNEL.35)
1053 HQUEUE16
GetTaskQueue( HTASK16 hTask
)
1057 if (!hTask
) hTask
= hCurrentTask
;
1058 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return 0;
1059 return pTask
->hQueue
;
1063 /***********************************************************************
1064 * SwitchStackTo (KERNEL.108)
1066 void SwitchStackTo( WORD seg
, WORD ptr
, WORD top
)
1069 STACK16FRAME
*oldFrame
, *newFrame
;
1070 INSTANCEDATA
*pData
;
1073 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
1074 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1075 dprintf_task( stddeb
, "SwitchStackTo: old=%04x:%04x new=%04x:%04x\n",
1076 IF1632_Saved16_ss
, IF1632_Saved16_sp
, seg
, ptr
);
1078 /* Save the old stack */
1080 oldFrame
= CURRENT_STACK16
;
1081 pData
->old_sp
= IF1632_Saved16_sp
;
1082 pData
->old_ss
= IF1632_Saved16_ss
;
1083 pData
->stacktop
= top
;
1084 pData
->stackmin
= ptr
;
1085 pData
->stackbottom
= ptr
;
1087 /* Switch to the new stack */
1089 IF1632_Saved16_ss
= pTask
->ss
= seg
;
1090 IF1632_Saved16_sp
= pTask
->sp
= ptr
- sizeof(STACK16FRAME
);
1091 newFrame
= CURRENT_STACK16
;
1093 /* Copy the stack frame and the local variables to the new stack */
1095 copySize
= oldFrame
->bp
- pData
->old_sp
;
1096 memcpy( newFrame
, oldFrame
, MAX( copySize
, sizeof(STACK16FRAME
) ));
1100 /***********************************************************************
1101 * SwitchStackBack (KERNEL.109)
1103 * Note: the function is declared as 'register' in the spec file in order
1104 * to make sure all registers are preserved, but we don't use them in any
1105 * way, so we don't need a SIGCONTEXT* argument.
1107 void SwitchStackBack(void)
1110 STACK16FRAME
*oldFrame
, *newFrame
;
1111 INSTANCEDATA
*pData
;
1113 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return;
1114 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( IF1632_Saved16_ss
))) return;
1117 fprintf( stderr
, "SwitchStackBack: no previous SwitchStackTo\n" );
1120 dprintf_task( stddeb
, "SwitchStackBack: restoring stack %04x:%04x\n",
1121 pData
->old_ss
, pData
->old_sp
);
1123 oldFrame
= CURRENT_STACK16
;
1125 /* Switch back to the old stack */
1127 IF1632_Saved16_ss
= pTask
->ss
= pData
->old_ss
;
1128 IF1632_Saved16_sp
= pTask
->sp
= pData
->old_sp
;
1129 pData
->old_ss
= pData
->old_sp
= 0;
1131 /* Build a stack frame for the return */
1133 newFrame
= CURRENT_STACK16
;
1134 newFrame
->saved_ss
= oldFrame
->saved_ss
;
1135 newFrame
->saved_sp
= oldFrame
->saved_sp
;
1136 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1137 newFrame
->entry_cs
= oldFrame
->entry_cs
;
1138 newFrame
->bp
= oldFrame
->bp
;
1139 newFrame
->ip
= oldFrame
->ip
;
1140 newFrame
->cs
= oldFrame
->cs
;
1144 /***********************************************************************
1145 * GetTaskQueueDS (KERNEL.118)
1148 void GetTaskQueueDS( SIGCONTEXT
*context
)
1150 DS_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1152 #endif /* WINELIB */
1155 /***********************************************************************
1156 * GetTaskQueueES (KERNEL.119)
1159 void GetTaskQueueES( SIGCONTEXT
*context
)
1161 ES_reg(context
) = GlobalHandleToSel( GetTaskQueue(0) );
1163 #endif /* WINELIB */
1166 /***********************************************************************
1167 * GetCurrentTask (KERNEL.36)
1169 HTASK16
GetCurrentTask(void)
1171 return hCurrentTask
;
1174 DWORD
WIN16_GetCurrentTask(void)
1176 /* This is the version used by relay code; the first task is */
1177 /* returned in the high word of the result */
1178 return MAKELONG( hCurrentTask
, hFirstTask
);
1182 /***********************************************************************
1183 * GetCurrentPDB (KERNEL.37)
1185 HANDLE
GetCurrentPDB(void)
1189 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1194 /***********************************************************************
1195 * GetInstanceData (KERNEL.54)
1197 int GetInstanceData( HANDLE instance
, WORD buffer
, int len
)
1199 char *ptr
= (char *)GlobalLock16( instance
);
1200 if (!ptr
|| !len
) return 0;
1201 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1202 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1207 /***********************************************************************
1208 * GetExeVersion (KERNEL.105)
1210 WORD
GetExeVersion(void)
1214 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1215 return pTask
->version
;
1219 /***********************************************************************
1220 * SetErrorMode (KERNEL.107)
1222 UINT
SetErrorMode( UINT mode
)
1227 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1228 oldMode
= pTask
->error_mode
;
1229 pTask
->error_mode
= mode
;
1234 /***********************************************************************
1235 * GetDOSEnvironment (KERNEL.131)
1237 SEGPTR
GetDOSEnvironment(void)
1241 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1242 return (SEGPTR
)WIN16_GlobalLock16( pTask
->pdb
.environment
);
1246 /***********************************************************************
1247 * GetNumTasks (KERNEL.152)
1249 WORD
GetNumTasks(void)
1255 /***********************************************************************
1256 * GetTaskDS (KERNEL.155)
1258 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1259 * I don't think we need to bother with this.
1261 HINSTANCE16
GetTaskDS(void)
1265 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1266 return pTask
->hInstance
;
1270 /***********************************************************************
1271 * IsTask (KERNEL.320)
1273 BOOL
IsTask( HTASK hTask
)
1277 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return FALSE
;
1278 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1279 return (pTask
->magic
== TDB_MAGIC
);
1283 /***********************************************************************
1284 * SetTaskSignalProc (KERNEL.38)
1286 FARPROC16
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1291 if (!hTask
) hTask
= hCurrentTask
;
1292 if (!(pTask
= (TDB
*)GlobalLock16( hTask
))) return NULL
;
1293 oldProc
= pTask
->userhandler
;
1294 pTask
->userhandler
= proc
;
1299 /***********************************************************************
1300 * SetSigHandler (KERNEL.140)
1302 WORD
SetSigHandler( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1303 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1305 fprintf(stdnimp
,"SetSigHandler(%p,%p,%p,%d,%d), unimplemented.\n",
1306 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1308 if (flag
!= 1) return 0;
1309 if (!newmode
) newhandler
= NULL
; /* Default handler */
1314 if (!(pTask
= (TDB
*)GlobalLock16( hCurrentTask
))) return 0;
1315 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1316 pTask
->signal_flags
= newmode
;
1317 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1318 pTask
->sighandler
= newhandler
;
1324 /***********************************************************************
1325 * GetExePtr (KERNEL.133)
1327 HMODULE16
GetExePtr( HANDLE16 handle
)
1333 /* Check for module handle */
1335 if (!(ptr
= GlobalLock16( handle
))) return 0;
1336 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return handle
;
1338 /* Check the owner for module handle */
1340 owner
= FarGetOwner( handle
);
1341 if (!(ptr
= GlobalLock16( owner
))) return 0;
1342 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return owner
;
1344 /* Search for this handle and its owner inside all tasks */
1349 TDB
*pTask
= (TDB
*)GlobalLock16( hTask
);
1350 if ((hTask
== handle
) ||
1351 (pTask
->hInstance
== handle
) ||
1352 (pTask
->hQueue
== handle
) ||
1353 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1354 if ((hTask
== owner
) ||
1355 (pTask
->hInstance
== owner
) ||
1356 (pTask
->hQueue
== owner
) ||
1357 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1358 hTask
= pTask
->hNext
;
1364 /***********************************************************************
1365 * TaskFirst (TOOLHELP.63)
1367 BOOL16
TaskFirst( TASKENTRY
*lpte
)
1369 lpte
->hNext
= hFirstTask
;
1370 return TaskNext( lpte
);
1374 /***********************************************************************
1375 * TaskNext (TOOLHELP.64)
1377 BOOL16
TaskNext( TASKENTRY
*lpte
)
1380 INSTANCEDATA
*pInstData
;
1382 dprintf_toolhelp( stddeb
, "TaskNext(%p): task=%04x\n", lpte
, lpte
->hNext
);
1383 if (!lpte
->hNext
) return FALSE
;
1384 pTask
= (TDB
*)GlobalLock16( lpte
->hNext
);
1385 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1386 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1387 lpte
->hTask
= lpte
->hNext
;
1388 lpte
->hTaskParent
= pTask
->hParent
;
1389 lpte
->hInst
= pTask
->hInstance
;
1390 lpte
->hModule
= pTask
->hModule
;
1391 lpte
->wSS
= pTask
->ss
;
1392 lpte
->wSP
= pTask
->sp
;
1393 lpte
->wStackTop
= pInstData
->stacktop
;
1394 lpte
->wStackMinimum
= pInstData
->stackmin
;
1395 lpte
->wStackBottom
= pInstData
->stackbottom
;
1396 lpte
->wcEvents
= pTask
->nEvents
;
1397 lpte
->hQueue
= pTask
->hQueue
;
1398 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1399 lpte
->szModule
[8] = '\0';
1400 lpte
->wPSPOffset
= 0x100; /*??*/
1401 lpte
->hNext
= pTask
->hNext
;
1406 /***********************************************************************
1407 * TaskFindHandle (TOOLHELP.65)
1409 BOOL16
TaskFindHandle( TASKENTRY
*lpte
, HTASK16 hTask
)
1411 lpte
->hNext
= hTask
;
1412 return TaskNext( lpte
);
1416 /***********************************************************************
1417 * GetAppCompatFlags (KERNEL.354) (USER32.205)
1419 DWORD
GetAppCompatFlags( HTASK32 hTask
)
1423 if (!hTask
) hTask
= GetCurrentTask();
1424 if (!(pTask
=(TDB
*)GlobalLock16( (HTASK16
)hTask
))) return 0;
1425 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1426 return pTask
->compat_flags
;