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