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