scheduler/process.c

   1 /*
   2  * Win32 processes
   3  *
   4  * Copyright 1996, 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include "process.h"
  12 #include "module.h"
  13 #include "file.h"
  14 #include "global.h"
  15 #include "heap.h"
  16 #include "task.h"
  17 #include "ldt.h"
  18 #include "thread.h"
  19 #include "winerror.h"
  20 #include "pe_image.h"
  21 #include "task.h"
  22 #include "server.h"
  23 #include "debug.h"
  24
  25 static BOOL32 PROCESS_Signaled( K32OBJ *obj, DWORD thread_id );
  26 static BOOL32 PROCESS_Satisfied( K32OBJ *obj, DWORD thread_id );
  27 static void PROCESS_AddWait( K32OBJ *obj, DWORD thread_id );
  28 static void PROCESS_RemoveWait( K32OBJ *obj, DWORD thread_id );
  29 static void PROCESS_Destroy( K32OBJ *obj );
  30
  31 const K32OBJ_OPS PROCESS_Ops =
  32 {
  33     PROCESS_Signaled,    /* signaled */
  34     PROCESS_Satisfied,   /* satisfied */
  35     PROCESS_AddWait,     /* add_wait */
  36     PROCESS_RemoveWait,  /* remove_wait */
  37     NULL,                /* read */
  38     NULL,                /* write */
  39     PROCESS_Destroy      /* destroy */
  40 };
  41
  42
  43 /***********************************************************************
  44  *           PROCESS_Current
  45  */
  46 PDB32 *PROCESS_Current(void)
  47 {
  48     return THREAD_Current()->process;
  49 }
  50
  51
  52 /***********************************************************************
  53  *           PROCESS_GetPtr
  54  *
  55  * Get a process from a handle, incrementing the PDB refcount.
  56  */
  57 PDB32 *PROCESS_GetPtr( HANDLE32 handle, DWORD access, int *server_handle )
  58 {
  59     return (PDB32 *)HANDLE_GetObjPtr( PROCESS_Current(), handle,
  60                                      K32OBJ_PROCESS, access, server_handle );
  61 }
  62
  63
  64 /***********************************************************************
  65  *           PROCESS_IdToPDB
  66  *
  67  * Convert a process id to a PDB, making sure it is valid.
  68  */
  69 PDB32 *PROCESS_IdToPDB( DWORD id )
  70 {
  71     PDB32 *pdb;
  72
  73     if (!id) return PROCESS_Current();
  74     pdb = PROCESS_ID_TO_PDB( id );
  75     if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS ))
  76     {
  77         SetLastError( ERROR_INVALID_PARAMETER );
  78         return NULL;
  79     }
  80     return pdb;
  81 }
  82
  83
  84
  85 /***********************************************************************
  86  *           PROCESS_BuildEnvDB
  87  *
  88  * Build the env DB for the initial process
  89  */
  90 static BOOL32 PROCESS_BuildEnvDB( PDB32 *pdb )
  91 {
  92     /* Allocate the env DB (FIXME: should not be on the system heap) */
  93
  94     if (!(pdb->env_db = HeapAlloc(SystemHeap,HEAP_ZERO_MEMORY,sizeof(ENVDB))))
  95         return FALSE;
  96     InitializeCriticalSection( &pdb->env_db->section );
  97
  98     /* Allocate the standard handles */
  99
 100     pdb->env_db->hStdin  = FILE_DupUnixHandle( 0 );
 101     pdb->env_db->hStdout = FILE_DupUnixHandle( 1 );
 102     pdb->env_db->hStderr = FILE_DupUnixHandle( 2 );
 103     FILE_SetFileType( pdb->env_db->hStdin,  FILE_TYPE_CHAR );
 104     FILE_SetFileType( pdb->env_db->hStdout, FILE_TYPE_CHAR );
 105     FILE_SetFileType( pdb->env_db->hStderr, FILE_TYPE_CHAR );
 106
 107     /* Build the command-line */
 108
 109     pdb->env_db->cmd_line = HEAP_strdupA( SystemHeap, 0, "kernel32" );
 110
 111     /* Build the environment strings */
 112
 113     return ENV_BuildEnvironment( pdb );
 114 }
 115
 116
 117 /***********************************************************************
 118  *           PROCESS_InheritEnvDB
 119  */
 120 static BOOL32 PROCESS_InheritEnvDB( PDB32 *pdb, LPCSTR cmd_line, LPCSTR env,
 121                                     STARTUPINFO32A *startup )
 122 {
 123     if (!(pdb->env_db = HeapAlloc(pdb->heap, HEAP_ZERO_MEMORY, sizeof(ENVDB))))
 124         return FALSE;
 125     InitializeCriticalSection( &pdb->env_db->section );
 126
 127     /* Copy the parent environment */
 128
 129     if (!ENV_InheritEnvironment( pdb, env )) return FALSE;
 130
 131     /* Copy the command line */
 132
 133     if (!(pdb->env_db->cmd_line = HEAP_strdupA( pdb->heap, 0, cmd_line )))
 134         return FALSE;
 135
 136     /* Remember startup info */
 137     if (!(pdb->env_db->startup_info =
 138           HeapAlloc( pdb->heap, HEAP_ZERO_MEMORY, sizeof(STARTUPINFO32A) )))
 139         return FALSE;
 140     *pdb->env_db->startup_info = *startup;
 141
 142     /* Inherit the standard handles */
 143     if (pdb->env_db->startup_info->dwFlags & STARTF_USESTDHANDLES)
 144     {
 145         pdb->env_db->hStdin  = pdb->env_db->startup_info->hStdInput;
 146         pdb->env_db->hStdout = pdb->env_db->startup_info->hStdOutput;
 147         pdb->env_db->hStderr = pdb->env_db->startup_info->hStdError;
 148     }
 149     else
 150     {
 151         pdb->env_db->hStdin  = pdb->parent->env_db->hStdin;
 152         pdb->env_db->hStdout = pdb->parent->env_db->hStdout;
 153         pdb->env_db->hStderr = pdb->parent->env_db->hStderr;
 154     }
 155
 156     return TRUE;
 157 }
 158
 159
 160 /***********************************************************************
 161  *           PROCESS_FreePDB
 162  *
 163  * Free a PDB and all associated storage.
 164  */
 165 static void PROCESS_FreePDB( PDB32 *pdb )
 166 {
 167     pdb->header.type = K32OBJ_UNKNOWN;
 168     if (pdb->handle_table) HANDLE_CloseAll( pdb, NULL );
 169     ENV_FreeEnvironment( pdb );
 170     if (pdb->heap && (pdb->heap != pdb->system_heap)) HeapDestroy( pdb->heap );
 171     if (pdb->load_done_evt) K32OBJ_DecCount( pdb->load_done_evt );
 172     if (pdb->event) K32OBJ_DecCount( pdb->event );
 173     DeleteCriticalSection( &pdb->crit_section );
 174     HeapFree( SystemHeap, 0, pdb );
 175 }
 176
 177
 178 /***********************************************************************
 179  *           PROCESS_CreatePDB
 180  *
 181  * Allocate and fill a PDB structure.
 182  * Runs in the context of the parent process.
 183  */
 184 static PDB32 *PROCESS_CreatePDB( PDB32 *parent )
 185 {
 186     PDB32 *pdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(PDB32) );
 187
 188     if (!pdb) return NULL;
 189     pdb->header.type     = K32OBJ_PROCESS;
 190     pdb->header.refcount = 1;
 191     pdb->exit_code       = 0x103; /* STILL_ACTIVE */
 192     pdb->threads         = 1;
 193     pdb->running_threads = 1;
 194     pdb->ring0_threads   = 1;
 195     pdb->system_heap     = SystemHeap;
 196     pdb->parent          = parent;
 197     pdb->group           = pdb;
 198     pdb->priority        = 8;  /* Normal */
 199     pdb->heap            = pdb->system_heap;  /* will be changed later on */
 200
 201     InitializeCriticalSection( &pdb->crit_section );
 202
 203     /* Allocate the events */
 204
 205     if (!(pdb->event = EVENT_Create( TRUE, FALSE ))) goto error;
 206     if (!(pdb->load_done_evt = EVENT_Create( TRUE, FALSE ))) goto error;
 207
 208     /* Create the handle table */
 209
 210     if (!HANDLE_CreateTable( pdb, TRUE )) goto error;
 211
 212     return pdb;
 213
 214 error:
 215     PROCESS_FreePDB( pdb );
 216     return NULL;
 217 }
 218
 219
 220 /***********************************************************************
 221  *           PROCESS_Init
 222  */
 223 BOOL32 PROCESS_Init(void)
 224 {
 225     PDB32 *pdb;
 226     THDB *thdb;
 227
 228     /* Initialize virtual memory management */
 229     if (!VIRTUAL_Init()) return FALSE;
 230
 231     /* Create the system and SEGPTR heaps */
 232     if (!(SystemHeap = HeapCreate( HEAP_GROWABLE, 0x10000, 0 ))) return FALSE;
 233     if (!(SegptrHeap = HeapCreate( HEAP_WINE_SEGPTR, 0, 0 ))) return FALSE;
 234
 235     /* Create the initial process and thread structures */
 236     if (!(pdb = PROCESS_CreatePDB( NULL ))) return FALSE;
 237     if (!(thdb = THREAD_Create( pdb, 0, FALSE, NULL, NULL, NULL, NULL ))) return FALSE;
 238     thdb->unix_pid = getpid();
 239
 240     /* Create the environment DB of the first process */
 241     if (!PROCESS_BuildEnvDB( pdb )) return FALSE;
 242
 243     /* Initialize the first thread */
 244     if (CLIENT_InitThread()) return FALSE;
 245
 246     return TRUE;
 247 }
 248
 249
 250 /***********************************************************************
 251  *           PROCESS_Create
 252  *
 253  * Create a new process database and associated info.
 254  */
 255 PDB32 *PROCESS_Create( NE_MODULE *pModule, LPCSTR cmd_line, LPCSTR env,
 256                        HINSTANCE16 hInstance, HINSTANCE16 hPrevInstance,
 257                        STARTUPINFO32A *startup, PROCESS_INFORMATION *info )
 258 {
 259     DWORD size, commit;
 260     int server_thandle, server_phandle;
 261     UINT32 cmdShow = 0;
 262     THDB *thdb = NULL;
 263     PDB32 *parent = PROCESS_Current();
 264     PDB32 *pdb = PROCESS_CreatePDB( parent );
 265     TDB *pTask;
 266
 267     if (!pdb) return NULL;
 268     info->hThread = info->hProcess = INVALID_HANDLE_VALUE32;
 269
 270     /* Create the heap */
 271
 272     if (pModule->module32)
 273     {
 274         size  = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapReserve;
 275         commit = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapCommit;
 276     }
 277     else
 278     {
 279         size = 0x10000;
 280         commit = 0;
 281         pdb->flags |= PDB32_WIN16_PROC;  /* This is a Win16 process */
 282     }
 283     if (!(pdb->heap = HeapCreate( HEAP_GROWABLE, size, commit ))) goto error;
 284     pdb->heap_list = pdb->heap;
 285
 286     /* Inherit the env DB from the parent */
 287
 288     if (!PROCESS_InheritEnvDB( pdb, cmd_line, env, startup )) goto error;
 289
 290     /* Create the main thread */
 291
 292     if (pModule->module32)
 293         size = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfStackReserve;
 294     else
 295         size = 0;
 296     if (!(thdb = THREAD_Create( pdb, size, FALSE, &server_thandle, &server_phandle,
 297                                 NULL, NULL ))) goto error;
 298     if ((info->hThread = HANDLE_Alloc( parent, &thdb->header, THREAD_ALL_ACCESS,
 299                                        FALSE, server_thandle )) == INVALID_HANDLE_VALUE32)
 300         goto error;
 301     if ((info->hProcess = HANDLE_Alloc( parent, &pdb->header, PROCESS_ALL_ACCESS,
 302                                         FALSE, server_phandle )) == INVALID_HANDLE_VALUE32)
 303         goto error;
 304     info->dwProcessId = PDB_TO_PROCESS_ID(pdb);
 305     info->dwThreadId  = THDB_TO_THREAD_ID(thdb);
 306
 307 #if 0
 308     thdb->unix_pid = getpid(); /* FIXME: wrong here ... */
 309 #else
 310     /* All Win16 'threads' have the same unix_pid, no matter by which thread
 311        they were created ! */
 312     pTask = (TDB *)GlobalLock16( parent->task );
 313     thdb->unix_pid = pTask? pTask->thdb->unix_pid : THREAD_Current()->unix_pid;
 314 #endif
 315
 316     /* Create a Win16 task for this process */
 317
 318     if (startup->dwFlags & STARTF_USESHOWWINDOW)
 319         cmdShow = startup->wShowWindow;
 320
 321     pdb->task = TASK_Create( thdb, pModule, hInstance, hPrevInstance, cmdShow);
 322     if (!pdb->task) goto error;
 323
 324     return pdb;
 325
 326 error:
 327     if (info->hThread != INVALID_HANDLE_VALUE32) CloseHandle( info->hThread );
 328     if (info->hProcess != INVALID_HANDLE_VALUE32) CloseHandle( info->hProcess );
 329     if (thdb) K32OBJ_DecCount( &thdb->header );
 330     PROCESS_FreePDB( pdb );
 331     return NULL;
 332 }
 333
 334
 335 /***********************************************************************
 336  *           PROCESS_Signaled
 337  */
 338 static BOOL32 PROCESS_Signaled( K32OBJ *obj, DWORD thread_id )
 339 {
 340     PDB32 *pdb = (PDB32 *)obj;
 341     assert( obj->type == K32OBJ_PROCESS );
 342     return K32OBJ_OPS( pdb->event )->signaled( pdb->event, thread_id );
 343 }
 344
 345
 346 /***********************************************************************
 347  *           PROCESS_Satisfied
 348  *
 349  * Wait on this object has been satisfied.
 350  */
 351 static BOOL32 PROCESS_Satisfied( K32OBJ *obj, DWORD thread_id )
 352 {
 353     PDB32 *pdb = (PDB32 *)obj;
 354     assert( obj->type == K32OBJ_PROCESS );
 355     return K32OBJ_OPS( pdb->event )->satisfied( pdb->event, thread_id );
 356 }
 357
 358
 359 /***********************************************************************
 360  *           PROCESS_AddWait
 361  *
 362  * Add thread to object wait queue.
 363  */
 364 static void PROCESS_AddWait( K32OBJ *obj, DWORD thread_id )
 365 {
 366     PDB32 *pdb = (PDB32 *)obj;
 367     assert( obj->type == K32OBJ_PROCESS );
 368     return K32OBJ_OPS( pdb->event )->add_wait( pdb->event, thread_id );
 369 }
 370
 371
 372 /***********************************************************************
 373  *           PROCESS_RemoveWait
 374  *
 375  * Remove thread from object wait queue.
 376  */
 377 static void PROCESS_RemoveWait( K32OBJ *obj, DWORD thread_id )
 378 {
 379     PDB32 *pdb = (PDB32 *)obj;
 380     assert( obj->type == K32OBJ_PROCESS );
 381     return K32OBJ_OPS( pdb->event )->remove_wait( pdb->event, thread_id );
 382 }
 383
 384
 385 /***********************************************************************
 386  *           PROCESS_Destroy
 387  */
 388 static void PROCESS_Destroy( K32OBJ *ptr )
 389 {
 390     PDB32 *pdb = (PDB32 *)ptr;
 391     assert( ptr->type == K32OBJ_PROCESS );
 392
 393     /* Free everything */
 394
 395     ptr->type = K32OBJ_UNKNOWN;
 396     PROCESS_FreePDB( pdb );
 397 }
 398
 399
 400 /***********************************************************************
 401  *           ExitProcess   (KERNEL32.100)
 402  */
 403 void WINAPI ExitProcess( DWORD status )
 404 {
 405     PDB32 *pdb = PROCESS_Current();
 406     TDB *pTask = (TDB *)GlobalLock16( pdb->task );
 407     if ( pTask ) pTask->nEvents++;
 408
 409     if ( pTask && pTask->thdb != THREAD_Current() )
 410         ExitThread( status );
 411
 412     SYSTEM_LOCK();
 413     /* FIXME: should kill all running threads of this process */
 414     pdb->exit_code = status;
 415     EVENT_Set( pdb->event );
 416     if (pdb->console) FreeConsole();
 417     SYSTEM_UNLOCK();
 418
 419     __RESTORE_ES;  /* Necessary for Pietrek's showseh example program */
 420     TASK_KillCurrentTask( status );
 421 }
 422
 423
 424 /******************************************************************************
 425  *           TerminateProcess   (KERNEL32.684)
 426  */
 427 BOOL32 WINAPI TerminateProcess( HANDLE32 handle, DWORD exit_code )
 428 {
 429     int server_handle;
 430     BOOL32 ret;
 431     PDB32 *pdb = PROCESS_GetPtr( handle, PROCESS_TERMINATE, &server_handle );
 432     if (!pdb) return FALSE;
 433     ret = !CLIENT_TerminateProcess( server_handle, exit_code );
 434     K32OBJ_DecCount( &pdb->header );
 435     return ret;
 436 }
 437
 438 /***********************************************************************
 439  *           GetCurrentProcess   (KERNEL32.198)
 440  */
 441 HANDLE32 WINAPI GetCurrentProcess(void)
 442 {
 443     return CURRENT_PROCESS_PSEUDOHANDLE;
 444 }
 445
 446
 447 /*********************************************************************
 448  *           OpenProcess   (KERNEL32.543)
 449  */
 450 HANDLE32 WINAPI OpenProcess( DWORD access, BOOL32 inherit, DWORD id )
 451 {
 452     int server_handle;
 453     PDB32 *pdb = PROCESS_ID_TO_PDB(id);
 454     if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS ))
 455     {
 456         SetLastError( ERROR_INVALID_HANDLE );
 457         return 0;
 458     }
 459     if ((server_handle = CLIENT_OpenProcess( pdb->server_pid, access, inherit )) == -1)
 460     {
 461         SetLastError( ERROR_INVALID_HANDLE );
 462         return 0;
 463     }
 464     return HANDLE_Alloc( PROCESS_Current(), &pdb->header, access,
 465                          inherit, server_handle );
 466 }
 467
 468
 469 /***********************************************************************
 470  *           GetCurrentProcessId   (KERNEL32.199)
 471  */
 472 DWORD WINAPI GetCurrentProcessId(void)
 473 {
 474     PDB32 *pdb = PROCESS_Current();
 475     return PDB_TO_PROCESS_ID( pdb );
 476 }
 477
 478
 479 /***********************************************************************
 480  *           GetProcessHeap    (KERNEL32.259)
 481  */
 482 HANDLE32 WINAPI GetProcessHeap(void)
 483 {
 484     PDB32 *pdb = PROCESS_Current();
 485     return pdb->heap ? pdb->heap : SystemHeap;
 486 }
 487
 488
 489 /***********************************************************************
 490  *           GetThreadLocale    (KERNEL32.295)
 491  */
 492 LCID WINAPI GetThreadLocale(void)
 493 {
 494     return PROCESS_Current()->locale;
 495 }
 496
 497
 498 /***********************************************************************
 499  *           SetPriorityClass   (KERNEL32.503)
 500  */
 501 BOOL32 WINAPI SetPriorityClass( HANDLE32 hprocess, DWORD priorityclass )
 502 {
 503     PDB32 *pdb = PROCESS_GetPtr( hprocess, PROCESS_SET_INFORMATION, NULL );
 504     if (!pdb) return FALSE;
 505     switch (priorityclass)
 506     {
 507     case NORMAL_PRIORITY_CLASS:
 508         pdb->priority = 0x00000008;
 509         break;
 510     case IDLE_PRIORITY_CLASS:
 511         pdb->priority = 0x00000004;
 512         break;
 513     case HIGH_PRIORITY_CLASS:
 514         pdb->priority = 0x0000000d;
 515         break;
 516     case REALTIME_PRIORITY_CLASS:
 517         pdb->priority = 0x00000018;
 518         break;
 519     default:
 520         WARN(process,"Unknown priority class %ld\n",priorityclass);
 521         break;
 522     }
 523     K32OBJ_DecCount( &pdb->header );
 524     return TRUE;
 525 }
 526
 527
 528 /***********************************************************************
 529  *           GetPriorityClass   (KERNEL32.250)
 530  */
 531 DWORD WINAPI GetPriorityClass(HANDLE32 hprocess)
 532 {
 533     PDB32 *pdb = PROCESS_GetPtr( hprocess, PROCESS_QUERY_INFORMATION, NULL );
 534     DWORD ret = 0;
 535     if (pdb)
 536     {
 537         switch (pdb->priority)
 538         {
 539         case 0x00000008:
 540             ret = NORMAL_PRIORITY_CLASS;
 541             break;
 542         case 0x00000004:
 543             ret = IDLE_PRIORITY_CLASS;
 544             break;
 545         case 0x0000000d:
 546             ret = HIGH_PRIORITY_CLASS;
 547             break;
 548         case 0x00000018:
 549             ret = REALTIME_PRIORITY_CLASS;
 550             break;
 551         default:
 552             WARN(process,"Unknown priority %ld\n",pdb->priority);
 553         }
 554         K32OBJ_DecCount( &pdb->header );
 555     }
 556     return ret;
 557 }
 558
 559
 560 /***********************************************************************
 561  *           GetStdHandle    (KERNEL32.276)
 562  *
 563  * FIXME: These should be allocated when a console is created, or inherited
 564  *        from the parent.
 565  */
 566 HANDLE32 WINAPI GetStdHandle( DWORD std_handle )
 567 {
 568     HFILE32 hFile;
 569     int fd;
 570     PDB32 *pdb = PROCESS_Current();
 571
 572     switch(std_handle)
 573     {
 574     case STD_INPUT_HANDLE:
 575         if (pdb->env_db->hStdin) return pdb->env_db->hStdin;
 576         fd = 0;
 577         break;
 578     case STD_OUTPUT_HANDLE:
 579         if (pdb->env_db->hStdout) return pdb->env_db->hStdout;
 580         fd = 1;
 581         break;
 582     case STD_ERROR_HANDLE:
 583         if (pdb->env_db->hStderr) return pdb->env_db->hStderr;
 584         fd = 2;
 585         break;
 586     default:
 587         SetLastError( ERROR_INVALID_PARAMETER );
 588         return INVALID_HANDLE_VALUE32;
 589     }
 590     hFile = FILE_DupUnixHandle( fd );
 591     if (hFile != HFILE_ERROR32)
 592     {
 593         FILE_SetFileType( hFile, FILE_TYPE_CHAR );
 594         switch(std_handle)
 595         {
 596         case STD_INPUT_HANDLE:  pdb->env_db->hStdin  = hFile; break;
 597         case STD_OUTPUT_HANDLE: pdb->env_db->hStdout = hFile; break;
 598         case STD_ERROR_HANDLE:  pdb->env_db->hStderr = hFile; break;
 599         }
 600     }
 601     return hFile;
 602 }
 603
 604
 605 /***********************************************************************
 606  *           SetStdHandle    (KERNEL32.506)
 607  */
 608 BOOL32 WINAPI SetStdHandle( DWORD std_handle, HANDLE32 handle )
 609 {
 610     PDB32 *pdb = PROCESS_Current();
 611     /* FIXME: should we close the previous handle? */
 612     switch(std_handle)
 613     {
 614     case STD_INPUT_HANDLE:
 615         pdb->env_db->hStdin = handle;
 616         return TRUE;
 617     case STD_OUTPUT_HANDLE:
 618         pdb->env_db->hStdout = handle;
 619         return TRUE;
 620     case STD_ERROR_HANDLE:
 621         pdb->env_db->hStderr = handle;
 622         return TRUE;
 623     }
 624     SetLastError( ERROR_INVALID_PARAMETER );
 625     return FALSE;
 626 }
 627
 628 /***********************************************************************
 629  *           GetProcessVersion    (KERNEL32)
 630  */
 631 DWORD WINAPI GetProcessVersion( DWORD processid )
 632 {
 633     TDB *pTask;
 634     PDB32 *pdb = PROCESS_IdToPDB( processid );
 635
 636     if (!pdb) return 0;
 637     if (!(pTask = (TDB *)GlobalLock16( pdb->task ))) return 0;
 638     return (pTask->version&0xff) | (((pTask->version >>8) & 0xff)<<16);
 639 }
 640
 641 /***********************************************************************
 642  *           GetProcessFlags    (KERNEL32)
 643  */
 644 DWORD WINAPI GetProcessFlags( DWORD processid )
 645 {
 646     PDB32 *pdb = PROCESS_IdToPDB( processid );
 647     if (!pdb) return 0;
 648     return pdb->flags;
 649 }
 650
 651 /***********************************************************************
 652  *              SetProcessWorkingSetSize        [KERNEL32.662]
 653  * Sets the min/max working set sizes for a specified process.
 654  *
 655  * PARAMS
 656  *    hProcess [I] Handle to the process of interest
 657  *    minset   [I] Specifies minimum working set size
 658  *    maxset   [I] Specifies maximum working set size
 659  *
 660  * RETURNS  STD
 661  */
 662 BOOL32 WINAPI SetProcessWorkingSetSize(HANDLE32 hProcess,DWORD minset,
 663                                        DWORD maxset)
 664 {
 665     FIXME(process,"(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
 666     if(( minset == -1) && (maxset == -1)) {
 667         /* Trim the working set to zero */
 668         /* Swap the process out of physical RAM */
 669     }
 670     return TRUE;
 671 }
 672
 673 /***********************************************************************
 674  *           GetProcessWorkingSetSize    (KERNEL32)
 675  */
 676 BOOL32 WINAPI GetProcessWorkingSetSize(HANDLE32 hProcess,LPDWORD minset,
 677                                        LPDWORD maxset)
 678 {
 679         FIXME(process,"(0x%08x,%p,%p): stub\n",hProcess,minset,maxset);
 680         /* 32 MB working set size */
 681         if (minset) *minset = 32*1024*1024;
 682         if (maxset) *maxset = 32*1024*1024;
 683         return TRUE;
 684 }
 685
 686 /***********************************************************************
 687  *           SetProcessShutdownParameters    (KERNEL32)
 688  */
 689 BOOL32 WINAPI SetProcessShutdownParameters(DWORD level,DWORD flags)
 690 {
 691     FIXME(process,"(%ld,0x%08lx): stub\n",level,flags);
 692     return TRUE;
 693 }
 694
 695 /***********************************************************************
 696  *           ReadProcessMemory                  (KERNEL32)
 697  * FIXME: check this, if we ever run win32 binaries in different addressspaces
 698  *        ... and add a sizecheck
 699  */
 700 BOOL32 WINAPI ReadProcessMemory( HANDLE32 hProcess, LPCVOID lpBaseAddress,
 701                                  LPVOID lpBuffer, DWORD nSize,
 702                                  LPDWORD lpNumberOfBytesRead )
 703 {
 704         memcpy(lpBuffer,lpBaseAddress,nSize);
 705         if (lpNumberOfBytesRead) *lpNumberOfBytesRead = nSize;
 706         return TRUE;
 707 }
 708
 709 /***********************************************************************
 710  *           WriteProcessMemory                 (KERNEL32)
 711  * FIXME: check this, if we ever run win32 binaries in different addressspaces
 712  *        ... and add a sizecheck
 713  */
 714 BOOL32 WINAPI WriteProcessMemory(HANDLE32 hProcess, LPVOID lpBaseAddress,
 715                                  LPVOID lpBuffer, DWORD nSize,
 716                                  LPDWORD lpNumberOfBytesWritten )
 717 {
 718         memcpy(lpBaseAddress,lpBuffer,nSize);
 719         if (lpNumberOfBytesWritten) *lpNumberOfBytesWritten = nSize;
 720         return TRUE;
 721 }
 722
 723 /***********************************************************************
 724  *           ConvertToGlobalHandle              (KERNEL32)
 725  * FIXME: this is not correctly implemented...
 726  */
 727 HANDLE32 WINAPI ConvertToGlobalHandle(HANDLE32 h)
 728 {
 729         FIXME(process,"(%d): stub\n",h);
 730         return h;
 731 }
 732
 733 /***********************************************************************
 734  *           RegisterServiceProcess             (KERNEL32)
 735  *
 736  * A service process calls this function to ensure that it continues to run
 737  * even after a user logged off.
 738  */
 739 DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
 740 {
 741         /* I don't think that Wine needs to do anything in that function */
 742         return 1; /* success */
 743 }
 744
 745 /***********************************************************************
 746  * GetExitCodeProcess [KERNEL32.325]
 747  *
 748  * Gets termination status of specified process
 749  *
 750  * RETURNS
 751  *   Success: TRUE
 752  *   Failure: FALSE
 753  *
 754  * FIXME
 755  *   Should call SetLastError (but doesn't).
 756  */
 757 BOOL32 WINAPI GetExitCodeProcess(
 758     HANDLE32 hProcess,  /* [I] handle to the process */
 759     LPDWORD lpExitCode) /* [O] address to receive termination status */
 760 {
 761     PDB32 *process;
 762     int server_handle;
 763     struct get_process_info_reply info;
 764
 765     if (!(process = PROCESS_GetPtr( hProcess, PROCESS_QUERY_INFORMATION,
 766                                     &server_handle )))
 767         return FALSE;
 768     if (server_handle != -1)
 769     {
 770         CLIENT_GetProcessInfo( server_handle, &info );
 771         if (lpExitCode) *lpExitCode = info.exit_code;
 772     }
 773     else if (lpExitCode) *lpExitCode = process->exit_code;
 774     K32OBJ_DecCount( &process->header );
 775     return TRUE;
 776 }
 777
 778 /***********************************************************************
 779  * GetProcessHeaps [KERNEL32.376]
 780  */
 781 DWORD WINAPI GetProcessHeaps(DWORD nrofheaps,HANDLE32 *heaps) {
 782         FIXME(win32,"(%ld,%p), incomplete implementation.\n",nrofheaps,heaps);
 783
 784         if (nrofheaps) {
 785                 heaps[0] = GetProcessHeap();
 786                 /* ... probably SystemHeap too ? */
 787                 return 1;
 788         }
 789         /* number of available heaps */
 790         return 1;
 791 }
 792
 793 /***********************************************************************
 794  * PROCESS_SuspendOtherThreads
 795  */
 796
 797 void PROCESS_SuspendOtherThreads(void)
 798 {
 799     PDB32 *pdb;
 800     THREAD_ENTRY *entry;
 801
 802     SYSTEM_LOCK();
 803
 804     pdb = PROCESS_Current();
 805     entry = pdb->thread_list->next;
 806     for (;;)
 807     {
 808          if (entry->thread != THREAD_Current() && !THREAD_IsWin16(entry->thread))
 809          {
 810              HANDLE32 handle = HANDLE_Alloc( PROCESS_Current(),
 811                                              &entry->thread->header,
 812                                              THREAD_ALL_ACCESS, FALSE, -1 );
 813              SuspendThread(handle);
 814              CloseHandle(handle);
 815          }
 816          if (entry == pdb->thread_list) break;
 817          entry = entry->next;
 818     }
 819
 820     SYSTEM_UNLOCK();
 821 }
 822
 823 /***********************************************************************
 824  * PROCESS_ResumeOtherThreads
 825  */
 826
 827 void PROCESS_ResumeOtherThreads(void)
 828 {
 829     PDB32 *pdb;
 830     THREAD_ENTRY *entry;
 831
 832     SYSTEM_LOCK();
 833
 834     pdb = PROCESS_Current();
 835     entry = pdb->thread_list->next;
 836     for (;;)
 837     {
 838          if (entry->thread != THREAD_Current() && !THREAD_IsWin16(entry->thread))
 839          {
 840              HANDLE32 handle = HANDLE_Alloc( PROCESS_Current(),
 841                                              &entry->thread->header,
 842                                              THREAD_ALL_ACCESS, FALSE, -1 );
 843              ResumeThread(handle);
 844              CloseHandle(handle);
 845          }
 846          if (entry == pdb->thread_list) break;
 847          entry = entry->next;
 848     }
 849
 850     SYSTEM_UNLOCK();
 851 }
 852