loader/task.c

   1 /*
   2  * Task functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <assert.h>
  10 #include <unistd.h>
  11
  12 #include "wine/winbase16.h"
  13 #include "user.h"
  14 #include "callback.h"
  15 #include "drive.h"
  16 #include "file.h"
  17 #include "global.h"
  18 #include "instance.h"
  19 #include "message.h"
  20 #include "miscemu.h"
  21 #include "module.h"
  22 #include "neexe.h"
  23 #include "peexe.h"
  24 #include "pe_image.h"
  25 #include "process.h"
  26 #include "queue.h"
  27 #include "selectors.h"
  28 #include "stackframe.h"
  29 #include "task.h"
  30 #include "thread.h"
  31 #include "toolhelp.h"
  32 #include "winnt.h"
  33 #include "winsock.h"
  34 #include "thread.h"
  35 #include "syslevel.h"
  36 #include "debugtools.h"
  37 #include "dosexe.h"
  38 #include "dde_proc.h"
  39 #include "services.h"
  40 #include "server.h"
  41
  42 DECLARE_DEBUG_CHANNEL(relay)
  43 DECLARE_DEBUG_CHANNEL(task)
  44 DECLARE_DEBUG_CHANNEL(toolhelp)
  45
  46   /* Min. number of thunks allocated when creating a new segment */
  47 #define MIN_THUNKS  32
  48
  49   /* Pointer to function to switch to a larger stack */
  50 int (*IF1632_CallLargeStack)( int (*func)(), void *arg ) = NULL;
  51
  52   /* Pointer to debugger callback routine */
  53 void (*TASK_AddTaskEntryBreakpoint)( HTASK16 hTask ) = NULL;
  54
  55 static THHOOK DefaultThhook = { 0 };
  56 THHOOK *pThhook = &DefaultThhook;
  57
  58 #define hCurrentTask (pThhook->CurTDB)
  59 #define hFirstTask   (pThhook->HeadTDB)
  60 #define hLockedTask  (pThhook->LockTDB)
  61
  62 static HTASK16 hTaskToKill = 0;
  63 static UINT16 nTaskCount = 0;
  64
  65 static void TASK_YieldToSystem( void );
  66
  67 extern BOOL THREAD_InitDone;
  68
  69
  70 /***********************************************************************
  71  *           TASK_InstallTHHook
  72  */
  73 void TASK_InstallTHHook( THHOOK *pNewThhook )
  74 {
  75      THHOOK *pOldThhook = pThhook;
  76
  77      pThhook = pNewThhook? pNewThhook : &DefaultThhook;
  78
  79      *pThhook = *pOldThhook;
  80 }
  81
  82 /***********************************************************************
  83  *           TASK_GetNextTask
  84  */
  85 HTASK16 TASK_GetNextTask( HTASK16 hTask )
  86 {
  87     TDB* pTask = (TDB*)GlobalLock16(hTask);
  88
  89     if (pTask->hNext) return pTask->hNext;
  90     return (hFirstTask != hTask) ? hFirstTask : 0;
  91 }
  92
  93 /***********************************************************************
  94  *           TASK_LinkTask
  95  */
  96 static void TASK_LinkTask( HTASK16 hTask )
  97 {
  98     HTASK16 *prevTask;
  99     TDB *pTask;
 100
 101     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 102     prevTask = &hFirstTask;
 103     while (*prevTask)
 104     {
 105         TDB *prevTaskPtr = (TDB *)GlobalLock16( *prevTask );
 106         if (prevTaskPtr->priority >= pTask->priority) break;
 107         prevTask = &prevTaskPtr->hNext;
 108     }
 109     pTask->hNext = *prevTask;
 110     *prevTask = hTask;
 111     nTaskCount++;
 112 }
 113
 114
 115 /***********************************************************************
 116  *           TASK_UnlinkTask
 117  */
 118 static void TASK_UnlinkTask( HTASK16 hTask )
 119 {
 120     HTASK16 *prevTask;
 121     TDB *pTask;
 122
 123     prevTask = &hFirstTask;
 124     while (*prevTask && (*prevTask != hTask))
 125     {
 126         pTask = (TDB *)GlobalLock16( *prevTask );
 127         prevTask = &pTask->hNext;
 128     }
 129     if (*prevTask)
 130     {
 131         pTask = (TDB *)GlobalLock16( *prevTask );
 132         *prevTask = pTask->hNext;
 133         pTask->hNext = 0;
 134         nTaskCount--;
 135     }
 136 }
 137
 138
 139 /***********************************************************************
 140  *           TASK_CreateThunks
 141  *
 142  * Create a thunk free-list in segment 'handle', starting from offset 'offset'
 143  * and containing 'count' entries.
 144  */
 145 static void TASK_CreateThunks( HGLOBAL16 handle, WORD offset, WORD count )
 146 {
 147     int i;
 148     WORD free;
 149     THUNKS *pThunk;
 150
 151     pThunk = (THUNKS *)((BYTE *)GlobalLock16( handle ) + offset);
 152     pThunk->next = 0;
 153     pThunk->magic = THUNK_MAGIC;
 154     pThunk->free = (int)&pThunk->thunks - (int)pThunk;
 155     free = pThunk->free;
 156     for (i = 0; i < count-1; i++)
 157     {
 158         free += 8;  /* Offset of next thunk */
 159         pThunk->thunks[4*i] = free;
 160     }
 161     pThunk->thunks[4*i] = 0;  /* Last thunk */
 162 }
 163
 164
 165 /***********************************************************************
 166  *           TASK_AllocThunk
 167  *
 168  * Allocate a thunk for MakeProcInstance().
 169  */
 170 static SEGPTR TASK_AllocThunk( HTASK16 hTask )
 171 {
 172     TDB *pTask;
 173     THUNKS *pThunk;
 174     WORD sel, base;
 175
 176     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
 177     sel = pTask->hCSAlias;
 178     pThunk = &pTask->thunks;
 179     base = (int)pThunk - (int)pTask;
 180     while (!pThunk->free)
 181     {
 182         sel = pThunk->next;
 183         if (!sel)  /* Allocate a new segment */
 184         {
 185             sel = GLOBAL_Alloc( GMEM_FIXED, sizeof(THUNKS) + (MIN_THUNKS-1)*8,
 186                                 pTask->hPDB, TRUE, FALSE, FALSE );
 187             if (!sel) return (SEGPTR)0;
 188             TASK_CreateThunks( sel, 0, MIN_THUNKS );
 189             pThunk->next = sel;
 190         }
 191         pThunk = (THUNKS *)GlobalLock16( sel );
 192         base = 0;
 193     }
 194     base += pThunk->free;
 195     pThunk->free = *(WORD *)((BYTE *)pThunk + pThunk->free);
 196     return PTR_SEG_OFF_TO_SEGPTR( sel, base );
 197 }
 198
 199
 200 /***********************************************************************
 201  *           TASK_FreeThunk
 202  *
 203  * Free a MakeProcInstance() thunk.
 204  */
 205 static BOOL TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
 206 {
 207     TDB *pTask;
 208     THUNKS *pThunk;
 209     WORD sel, base;
 210
 211     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
 212     sel = pTask->hCSAlias;
 213     pThunk = &pTask->thunks;
 214     base = (int)pThunk - (int)pTask;
 215     while (sel && (sel != HIWORD(thunk)))
 216     {
 217         sel = pThunk->next;
 218         pThunk = (THUNKS *)GlobalLock16( sel );
 219         base = 0;
 220     }
 221     if (!sel) return FALSE;
 222     *(WORD *)((BYTE *)pThunk + LOWORD(thunk) - base) = pThunk->free;
 223     pThunk->free = LOWORD(thunk) - base;
 224     return TRUE;
 225 }
 226
 227
 228 /***********************************************************************
 229  *           TASK_CallToStart
 230  *
 231  * 32-bit entry point for a new task. This function is responsible for
 232  * setting up the registers and jumping to the 16-bit entry point.
 233  */
 234 static void TASK_CallToStart(void)
 235 {
 236     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 237     NE_MODULE *pModule = NE_GetPtr( pTask->hModule );
 238     SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
 239
 240     SET_CUR_THREAD( pTask->thdb );
 241     CLIENT_InitThread();
 242
 243     /* Terminate the stack frame chain */
 244     memset(THREAD_STACK16( pTask->thdb ), '\0', sizeof(STACK16FRAME));
 245
 246     /* Call USER signal proc */
 247     PROCESS_CallUserSignalProc( USIG_THREAD_INIT, 0, 0 );  /* for initial thread */
 248     PROCESS_CallUserSignalProc( USIG_PROCESS_INIT, 0, 0 );
 249     PROCESS_CallUserSignalProc( USIG_PROCESS_LOADED, 0, 0 );
 250     PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING, 0, 0 );
 251
 252     if (pModule->flags & NE_FFLAGS_WIN32)
 253     {
 254         ERR_(task)("Called for Win32 task!\n" );
 255         ExitProcess( 1 );
 256     }
 257     else if (pModule->dos_image)
 258     {
 259         DOSVM_Enter( NULL );
 260         ExitProcess( 0 );
 261     }
 262     else
 263     {
 264         /* Registers at initialization must be:
 265          * ax   zero
 266          * bx   stack size in bytes
 267          * cx   heap size in bytes
 268          * si   previous app instance
 269          * di   current app instance
 270          * bp   zero
 271          * es   selector to the PSP
 272          * ds   dgroup of the application
 273          * ss   stack selector
 274          * sp   top of the stack
 275          */
 276         CONTEXT context;
 277
 278         memset( &context, 0, sizeof(context) );
 279         CS_reg(&context)  = GlobalHandleToSel16(pSegTable[pModule->cs - 1].hSeg);
 280         DS_reg(&context)  = GlobalHandleToSel16(pSegTable[pModule->dgroup - 1].hSeg);
 281         ES_reg(&context)  = pTask->hPDB;
 282         EIP_reg(&context) = pModule->ip;
 283         EBX_reg(&context) = pModule->stack_size;
 284         ECX_reg(&context) = pModule->heap_size;
 285         EDI_reg(&context) = context.SegDs;
 286
 287         TRACE_(task)("Starting main program: cs:ip=%04lx:%04x ds=%04lx ss:sp=%04x:%04x\n",
 288                       CS_reg(&context), IP_reg(&context), DS_reg(&context),
 289                       SELECTOROF(pTask->thdb->cur_stack),
 290                       OFFSETOF(pTask->thdb->cur_stack) );
 291
 292         Callbacks->CallRegisterShortProc( &context, 0 );
 293         /* This should never return */
 294         ERR_(task)("Main program returned! (should never happen)\n" );
 295         ExitProcess( 1 );
 296     }
 297 }
 298
 299
 300 /***********************************************************************
 301  *           TASK_Create
 302  *
 303  * NOTE: This routine might be called by a Win32 thread. We don't have
 304  *       any real problems with that, since we operated merely on a private
 305  *       TDB structure that is not yet linked into the task list.
 306  */
 307 BOOL TASK_Create( THDB *thdb, NE_MODULE *pModule, HINSTANCE16 hInstance,
 308                   HINSTANCE16 hPrevInstance, UINT16 cmdShow)
 309 {
 310     HTASK16 hTask;
 311     TDB *pTask;
 312     LPSTR cmd_line;
 313     WORD sp;
 314     char *stack32Top;
 315     char name[10];
 316     STACK16FRAME *frame16;
 317     STACK32FRAME *frame32;
 318     PDB *pdb32 = thdb->process;
 319     SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
 320
 321       /* Allocate the task structure */
 322
 323     hTask = GLOBAL_Alloc( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB),
 324                           pModule->self, FALSE, FALSE, FALSE );
 325     if (!hTask) return FALSE;
 326     pTask = (TDB *)GlobalLock16( hTask );
 327
 328     /* Fill the task structure */
 329
 330     pTask->nEvents       = 0;
 331     pTask->hSelf         = hTask;
 332     pTask->flags         = 0;
 333
 334     if (pModule->flags & NE_FFLAGS_WIN32)
 335         pTask->flags    |= TDBF_WIN32;
 336     if (pModule->lpDosTask)
 337         pTask->flags    |= TDBF_WINOLDAP;
 338
 339     pTask->version       = pModule->expected_version;
 340     pTask->hInstance     = hInstance? hInstance : pModule->self;
 341     pTask->hPrevInstance = hPrevInstance;
 342     pTask->hModule       = pModule->self;
 343     pTask->hParent       = GetCurrentTask();
 344     pTask->magic         = TDB_MAGIC;
 345     pTask->nCmdShow      = cmdShow;
 346     pTask->thdb          = thdb;
 347     pTask->curdrive      = DRIVE_GetCurrentDrive() | 0x80;
 348     strcpy( pTask->curdir, "\\" );
 349     lstrcpynA( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
 350                  sizeof(pTask->curdir) - 1 );
 351
 352       /* Create the thunks block */
 353
 354     TASK_CreateThunks( hTask, (int)&pTask->thunks - (int)pTask, 7 );
 355
 356       /* Copy the module name */
 357
 358     GetModuleName16( pModule->self, name, sizeof(name) );
 359     strncpy( pTask->module_name, name, sizeof(pTask->module_name) );
 360
 361       /* Allocate a selector for the PDB */
 362
 363     pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16),
 364                                     pModule->self, FALSE, FALSE, FALSE, NULL );
 365
 366       /* Fill the PDB */
 367
 368     pTask->pdb.int20 = 0x20cd;
 369     pTask->pdb.dispatcher[0] = 0x9a;  /* ljmp */
 370     PUT_DWORD(&pTask->pdb.dispatcher[1], (DWORD)NE_GetEntryPoint(
 371            GetModuleHandle16("KERNEL"), 102 ));  /* KERNEL.102 is DOS3Call() */
 372     pTask->pdb.savedint22 = INT_GetPMHandler( 0x22 );
 373     pTask->pdb.savedint23 = INT_GetPMHandler( 0x23 );
 374     pTask->pdb.savedint24 = INT_GetPMHandler( 0x24 );
 375     pTask->pdb.fileHandlesPtr =
 376         PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(pTask->hPDB),
 377                                (int)&((PDB16 *)0)->fileHandles );
 378     pTask->pdb.hFileHandles = 0;
 379     memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
 380     pTask->pdb.environment    = pdb32->env_db->env_sel;
 381     pTask->pdb.nbFiles        = 20;
 382
 383     /* Fill the command line */
 384
 385     cmd_line = pdb32->env_db->cmd_line;
 386     while (*cmd_line && (*cmd_line != ' ') && (*cmd_line != '\t')) cmd_line++;
 387     while ((*cmd_line == ' ') || (*cmd_line == '\t')) cmd_line++;
 388     lstrcpynA( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
 389     pTask->pdb.cmdLine[0] = strlen( pTask->pdb.cmdLine + 1 );
 390
 391       /* Get the compatibility flags */
 392
 393     pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 );
 394
 395       /* Allocate a code segment alias for the TDB */
 396
 397     pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, (void *)pTask,
 398                                           sizeof(TDB), pTask->hPDB, TRUE,
 399                                           FALSE, FALSE, NULL );
 400
 401       /* Set the owner of the environment block */
 402
 403     FarSetOwner16( pTask->pdb.environment, pTask->hPDB );
 404
 405       /* Default DTA overwrites command-line */
 406
 407     pTask->dta = PTR_SEG_OFF_TO_SEGPTR( pTask->hPDB,
 408                                 (int)&pTask->pdb.cmdLine - (int)&pTask->pdb );
 409
 410     /* Enter task handle into thread and process */
 411
 412     pTask->thdb->teb.htask16 = pTask->thdb->process->task = hTask;
 413      TRACE_(task)("module='%s' cmdline='%s' task=%04x\n", name, cmd_line, hTask );
 414
 415     if (pTask->flags & TDBF_WIN32) return TRUE;
 416
 417     /* If we have a DGROUP/hInstance, use it for 16-bit stack */
 418
 419     if ( hInstance )
 420     {
 421         if (!(sp = pModule->sp))
 422             sp = pSegTable[pModule->ss-1].minsize + pModule->stack_size;
 423         sp &= ~1;  sp -= sizeof(STACK16FRAME);
 424         pTask->thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( hInstance, sp );
 425     }
 426
 427     /* Create the 16-bit stack frame */
 428
 429     pTask->thdb->cur_stack -= sizeof(STACK16FRAME);
 430     frame16 = (STACK16FRAME *)PTR_SEG_TO_LIN( pTask->thdb->cur_stack );
 431     frame16->ebp = OFFSETOF( pTask->thdb->cur_stack ) + (int)&((STACK16FRAME *)0)->bp;
 432     frame16->bp = LOWORD(frame16->ebp);
 433     frame16->ds = frame16->es = hInstance;
 434     frame16->fs = 0;
 435     frame16->entry_point = 0;
 436     frame16->entry_cs = 0;
 437     frame16->mutex_count = 1; /* TASK_Reschedule is called from 16-bit code */
 438     /* The remaining fields will be initialized in TASK_Reschedule */
 439
 440     /* Create the 32-bit stack frame */
 441
 442     stack32Top = (char*)pTask->thdb->teb.stack_top;
 443     frame16->frame32 = frame32 = (STACK32FRAME *)stack32Top - 1;
 444     frame32->frame16 = pTask->thdb->cur_stack + sizeof(STACK16FRAME);
 445     frame32->edi     = 0;
 446     frame32->esi     = 0;
 447     frame32->edx     = 0;
 448     frame32->ecx     = 0;
 449     frame32->ebx     = 0;
 450     frame32->retaddr = (DWORD)TASK_CallToStart;
 451     /* The remaining fields will be initialized in TASK_Reschedule */
 452
 453     return TRUE;
 454 }
 455
 456 /***********************************************************************
 457  *           TASK_StartTask
 458  *
 459  * NOTE: This routine might be called by a Win32 thread. Thus, we need
 460  *       to be careful to protect global data structures. We do this
 461  *       by entering the Win16Lock while linking the task into the
 462  *       global task list.
 463  */
 464 void TASK_StartTask( HTASK16 hTask )
 465 {
 466     TDB *pTask = (TDB *)GlobalLock16( hTask );
 467     if ( !pTask ) return;
 468
 469     /* Add the task to the linked list */
 470
 471     SYSLEVEL_EnterWin16Lock();
 472     TASK_LinkTask( hTask );
 473     SYSLEVEL_LeaveWin16Lock();
 474
 475     TRACE_(task)("linked task %04x\n", hTask );
 476
 477     /* If requested, add entry point breakpoint */
 478
 479     if ( TASK_AddTaskEntryBreakpoint )
 480         TASK_AddTaskEntryBreakpoint( hTask );
 481
 482     /* Get the task up and running. */
 483
 484     if ( THREAD_IsWin16( pTask->thdb ) )
 485     {
 486         pTask->nEvents++;
 487
 488         /* If we ourselves are a 16-bit task, we simply Yield().
 489            If we are 32-bit however, we need to signal the scheduler. */
 490
 491         if ( THREAD_IsWin16( THREAD_Current() ) )
 492             OldYield16();
 493         else
 494             EVENT_WakeUp();
 495     }
 496 }
 497
 498
 499 /***********************************************************************
 500  *           TASK_DeleteTask
 501  */
 502 static void TASK_DeleteTask( HTASK16 hTask )
 503 {
 504     TDB *pTask;
 505     HGLOBAL16 hPDB;
 506
 507     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 508     hPDB = pTask->hPDB;
 509
 510     pTask->magic = 0xdead; /* invalidate signature */
 511
 512     /* Delete the Win32 part of the task */
 513
 514 /*    PROCESS_FreePDB( pTask->thdb->process ); FIXME */
 515 /*    K32OBJ_DecCount( &pTask->thdb->header ); FIXME */
 516
 517     /* Free the selector aliases */
 518
 519     GLOBAL_FreeBlock( pTask->hCSAlias );
 520     GLOBAL_FreeBlock( pTask->hPDB );
 521
 522     /* Free the task module */
 523
 524     FreeModule16( pTask->hModule );
 525
 526     /* Free the task structure itself */
 527
 528     GlobalFree16( hTask );
 529
 530     /* Free all memory used by this task (including the 32-bit stack, */
 531     /* the environment block and the thunk segments). */
 532
 533     GlobalFreeAll16( hPDB );
 534 }
 535
 536 /***********************************************************************
 537  *           TASK_KillTask
 538  */
 539 void TASK_KillTask( HTASK16 hTask )
 540 {
 541     TDB *pTask;
 542
 543     /* Enter the Win16Lock to protect global data structures */
 544     SYSLEVEL_EnterWin16Lock();
 545
 546     if ( !hTask ) hTask = GetCurrentTask();
 547     pTask = (TDB *)GlobalLock16( hTask );
 548     if ( !pTask )
 549     {
 550         SYSLEVEL_LeaveWin16Lock();
 551         return;
 552     }
 553
 554     TRACE_(task)("Killing task %04x\n", hTask );
 555
 556     /* Delete active sockets */
 557
 558     if( pTask->pwsi )
 559         WINSOCK_DeleteTaskWSI( pTask, pTask->pwsi );
 560
 561 #ifdef MZ_SUPPORTED
 562 {
 563     /* Kill DOS VM task */
 564     NE_MODULE *pModule = NE_GetPtr( pTask->hModule );
 565     if ( pModule->lpDosTask )
 566         MZ_KillModule( pModule->lpDosTask );
 567 }
 568 #endif
 569
 570     /* Perform USER cleanup */
 571
 572     if (pTask->userhandler)
 573         pTask->userhandler( hTask, USIG16_TERMINATION, 0,
 574                             pTask->hInstance, pTask->hQueue );
 575
 576     PROCESS_CallUserSignalProc( USIG_PROCESS_EXIT, 0, 0 );
 577     PROCESS_CallUserSignalProc( USIG_THREAD_EXIT, 0, 0 );     /* FIXME */
 578     PROCESS_CallUserSignalProc( USIG_PROCESS_DESTROY, 0, 0 );
 579
 580     if (nTaskCount <= 1)
 581     {
 582         TRACE_(task)("this is the last task, exiting\n" );
 583         SERVICE_Exit();
 584         USER_ExitWindows();
 585     }
 586
 587     /* FIXME: Hack! Send a message to the initial task so that
 588      * the GetMessage wakes up and the initial task can check whether
 589      * it is the only remaining one and terminate itself ...
 590      * The initial task should probably install hooks or something
 591      * to get informed about task termination :-/
 592      */
 593     Callout.PostAppMessage16( PROCESS_Initial()->task, WM_NULL, 0, 0 );
 594
 595     /* Remove the task from the list to be sure we never switch back to it */
 596     TASK_UnlinkTask( hTask );
 597     if( nTaskCount )
 598     {
 599         TDB* p = (TDB *)GlobalLock16( hFirstTask );
 600         while( p )
 601         {
 602             if( p->hYieldTo == hTask ) p->hYieldTo = 0;
 603             p = (TDB *)GlobalLock16( p->hNext );
 604         }
 605     }
 606
 607     pTask->nEvents = 0;
 608
 609     if ( hLockedTask == hTask )
 610         hLockedTask = 0;
 611
 612     if ( hTaskToKill && ( hTaskToKill != hCurrentTask ) )
 613     {
 614         /* If another task is already marked for destruction, */
 615         /* we can kill it now, as we are in another context.  */
 616         TASK_DeleteTask( hTaskToKill );
 617         hTaskToKill = 0;
 618     }
 619
 620     /*
 621      * If hTask is not the task currently scheduled by the Win16
 622      * scheduler, we simply delete it; otherwise we mark it for
 623      * destruction.  Note that if the current task is a 32-bit
 624      * one, hCurrentTask is *different* from GetCurrentTask()!
 625      */
 626     if ( hTask == hCurrentTask )
 627     {
 628         assert( hTaskToKill == 0 || hTaskToKill == hCurrentTask );
 629         hTaskToKill = hCurrentTask;
 630     }
 631     else
 632         TASK_DeleteTask( hTask );
 633
 634     SYSLEVEL_LeaveWin16Lock();
 635 }
 636
 637
 638 /***********************************************************************
 639  *           TASK_KillCurrentTask
 640  *
 641  * Kill the currently running task. As it's not possible to kill the
 642  * current task like this, it is simply marked for destruction, and will
 643  * be killed when either TASK_Reschedule or this function is called again
 644  * in the context of another task.
 645  */
 646 void TASK_KillCurrentTask( INT16 exitCode )
 647 {
 648     if ( !THREAD_IsWin16( THREAD_Current() ) )
 649     {
 650         FIXME_(task)("called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel);
 651         return;
 652     }
 653
 654     assert(hCurrentTask == GetCurrentTask());
 655
 656     TRACE_(task)("Killing current task %04x\n", hCurrentTask );
 657
 658     TASK_KillTask( 0 );
 659
 660     TASK_YieldToSystem();
 661
 662     /* We should never return from this Yield() */
 663
 664     ERR_(task)("Return of the living dead %04x!!!\n", hCurrentTask);
 665     exit(1);
 666 }
 667
 668 /***********************************************************************
 669  *           TASK_Reschedule
 670  *
 671  * This is where all the magic of task-switching happens!
 672  *
 673  * Note: This function should only be called via the TASK_YieldToSystem()
 674  *       wrapper, to make sure that all the context is saved correctly.
 675  *
 676  *       It must not call functions that may yield control.
 677  */
 678 BOOL TASK_Reschedule(void)
 679 {
 680     TDB *pOldTask = NULL, *pNewTask;
 681     HTASK16 hTask = 0;
 682     STACK16FRAME *newframe16;
 683     BOOL pending = FALSE;
 684
 685     /* Get the initial task up and running */
 686     if (!hCurrentTask && GetCurrentTask())
 687     {
 688         /* We need to remove one pair of stackframes (exept for Winelib) */
 689         STACK16FRAME *oldframe16 = CURRENT_STACK16;
 690         STACK32FRAME *oldframe32 = oldframe16->frame32;
 691         STACK16FRAME *newframe16 = PTR_SEG_TO_LIN( oldframe32->frame16 );
 692         STACK32FRAME *newframe32 = newframe16->frame32;
 693         if (newframe32)
 694         {
 695             newframe16->entry_ip     = oldframe16->entry_ip;
 696             newframe16->entry_cs     = oldframe16->entry_cs;
 697             newframe16->ip           = oldframe16->ip;
 698             newframe16->cs           = oldframe16->cs;
 699             newframe32->ebp          = oldframe32->ebp;
 700             newframe32->restore_addr = oldframe32->restore_addr;
 701             newframe32->codeselector = oldframe32->codeselector;
 702
 703             THREAD_Current()->cur_stack = oldframe32->frame16;
 704         }
 705
 706         hCurrentTask = GetCurrentTask();
 707         pNewTask = (TDB *)GlobalLock16( hCurrentTask );
 708         pNewTask->ss_sp = pNewTask->thdb->cur_stack;
 709         return FALSE;
 710     }
 711
 712     /* NOTE: As we are entered from 16-bit code, we hold the Win16Lock.
 713              We hang onto it thoughout most of this routine, so that accesses
 714              to global variables (most notably the task list) are protected. */
 715     assert(hCurrentTask == GetCurrentTask());
 716
 717     TRACE_(task)("entered with hTask %04x (pid %d)\n", hCurrentTask, getpid());
 718
 719 #ifdef CONFIG_IPC
 720     /* FIXME: What about the Win16Lock ??? */
 721     dde_reschedule();
 722 #endif
 723       /* First check if there's a task to kill */
 724
 725     if (hTaskToKill && (hTaskToKill != hCurrentTask))
 726     {
 727         TASK_DeleteTask( hTaskToKill );
 728         hTaskToKill = 0;
 729     }
 730
 731     /* Find a task to yield to */
 732
 733     pOldTask = (TDB *)GlobalLock16( hCurrentTask );
 734     if (pOldTask && pOldTask->hYieldTo)
 735     {
 736         /* check for DirectedYield() */
 737
 738         hTask = pOldTask->hYieldTo;
 739         pNewTask = (TDB *)GlobalLock16( hTask );
 740         if( !pNewTask || !pNewTask->nEvents) hTask = 0;
 741         pOldTask->hYieldTo = 0;
 742     }
 743
 744     /* extract hardware events only! */
 745
 746     if (!hTask) pending = EVENT_WaitNetEvent( FALSE, TRUE );
 747
 748     while (!hTask)
 749     {
 750         /* Find a task that has an event pending */
 751
 752         hTask = hFirstTask;
 753         while (hTask)
 754         {
 755             pNewTask = (TDB *)GlobalLock16( hTask );
 756
 757             TRACE_(task)("\ttask = %04x, events = %i\n", hTask, pNewTask->nEvents);
 758
 759             if (pNewTask->nEvents) break;
 760             hTask = pNewTask->hNext;
 761         }
 762         if (hLockedTask && (hTask != hLockedTask)) hTask = 0;
 763         if (hTask) break;
 764
 765         /* If a non-hardware event is pending, return to TASK_YieldToSystem
 766            temporarily to process it safely */
 767         if (pending) return TRUE;
 768
 769         /* No task found, wait for some events to come in */
 770
 771         /* NOTE: We release the Win16Lock while waiting for events. This is to enable
 772                  Win32 threads to thunk down to 16-bit temporarily. Since Win16
 773                  tasks won't execute and Win32 threads are not allowed to enter
 774                  TASK_Reschedule anyway, there should be no re-entrancy problem ... */
 775
 776         SYSLEVEL_ReleaseWin16Lock();
 777         pending = EVENT_WaitNetEvent( TRUE, TRUE );
 778         SYSLEVEL_RestoreWin16Lock();
 779     }
 780
 781     if (hTask == hCurrentTask)
 782     {
 783         /* Allow Win32 threads to thunk down even while a Win16 task is
 784            in a tight PeekMessage() or Yield() loop ... */
 785         SYSLEVEL_ReleaseWin16Lock();
 786         SYSLEVEL_RestoreWin16Lock();
 787
 788         TRACE_(task)("returning to the current task(%04x)\n", hTask );
 789         return FALSE;  /* Nothing to do */
 790     }
 791     pNewTask = (TDB *)GlobalLock16( hTask );
 792     TRACE_(task)("Switching to task %04x (%.8s)\n",
 793                   hTask, pNewTask->module_name );
 794
 795      /* Make the task the last in the linked list (round-robin scheduling) */
 796
 797     pNewTask->priority++;
 798     TASK_UnlinkTask( hTask );
 799     TASK_LinkTask( hTask );
 800     pNewTask->priority--;
 801
 802     /* Finish initializing the new task stack if necessary */
 803
 804     newframe16 = THREAD_STACK16( pNewTask->thdb );
 805     if (!newframe16->entry_cs)
 806     {
 807         STACK16FRAME *oldframe16 = CURRENT_STACK16;
 808         STACK32FRAME *oldframe32 = oldframe16->frame32;
 809         STACK32FRAME *newframe32 = newframe16->frame32;
 810         newframe16->entry_ip     = oldframe16->entry_ip;
 811         newframe16->entry_cs     = oldframe16->entry_cs;
 812         newframe16->ip           = oldframe16->ip;
 813         newframe16->cs           = oldframe16->cs;
 814         newframe32->ebp          = oldframe32->ebp;
 815         newframe32->restore_addr = oldframe32->restore_addr;
 816         newframe32->codeselector = oldframe32->codeselector;
 817     }
 818
 819     /* Switch to the new stack */
 820
 821     /* NOTE: We need to release/restore the Win16Lock, as the task
 822              switched to might be at another recursion level than
 823              the old task ... */
 824
 825     SYSLEVEL_ReleaseWin16Lock();
 826
 827     hCurrentTask = hTask;
 828     SET_CUR_THREAD( pNewTask->thdb );
 829     pNewTask->ss_sp = pNewTask->thdb->cur_stack;
 830
 831     SYSLEVEL_RestoreWin16Lock();
 832
 833     return FALSE;
 834 }
 835
 836
 837 /***********************************************************************
 838  *           TASK_YieldToSystem
 839  *
 840  * Scheduler interface, this way we ensure that all "unsafe" events are
 841  * processed outside the scheduler.
 842  */
 843 static void TASK_YieldToSystem( void )
 844 {
 845     if ( !THREAD_IsWin16( THREAD_Current() ) )
 846     {
 847         FIXME_(task)("called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel);
 848         return;
 849     }
 850
 851     if ( Callbacks->CallTaskRescheduleProc() )
 852     {
 853         /* NOTE: We get here only when no task has an event. This means also
 854                  the current task, so we shouldn't actually return to the
 855                  caller here. But, we need to do so, as the EVENT_WaitNetEvent
 856                  call could lead to a complex series of inter-task SendMessage
 857                  calls which might leave this task in a state where it again
 858                  has no event, but where its queue's wakeMask is also reset
 859                  to zero. Reentering TASK_Reschedule in this state would be
 860                  suicide.  Hence, we do return to the caller after processing
 861                  non-hardware events. Actually, this should not hurt anyone,
 862                  as the caller must be WaitEvent, and thus the QUEUE_WaitBits
 863                  loop in USER. Should there actually be no message pending
 864                  for this task after processing non-hardware events, that loop
 865                  will simply return to WaitEvent.  */
 866
 867         EVENT_WaitNetEvent( FALSE, FALSE );
 868     }
 869 }
 870
 871
 872 /***********************************************************************
 873  *           InitTask  (KERNEL.91)
 874  *
 875  * Called by the application startup code.
 876  */
 877 void WINAPI InitTask16( CONTEXT *context )
 878 {
 879     TDB *pTask;
 880     NE_MODULE *pModule;
 881     SEGTABLEENTRY *pSegTable;
 882     INSTANCEDATA *pinstance;
 883     LONG stacklow, stackhi;
 884
 885     if (context) EAX_reg(context) = 0;
 886     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
 887     if (!(pModule = NE_GetPtr( pTask->hModule ))) return;
 888
 889     /* Initialize implicitly loaded DLLs */
 890     NE_InitializeDLLs( pTask->hModule );
 891
 892     if (context)
 893     {
 894         /* Registers on return are:
 895          * ax     1 if OK, 0 on error
 896          * cx     stack limit in bytes
 897          * dx     cmdShow parameter
 898          * si     instance handle of the previous instance
 899          * di     instance handle of the new task
 900          * es:bx  pointer to command-line inside PSP
 901          *
 902          * 0 (=%bp) is pushed on the stack
 903          */
 904         SEGPTR ptr = STACK16_PUSH( pTask->thdb, sizeof(WORD) );
 905         *(WORD *)PTR_SEG_TO_LIN(ptr) = 0;
 906         SP_reg(context) -= 2;
 907
 908         EAX_reg(context) = 1;
 909
 910         if (!pTask->pdb.cmdLine[0]) EBX_reg(context) = 0x80;
 911         else
 912         {
 913             LPBYTE p = &pTask->pdb.cmdLine[1];
 914             while ((*p == ' ') || (*p == '\t')) p++;
 915             EBX_reg(context) = 0x80 + (p - pTask->pdb.cmdLine);
 916         }
 917         ECX_reg(context) = pModule->stack_size;
 918         EDX_reg(context) = pTask->nCmdShow;
 919         ESI_reg(context) = (DWORD)pTask->hPrevInstance;
 920         EDI_reg(context) = (DWORD)pTask->hInstance;
 921         ES_reg (context) = (WORD)pTask->hPDB;
 922     }
 923
 924     /* Initialize the local heap */
 925     if ( pModule->heap_size )
 926     {
 927         LocalInit16( pTask->hInstance, 0, pModule->heap_size );
 928     }
 929
 930     /* Initialize the INSTANCEDATA structure */
 931     pSegTable = NE_SEG_TABLE( pModule );
 932     stacklow = pSegTable[pModule->ss - 1].minsize;
 933     stackhi  = stacklow + pModule->stack_size;
 934     if (stackhi > 0xffff) stackhi = 0xffff;
 935     pinstance = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN(CURRENT_DS, 0);
 936     pinstance->stackbottom = stackhi; /* yup, that's right. Confused me too. */
 937     pinstance->stacktop    = stacklow;
 938     pinstance->stackmin    = OFFSETOF( pTask->thdb->cur_stack );
 939 }
 940
 941
 942 /***********************************************************************
 943  *           WaitEvent  (KERNEL.30)
 944  */
 945 BOOL16 WINAPI WaitEvent16( HTASK16 hTask )
 946 {
 947     TDB *pTask;
 948
 949     if (!hTask) hTask = GetCurrentTask();
 950     pTask = (TDB *)GlobalLock16( hTask );
 951
 952     if ( !THREAD_IsWin16( THREAD_Current() ) )
 953     {
 954         FIXME_(task)("called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel);
 955         return TRUE;
 956     }
 957
 958     if (pTask->nEvents > 0)
 959     {
 960         pTask->nEvents--;
 961         return FALSE;
 962     }
 963     TASK_YieldToSystem();
 964
 965     /* When we get back here, we have an event */
 966
 967     if (pTask->nEvents > 0) pTask->nEvents--;
 968     return TRUE;
 969 }
 970
 971
 972 /***********************************************************************
 973  *           PostEvent  (KERNEL.31)
 974  */
 975 void WINAPI PostEvent16( HTASK16 hTask )
 976 {
 977     TDB *pTask;
 978
 979     if (!hTask) hTask = GetCurrentTask();
 980     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 981
 982     if ( !THREAD_IsWin16( pTask->thdb ) )
 983     {
 984         FIXME_(task)("called for Win32 thread (%04x)!\n", pTask->thdb->teb_sel );
 985         return;
 986     }
 987
 988     pTask->nEvents++;
 989
 990     if ( !THREAD_IsWin16( THREAD_Current() ) )
 991     {
 992         /* wake-up the scheduler waiting in EVENT_WaitNetEvent */
 993         EVENT_WakeUp();
 994     }
 995 }
 996
 997
 998 /***********************************************************************
 999  *           SetPriority  (KERNEL.32)
1000  */
1001 void WINAPI SetPriority16( HTASK16 hTask, INT16 delta )
1002 {
1003     TDB *pTask;
1004     INT16 newpriority;
1005
1006     if (!hTask) hTask = GetCurrentTask();
1007     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
1008     newpriority = pTask->priority + delta;
1009     if (newpriority < -32) newpriority = -32;
1010     else if (newpriority > 15) newpriority = 15;
1011
1012     pTask->priority = newpriority + 1;
1013     TASK_UnlinkTask( hTask );
1014     TASK_LinkTask( hTask );
1015     pTask->priority--;
1016 }
1017
1018
1019 /***********************************************************************
1020  *           LockCurrentTask  (KERNEL.33)
1021  */
1022 HTASK16 WINAPI LockCurrentTask16( BOOL16 bLock )
1023 {
1024     if (bLock) hLockedTask = GetCurrentTask();
1025     else hLockedTask = 0;
1026     return hLockedTask;
1027 }
1028
1029
1030 /***********************************************************************
1031  *           IsTaskLocked  (KERNEL.122)
1032  */
1033 HTASK16 WINAPI IsTaskLocked16(void)
1034 {
1035     return hLockedTask;
1036 }
1037
1038
1039 /***********************************************************************
1040  *           OldYield  (KERNEL.117)
1041  */
1042 void WINAPI OldYield16(void)
1043 {
1044     TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
1045
1046     if ( !THREAD_IsWin16( THREAD_Current() ) )
1047     {
1048         FIXME_(task)("called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel);
1049         return;
1050     }
1051
1052     if (pCurTask) pCurTask->nEvents++;  /* Make sure we get back here */
1053     TASK_YieldToSystem();
1054     if (pCurTask) pCurTask->nEvents--;
1055 }
1056
1057
1058 /***********************************************************************
1059  *           DirectedYield  (KERNEL.150)
1060  */
1061 void WINAPI DirectedYield16( HTASK16 hTask )
1062 {
1063     TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
1064
1065     if ( !THREAD_IsWin16( THREAD_Current() ) )
1066     {
1067         FIXME_(task)("called for Win32 thread (%04x)!\n", THREAD_Current()->teb_sel);
1068         return;
1069     }
1070
1071     TRACE_(task)("%04x: DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
1072
1073     pCurTask->hYieldTo = hTask;
1074     OldYield16();
1075
1076     TRACE_(task)("%04x: back from DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
1077 }
1078
1079 /***********************************************************************
1080  *           Yield16  (KERNEL.29)
1081  */
1082 void WINAPI Yield16(void)
1083 {
1084     TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
1085
1086     if (pCurTask) pCurTask->hYieldTo = 0;
1087     if (pCurTask && pCurTask->hQueue) Callout.UserYield16();
1088     else OldYield16();
1089 }
1090
1091 /***********************************************************************
1092  *           KERNEL_490  (KERNEL.490)
1093  */
1094 HTASK16 WINAPI KERNEL_490( HTASK16 someTask )
1095 {
1096     if ( !someTask ) return 0;
1097
1098     FIXME_(task)("(%04x): stub\n", someTask );
1099     return 0;
1100 }
1101
1102 /***********************************************************************
1103  *           MakeProcInstance16  (KERNEL.51)
1104  */
1105 FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
1106 {
1107     BYTE *thunk,*lfunc;
1108     SEGPTR thunkaddr;
1109
1110     if (!func) {
1111       ERR_(task)("Ouch ! MakeProcInstance called with func == NULL !\n");
1112       return (FARPROC16)0; /* Windows seems to do the same */
1113     }
1114     if (!hInstance) hInstance = CURRENT_DS;
1115     thunkaddr = TASK_AllocThunk( GetCurrentTask() );
1116     if (!thunkaddr) return (FARPROC16)0;
1117     thunk = PTR_SEG_TO_LIN( thunkaddr );
1118     lfunc = PTR_SEG_TO_LIN( func );
1119
1120     TRACE_(task)("(%08lx,%04x): got thunk %08lx\n",
1121                   (DWORD)func, hInstance, (DWORD)thunkaddr );
1122     if (((lfunc[0]==0x8c) && (lfunc[1]==0xd8)) ||
1123         ((lfunc[0]==0x1e) && (lfunc[1]==0x58))
1124     ) {
1125         FIXME_(task)("thunk would be useless for %p, overwriting with nop;nop;\n", func );
1126         lfunc[0]=0x90; /* nop */
1127         lfunc[1]=0x90; /* nop */
1128     }
1129
1130     *thunk++ = 0xb8;    /* movw instance, %ax */
1131     *thunk++ = (BYTE)(hInstance & 0xff);
1132     *thunk++ = (BYTE)(hInstance >> 8);
1133     *thunk++ = 0xea;    /* ljmp func */
1134     *(DWORD *)thunk = (DWORD)func;
1135     return (FARPROC16)thunkaddr;
1136 }
1137
1138
1139 /***********************************************************************
1140  *           FreeProcInstance16  (KERNEL.52)
1141  */
1142 void WINAPI FreeProcInstance16( FARPROC16 func )
1143 {
1144     TRACE_(task)("(%08lx)\n", (DWORD)func );
1145     TASK_FreeThunk( GetCurrentTask(), (SEGPTR)func );
1146 }
1147
1148
1149 /**********************************************************************
1150  *          GetCodeHandle    (KERNEL.93)
1151  */
1152 HANDLE16 WINAPI GetCodeHandle16( FARPROC16 proc )
1153 {
1154     HANDLE16 handle;
1155     BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
1156
1157     /* Return the code segment containing 'proc'. */
1158     /* Not sure if this is really correct (shouldn't matter that much). */
1159
1160     /* Check if it is really a thunk */
1161     if ((thunk[0] == 0xb8) && (thunk[3] == 0xea))
1162         handle = GlobalHandle16( thunk[6] + (thunk[7] << 8) );
1163     else
1164         handle = GlobalHandle16( HIWORD(proc) );
1165
1166     return handle;
1167 }
1168
1169 /**********************************************************************
1170  *          GetCodeInfo    (KERNEL.104)
1171  */
1172 VOID WINAPI GetCodeInfo16( FARPROC16 proc, SEGINFO *segInfo )
1173 {
1174     BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
1175     NE_MODULE *pModule = NULL;
1176     SEGTABLEENTRY *pSeg = NULL;
1177     WORD segNr;
1178
1179     /* proc is either a thunk, or else a pair of module handle
1180        and segment number. In the first case, we also need to
1181        extract module and segment number. */
1182
1183     if ((thunk[0] == 0xb8) && (thunk[3] == 0xea))
1184     {
1185         WORD selector = thunk[6] + (thunk[7] << 8);
1186         pModule = NE_GetPtr( GlobalHandle16( selector ) );
1187         pSeg = pModule? NE_SEG_TABLE( pModule ) : NULL;
1188
1189         if ( pModule )
1190             for ( segNr = 0; segNr < pModule->seg_count; segNr++, pSeg++ )
1191                 if ( GlobalHandleToSel16(pSeg->hSeg) == selector )
1192                     break;
1193
1194         if ( pModule && segNr >= pModule->seg_count )
1195             pSeg = NULL;
1196     }
1197     else
1198     {
1199         pModule = NE_GetPtr( HIWORD( proc ) );
1200         segNr   = LOWORD( proc );
1201
1202         if ( pModule && segNr < pModule->seg_count )
1203             pSeg = NE_SEG_TABLE( pModule ) + segNr;
1204     }
1205
1206     /* fill in segment information */
1207
1208     segInfo->offSegment = pSeg? pSeg->filepos : 0;
1209     segInfo->cbSegment  = pSeg? pSeg->size : 0;
1210     segInfo->flags      = pSeg? pSeg->flags : 0;
1211     segInfo->cbAlloc    = pSeg? pSeg->minsize : 0;
1212     segInfo->h          = pSeg? pSeg->hSeg : 0;
1213     segInfo->alignShift = pModule? pModule->alignment : 0;
1214 }
1215
1216
1217 /**********************************************************************
1218  *          DefineHandleTable16    (KERNEL.94)
1219  */
1220 BOOL16 WINAPI DefineHandleTable16( WORD wOffset )
1221 {
1222     return TRUE;  /* FIXME */
1223 }
1224
1225
1226 /***********************************************************************
1227  *           SetTaskQueue  (KERNEL.34)
1228  */
1229 HQUEUE16 WINAPI SetTaskQueue16( HTASK16 hTask, HQUEUE16 hQueue )
1230 {
1231     HQUEUE16 hPrev;
1232     TDB *pTask;
1233
1234     if (!hTask) hTask = GetCurrentTask();
1235     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
1236
1237     hPrev = pTask->hQueue;
1238     pTask->hQueue = hQueue;
1239
1240     TIMER_SwitchQueue( hPrev, hQueue );
1241
1242     return hPrev;
1243 }
1244
1245
1246 /***********************************************************************
1247  *           GetTaskQueue  (KERNEL.35)
1248  */
1249 HQUEUE16 WINAPI GetTaskQueue16( HTASK16 hTask )
1250 {
1251     TDB *pTask;
1252
1253     if (!hTask) hTask = GetCurrentTask();
1254     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
1255     return pTask->hQueue;
1256 }
1257
1258 /***********************************************************************
1259  *           SetThreadQueue  (KERNEL.463)
1260  */
1261 HQUEUE16 WINAPI SetThreadQueue16( DWORD thread, HQUEUE16 hQueue )
1262 {
1263     THDB *thdb = thread? THREAD_IdToTHDB( thread ) : THREAD_Current();
1264     HQUEUE16 oldQueue = thdb? thdb->teb.queue : 0;
1265
1266     if ( thdb )
1267     {
1268         thdb->teb.queue = hQueue;
1269
1270         if ( GetTaskQueue16( thdb->process->task ) == oldQueue )
1271             SetTaskQueue16( thdb->process->task, hQueue );
1272     }
1273
1274     return oldQueue;
1275 }
1276
1277 /***********************************************************************
1278  *           GetThreadQueue  (KERNEL.464)
1279  */
1280 HQUEUE16 WINAPI GetThreadQueue16( DWORD thread )
1281 {
1282     THDB *thdb = NULL;
1283     if ( !thread )
1284         thdb = THREAD_Current();
1285     else if ( HIWORD(thread) )
1286         thdb = THREAD_IdToTHDB( thread );
1287     else if ( IsTask16( (HTASK16)thread ) )
1288         thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
1289
1290     return (HQUEUE16)(thdb? thdb->teb.queue : 0);
1291 }
1292
1293 /***********************************************************************
1294  *           SetFastQueue  (KERNEL.624)
1295  */
1296 VOID WINAPI SetFastQueue16( DWORD thread, HANDLE hQueue )
1297 {
1298     THDB *thdb = NULL;
1299     if ( !thread )
1300         thdb = THREAD_Current();
1301     else if ( HIWORD(thread) )
1302         thdb = THREAD_IdToTHDB( thread );
1303     else if ( IsTask16( (HTASK16)thread ) )
1304         thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
1305
1306     if ( thdb ) thdb->teb.queue = (HQUEUE16) hQueue;
1307 }
1308
1309 /***********************************************************************
1310  *           GetFastQueue  (KERNEL.625)
1311  */
1312 HANDLE WINAPI GetFastQueue16( void )
1313 {
1314     THDB *thdb = THREAD_Current();
1315     if (!thdb) return 0;
1316
1317     if (!thdb->teb.queue)
1318         Callout.InitThreadInput16( 0, THREAD_IsWin16(thdb)? 4 : 5 );
1319
1320     if (!thdb->teb.queue)
1321         FIXME_(task)("(): should initialize thread-local queue, expect failure!\n" );
1322
1323     return (HANDLE)thdb->teb.queue;
1324 }
1325
1326 /***********************************************************************
1327  *           SwitchStackTo   (KERNEL.108)
1328  */
1329 void WINAPI SwitchStackTo16( WORD seg, WORD ptr, WORD top )
1330 {
1331     TDB *pTask;
1332     STACK16FRAME *oldFrame, *newFrame;
1333     INSTANCEDATA *pData;
1334     UINT16 copySize;
1335
1336     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
1337     if (!(pData = (INSTANCEDATA *)GlobalLock16( seg ))) return;
1338     TRACE_(task)("old=%04x:%04x new=%04x:%04x\n",
1339                   SELECTOROF( pTask->thdb->cur_stack ),
1340                   OFFSETOF( pTask->thdb->cur_stack ), seg, ptr );
1341
1342     /* Save the old stack */
1343
1344     oldFrame = THREAD_STACK16( pTask->thdb );
1345     /* pop frame + args and push bp */
1346     pData->old_ss_sp   = pTask->thdb->cur_stack + sizeof(STACK16FRAME)
1347                            + 2 * sizeof(WORD);
1348     *(WORD *)PTR_SEG_TO_LIN(pData->old_ss_sp) = oldFrame->bp;
1349     pData->stacktop    = top;
1350     pData->stackmin    = ptr;
1351     pData->stackbottom = ptr;
1352
1353     /* Switch to the new stack */
1354
1355     /* Note: we need to take the 3 arguments into account; otherwise,
1356      * the stack will underflow upon return from this function.
1357      */
1358     copySize = oldFrame->bp - OFFSETOF(pData->old_ss_sp);
1359     copySize += 3 * sizeof(WORD) + sizeof(STACK16FRAME);
1360     pTask->thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( seg, ptr - copySize );
1361     newFrame = THREAD_STACK16( pTask->thdb );
1362
1363     /* Copy the stack frame and the local variables to the new stack */
1364
1365     memmove( newFrame, oldFrame, copySize );
1366     newFrame->bp = ptr;
1367     *(WORD *)PTR_SEG_OFF_TO_LIN( seg, ptr ) = 0;  /* clear previous bp */
1368 }
1369
1370
1371 /***********************************************************************
1372  *           SwitchStackBack   (KERNEL.109)
1373  */
1374 void WINAPI SwitchStackBack16( CONTEXT *context )
1375 {
1376     TDB *pTask;
1377     STACK16FRAME *oldFrame, *newFrame;
1378     INSTANCEDATA *pData;
1379
1380     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
1381     if (!(pData = (INSTANCEDATA *)GlobalLock16(SELECTOROF(pTask->thdb->cur_stack))))
1382         return;
1383     if (!pData->old_ss_sp)
1384     {
1385         WARN_(task)("No previous SwitchStackTo\n" );
1386         return;
1387     }
1388     TRACE_(task)("restoring stack %04x:%04x\n",
1389                  SELECTOROF(pData->old_ss_sp), OFFSETOF(pData->old_ss_sp) );
1390
1391     oldFrame = THREAD_STACK16( pTask->thdb );
1392
1393     /* Pop bp from the previous stack */
1394
1395     BP_reg(context) = *(WORD *)PTR_SEG_TO_LIN(pData->old_ss_sp);
1396     pData->old_ss_sp += sizeof(WORD);
1397
1398     /* Switch back to the old stack */
1399
1400     pTask->thdb->cur_stack = pData->old_ss_sp - sizeof(STACK16FRAME);
1401     SS_reg(context)  = SELECTOROF(pData->old_ss_sp);
1402     ESP_reg(context) = OFFSETOF(pData->old_ss_sp) - sizeof(DWORD); /*ret addr*/
1403     pData->old_ss_sp = 0;
1404
1405     /* Build a stack frame for the return */
1406
1407     newFrame = THREAD_STACK16( pTask->thdb );
1408     newFrame->frame32 = oldFrame->frame32;
1409     if (TRACE_ON(relay))
1410     {
1411         newFrame->entry_ip = oldFrame->entry_ip;
1412         newFrame->entry_cs = oldFrame->entry_cs;
1413     }
1414 }
1415
1416
1417 /***********************************************************************
1418  *           GetTaskQueueDS  (KERNEL.118)
1419  */
1420 void WINAPI GetTaskQueueDS16( CONTEXT *context )
1421 {
1422     DS_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
1423 }
1424
1425
1426 /***********************************************************************
1427  *           GetTaskQueueES  (KERNEL.119)
1428  */
1429 void WINAPI GetTaskQueueES16( CONTEXT *context )
1430 {
1431     ES_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
1432 }
1433
1434
1435 /***********************************************************************
1436  *           GetCurrentTask   (KERNEL.36)
1437  */
1438 HTASK16 WINAPI GetCurrentTask(void)
1439 {
1440     return THREAD_InitDone? PROCESS_Current()->task : 0;
1441 }
1442
1443 DWORD WINAPI WIN16_GetCurrentTask(void)
1444 {
1445     /* This is the version used by relay code; the first task is */
1446     /* returned in the high word of the result */
1447     return MAKELONG( GetCurrentTask(), hFirstTask );
1448 }
1449
1450
1451 /***********************************************************************
1452  *           GetCurrentPDB   (KERNEL.37)
1453  *
1454  * UNDOC: returns PSP of KERNEL in high word
1455  */
1456 DWORD WINAPI GetCurrentPDB16(void)
1457 {
1458     TDB *pTask;
1459
1460     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1461     return MAKELONG(pTask->hPDB, 0); /* FIXME */
1462 }
1463
1464
1465 /***********************************************************************
1466  *           GetInstanceData   (KERNEL.54)
1467  */
1468 INT16 WINAPI GetInstanceData16( HINSTANCE16 instance, WORD buffer, INT16 len )
1469 {
1470     char *ptr = (char *)GlobalLock16( instance );
1471     if (!ptr || !len) return 0;
1472     if ((int)buffer + len >= 0x10000) len = 0x10000 - buffer;
1473     memcpy( (char *)GlobalLock16(CURRENT_DS) + buffer, ptr + buffer, len );
1474     return len;
1475 }
1476
1477
1478 /***********************************************************************
1479  *           GetExeVersion   (KERNEL.105)
1480  */
1481 WORD WINAPI GetExeVersion16(void)
1482 {
1483     TDB *pTask;
1484
1485     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1486     return pTask->version;
1487 }
1488
1489
1490 /***********************************************************************
1491  *           SetErrorMode16   (KERNEL.107)
1492  */
1493 UINT16 WINAPI SetErrorMode16( UINT16 mode )
1494 {
1495     TDB *pTask;
1496     UINT16 oldMode;
1497
1498     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1499     oldMode = pTask->error_mode;
1500     pTask->error_mode = mode;
1501     pTask->thdb->process->error_mode = mode;
1502     return oldMode;
1503 }
1504
1505
1506 /***********************************************************************
1507  *           SetErrorMode32   (KERNEL32.486)
1508  */
1509 UINT WINAPI SetErrorMode( UINT mode )
1510 {
1511     return SetErrorMode16( (UINT16)mode );
1512 }
1513
1514
1515 /***********************************************************************
1516  *           GetDOSEnvironment   (KERNEL.131)
1517  */
1518 SEGPTR WINAPI GetDOSEnvironment16(void)
1519 {
1520     TDB *pTask;
1521
1522     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1523     return PTR_SEG_OFF_TO_SEGPTR( pTask->pdb.environment, 0 );
1524 }
1525
1526
1527 /***********************************************************************
1528  *           GetNumTasks   (KERNEL.152)
1529  */
1530 UINT16 WINAPI GetNumTasks16(void)
1531 {
1532     return nTaskCount;
1533 }
1534
1535
1536 /***********************************************************************
1537  *           GetTaskDS   (KERNEL.155)
1538  *
1539  * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1540  * I don't think we need to bother with this.
1541  */
1542 HINSTANCE16 WINAPI GetTaskDS16(void)
1543 {
1544     TDB *pTask;
1545
1546     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1547     return pTask->hInstance;
1548 }
1549
1550 /***********************************************************************
1551  *           GetDummyModuleHandleDS   (KERNEL.602)
1552  */
1553 VOID WINAPI GetDummyModuleHandleDS16( CONTEXT *context )
1554 {
1555     TDB *pTask;
1556     WORD selector;
1557
1558     AX_reg( context ) = 0;
1559     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
1560     if (!(pTask->flags & TDBF_WIN32)) return;
1561
1562     selector = GlobalHandleToSel16( pTask->hModule );
1563     DS_reg( context ) = selector;
1564     AX_reg( context ) = selector;
1565 }
1566
1567 /***********************************************************************
1568  *           IsTask   (KERNEL.320)
1569  */
1570 BOOL16 WINAPI IsTask16( HTASK16 hTask )
1571 {
1572     TDB *pTask;
1573
1574     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return FALSE;
1575     if (GlobalSize16( hTask ) < sizeof(TDB)) return FALSE;
1576     return (pTask->magic == TDB_MAGIC);
1577 }
1578
1579
1580 /***********************************************************************
1581  *           SetTaskSignalProc   (KERNEL.38)
1582  *
1583  * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1584  */
1585 FARPROC16 WINAPI SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
1586 {
1587     TDB *pTask;
1588     FARPROC16 oldProc;
1589
1590     if (!hTask) hTask = GetCurrentTask();
1591     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return NULL;
1592     oldProc = (FARPROC16)pTask->userhandler;
1593     pTask->userhandler = (USERSIGNALPROC)proc;
1594     return oldProc;
1595 }
1596
1597
1598 /***********************************************************************
1599  *           SetSigHandler   (KERNEL.140)
1600  */
1601 WORD WINAPI SetSigHandler16( FARPROC16 newhandler, FARPROC16* oldhandler,
1602                            UINT16 *oldmode, UINT16 newmode, UINT16 flag )
1603 {
1604     FIXME_(task)("(%p,%p,%p,%d,%d), unimplemented.\n",
1605           newhandler,oldhandler,oldmode,newmode,flag );
1606
1607     if (flag != 1) return 0;
1608     if (!newmode) newhandler = NULL;  /* Default handler */
1609     if (newmode != 4)
1610     {
1611         TDB *pTask;
1612
1613         if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return 0;
1614         if (oldmode) *oldmode = pTask->signal_flags;
1615         pTask->signal_flags = newmode;
1616         if (oldhandler) *oldhandler = pTask->sighandler;
1617         pTask->sighandler = newhandler;
1618     }
1619     return 0;
1620 }
1621
1622
1623 /***********************************************************************
1624  *           GlobalNotify   (KERNEL.154)
1625  *
1626  * Note that GlobalNotify does _not_ return the old NotifyProc
1627  * -- contrary to LocalNotify !!
1628  */
1629 VOID WINAPI GlobalNotify16( FARPROC16 proc )
1630 {
1631     TDB *pTask;
1632
1633     if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
1634     pTask->discardhandler = proc;
1635 }
1636
1637
1638 /***********************************************************************
1639  *           GetExePtr   (KERNEL.133)
1640  */
1641 static HMODULE16 GetExePtrHelper( HANDLE16 handle, HTASK16 *hTask )
1642 {
1643     char *ptr;
1644     HANDLE16 owner;
1645
1646       /* Check for module handle */
1647
1648     if (!(ptr = GlobalLock16( handle ))) return 0;
1649     if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return handle;
1650
1651       /* Search for this handle inside all tasks */
1652
1653     *hTask = hFirstTask;
1654     while (*hTask)
1655     {
1656         TDB *pTask = (TDB *)GlobalLock16( *hTask );
1657         if ((*hTask == handle) ||
1658             (pTask->hInstance == handle) ||
1659             (pTask->hQueue == handle) ||
1660             (pTask->hPDB == handle)) return pTask->hModule;
1661         *hTask = pTask->hNext;
1662     }
1663
1664       /* Check the owner for module handle */
1665
1666     owner = FarGetOwner16( handle );
1667     if (!(ptr = GlobalLock16( owner ))) return 0;
1668     if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return owner;
1669
1670       /* Search for the owner inside all tasks */
1671
1672     *hTask = hFirstTask;
1673     while (*hTask)
1674     {
1675         TDB *pTask = (TDB *)GlobalLock16( *hTask );
1676         if ((*hTask == owner) ||
1677             (pTask->hInstance == owner) ||
1678             (pTask->hQueue == owner) ||
1679             (pTask->hPDB == owner)) return pTask->hModule;
1680         *hTask = pTask->hNext;
1681     }
1682
1683     return 0;
1684 }
1685
1686 HMODULE16 WINAPI GetExePtr( HANDLE16 handle )
1687 {
1688     HTASK16 dummy;
1689     return GetExePtrHelper( handle, &dummy );
1690 }
1691
1692 void WINAPI WIN16_GetExePtr( CONTEXT *context )
1693 {
1694     WORD *stack = PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context));
1695     HANDLE16 handle = (HANDLE16)stack[2];
1696     HTASK16 hTask = 0;
1697     HMODULE16 hModule;
1698
1699     hModule = GetExePtrHelper( handle, &hTask );
1700
1701     AX_reg(context) = CX_reg(context) = hModule;
1702     if (hTask) ES_reg(context) = hTask;
1703 }
1704
1705 /***********************************************************************
1706  *           TaskFirst   (TOOLHELP.63)
1707  */
1708 BOOL16 WINAPI TaskFirst16( TASKENTRY *lpte )
1709 {
1710     lpte->hNext = hFirstTask;
1711     return TaskNext16( lpte );
1712 }
1713
1714
1715 /***********************************************************************
1716  *           TaskNext   (TOOLHELP.64)
1717  */
1718 BOOL16 WINAPI TaskNext16( TASKENTRY *lpte )
1719 {
1720     TDB *pTask;
1721     INSTANCEDATA *pInstData;
1722
1723     TRACE_(toolhelp)("(%p): task=%04x\n", lpte, lpte->hNext );
1724     if (!lpte->hNext) return FALSE;
1725     pTask = (TDB *)GlobalLock16( lpte->hNext );
1726     if (!pTask || pTask->magic != TDB_MAGIC) return FALSE;
1727     pInstData = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN( pTask->hInstance, 0 );
1728     lpte->hTask         = lpte->hNext;
1729     lpte->hTaskParent   = pTask->hParent;
1730     lpte->hInst         = pTask->hInstance;
1731     lpte->hModule       = pTask->hModule;
1732     lpte->wSS           = SELECTOROF( pTask->thdb->cur_stack );
1733     lpte->wSP           = OFFSETOF( pTask->thdb->cur_stack );
1734     lpte->wStackTop     = pInstData->stacktop;
1735     lpte->wStackMinimum = pInstData->stackmin;
1736     lpte->wStackBottom  = pInstData->stackbottom;
1737     lpte->wcEvents      = pTask->nEvents;
1738     lpte->hQueue        = pTask->hQueue;
1739     strncpy( lpte->szModule, pTask->module_name, 8 );
1740     lpte->szModule[8]   = '\0';
1741     lpte->wPSPOffset    = 0x100;  /*??*/
1742     lpte->hNext         = pTask->hNext;
1743     return TRUE;
1744 }
1745
1746
1747 /***********************************************************************
1748  *           TaskFindHandle   (TOOLHELP.65)
1749  */
1750 BOOL16 WINAPI TaskFindHandle16( TASKENTRY *lpte, HTASK16 hTask )
1751 {
1752     lpte->hNext = hTask;
1753     return TaskNext16( lpte );
1754 }
1755
1756
1757 /***********************************************************************
1758  *           GetAppCompatFlags16   (KERNEL.354)
1759  */
1760 DWORD WINAPI GetAppCompatFlags16( HTASK16 hTask )
1761 {
1762     return GetAppCompatFlags( hTask );
1763 }
1764
1765
1766 /***********************************************************************
1767  *           GetAppCompatFlags32   (USER32.206)
1768  */
1769 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
1770 {
1771     TDB *pTask;
1772
1773     if (!hTask) hTask = GetCurrentTask();
1774     if (!(pTask=(TDB *)GlobalLock16( (HTASK16)hTask ))) return 0;
1775     if (GlobalSize16(hTask) < sizeof(TDB)) return 0;
1776     return pTask->compat_flags;
1777 }