4 * Copyright 1995 Alexandre Julliard
22 #include "selectors.h"
28 /* Min. number of thunks allocated when creating a new segment */
31 /* 32-bit stack size for each task */
32 /* Must not be greater than 64k, or MAKE_SEGPTR won't work */
33 #define STACK32_SIZE 0x10000
35 /* ------ Internal variables ------ */
37 static HTASK hFirstTask
= 0;
38 static HTASK hCurrentTask
= 0;
39 static HTASK hTaskToKill
= 0;
40 static HTASK hLockedTask
= 0;
41 static WORD nTaskCount
= 0;
42 static HANDLE hDOSEnvironment
= 0;
44 /* ------ Internal declarations ------ */
46 /* TASK_Reschedule() 16-bit entry point */
47 static FARPROC TASK_RescheduleProc
;
50 #define TASK_SCHEDULE() TASK_Reschedule();
52 #define TASK_SCHEDULE() CallTo16_word_(TASK_RescheduleProc,0)
55 static HANDLE
TASK_CreateDOSEnvironment(void);
57 /***********************************************************************
62 TASK_RescheduleProc
= (FARPROC
)GetWndProcEntry16( "TASK_Reschedule" );
63 if (!(hDOSEnvironment
= TASK_CreateDOSEnvironment()))
64 fprintf( stderr
, "Not enough memory for DOS Environment\n" );
65 return (hDOSEnvironment
!= 0);
69 /***********************************************************************
70 * TASK_CreateDOSEnvironment
72 * Create the original DOS environment.
74 static HANDLE
TASK_CreateDOSEnvironment(void)
76 static const char program_name
[] = "KRNL386.EXE";
78 int initial_size
, size
;
81 extern char **environ
;
82 extern char WindowsDirectory
[], SystemDirectory
[];
84 /* DOS environment format:
93 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
96 /* First compute the size of the fixed part of the environment */
98 initial_size
= 5 + /* PATH= */
99 strlen(WindowsPath
) + 1 + /* path value */
101 strlen(WindowsDirectory
) + 1 + /* windir value */
102 1 + /* BYTE 0 at end */
103 sizeof(WORD
) + /* WORD 1 */
104 strlen(SystemDirectory
) + 1 + /* program directory */
105 strlen(program_name
) + 1; /* program name */
107 /* Compute the total size of the Unix environment (except path) */
109 for (e
= environ
, size
= initial_size
; *e
; e
++)
111 if (strncasecmp(*e
, "path=", 5))
113 int len
= strlen(*e
) + 1;
114 if (size
+ len
>= 32767)
116 fprintf( stderr
, "Warning: environment larger than 32k.\n" );
124 /* Now allocate the environment */
126 if (!(handle
= GlobalAlloc( GMEM_FIXED
, size
))) return 0;
127 p
= (char *)GlobalLock( handle
);
129 /* And fill it with the Unix environment */
131 for (e
= environ
, size
= initial_size
; *e
; e
++)
133 if (strncasecmp(*e
, "path=", 5))
135 int len
= strlen(*e
) + 1;
136 if (size
+ len
>= 32767) break;
143 /* Now add the path and Windows directory */
145 strcpy( p
, "PATH=" );
146 strcat( p
, WindowsPath
);
149 strcpy( p
, "windir=" );
150 strcat( p
, WindowsDirectory
);
153 /* Now add the program name */
158 strcpy( p
, SystemDirectory
);
160 strcat( p
, program_name
);
164 p
= (char *) GlobalLock( handle
);
165 dprintf_task(stddeb
, "Master DOS environment at %p\n", p
);
166 for (; *p
; p
+= strlen(p
) + 1) dprintf_task(stddeb
, " %s\n", p
);
167 dprintf_task( stddeb
, "Progname: %s\n", p
+3 );
173 /***********************************************************************
176 static void TASK_LinkTask( HTASK hTask
)
181 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
182 prevTask
= &hFirstTask
;
185 TDB
*prevTaskPtr
= (TDB
*)GlobalLock( *prevTask
);
186 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
187 prevTask
= &prevTaskPtr
->hNext
;
189 pTask
->hNext
= *prevTask
;
195 /***********************************************************************
198 static void TASK_UnlinkTask( HTASK hTask
)
203 prevTask
= &hFirstTask
;
204 while (*prevTask
&& (*prevTask
!= hTask
))
206 pTask
= (TDB
*)GlobalLock( *prevTask
);
207 prevTask
= &pTask
->hNext
;
211 pTask
= (TDB
*)GlobalLock( *prevTask
);
212 *prevTask
= pTask
->hNext
;
219 /***********************************************************************
222 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
223 * and containing 'count' entries.
225 static void TASK_CreateThunks( HGLOBAL handle
, WORD offset
, WORD count
)
231 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock( handle
) + offset
);
233 pThunk
->magic
= THUNK_MAGIC
;
234 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
236 for (i
= 0; i
< count
-1; i
++)
238 free
+= 8; /* Offset of next thunk */
239 pThunk
->thunks
[4*i
] = free
;
241 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
245 /***********************************************************************
248 * Allocate a thunk for MakeProcInstance().
250 static SEGPTR
TASK_AllocThunk( HTASK hTask
)
256 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
257 sel
= pTask
->hCSAlias
;
258 pThunk
= &pTask
->thunks
;
259 base
= (int)pThunk
- (int)pTask
;
260 while (!pThunk
->free
)
263 if (!sel
) /* Allocate a new segment */
265 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
266 pTask
->hPDB
, TRUE
, FALSE
, FALSE
);
267 if (!sel
) return (SEGPTR
)0;
268 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
271 pThunk
= (THUNKS
*)GlobalLock( sel
);
274 base
+= pThunk
->free
;
275 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
276 return MAKELONG( base
, sel
);
280 /***********************************************************************
283 * Free a MakeProcInstance() thunk.
285 static BOOL
TASK_FreeThunk( HTASK hTask
, SEGPTR thunk
)
291 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
292 sel
= pTask
->hCSAlias
;
293 pThunk
= &pTask
->thunks
;
294 base
= (int)pThunk
- (int)pTask
;
295 while (sel
&& (sel
!= HIWORD(thunk
)))
298 pThunk
= (THUNKS
*)GlobalLock( sel
);
301 if (!sel
) return FALSE
;
302 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
303 pThunk
->free
= LOWORD(thunk
) - base
;
308 /***********************************************************************
311 * 32-bit entry point for a new task. This function is responsible for
312 * setting up the registers and jumping to the 16-bit entry point.
314 static void TASK_CallToStart(void)
316 int cs_reg
, ds_reg
, ip_reg
;
317 TDB
*pTask
= (TDB
*)GlobalLock( hCurrentTask
);
318 NE_MODULE
*pModule
= (NE_MODULE
*)GlobalLock( pTask
->hModule
);
319 SEGTABLEENTRY
*pSegTable
= NE_SEG_TABLE( pModule
);
321 /* Registers at initialization must be:
323 * bx stack size in bytes
324 * cx heap size in bytes
325 * si previous app instance
326 * di current app instance
328 * es selector to the PSP
329 * ds dgroup of the application
331 * sp top of the stack
334 cs_reg
= pSegTable
[pModule
->cs
- 1].selector
;
335 ip_reg
= pModule
->ip
;
336 ds_reg
= pSegTable
[pModule
->dgroup
- 1].selector
;
338 /* JBP: I doubt a CallTo16_regs_ is possible in libwine.a, and IF1632 is not
341 IF1632_Saved16_ss
= pTask
->ss
;
342 IF1632_Saved16_sp
= pTask
->sp
;
343 dprintf_task( stddeb
, "Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
344 cs_reg
, ip_reg
, ds_reg
,
345 IF1632_Saved16_ss
, IF1632_Saved16_sp
);
347 CallTo16_regs_( (FARPROC
)(cs_reg
<< 16 | ip_reg
), ds_reg
,
348 pTask
->hPDB
/*es*/, 0 /*bp*/, 0 /*ax*/,
349 pModule
->stack_size
/*bx*/, pModule
->heap_size
/*cx*/,
350 0 /*dx*/, 0 /*si*/, ds_reg
/*di*/ );
352 fprintf(stderr
, "JBP: Ignoring main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
353 cs_reg
, ip_reg
, ds_reg
,
354 pTask
->ss
, pTask
->sp
);
356 /* This should never return */
357 fprintf( stderr
, "TASK_CallToStart: Main program returned!\n" );
358 TASK_KillCurrentTask( 1 );
362 /***********************************************************************
365 HTASK
TASK_CreateTask( HMODULE hModule
, HANDLE hInstance
, HANDLE hPrevInstance
,
366 HANDLE hEnvironment
, char *cmdLine
, WORD cmdShow
)
372 SEGTABLEENTRY
*pSegTable
;
376 char *stack16Top
, *stack32Top
;
377 STACK16FRAME
*frame16
;
378 STACK32FRAME
*frame32
;
379 extern DWORD CALL16_RetAddr_word
;
382 if (!(pModule
= (NE_MODULE
*)GlobalLock( hModule
))) return 0;
383 pSegTable
= NE_SEG_TABLE( pModule
);
385 /* Allocate the task structure */
387 hTask
= GLOBAL_Alloc( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
),
388 hModule
, FALSE
, FALSE
, FALSE
);
389 if (!hTask
) return 0;
390 pTask
= (TDB
*)GlobalLock( hTask
);
392 /* Allocate the new environment block */
394 if (!(hParentEnv
= hEnvironment
))
396 TDB
*pParent
= (TDB
*)GlobalLock( hCurrentTask
);
397 hParentEnv
= pParent
? pParent
->pdb
.environment
: hDOSEnvironment
;
399 /* FIXME: do we really need to make a copy also when */
400 /* we don't use the parent environment? */
401 if (!(hEnvironment
= GlobalAlloc( GMEM_FIXED
, GlobalSize( hParentEnv
) )))
406 memcpy( GlobalLock( hEnvironment
), GlobalLock( hParentEnv
),
407 GlobalSize( hParentEnv
) );
409 /* Get current directory */
411 GetModuleFileName( hModule
, filename
, sizeof(filename
) );
412 name
= strrchr(filename
, '\\');
413 if (name
) *(name
+1) = 0;
415 /* Fill the task structure */
417 pTask
->nEvents
= 1; /* So the task can be started */
418 pTask
->hSelf
= hTask
;
420 pTask
->version
= pModule
->expected_version
;
421 pTask
->hInstance
= hInstance
;
422 pTask
->hPrevInstance
= hPrevInstance
;
423 pTask
->hModule
= hModule
;
424 pTask
->hParent
= hCurrentTask
;
426 pTask
->curdrive
= 'C' - 'A' + 0x80;
428 pTask
->curdrive
= filename
[0] - 'A' + 0x80;
430 pTask
->magic
= TDB_MAGIC
;
431 pTask
->nCmdShow
= cmdShow
;
432 strcpy( pTask
->curdir
, filename
+2 );
434 /* Create the thunks block */
436 TASK_CreateThunks( hTask
, (int)&pTask
->thunks
- (int)pTask
, 7 );
438 /* Copy the module name */
440 name
= MODULE_GetModuleName( hModule
);
441 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
445 pTask
->pdb
.int20
= 0x20cd;
446 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
447 *(DWORD
*)&pTask
->pdb
.dispatcher
[1] = MODULE_GetEntryPoint( GetModuleHandle("KERNEL"), 102 ); /* KERNEL.102 is DOS3Call() */
449 pTask
->pdb
.savedint22
= INT_GetHandler( 0x22 );
450 pTask
->pdb
.savedint23
= INT_GetHandler( 0x23 );
451 pTask
->pdb
.savedint24
= INT_GetHandler( 0x24 );
453 pTask
->pdb
.environment
= hEnvironment
;
454 strncpy( pTask
->pdb
.cmdLine
+ 1, cmdLine
, 126 );
455 pTask
->pdb
.cmdLine
[127] = '\0';
456 pTask
->pdb
.cmdLine
[0] = strlen( pTask
->pdb
.cmdLine
+ 1 );
458 /* Get the compatibility flags */
460 pTask
->compat_flags
= GetProfileInt( name
, "Compatibility", 0 );
462 /* Allocate a selector for the PDB */
464 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB
),
465 hModule
, FALSE
, FALSE
, FALSE
, NULL
);
467 /* Allocate a code segment alias for the TDB */
469 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
470 sizeof(TDB
), pTask
->hPDB
, TRUE
,
471 FALSE
, FALSE
, NULL
);
473 /* Set the owner of the environment block */
475 FarSetOwner( pTask
->pdb
.environment
, pTask
->hPDB
);
477 /* Default DTA overwrites command-line */
479 pTask
->dta
= MAKELONG( (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
,
482 /* Allocate the 32-bit stack */
485 pTask
->hStack32
= GLOBAL_Alloc( GMEM_FIXED
, STACK32_SIZE
, pTask
->hPDB
,
486 FALSE
, FALSE
, FALSE
);
488 /* Create the 32-bit stack frame */
490 *(DWORD
*)GlobalLock(pTask
->hStack32
) = 0xDEADBEEF;
491 stack32Top
= (char*)GlobalLock(pTask
->hStack32
) + STACK32_SIZE
;
492 frame32
= (STACK32FRAME
*)stack32Top
- 1;
493 frame32
->saved_esp
= (DWORD
)stack32Top
;
500 frame32
->retaddr
= (DWORD
)TASK_CallToStart
;
501 frame32
->codeselector
= WINE_CODE_SELECTOR
;
502 pTask
->esp
= (DWORD
)frame32
;
504 /* Create the 16-bit stack frame */
506 pTask
->ss
= hInstance
;
507 pTask
->sp
= ((pModule
->sp
!= 0) ? pModule
->sp
:
508 pSegTable
[pModule
->ss
-1].minsize
+ pModule
->stack_size
) & ~1;
509 stack16Top
= (char *)PTR_SEG_OFF_TO_LIN( pTask
->ss
, pTask
->sp
);
510 frame16
= (STACK16FRAME
*)stack16Top
- 1;
511 frame16
->saved_ss
= 0; /*pTask->ss;*/
512 frame16
->saved_sp
= 0; /*pTask->sp;*/
513 frame16
->ds
= frame16
->es
= pTask
->hInstance
;
514 frame16
->entry_point
= 0;
515 frame16
->ordinal_number
= 24; /* WINPROCS.24 is TASK_Reschedule */
516 frame16
->dll_id
= 24; /* WINPROCS */
518 frame16
->ip
= LOWORD( CALL16_RetAddr_word
);
519 frame16
->cs
= HIWORD( CALL16_RetAddr_word
);
520 pTask
->sp
-= sizeof(STACK16FRAME
);
522 /* If there's no 16-bit stack yet, use a part of the new task stack */
523 /* This is only needed to have a stack to switch from on the first */
524 /* call to DirectedYield(). */
526 if (!IF1632_Saved16_ss
)
528 IF1632_Saved16_ss
= pTask
->ss
;
529 IF1632_Saved16_sp
= pTask
->sp
;
532 /* Add a breakpoint at the start of the task */
536 DBG_ADDR addr
= { pSegTable
[pModule
->cs
-1].selector
, pModule
->ip
};
537 fprintf( stderr
, "Task '%s': ", name
);
538 DEBUG_AddBreakpoint( &addr
);
542 /* Add the task to the linked list */
544 TASK_LinkTask( hTask
);
546 dprintf_task( stddeb
, "CreateTask: module='%s' cmdline='%s' task="NPFMT
"\n",
547 name
, cmdLine
, hTask
);
553 /***********************************************************************
556 static void TASK_DeleteTask( HTASK hTask
)
560 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
562 /* Free the task module */
564 FreeModule( pTask
->hModule
);
566 /* Free all memory used by this task (including the 32-bit stack, */
567 /* the environment block and the thunk segments). */
569 GlobalFreeAll( pTask
->hPDB
);
571 /* Free message queue */
573 MSG_DeleteMsgQueue( pTask
->hQueue
);
575 /* Free the selector aliases */
577 GLOBAL_FreeBlock( pTask
->hCSAlias
);
578 GLOBAL_FreeBlock( pTask
->hPDB
);
580 /* Free the task structure itself */
586 /***********************************************************************
587 * TASK_KillCurrentTask
589 * Kill the currently running task. As it's not possible to kill the
590 * current task like this, it is simply marked for destruction, and will
591 * be killed when either TASK_Reschedule or this function is called again
592 * in the context of another task.
594 void TASK_KillCurrentTask( int exitCode
)
596 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
598 /* If another task is already marked for destruction, */
599 /* we call kill it now, as we are in another context. */
600 TASK_DeleteTask( hTaskToKill
);
605 dprintf_task( stddeb
, "Killing the last task, exiting\n" );
609 /* Remove the task from the list to be sure we never switch back to it */
610 TASK_UnlinkTask( hCurrentTask
);
612 hTaskToKill
= hCurrentTask
;
616 /* We should never return from this Yield() */
618 fprintf(stderr
,"It's alive! Alive!!!\n");
623 /***********************************************************************
626 * This is where all the magic of task-switching happens!
628 * This function should only be called via the TASK_SCHEDULE() macro, to make
629 * sure that all the context is saved correctly.
631 void TASK_Reschedule(void)
633 TDB
*pOldTask
= NULL
, *pNewTask
;
639 /* First check if there's a task to kill */
641 if (hTaskToKill
&& (hTaskToKill
!= hCurrentTask
))
643 TASK_DeleteTask( hTaskToKill
);
647 /* If current task is locked, simply return */
649 if (hLockedTask
) return;
651 /* Find a task to yield to */
653 pOldTask
= (TDB
*)GlobalLock( hCurrentTask
);
654 if (pOldTask
&& pOldTask
->hYieldTo
)
656 /* If a task is stored in hYieldTo of the current task (put there */
657 /* by DirectedYield), yield to it only if it has events pending. */
658 hTask
= pOldTask
->hYieldTo
;
659 if (!(pNewTask
= (TDB
*)GlobalLock( hTask
)) || !pNewTask
->nEvents
)
668 pNewTask
= (TDB
*)GlobalLock( hTask
);
669 if (pNewTask
->nEvents
&& (hTask
!= hCurrentTask
)) break;
670 hTask
= pNewTask
->hNext
;
674 /* If there's a task to kill, switch to any other task, */
675 /* even if it doesn't have events pending. */
677 if (!hTask
&& hTaskToKill
) hTask
= hFirstTask
;
679 if (!hTask
) return; /* Do nothing */
681 pNewTask
= (TDB
*)GlobalLock( hTask
);
682 dprintf_task( stddeb
, "Switching to task "NPFMT
" (%.8s)\n",
683 hTask
, pNewTask
->module_name
);
685 /* Save the stacks of the previous task (if any) */
687 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
690 pOldTask
->ss
= IF1632_Saved16_ss
;
691 pOldTask
->sp
= IF1632_Saved16_sp
;
692 pOldTask
->esp
= IF1632_Saved32_esp
;
694 else IF1632_Original32_esp
= IF1632_Saved32_esp
;
697 /* Make the task the last in the linked list (round-robin scheduling) */
699 pNewTask
->priority
++;
700 TASK_UnlinkTask( hTask
);
701 TASK_LinkTask( hTask
);
702 pNewTask
->priority
--;
704 /* Switch to the new stack */
706 hCurrentTask
= hTask
;
707 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
708 IF1632_Saved16_ss
= pNewTask
->ss
;
709 IF1632_Saved16_sp
= pNewTask
->sp
;
710 IF1632_Saved32_esp
= pNewTask
->esp
;
711 IF1632_Stack32_base
= WIN16_GlobalLock( pNewTask
->hStack32
);
716 /***********************************************************************
717 * InitTask (KERNEL.91)
719 void InitTask( struct sigcontext_struct context
)
721 static int firstTask
= 1;
724 SEGTABLEENTRY
*pSegTable
;
725 INSTANCEDATA
*pinstance
;
726 LONG stacklow
, stackhi
;
728 EAX_reg(&context
) = 0;
729 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return;
730 if (!(pModule
= (NE_MODULE
*)GlobalLock( pTask
->hModule
))) return;
734 extern BOOL
WIDGETS_Init(void);
735 extern BOOL
WIN_CreateDesktopWindow(void);
737 /* Perform global initialisations that need a task context */
739 /* Initialize built-in window classes */
740 if (!WIDGETS_Init()) return;
742 /* Create desktop window */
743 if (!WIN_CreateDesktopWindow()) return;
749 NE_InitializeDLLs( pTask
->hModule
);
752 /* Registers on return are:
753 * ax 1 if OK, 0 on error
754 * cx stack limit in bytes
755 * dx cmdShow parameter
756 * si instance handle of the previous instance
757 * di instance handle of the new task
758 * es:bx pointer to command-line inside PSP
760 EAX_reg(&context
) = 1;
761 EBX_reg(&context
) = 0x81;
762 ECX_reg(&context
) = pModule
->stack_size
;
763 EDX_reg(&context
) = pTask
->nCmdShow
;
764 ESI_reg(&context
) = (DWORD
)pTask
->hPrevInstance
;
765 EDI_reg(&context
) = (DWORD
)pTask
->hInstance
;
766 ES_reg (&context
) = (WORD
)pTask
->hPDB
;
768 /* Initialize the local heap */
769 if ( pModule
->heap_size
)
771 LocalInit( pTask
->hInstance
, 0, pModule
->heap_size
);
775 /* Initialize the INSTANCEDATA structure */
776 pSegTable
= NE_SEG_TABLE( pModule
);
777 stacklow
= pSegTable
[pModule
->ss
- 1].minsize
;
778 stackhi
= stacklow
+ pModule
->stack_size
;
779 if (stackhi
> 0xffff) stackhi
= 0xffff;
780 pinstance
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN(CURRENT_DS
, 0);
781 pinstance
->stackbottom
= stackhi
; /* yup, that's right. Confused me too. */
782 pinstance
->stacktop
= stacklow
;
783 #ifndef WINELIB /* FIXME: JBP: IF1632 not allowed in libwine.a */
784 pinstance
->stackmin
= IF1632_Saved16_sp
;
789 /***********************************************************************
790 * WaitEvent (KERNEL.30)
792 BOOL
WaitEvent( HTASK hTask
)
796 if (!hTask
) hTask
= hCurrentTask
;
797 pTask
= (TDB
*)GlobalLock( hTask
);
798 if (pTask
->nEvents
> 0)
804 /* When we get back here, we have an event (or the task is the only one) */
805 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
810 /***********************************************************************
811 * PostEvent (KERNEL.31)
813 void PostEvent( HTASK hTask
)
817 if (!hTask
) hTask
= hCurrentTask
;
818 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
823 /***********************************************************************
824 * SetPriority (KERNEL.32)
826 void SetPriority( HTASK hTask
, int delta
)
831 if (!hTask
) hTask
= hCurrentTask
;
832 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return;
833 newpriority
= pTask
->priority
+ delta
;
834 if (newpriority
< -32) newpriority
= -32;
835 else if (newpriority
> 15) newpriority
= 15;
837 pTask
->priority
= newpriority
+ 1;
838 TASK_UnlinkTask( hTask
);
839 TASK_LinkTask( hTask
);
844 /***********************************************************************
845 * LockCurrentTask (KERNEL.33)
847 HTASK
LockCurrentTask( BOOL bLock
)
849 if (bLock
) hLockedTask
= hCurrentTask
;
850 else hLockedTask
= 0;
855 /***********************************************************************
856 * IsTaskLocked (KERNEL.122)
858 WORD
IsTaskLocked(void)
864 /***********************************************************************
865 * OldYield (KERNEL.117)
871 pCurTask
= (TDB
*)GlobalLock( hCurrentTask
);
872 if (pCurTask
) pCurTask
->nEvents
++; /* Make sure we get back here */
874 if (pCurTask
) pCurTask
->nEvents
--;
878 /***********************************************************************
879 * DirectedYield (KERNEL.150)
881 void DirectedYield( HTASK hTask
)
885 if ((pCurTask
= (TDB
*)GlobalLock( hCurrentTask
)) != NULL
)
886 pCurTask
->hYieldTo
= hTask
;
892 /***********************************************************************
901 /***********************************************************************
902 * MakeProcInstance (KERNEL.51)
904 FARPROC
MakeProcInstance( FARPROC func
, HANDLE hInstance
)
909 thunkaddr
= TASK_AllocThunk( hCurrentTask
);
910 if (!thunkaddr
) return (FARPROC
)0;
911 thunk
= PTR_SEG_TO_LIN( thunkaddr
);
913 dprintf_task( stddeb
, "MakeProcInstance(%08lx,"NPFMT
"): got thunk %08lx\n",
914 (SEGPTR
)func
, hInstance
, (SEGPTR
)thunkaddr
);
916 *thunk
++ = 0xb8; /* movw instance, %ax */
918 *thunk
++ = (BYTE
)(hInstance
& 0xff);
919 *thunk
++ = (BYTE
)(hInstance
>> 8);
921 *thunk
++ = 0xea; /* ljmp func */
922 *(DWORD
*)thunk
= (DWORD
)func
;
923 return (FARPROC
)thunkaddr
;
927 /***********************************************************************
928 * FreeProcInstance (KERNEL.52)
930 void FreeProcInstance( FARPROC func
)
932 dprintf_task( stddeb
, "FreeProcInstance(%08lx)\n", (SEGPTR
)func
);
933 TASK_FreeThunk( hCurrentTask
, (SEGPTR
)func
);
937 /**********************************************************************
938 * GetCodeHandle (KERNEL.93)
940 HANDLE
GetCodeHandle( FARPROC proc
)
943 BYTE
*thunk
= (BYTE
*)PTR_SEG_TO_LIN( proc
);
945 /* Return the code segment containing 'proc'. */
946 /* Not sure if this is really correct (shouldn't matter that much). */
948 /* Check if it is really a thunk */
949 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
950 handle
= GlobalHandle( thunk
[6] + (thunk
[7] << 8) );
952 handle
= GlobalHandle( HIWORD(proc
) );
954 printf( "STUB: GetCodeHandle(%08lx) returning "NPFMT
"\n",
955 (DWORD
)proc
, handle
);
960 /***********************************************************************
961 * SetTaskQueue (KERNEL.34)
963 HGLOBAL
SetTaskQueue( HANDLE hTask
, HGLOBAL hQueue
)
968 if (!hTask
) hTask
= hCurrentTask
;
969 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
970 hPrev
= pTask
->hQueue
;
971 pTask
->hQueue
= hQueue
;
976 /***********************************************************************
977 * GetTaskQueue (KERNEL.35)
979 HGLOBAL
GetTaskQueue( HANDLE hTask
)
983 if (!hTask
) hTask
= hCurrentTask
;
984 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return 0;
985 return pTask
->hQueue
;
989 /***********************************************************************
990 * GetTaskQueueDS (KERNEL.118)
993 void GetTaskQueueDS( struct sigcontext_struct context
)
995 DS_reg(&context
) = GlobalHandleToSel( GetTaskQueue(0) );
1000 /***********************************************************************
1001 * GetTaskQueueES (KERNEL.119)
1004 void GetTaskQueueES( struct sigcontext_struct context
)
1006 ES_reg(&context
) = GlobalHandleToSel( GetTaskQueue(0) );
1008 #endif /* WINELIB */
1011 /***********************************************************************
1012 * GetCurrentTask (KERNEL.36)
1014 HTASK
GetCurrentTask(void)
1016 /* Undocumented: first task is returned in high word */
1018 return hCurrentTask
;
1020 return MAKELONG( hCurrentTask
, hFirstTask
);
1025 /***********************************************************************
1026 * GetCurrentPDB (KERNEL.37)
1028 HANDLE
GetCurrentPDB(void)
1032 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1037 /***********************************************************************
1038 * GetInstanceData (KERNEL.54)
1040 int GetInstanceData( HANDLE instance
, WORD buffer
, int len
)
1042 char *ptr
= (char *)GlobalLock( instance
);
1043 if (!ptr
|| !len
) return 0;
1044 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1045 memcpy( ptr
+ buffer
, (char *)GlobalLock( CURRENT_DS
) + buffer
, len
);
1050 /***********************************************************************
1051 * GetDOSEnvironment (KERNEL.131)
1053 SEGPTR
GetDOSEnvironment(void)
1057 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1058 return (SEGPTR
)WIN16_GlobalLock( pTask
->pdb
.environment
);
1062 /***********************************************************************
1063 * GetNumTasks (KERNEL.152)
1065 WORD
GetNumTasks(void)
1071 /***********************************************************************
1072 * GetTaskDS (KERNEL.155)
1074 HINSTANCE
GetTaskDS(void)
1078 if (!(pTask
= (TDB
*)GlobalLock( hCurrentTask
))) return 0;
1079 return pTask
->hInstance
;
1083 /***********************************************************************
1084 * IsTask (KERNEL.320)
1086 BOOL
IsTask( HTASK hTask
)
1090 if (!(pTask
= (TDB
*)GlobalLock( hTask
))) return FALSE
;
1091 if (GlobalSize( hTask
) < sizeof(TDB
)) return FALSE
;
1092 return (pTask
->magic
== TDB_MAGIC
);
1096 /***********************************************************************
1097 * GetExePtr (KERNEL.133)
1099 HMODULE
GetExePtr( HANDLE handle
)
1105 /* Check for module handle */
1107 if (!(ptr
= GlobalLock( handle
))) return 0;
1108 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return handle
;
1110 /* Check the owner for module handle */
1113 owner
= FarGetOwner( handle
);
1116 fprintf(stderr
,"JBP: FarGetOwner() ignored.\n");
1118 if (!(ptr
= GlobalLock( owner
))) return 0;
1119 if (((NE_MODULE
*)ptr
)->magic
== NE_SIGNATURE
) return owner
;
1121 /* Search for this handle and its owner inside all tasks */
1126 TDB
*pTask
= (TDB
*)GlobalLock( hTask
);
1127 if ((hTask
== handle
) ||
1128 (pTask
->hInstance
== handle
) ||
1129 (pTask
->hQueue
== handle
) ||
1130 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1131 if ((hTask
== owner
) ||
1132 (pTask
->hInstance
== owner
) ||
1133 (pTask
->hQueue
== owner
) ||
1134 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1135 hTask
= pTask
->hNext
;
1141 /***********************************************************************
1142 * TaskFirst (TOOLHELP.63)
1144 BOOL
TaskFirst( TASKENTRY
*lpte
)
1146 lpte
->hNext
= hFirstTask
;
1147 return TaskNext( lpte
);
1151 /***********************************************************************
1152 * TaskNext (TOOLHELP.64)
1154 BOOL
TaskNext( TASKENTRY
*lpte
)
1157 INSTANCEDATA
*pInstData
;
1159 dprintf_toolhelp( stddeb
, "TaskNext(%p): task="NPFMT
"\n", lpte
, lpte
->hNext
);
1160 if (!lpte
->hNext
) return FALSE
;
1161 pTask
= (TDB
*)GlobalLock( lpte
->hNext
);
1162 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1163 pInstData
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( pTask
->hInstance
, 0 );
1164 lpte
->hTask
= lpte
->hNext
;
1165 lpte
->hTaskParent
= pTask
->hParent
;
1166 lpte
->hInst
= pTask
->hInstance
;
1167 lpte
->hModule
= pTask
->hModule
;
1168 lpte
->wSS
= pTask
->ss
;
1169 lpte
->wSP
= pTask
->sp
;
1170 lpte
->wStackTop
= pInstData
->stacktop
;
1171 lpte
->wStackMinimum
= pInstData
->stackmin
;
1172 lpte
->wStackBottom
= pInstData
->stackbottom
;
1173 lpte
->wcEvents
= pTask
->nEvents
;
1174 lpte
->hQueue
= pTask
->hQueue
;
1175 strncpy( lpte
->szModule
, pTask
->module_name
, 8 );
1176 lpte
->szModule
[8] = '\0';
1177 lpte
->wPSPOffset
= 0x100; /*??*/
1178 lpte
->hNext
= pTask
->hNext
;
1183 /***********************************************************************
1184 * TaskFindHandle (TOOLHELP.65)
1186 BOOL
TaskFindHandle( TASKENTRY
*lpte
, HTASK hTask
)
1188 lpte
->hNext
= hTask
;
1189 return TaskNext( lpte
);