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;