loader/task.c

   1 /*
   2  * Task functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #include "windows.h"
  12 #include "task.h"
  13 #include "callback.h"
  14 #include "file.h"
  15 #include "global.h"
  16 #include "instance.h"
  17 #include "message.h"
  18 #include "miscemu.h"
  19 #include "module.h"
  20 #include "neexe.h"
  21 #include "options.h"
  22 #include "peexe.h"
  23 #include "pe_image.h"
  24 #include "process.h"
  25 #include "queue.h"
  26 #include "selectors.h"
  27 #include "stackframe.h"
  28 #include "thread.h"
  29 #include "toolhelp.h"
  30 #include "winnt.h"
  31 #include "stddebug.h"
  32 #include "debug.h"
  33 #include "dde_proc.h"
  34
  35 #ifndef WINELIB
  36 #include "debugger.h"
  37 #endif
  38
  39   /* Min. number of thunks allocated when creating a new segment */
  40 #define MIN_THUNKS  32
  41
  42 extern void USER_AppExit( HTASK16, HINSTANCE16, HQUEUE16 );
  43
  44   /* Saved 16-bit stack for current process (Win16 only) */
  45 WORD IF1632_Saved16_ss = 0;
  46 WORD IF1632_Saved16_sp = 0;
  47
  48   /* Saved 32-bit stack for current process (Win16 only) */
  49 DWORD IF1632_Saved32_esp = 0;
  50
  51   /* Original Unix stack */
  52 DWORD IF1632_Original32_esp;
  53
  54 static HTASK16 hFirstTask = 0;
  55 static HTASK16 hCurrentTask = 0;
  56 static HTASK16 hTaskToKill = 0;
  57 static HTASK16 hLockedTask = 0;
  58 static UINT16 nTaskCount = 0;
  59 static HGLOBAL16 hDOSEnvironment = 0;
  60
  61   /* TASK_Reschedule() 16-bit entry point */
  62 static FARPROC16 TASK_RescheduleProc;
  63
  64 #ifdef WINELIB
  65 #define TASK_SCHEDULE()  TASK_Reschedule()
  66 #else
  67 #define TASK_SCHEDULE()  CallTo16_word_(TASK_RescheduleProc)
  68 #endif
  69
  70 static HGLOBAL16 TASK_CreateDOSEnvironment(void);
  71 static void      TASK_YieldToSystem(TDB*);
  72
  73 /***********************************************************************
  74  *           TASK_Init
  75  */
  76 BOOL32 TASK_Init(void)
  77 {
  78     TASK_RescheduleProc = MODULE_GetWndProcEntry16( "TASK_Reschedule" );
  79     if (!(hDOSEnvironment = TASK_CreateDOSEnvironment()))
  80         fprintf( stderr, "Not enough memory for DOS Environment\n" );
  81     return (hDOSEnvironment != 0);
  82 }
  83
  84
  85 /***********************************************************************
  86  *           TASK_GetNextTask
  87  */
  88 HTASK16 TASK_GetNextTask( HTASK16 hTask )
  89 {
  90     TDB* pTask = (TDB*)GlobalLock16(hTask);
  91
  92     if (pTask->hNext) return pTask->hNext;
  93     return (hFirstTask != hTask) ? hFirstTask : 0;
  94 }
  95
  96
  97 /***********************************************************************
  98  *           TASK_CreateDOSEnvironment
  99  *
 100  * Create the original DOS environment.
 101  */
 102 static HGLOBAL16 TASK_CreateDOSEnvironment(void)
 103 {
 104     static const char program_name[] = "KRNL386.EXE";
 105     char **e, *p;
 106     int initial_size, size, i, winpathlen, sysdirlen;
 107     HGLOBAL16 handle;
 108
 109     extern char **environ;
 110
 111     /* DOS environment format:
 112      * ASCIIZ   string 1
 113      * ASCIIZ   string 2
 114      * ...
 115      * ASCIIZ   string n
 116      * ASCIIZ   PATH=xxx
 117      * BYTE     0
 118      * WORD     1
 119      * ASCIIZ   program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
 120      */
 121
 122     /* First compute the size of the fixed part of the environment */
 123
 124     for (i = winpathlen = 0; ; i++)
 125     {
 126         int len = DIR_GetDosPath( i, NULL, 0 );
 127         if (!len) break;
 128         winpathlen += len + 1;
 129     }
 130     if (!winpathlen) winpathlen = 1;
 131     sysdirlen  = GetSystemDirectory32A( NULL, 0 ) + 1;
 132     initial_size = 5 + winpathlen +           /* PATH=xxxx */
 133                    1 +                        /* BYTE 0 at end */
 134                    sizeof(WORD) +             /* WORD 1 */
 135                    sysdirlen +                /* program directory */
 136                    strlen(program_name) + 1;  /* program name */
 137
 138     /* Compute the total size of the Unix environment (except path) */
 139
 140     for (e = environ, size = initial_size; *e; e++)
 141     {
 142         if (lstrncmpi32A(*e, "path=", 5))
 143         {
 144             int len = strlen(*e) + 1;
 145             if (size + len >= 32767)
 146             {
 147                 fprintf( stderr, "Warning: environment larger than 32k.\n" );
 148                 break;
 149             }
 150             size += len;
 151         }
 152     }
 153
 154
 155     /* Now allocate the environment */
 156
 157     if (!(handle = GlobalAlloc16( GMEM_FIXED, size ))) return 0;
 158     p = (char *)GlobalLock16( handle );
 159
 160     /* And fill it with the Unix environment */
 161
 162     for (e = environ, size = initial_size; *e; e++)
 163     {
 164         if (lstrncmpi32A(*e, "path=", 5))
 165         {
 166             int len = strlen(*e) + 1;
 167             if (size + len >= 32767) break;
 168             strcpy( p, *e );
 169             size += len;
 170             p    += len;
 171         }
 172     }
 173
 174     /* Now add the path */
 175
 176     strcpy( p, "PATH=" );
 177     for (i = 0, p += 5; ; i++)
 178     {
 179         if (!DIR_GetDosPath( i, p, winpathlen )) break;
 180         p += strlen(p);
 181         *p++ = ';';
 182     }
 183     if (p[-1] == ';') p[-1] = '\0';
 184     else p++;
 185
 186     /* Now add the program name */
 187
 188     *p++ = '\0';
 189     PUT_WORD( p, 1 );
 190     p += sizeof(WORD);
 191     GetSystemDirectory32A( p, sysdirlen );
 192     strcat( p, "\\" );
 193     strcat( p, program_name );
 194
 195     /* Display it */
 196
 197     p = (char *) GlobalLock16( handle );
 198     dprintf_task(stddeb, "Master DOS environment at %p\n", p);
 199     for (; *p; p += strlen(p) + 1) dprintf_task(stddeb, "    %s\n", p);
 200     dprintf_task( stddeb, "Progname: %s\n", p+3 );
 201
 202     return handle;
 203 }
 204
 205
 206 /***********************************************************************
 207  *           TASK_LinkTask
 208  */
 209 static void TASK_LinkTask( HTASK16 hTask )
 210 {
 211     HTASK16 *prevTask;
 212     TDB *pTask;
 213
 214     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 215     prevTask = &hFirstTask;
 216     while (*prevTask)
 217     {
 218         TDB *prevTaskPtr = (TDB *)GlobalLock16( *prevTask );
 219         if (prevTaskPtr->priority >= pTask->priority) break;
 220         prevTask = &prevTaskPtr->hNext;
 221     }
 222     pTask->hNext = *prevTask;
 223     *prevTask = hTask;
 224     nTaskCount++;
 225 }
 226
 227
 228 /***********************************************************************
 229  *           TASK_UnlinkTask
 230  */
 231 static void TASK_UnlinkTask( HTASK16 hTask )
 232 {
 233     HTASK16 *prevTask;
 234     TDB *pTask;
 235
 236     prevTask = &hFirstTask;
 237     while (*prevTask && (*prevTask != hTask))
 238     {
 239         pTask = (TDB *)GlobalLock16( *prevTask );
 240         prevTask = &pTask->hNext;
 241     }
 242     if (*prevTask)
 243     {
 244         pTask = (TDB *)GlobalLock16( *prevTask );
 245         *prevTask = pTask->hNext;
 246         pTask->hNext = 0;
 247         nTaskCount--;
 248     }
 249 }
 250
 251
 252 /***********************************************************************
 253  *           TASK_CreateThunks
 254  *
 255  * Create a thunk free-list in segment 'handle', starting from offset 'offset'
 256  * and containing 'count' entries.
 257  */
 258 static void TASK_CreateThunks( HGLOBAL16 handle, WORD offset, WORD count )
 259 {
 260     int i;
 261     WORD free;
 262     THUNKS *pThunk;
 263
 264     pThunk = (THUNKS *)((BYTE *)GlobalLock16( handle ) + offset);
 265     pThunk->next = 0;
 266     pThunk->magic = THUNK_MAGIC;
 267     pThunk->free = (int)&pThunk->thunks - (int)pThunk;
 268     free = pThunk->free;
 269     for (i = 0; i < count-1; i++)
 270     {
 271         free += 8;  /* Offset of next thunk */
 272         pThunk->thunks[4*i] = free;
 273     }
 274     pThunk->thunks[4*i] = 0;  /* Last thunk */
 275 }
 276
 277
 278 /***********************************************************************
 279  *           TASK_AllocThunk
 280  *
 281  * Allocate a thunk for MakeProcInstance().
 282  */
 283 static SEGPTR TASK_AllocThunk( HTASK16 hTask )
 284 {
 285     TDB *pTask;
 286     THUNKS *pThunk;
 287     WORD sel, base;
 288
 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)
 294     {
 295         sel = pThunk->next;
 296         if (!sel)  /* Allocate a new segment */
 297         {
 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 );
 302             pThunk->next = sel;
 303         }
 304         pThunk = (THUNKS *)GlobalLock16( sel );
 305         base = 0;
 306     }
 307     base += pThunk->free;
 308     pThunk->free = *(WORD *)((BYTE *)pThunk + pThunk->free);
 309     return PTR_SEG_OFF_TO_SEGPTR( sel, base );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           TASK_FreeThunk
 315  *
 316  * Free a MakeProcInstance() thunk.
 317  */
 318 static BOOL TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
 319 {
 320     TDB *pTask;
 321     THUNKS *pThunk;
 322     WORD sel, base;
 323
 324     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
 325     sel = pTask->hCSAlias;
 326     pThunk = &pTask->thunks;
 327     base = (int)pThunk - (int)pTask;
 328     while (sel && (sel != HIWORD(thunk)))
 329     {
 330         sel = pThunk->next;
 331         pThunk = (THUNKS *)GlobalLock16( sel );
 332         base = 0;
 333     }
 334     if (!sel) return FALSE;
 335     *(WORD *)((BYTE *)pThunk + LOWORD(thunk) - base) = pThunk->free;
 336     pThunk->free = LOWORD(thunk) - base;
 337     return TRUE;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           TASK_CallToStart
 343  *
 344  * 32-bit entry point for a new task. This function is responsible for
 345  * setting up the registers and jumping to the 16-bit entry point.
 346  */
 347 #ifndef WINELIB
 348 static void TASK_CallToStart(void)
 349 {
 350     int cs_reg, ds_reg, ip_reg;
 351     int exit_code = 1;
 352     TDB *pTask = (TDB *)GlobalLock16( hCurrentTask );
 353     NE_MODULE *pModule = MODULE_GetPtr( pTask->hModule );
 354     SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
 355
 356     IF1632_Saved16_ss = pTask->ss;
 357     IF1632_Saved16_sp = pTask->sp;
 358
 359     if (pModule->flags & NE_FFLAGS_WIN32)
 360     {
 361         /* FIXME: all this is an ugly hack */
 362
 363         extern void InitTask( CONTEXT *context );
 364
 365         InitTask( NULL );
 366         InitApp( pTask->hModule );
 367         __asm__ __volatile__("movw %w0,%%fs"::"r" (pCurrentThread->teb_sel));
 368         PE_InitializeDLLs( pTask->hModule );
 369         exit_code = CallTaskStart32((FARPROC32)(pModule->pe_module->load_addr +
 370                 pModule->pe_module->pe_header->OptionalHeader.AddressOfEntryPoint) );
 371         TASK_KillCurrentTask( exit_code );
 372     }
 373     else
 374     {
 375         /* Registers at initialization must be:
 376          * ax   zero
 377          * bx   stack size in bytes
 378          * cx   heap size in bytes
 379          * si   previous app instance
 380          * di   current app instance
 381          * bp   zero
 382          * es   selector to the PSP
 383          * ds   dgroup of the application
 384          * ss   stack selector
 385          * sp   top of the stack
 386          */
 387
 388         cs_reg = pSegTable[pModule->cs - 1].selector;
 389         ip_reg = pModule->ip;
 390         ds_reg = pSegTable[pModule->dgroup - 1].selector;
 391
 392         dprintf_task( stddeb, "Starting main program: cs:ip=%04x:%04x ds=%04x ss:sp=%04x:%04x\n",
 393                       cs_reg, ip_reg, ds_reg,
 394                       IF1632_Saved16_ss, IF1632_Saved16_sp);
 395
 396         CallTo16_regs_( (FARPROC16)(cs_reg << 16 | ip_reg), ds_reg,
 397                         pTask->hPDB /*es*/, 0 /*bp*/, 0 /*ax*/,
 398                         pModule->stack_size /*bx*/, pModule->heap_size /*cx*/,
 399                         0 /*dx*/, 0 /*si*/, ds_reg /*di*/ );
 400         /* This should never return */
 401         fprintf( stderr, "TASK_CallToStart: Main program returned!\n" );
 402         TASK_KillCurrentTask( 1 );
 403     }
 404 }
 405 #endif
 406
 407
 408 /***********************************************************************
 409  *           TASK_CreateTask
 410  */
 411 HTASK16 TASK_CreateTask( HMODULE16 hModule, HINSTANCE16 hInstance,
 412                          HINSTANCE16 hPrevInstance, HANDLE16 hEnvironment,
 413                          LPCSTR cmdLine, UINT16 cmdShow )
 414 {
 415     HTASK16 hTask;
 416     TDB *pTask;
 417     PDB32 *pdb32;
 418     HGLOBAL16 hParentEnv;
 419     NE_MODULE *pModule;
 420     SEGTABLEENTRY *pSegTable;
 421     LPSTR name;
 422     char filename[256];
 423     char *stack16Top, *stack32Top;
 424     STACK16FRAME *frame16;
 425     STACK32FRAME *frame32;
 426 #ifndef WINELIB32
 427     extern DWORD CALLTO16_RetAddr_word;
 428 #endif
 429
 430     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 431     pSegTable = NE_SEG_TABLE( pModule );
 432
 433       /* Allocate the task structure */
 434
 435     hTask = GLOBAL_Alloc( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB),
 436                           hModule, FALSE, FALSE, FALSE );
 437     if (!hTask) return 0;
 438     pTask = (TDB *)GlobalLock16( hTask );
 439
 440       /* Allocate the new environment block */
 441
 442     if (!(hParentEnv = hEnvironment))
 443     {
 444         TDB *pParent = (TDB *)GlobalLock16( hCurrentTask );
 445         hParentEnv = pParent ? pParent->pdb.environment : hDOSEnvironment;
 446     }
 447     /* FIXME: do we really need to make a copy also when */
 448     /*        we don't use the parent environment? */
 449     if (!(hEnvironment = GlobalAlloc16( GMEM_FIXED, GlobalSize16(hParentEnv))))
 450     {
 451         GlobalFree16( hTask );
 452         return 0;
 453     }
 454     memcpy( GlobalLock16( hEnvironment ), GlobalLock16( hParentEnv ),
 455             GlobalSize16( hParentEnv ) );
 456
 457       /* Get current directory */
 458
 459     GetModuleFileName16( hModule, filename, sizeof(filename) );
 460     name = strrchr(filename, '\\');
 461     if (name) *(name+1) = 0;
 462
 463       /* Fill the task structure */
 464
 465     pTask->nEvents       = 1;  /* So the task can be started */
 466     pTask->hSelf         = hTask;
 467     pTask->flags         = 0;
 468
 469     if (pModule->flags & NE_FFLAGS_WIN32)
 470         pTask->flags    |= TDBF_WIN32;
 471
 472     pTask->version       = pModule->expected_version;
 473     pTask->hInstance     = hInstance;
 474     pTask->hPrevInstance = hPrevInstance;
 475     pTask->hModule       = hModule;
 476     pTask->hParent       = hCurrentTask;
 477     pTask->curdrive      = filename[0] - 'A' + 0x80;
 478     strcpy( pTask->curdir, filename+2 );
 479     pTask->magic         = TDB_MAGIC;
 480     pTask->nCmdShow      = cmdShow;
 481
 482       /* Create the thunks block */
 483
 484     TASK_CreateThunks( hTask, (int)&pTask->thunks - (int)pTask, 7 );
 485
 486       /* Copy the module name */
 487
 488     name = MODULE_GetModuleName( hModule );
 489     strncpy( pTask->module_name, name, sizeof(pTask->module_name) );
 490
 491       /* Allocate a selector for the PDB */
 492
 493     pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB),
 494                                       hModule, FALSE, FALSE, FALSE, NULL );
 495
 496       /* Fill the PDB */
 497
 498     pTask->pdb.int20 = 0x20cd;
 499     pTask->pdb.dispatcher[0] = 0x9a;  /* ljmp */
 500 #ifndef WINELIB
 501     *(FARPROC16 *)&pTask->pdb.dispatcher[1] = MODULE_GetEntryPoint( GetModuleHandle("KERNEL"), 102 );  /* KERNEL.102 is DOS3Call() */
 502 #endif
 503     pTask->pdb.savedint22 = INT_GetHandler( 0x22 );
 504     pTask->pdb.savedint23 = INT_GetHandler( 0x23 );
 505     pTask->pdb.savedint24 = INT_GetHandler( 0x24 );
 506     pTask->pdb.fileHandlesPtr =
 507         PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask->hPDB),
 508                                (int)&((PDB *)0)->fileHandles );
 509     pTask->pdb.hFileHandles = 0;
 510     memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
 511     pTask->pdb.environment    = hEnvironment;
 512     pTask->pdb.nbFiles        = 20;
 513     lstrcpyn32A( pTask->pdb.cmdLine + 1, cmdLine, 127 );
 514     pTask->pdb.cmdLine[0] = strlen( pTask->pdb.cmdLine + 1 );
 515
 516       /* Get the compatibility flags */
 517
 518     pTask->compat_flags = GetProfileInt32A( "Compatibility", name, 0 );
 519
 520       /* Allocate a code segment alias for the TDB */
 521
 522     pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, (void *)pTask,
 523                                           sizeof(TDB), pTask->hPDB, TRUE,
 524                                           FALSE, FALSE, NULL );
 525
 526       /* Set the owner of the environment block */
 527
 528     FarSetOwner( pTask->pdb.environment, pTask->hPDB );
 529
 530       /* Default DTA overwrites command-line */
 531
 532     pTask->dta = PTR_SEG_OFF_TO_SEGPTR( pTask->hPDB,
 533                                 (int)&pTask->pdb.cmdLine - (int)&pTask->pdb );
 534
 535     /* Create the Win32 part of the task */
 536
 537     pdb32 = PROCESS_Create( pTask );
 538     if (pModule->flags & NE_FFLAGS_WIN32)
 539     {
 540         LPTHREAD_START_ROUTINE start =
 541             (LPTHREAD_START_ROUTINE)(pModule->pe_module->load_addr +
 542             pModule->pe_module->pe_header->OptionalHeader.AddressOfEntryPoint);
 543         pTask->thdb = THREAD_Create( pdb32, 0, start );
 544     }
 545     else
 546         pTask->thdb = THREAD_Create( pdb32, 0, NULL );
 547
 548     /* Create the 32-bit stack frame */
 549
 550     stack32Top = (char*)pTask->thdb->teb.stack_top;
 551     frame32 = (STACK32FRAME *)stack32Top - 1;
 552     frame32->saved_esp = (DWORD)stack32Top;
 553     frame32->edi = 0;
 554     frame32->esi = 0;
 555     frame32->edx = 0;
 556     frame32->ecx = 0;
 557     frame32->ebx = 0;
 558     frame32->ebp = 0;
 559 #ifndef WINELIB
 560     frame32->retaddr = (DWORD)TASK_CallToStart;
 561     frame32->codeselector = WINE_CODE_SELECTOR;
 562 #endif
 563     pTask->esp = (DWORD)frame32;
 564
 565       /* Create the 16-bit stack frame */
 566
 567     pTask->ss = hInstance;
 568     pTask->sp = ((pModule->sp != 0) ? pModule->sp :
 569                  pSegTable[pModule->ss-1].minsize + pModule->stack_size) & ~1;
 570     stack16Top = (char *)PTR_SEG_OFF_TO_LIN( pTask->ss, pTask->sp );
 571     frame16 = (STACK16FRAME *)stack16Top - 1;
 572     frame16->saved_ss = 0;
 573     frame16->saved_sp = 0;
 574     frame16->ds = frame16->es = pTask->hInstance;
 575     frame16->entry_point = 0;
 576     frame16->entry_ip = OFFSETOF(TASK_RescheduleProc) + 14;
 577     frame16->entry_cs = SELECTOROF(TASK_RescheduleProc);
 578     frame16->bp = 0;
 579 #ifndef WINELIB
 580     frame16->ip = LOWORD( CALLTO16_RetAddr_word );
 581     frame16->cs = HIWORD( CALLTO16_RetAddr_word );
 582 #endif  /* WINELIB */
 583     pTask->sp -= sizeof(STACK16FRAME);
 584
 585       /* If there's no 16-bit stack yet, use a part of the new task stack */
 586       /* This is only needed to have a stack to switch from on the first  */
 587       /* call to DirectedYield(). */
 588
 589     if (!IF1632_Saved16_ss)
 590     {
 591         IF1632_Saved16_ss = pTask->ss;
 592         IF1632_Saved16_sp = pTask->sp;
 593     }
 594
 595       /* Add a breakpoint at the start of the task */
 596
 597 #ifndef WINELIB
 598     if (Options.debug)
 599     {
 600         if (pModule->flags & NE_FFLAGS_WIN32)
 601         {
 602             DBG_ADDR addr = { NULL, 0, pModule->pe_module->load_addr +
 603                               pModule->pe_module->pe_header->OptionalHeader.AddressOfEntryPoint };
 604             fprintf( stderr, "Win32 task '%s': ", name );
 605             DEBUG_AddBreakpoint( &addr );
 606         }
 607         else
 608         {
 609             DBG_ADDR addr = { NULL, pSegTable[pModule->cs-1].selector, pModule->ip };
 610             fprintf( stderr, "Win16 task '%s': ", name );
 611             DEBUG_AddBreakpoint( &addr );
 612         }
 613     }
 614 #endif  /* WINELIB */
 615
 616       /* Add the task to the linked list */
 617
 618     TASK_LinkTask( hTask );
 619
 620     dprintf_task( stddeb, "CreateTask: module='%s' cmdline='%s' task=%04x\n",
 621                   name, cmdLine, hTask );
 622
 623     return hTask;
 624 }
 625
 626
 627 /***********************************************************************
 628  *           TASK_DeleteTask
 629  */
 630 static void TASK_DeleteTask( HTASK16 hTask )
 631 {
 632     TDB *pTask;
 633     HGLOBAL16 hPDB;
 634
 635     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 636     hPDB = pTask->hPDB;
 637
 638     /* Delete the Win32 part of the task */
 639
 640     PROCESS_Destroy( &pTask->thdb->process->header );
 641     THREAD_Destroy( &pTask->thdb->header );
 642
 643     /* Free the task module */
 644
 645     FreeModule16( pTask->hModule );
 646
 647     /* Free the selector aliases */
 648
 649     GLOBAL_FreeBlock( pTask->hCSAlias );
 650     GLOBAL_FreeBlock( pTask->hPDB );
 651
 652     /* Free the task structure itself */
 653
 654     GlobalFree16( hTask );
 655
 656     /* Free all memory used by this task (including the 32-bit stack, */
 657     /* the environment block and the thunk segments). */
 658
 659     GlobalFreeAll( hPDB );
 660 }
 661
 662
 663 /***********************************************************************
 664  *           TASK_KillCurrentTask
 665  *
 666  * Kill the currently running task. As it's not possible to kill the
 667  * current task like this, it is simply marked for destruction, and will
 668  * be killed when either TASK_Reschedule or this function is called again
 669  * in the context of another task.
 670  */
 671 void TASK_KillCurrentTask( INT16 exitCode )
 672 {
 673     extern void EXEC_ExitWindows(void);
 674
 675     TDB* pTask = (TDB*) GlobalLock16( hCurrentTask );
 676     if (!pTask) EXEC_ExitWindows();  /* No current task yet */
 677
 678     /* Perform USER cleanup */
 679
 680     USER_AppExit( hCurrentTask, pTask->hInstance, pTask->hQueue );
 681
 682     if (hTaskToKill && (hTaskToKill != hCurrentTask))
 683     {
 684         /* If another task is already marked for destruction, */
 685         /* we can kill it now, as we are in another context.  */
 686         TASK_DeleteTask( hTaskToKill );
 687     }
 688
 689     if (nTaskCount <= 1)
 690     {
 691         dprintf_task( stddeb, "Killing the last task, exiting\n" );
 692         EXEC_ExitWindows();
 693     }
 694
 695     /* Remove the task from the list to be sure we never switch back to it */
 696     TASK_UnlinkTask( hCurrentTask );
 697     if( nTaskCount )
 698     {
 699         TDB* p = (TDB *)GlobalLock16( hFirstTask );
 700         while( p )
 701         {
 702             if( p->hYieldTo == hCurrentTask ) p->hYieldTo = 0;
 703             p = (TDB *)GlobalLock16( p->hNext );
 704         }
 705     }
 706
 707     hTaskToKill = hCurrentTask;
 708     hLockedTask = 0;
 709
 710     pTask->nEvents = 0;
 711     TASK_YieldToSystem(pTask);
 712
 713     /* We should never return from this Yield() */
 714
 715     fprintf(stderr,"Return of the living dead %04x!!!\n", hCurrentTask);
 716     exit(1);
 717 }
 718
 719 /***********************************************************************
 720  *           TASK_Reschedule
 721  *
 722  * This is where all the magic of task-switching happens!
 723  *
 724  * Note: This function should only be called via the TASK_YieldToSystem()
 725  *       wrapper, to make sure that all the context is saved correctly.
 726  *
 727  *       It must not call functions that may yield control.
 728  */
 729 void TASK_Reschedule(void)
 730 {
 731     TDB *pOldTask = NULL, *pNewTask;
 732     HTASK16 hTask = 0;
 733
 734 #ifdef CONFIG_IPC
 735     dde_reschedule();
 736 #endif
 737       /* First check if there's a task to kill */
 738
 739     if (hTaskToKill && (hTaskToKill != hCurrentTask))
 740     {
 741         TASK_DeleteTask( hTaskToKill );
 742         hTaskToKill = 0;
 743     }
 744
 745     /* Find a task to yield to */
 746
 747     pOldTask = (TDB *)GlobalLock16( hCurrentTask );
 748     if (pOldTask && pOldTask->hYieldTo)
 749     {
 750         /* check for DirectedYield() */
 751
 752         hTask = pOldTask->hYieldTo;
 753         pNewTask = (TDB *)GlobalLock16( hTask );
 754         if( !pNewTask || !pNewTask->nEvents) hTask = 0;
 755         pOldTask->hYieldTo = 0;
 756     }
 757
 758     /* extract hardware events only! */
 759
 760     if (!hTask) EVENT_WaitXEvent( FALSE, TRUE );
 761
 762     while (!hTask)
 763     {
 764         /* Find a task that has an event pending */
 765
 766         hTask = hFirstTask;
 767         while (hTask)
 768         {
 769             pNewTask = (TDB *)GlobalLock16( hTask );
 770
 771             dprintf_task( stddeb, "\ttask = %04x, events = %i\n", hTask, pNewTask->nEvents);
 772
 773             if (pNewTask->nEvents) break;
 774             hTask = pNewTask->hNext;
 775         }
 776         if (hLockedTask && (hTask != hLockedTask)) hTask = 0;
 777         if (hTask) break;
 778
 779         /* No task found, wait for some events to come in */
 780
 781         EVENT_WaitXEvent( TRUE, TRUE );
 782     }
 783
 784     if (hTask == hCurrentTask)
 785     {
 786        dprintf_task( stddeb, "returning to the current task(%04x)\n", hTask );
 787        return;  /* Nothing to do */
 788     }
 789     pNewTask = (TDB *)GlobalLock16( hTask );
 790     dprintf_task( stddeb, "Switching to task %04x (%.8s)\n",
 791                   hTask, pNewTask->module_name );
 792
 793       /* Save the stacks of the previous task (if any) */
 794
 795     if (pOldTask)
 796     {
 797         pOldTask->ss  = IF1632_Saved16_ss;
 798         pOldTask->sp  = IF1632_Saved16_sp;
 799         pOldTask->esp = IF1632_Saved32_esp;
 800     }
 801     else IF1632_Original32_esp = IF1632_Saved32_esp;
 802
 803      /* Make the task the last in the linked list (round-robin scheduling) */
 804
 805     pNewTask->priority++;
 806     TASK_UnlinkTask( hTask );
 807     TASK_LinkTask( hTask );
 808     pNewTask->priority--;
 809
 810       /* Switch to the new stack */
 811
 812     hCurrentTask = hTask;
 813     pCurrentThread = pNewTask->thdb;
 814     pCurrentProcess = pCurrentThread->process;
 815     IF1632_Saved16_ss   = pNewTask->ss;
 816     IF1632_Saved16_sp   = pNewTask->sp;
 817     IF1632_Saved32_esp  = pNewTask->esp;
 818 }
 819
 820
 821 /***********************************************************************
 822  *           TASK_YieldToSystem
 823  *
 824  * Scheduler interface, this way we ensure that all "unsafe" events are
 825  * processed outside the scheduler.
 826  */
 827 void TASK_YieldToSystem(TDB* pTask)
 828 {
 829   MESSAGEQUEUE*         pQ;
 830
 831   TASK_SCHEDULE();
 832
 833   if( pTask )
 834   {
 835     pQ = (MESSAGEQUEUE*)GlobalLock16(pTask->hQueue);
 836     if( pQ && pQ->flags & QUEUE_FLAG_XEVENT &&
 837             !(pQ->wakeBits & (QS_SENDMESSAGE | QS_SMRESULT)) )
 838     {
 839       pQ->flags &= ~QUEUE_FLAG_XEVENT;
 840       EVENT_WaitXEvent( FALSE, FALSE );
 841     }
 842   }
 843 }
 844
 845
 846 /***********************************************************************
 847  *           InitTask  (KERNEL.91)
 848  */
 849 void InitTask( CONTEXT *context )
 850 {
 851     TDB *pTask;
 852     NE_MODULE *pModule;
 853     SEGTABLEENTRY *pSegTable;
 854     INSTANCEDATA *pinstance;
 855     LONG stacklow, stackhi;
 856
 857     if (context) EAX_reg(context) = 0;
 858     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
 859     if (!(pModule = MODULE_GetPtr( pTask->hModule ))) return;
 860
 861 #ifndef WINELIB
 862     NE_InitializeDLLs( pTask->hModule );
 863 #endif
 864
 865     if (context)
 866     {
 867         /* Registers on return are:
 868          * ax     1 if OK, 0 on error
 869          * cx     stack limit in bytes
 870          * dx     cmdShow parameter
 871          * si     instance handle of the previous instance
 872          * di     instance handle of the new task
 873          * es:bx  pointer to command-line inside PSP
 874          */
 875         EAX_reg(context) = 1;
 876         EBX_reg(context) = 0x81;
 877         ECX_reg(context) = pModule->stack_size;
 878         EDX_reg(context) = pTask->nCmdShow;
 879         ESI_reg(context) = (DWORD)pTask->hPrevInstance;
 880         EDI_reg(context) = (DWORD)pTask->hInstance;
 881         ES_reg (context) = (WORD)pTask->hPDB;
 882     }
 883
 884     /* Initialize the local heap */
 885     if ( pModule->heap_size )
 886     {
 887         LocalInit( pTask->hInstance, 0, pModule->heap_size );
 888     }
 889
 890     /* Initialize the INSTANCEDATA structure */
 891     pSegTable = NE_SEG_TABLE( pModule );
 892     stacklow = pSegTable[pModule->ss - 1].minsize;
 893     stackhi  = stacklow + pModule->stack_size;
 894     if (stackhi > 0xffff) stackhi = 0xffff;
 895     pinstance = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN(CURRENT_DS, 0);
 896     pinstance->stackbottom = stackhi; /* yup, that's right. Confused me too. */
 897     pinstance->stacktop    = stacklow;
 898 #ifndef WINELIB
 899     pinstance->stackmin    = IF1632_Saved16_sp;
 900 #endif
 901 }
 902
 903
 904 /***********************************************************************
 905  *           WaitEvent  (KERNEL.30)
 906  */
 907 BOOL16 WaitEvent( HTASK16 hTask )
 908 {
 909     TDB *pTask;
 910
 911     if (!hTask) hTask = hCurrentTask;
 912     pTask = (TDB *)GlobalLock16( hTask );
 913     if (pTask->nEvents > 0)
 914     {
 915         pTask->nEvents--;
 916         return FALSE;
 917     }
 918     TASK_YieldToSystem(pTask);
 919
 920     /* When we get back here, we have an event */
 921
 922     if (pTask->nEvents > 0) pTask->nEvents--;
 923     return TRUE;
 924 }
 925
 926
 927 /***********************************************************************
 928  *           PostEvent  (KERNEL.31)
 929  */
 930 void PostEvent( HTASK16 hTask )
 931 {
 932     TDB *pTask;
 933
 934     if (!hTask) hTask = hCurrentTask;
 935     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 936     pTask->nEvents++;
 937 }
 938
 939
 940 /***********************************************************************
 941  *           SetPriority  (KERNEL.32)
 942  */
 943 void SetPriority( HTASK16 hTask, INT16 delta )
 944 {
 945     TDB *pTask;
 946     INT16 newpriority;
 947
 948     if (!hTask) hTask = hCurrentTask;
 949     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
 950     newpriority = pTask->priority + delta;
 951     if (newpriority < -32) newpriority = -32;
 952     else if (newpriority > 15) newpriority = 15;
 953
 954     pTask->priority = newpriority + 1;
 955     TASK_UnlinkTask( hTask );
 956     TASK_LinkTask( hTask );
 957     pTask->priority--;
 958 }
 959
 960
 961 /***********************************************************************
 962  *           LockCurrentTask  (KERNEL.33)
 963  */
 964 HTASK16 LockCurrentTask( BOOL16 bLock )
 965 {
 966     if (bLock) hLockedTask = hCurrentTask;
 967     else hLockedTask = 0;
 968     return hLockedTask;
 969 }
 970
 971
 972 /***********************************************************************
 973  *           IsTaskLocked  (KERNEL.122)
 974  */
 975 HTASK16 IsTaskLocked(void)
 976 {
 977     return hLockedTask;
 978 }
 979
 980
 981 /***********************************************************************
 982  *           OldYield  (KERNEL.117)
 983  */
 984 void OldYield(void)
 985 {
 986     TDB *pCurTask;
 987
 988     pCurTask = (TDB *)GlobalLock16( hCurrentTask );
 989     if (pCurTask) pCurTask->nEvents++;  /* Make sure we get back here */
 990     TASK_YieldToSystem(pCurTask);
 991     if (pCurTask) pCurTask->nEvents--;
 992 }
 993
 994
 995 /***********************************************************************
 996  *           DirectedYield  (KERNEL.150)
 997  */
 998 void DirectedYield( HTASK16 hTask )
 999 {
1000     TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
1001     pCurTask->hYieldTo = hTask;
1002     OldYield();
1003 }
1004
1005
1006 /***********************************************************************
1007  *           UserYield  (USER.332)
1008  */
1009 void UserYield(void)
1010 {
1011     TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
1012     MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( pCurTask->hQueue );
1013     /* Handle sent messages */
1014     if (queue && (queue->wakeBits & QS_SENDMESSAGE))
1015         QUEUE_ReceiveMessage( queue );
1016
1017     OldYield();
1018
1019     queue = (MESSAGEQUEUE *)GlobalLock16( pCurTask->hQueue );
1020     if (queue && (queue->wakeBits & QS_SENDMESSAGE))
1021         QUEUE_ReceiveMessage( queue );
1022 }
1023
1024
1025 /***********************************************************************
1026  *           Yield  (KERNEL.29)
1027  */
1028 void Yield(void)
1029 {
1030     TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
1031     if (pCurTask) pCurTask->hYieldTo = 0;
1032     if (pCurTask && pCurTask->hQueue) UserYield();
1033     else OldYield();
1034 }
1035
1036
1037 /***********************************************************************
1038  *           MakeProcInstance16  (KERNEL.51)
1039  */
1040 FARPROC16 MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
1041 {
1042     BYTE *thunk;
1043     SEGPTR thunkaddr;
1044
1045     if (__winelib) return func; /* func can be called directly in Winelib */
1046     thunkaddr = TASK_AllocThunk( hCurrentTask );
1047     if (!thunkaddr) return (FARPROC16)0;
1048     thunk = PTR_SEG_TO_LIN( thunkaddr );
1049
1050     dprintf_task( stddeb, "MakeProcInstance(%08lx,%04x): got thunk %08lx\n",
1051                   (DWORD)func, hInstance, (DWORD)thunkaddr );
1052
1053     *thunk++ = 0xb8;    /* movw instance, %ax */
1054     *thunk++ = (BYTE)(hInstance & 0xff);
1055     *thunk++ = (BYTE)(hInstance >> 8);
1056     *thunk++ = 0xea;    /* ljmp func */
1057     *(DWORD *)thunk = (DWORD)func;
1058     return (FARPROC16)thunkaddr;
1059 }
1060
1061
1062 /***********************************************************************
1063  *           FreeProcInstance16  (KERNEL.52)
1064  */
1065 void FreeProcInstance16( FARPROC16 func )
1066 {
1067     dprintf_task( stddeb, "FreeProcInstance(%08lx)\n", (DWORD)func );
1068     if (!__winelib) TASK_FreeThunk( hCurrentTask, (SEGPTR)func );
1069 }
1070
1071
1072 /**********************************************************************
1073  *          GetCodeHandle    (KERNEL.93)
1074  */
1075 HANDLE16 GetCodeHandle( FARPROC16 proc )
1076 {
1077     HANDLE16 handle;
1078     BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
1079
1080     if (__winelib) return 0;
1081
1082     /* Return the code segment containing 'proc'. */
1083     /* Not sure if this is really correct (shouldn't matter that much). */
1084
1085     /* Check if it is really a thunk */
1086     if ((thunk[0] == 0xb8) && (thunk[3] == 0xea))
1087         handle = GlobalHandle16( thunk[6] + (thunk[7] << 8) );
1088     else
1089         handle = GlobalHandle16( HIWORD(proc) );
1090
1091     return handle;
1092 }
1093
1094
1095 /***********************************************************************
1096  *           SetTaskQueue  (KERNEL.34)
1097  */
1098 HQUEUE16 SetTaskQueue( HTASK16 hTask, HQUEUE16 hQueue )
1099 {
1100     HQUEUE16 hPrev;
1101     TDB *pTask;
1102
1103     if (!hTask) hTask = hCurrentTask;
1104     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
1105
1106     hPrev = pTask->hQueue;
1107     pTask->hQueue = hQueue;
1108
1109     TIMER_SwitchQueue( hPrev, hQueue );
1110
1111     return hPrev;
1112 }
1113
1114
1115 /***********************************************************************
1116  *           GetTaskQueue  (KERNEL.35)
1117  */
1118 HQUEUE16 GetTaskQueue( HTASK16 hTask )
1119 {
1120     TDB *pTask;
1121
1122     if (!hTask) hTask = hCurrentTask;
1123     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
1124     return pTask->hQueue;
1125 }
1126
1127
1128 /***********************************************************************
1129  *           SwitchStackTo   (KERNEL.108)
1130  */
1131 void SwitchStackTo( WORD seg, WORD ptr, WORD top )
1132 {
1133     TDB *pTask;
1134     STACK16FRAME *oldFrame, *newFrame;
1135     INSTANCEDATA *pData;
1136     UINT16 copySize;
1137
1138     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
1139     if (!(pData = (INSTANCEDATA *)GlobalLock16( seg ))) return;
1140     dprintf_task( stddeb, "SwitchStackTo: old=%04x:%04x new=%04x:%04x\n",
1141                   IF1632_Saved16_ss, IF1632_Saved16_sp, seg, ptr );
1142
1143     /* Save the old stack */
1144
1145     oldFrame           = CURRENT_STACK16;
1146     pData->old_sp      = IF1632_Saved16_sp;
1147     pData->old_ss      = IF1632_Saved16_ss;
1148     pData->stacktop    = top;
1149     pData->stackmin    = ptr;
1150     pData->stackbottom = ptr;
1151
1152     /* Switch to the new stack */
1153
1154     IF1632_Saved16_ss = pTask->ss = seg;
1155     IF1632_Saved16_sp = pTask->sp = ptr - sizeof(STACK16FRAME);
1156     newFrame = CURRENT_STACK16;
1157
1158     /* Copy the stack frame and the local variables to the new stack */
1159
1160     copySize = oldFrame->bp - pData->old_sp;
1161     memcpy( newFrame, oldFrame, MAX( copySize, sizeof(STACK16FRAME) ));
1162 }
1163
1164
1165 /***********************************************************************
1166  *           SwitchStackBack   (KERNEL.109)
1167  *
1168  * Note: the function is declared as 'register' in the spec file in order
1169  * to make sure all registers are preserved, but we don't use them in any
1170  * way, so we don't need a CONTEXT* argument.
1171  */
1172 void SwitchStackBack(void)
1173 {
1174     TDB *pTask;
1175     STACK16FRAME *oldFrame, *newFrame;
1176     INSTANCEDATA *pData;
1177
1178     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
1179     if (!(pData = (INSTANCEDATA *)GlobalLock16( IF1632_Saved16_ss ))) return;
1180     if (!pData->old_ss)
1181     {
1182         fprintf( stderr, "SwitchStackBack: no previous SwitchStackTo\n" );
1183         return;
1184     }
1185     dprintf_task( stddeb, "SwitchStackBack: restoring stack %04x:%04x\n",
1186                   pData->old_ss, pData->old_sp );
1187
1188     oldFrame = CURRENT_STACK16;
1189
1190     /* Switch back to the old stack */
1191
1192     IF1632_Saved16_ss = pTask->ss = pData->old_ss;
1193     IF1632_Saved16_sp = pTask->sp = pData->old_sp;
1194     pData->old_ss = pData->old_sp = 0;
1195
1196     /* Build a stack frame for the return */
1197
1198     newFrame = CURRENT_STACK16;
1199     newFrame->saved_ss = oldFrame->saved_ss;
1200     newFrame->saved_sp = oldFrame->saved_sp;
1201     newFrame->entry_ip = oldFrame->entry_ip;
1202     newFrame->entry_cs = oldFrame->entry_cs;
1203     newFrame->bp       = oldFrame->bp;
1204     newFrame->ip       = oldFrame->ip;
1205     newFrame->cs       = oldFrame->cs;
1206 }
1207
1208
1209 /***********************************************************************
1210  *           GetTaskQueueDS  (KERNEL.118)
1211  */
1212 #ifndef WINELIB
1213 void GetTaskQueueDS( CONTEXT *context )
1214 {
1215     DS_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
1216 }
1217 #endif  /* WINELIB */
1218
1219
1220 /***********************************************************************
1221  *           GetTaskQueueES  (KERNEL.119)
1222  */
1223 #ifndef WINELIB
1224 void GetTaskQueueES( CONTEXT *context )
1225 {
1226     ES_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
1227 }
1228 #endif  /* WINELIB */
1229
1230
1231 /***********************************************************************
1232  *           GetCurrentTask   (KERNEL.36)
1233  */
1234 HTASK16 GetCurrentTask(void)
1235 {
1236     return hCurrentTask;
1237 }
1238
1239 DWORD WIN16_GetCurrentTask(void)
1240 {
1241     /* This is the version used by relay code; the first task is */
1242     /* returned in the high word of the result */
1243     return MAKELONG( hCurrentTask, hFirstTask );
1244 }
1245
1246
1247 /***********************************************************************
1248  *           GetCurrentPDB   (KERNEL.37)
1249  */
1250 HANDLE16 GetCurrentPDB(void)
1251 {
1252     TDB *pTask;
1253
1254     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1255     return pTask->hPDB;
1256 }
1257
1258
1259 /***********************************************************************
1260  *           GetInstanceData   (KERNEL.54)
1261  */
1262 INT16 GetInstanceData( HINSTANCE16 instance, WORD buffer, INT16 len )
1263 {
1264     char *ptr = (char *)GlobalLock16( instance );
1265     if (!ptr || !len) return 0;
1266     if ((int)buffer + len >= 0x10000) len = 0x10000 - buffer;
1267     memcpy( (char *)GlobalLock16(CURRENT_DS) + buffer, ptr + buffer, len );
1268     return len;
1269 }
1270
1271
1272 /***********************************************************************
1273  *           GetExeVersion   (KERNEL.105)
1274  */
1275 WORD GetExeVersion(void)
1276 {
1277     TDB *pTask;
1278
1279     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1280     return pTask->version;
1281 }
1282
1283
1284 /***********************************************************************
1285  *           SetErrorMode16   (KERNEL.107)
1286  */
1287 UINT16 SetErrorMode16( UINT16 mode )
1288 {
1289     TDB *pTask;
1290     UINT16 oldMode;
1291
1292     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1293     oldMode = pTask->error_mode;
1294     pTask->error_mode = mode;
1295     pTask->thdb->process->error_mode = mode;
1296     return oldMode;
1297 }
1298
1299
1300 /***********************************************************************
1301  *           SetErrorMode32   (KERNEL32.486)
1302  */
1303 UINT32 SetErrorMode32( UINT32 mode )
1304 {
1305     return SetErrorMode16( (UINT16)mode );
1306 }
1307
1308
1309 /***********************************************************************
1310  *           GetDOSEnvironment   (KERNEL.131)
1311  */
1312 SEGPTR GetDOSEnvironment(void)
1313 {
1314     TDB *pTask;
1315
1316     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1317     return (SEGPTR)WIN16_GlobalLock16( pTask->pdb.environment );
1318 }
1319
1320
1321 /***********************************************************************
1322  *           GetNumTasks   (KERNEL.152)
1323  */
1324 UINT16 GetNumTasks(void)
1325 {
1326     return nTaskCount;
1327 }
1328
1329
1330 /***********************************************************************
1331  *           GetTaskDS   (KERNEL.155)
1332  *
1333  * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1334  * I don't think we need to bother with this.
1335  */
1336 HINSTANCE16 GetTaskDS(void)
1337 {
1338     TDB *pTask;
1339
1340     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1341     return pTask->hInstance;
1342 }
1343
1344
1345 /***********************************************************************
1346  *           IsTask   (KERNEL.320)
1347  */
1348 BOOL16 IsTask( HTASK16 hTask )
1349 {
1350     TDB *pTask;
1351
1352     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return FALSE;
1353     if (GlobalSize16( hTask ) < sizeof(TDB)) return FALSE;
1354     return (pTask->magic == TDB_MAGIC);
1355 }
1356
1357
1358 /***********************************************************************
1359  *           SetTaskSignalProc   (KERNEL.38)
1360  */
1361 FARPROC16 SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
1362 {
1363     TDB *pTask;
1364     FARPROC16 oldProc;
1365
1366     if (!hTask) hTask = hCurrentTask;
1367     if (!(pTask = (TDB *)GlobalLock16( hTask ))) return NULL;
1368     oldProc = pTask->userhandler;
1369     pTask->userhandler = proc;
1370     return oldProc;
1371 }
1372
1373
1374 /***********************************************************************
1375  *           SetSigHandler   (KERNEL.140)
1376  */
1377 WORD SetSigHandler( FARPROC16 newhandler, FARPROC16* oldhandler,
1378                     UINT16 *oldmode, UINT16 newmode, UINT16 flag )
1379 {
1380     fprintf(stdnimp,"SetSigHandler(%p,%p,%p,%d,%d), unimplemented.\n",
1381             newhandler,oldhandler,oldmode,newmode,flag );
1382
1383     if (flag != 1) return 0;
1384     if (!newmode) newhandler = NULL;  /* Default handler */
1385     if (newmode != 4)
1386     {
1387         TDB *pTask;
1388
1389         if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1390         if (oldmode) *oldmode = pTask->signal_flags;
1391         pTask->signal_flags = newmode;
1392         if (oldhandler) *oldhandler = pTask->sighandler;
1393         pTask->sighandler = newhandler;
1394     }
1395     return 0;
1396 }
1397
1398
1399 /***********************************************************************
1400  *           GlobalNotify   (KERNEL.154)
1401  */
1402 VOID GlobalNotify( FARPROC16 proc )
1403 {
1404     TDB *pTask;
1405
1406     if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
1407     pTask->discardhandler = proc;
1408 }
1409
1410
1411 /***********************************************************************
1412  *           GetExePtr   (KERNEL.133)
1413  */
1414 HMODULE16 GetExePtr( HANDLE16 handle )
1415 {
1416     char *ptr;
1417     HTASK16 hTask;
1418     HANDLE16 owner;
1419
1420       /* Check for module handle */
1421
1422     if (!(ptr = GlobalLock16( handle ))) return 0;
1423     if (((NE_MODULE *)ptr)->magic == NE_SIGNATURE) return handle;
1424
1425       /* Check the owner for module handle */
1426
1427     owner = FarGetOwner( handle );
1428     if (!(ptr = GlobalLock16( owner ))) return 0;
1429     if (((NE_MODULE *)ptr)->magic == NE_SIGNATURE) return owner;
1430
1431       /* Search for this handle and its owner inside all tasks */
1432
1433     hTask = hFirstTask;
1434     while (hTask)
1435     {
1436         TDB *pTask = (TDB *)GlobalLock16( hTask );
1437         if ((hTask == handle) ||
1438             (pTask->hInstance == handle) ||
1439             (pTask->hQueue == handle) ||
1440             (pTask->hPDB == handle)) return pTask->hModule;
1441         if ((hTask == owner) ||
1442             (pTask->hInstance == owner) ||
1443             (pTask->hQueue == owner) ||
1444             (pTask->hPDB == owner)) return pTask->hModule;
1445         hTask = pTask->hNext;
1446     }
1447     return 0;
1448 }
1449
1450
1451 /***********************************************************************
1452  *           TaskFirst   (TOOLHELP.63)
1453  */
1454 BOOL16 TaskFirst( TASKENTRY *lpte )
1455 {
1456     lpte->hNext = hFirstTask;
1457     return TaskNext( lpte );
1458 }
1459
1460
1461 /***********************************************************************
1462  *           TaskNext   (TOOLHELP.64)
1463  */
1464 BOOL16 TaskNext( TASKENTRY *lpte )
1465 {
1466     TDB *pTask;
1467     INSTANCEDATA *pInstData;
1468
1469     dprintf_toolhelp( stddeb, "TaskNext(%p): task=%04x\n", lpte, lpte->hNext );
1470     if (!lpte->hNext) return FALSE;
1471     pTask = (TDB *)GlobalLock16( lpte->hNext );
1472     if (!pTask || pTask->magic != TDB_MAGIC) return FALSE;
1473     pInstData = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN( pTask->hInstance, 0 );
1474     lpte->hTask         = lpte->hNext;
1475     lpte->hTaskParent   = pTask->hParent;
1476     lpte->hInst         = pTask->hInstance;
1477     lpte->hModule       = pTask->hModule;
1478     lpte->wSS           = pTask->ss;
1479     lpte->wSP           = pTask->sp;
1480     lpte->wStackTop     = pInstData->stacktop;
1481     lpte->wStackMinimum = pInstData->stackmin;
1482     lpte->wStackBottom  = pInstData->stackbottom;
1483     lpte->wcEvents      = pTask->nEvents;
1484     lpte->hQueue        = pTask->hQueue;
1485     strncpy( lpte->szModule, pTask->module_name, 8 );
1486     lpte->szModule[8]   = '\0';
1487     lpte->wPSPOffset    = 0x100;  /*??*/
1488     lpte->hNext         = pTask->hNext;
1489     return TRUE;
1490 }
1491
1492
1493 /***********************************************************************
1494  *           TaskFindHandle   (TOOLHELP.65)
1495  */
1496 BOOL16 TaskFindHandle( TASKENTRY *lpte, HTASK16 hTask )
1497 {
1498     lpte->hNext = hTask;
1499     return TaskNext( lpte );
1500 }
1501
1502
1503 /***********************************************************************
1504  *           GetAppCompatFlags   (KERNEL.354) (USER32.205)
1505  */
1506 DWORD GetAppCompatFlags( HTASK32 hTask )
1507 {
1508     TDB *pTask;
1509
1510     if (!hTask) hTask = GetCurrentTask();
1511     if (!(pTask=(TDB *)GlobalLock16( (HTASK16)hTask ))) return 0;
1512     if (GlobalSize16(hTask) < sizeof(TDB)) return 0;
1513     return pTask->compat_flags;
1514 }