dlls/ntdll/process.c

   1 /*
   2  * NT basis DLL
   3  *
   4  * This file contains the Nt* API functions of NTDLL.DLL.
   5  * In the original ntdll.dll they all seem to just call int 0x2e (down to the NTOSKRNL)
   6  *
   7  * Copyright 1996-1998 Marcus Meissner
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <time.h>
  31 #ifdef HAVE_UNISTD_H
  32 # include <unistd.h>
  33 #endif
  34
  35 #include "ntstatus.h"
  36 #define WIN32_NO_STATUS
  37 #include "wine/debug.h"
  38 #include "windef.h"
  39 #include "winternl.h"
  40 #include "ntdll_misc.h"
  41 #include "wine/server.h"
  42
  43 #ifdef HAVE_MACH_MACH_H
  44 #include <mach/mach.h>
  45 #endif
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  48
  49 static ULONG execute_flags = MEM_EXECUTE_OPTION_DISABLE;
  50
  51 /*
  52  *      Process object
  53  */
  54
  55 /******************************************************************************
  56  *  NtTerminateProcess                  [NTDLL.@]
  57  *
  58  *  Native applications must kill themselves when done
  59  */
  60 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code )
  61 {
  62     NTSTATUS ret;
  63     BOOL self;
  64     SERVER_START_REQ( terminate_process )
  65     {
  66         req->handle    = wine_server_obj_handle( handle );
  67         req->exit_code = exit_code;
  68         ret = wine_server_call( req );
  69         self = !ret && reply->self;
  70     }
  71     SERVER_END_REQ;
  72     if (self && handle) _exit( exit_code );
  73     return ret;
  74 }
  75
  76 /******************************************************************************
  77  *  RtlGetCurrentPeb  [NTDLL.@]
  78  *
  79  */
  80 PEB * WINAPI RtlGetCurrentPeb(void)
  81 {
  82     return NtCurrentTeb()->Peb;
  83 }
  84
  85 /***********************************************************************
  86  *           __wine_make_process_system   (NTDLL.@)
  87  *
  88  * Mark the current process as a system process.
  89  * Returns the event that is signaled when all non-system processes have exited.
  90  */
  91 HANDLE CDECL __wine_make_process_system(void)
  92 {
  93     HANDLE ret = 0;
  94     SERVER_START_REQ( make_process_system )
  95     {
  96         if (!wine_server_call( req )) ret = wine_server_ptr_handle( reply->event );
  97     }
  98     SERVER_END_REQ;
  99     return ret;
 100 }
 101
 102 static UINT process_error_mode;
 103
 104 #define UNIMPLEMENTED_INFO_CLASS(c) \
 105     case c: \
 106         FIXME("(process=%p) Unimplemented information class: " #c "\n", ProcessHandle); \
 107         ret = STATUS_INVALID_INFO_CLASS; \
 108         break
 109
 110 ULONG_PTR get_system_affinity_mask(void)
 111 {
 112     ULONG num_cpus = NtCurrentTeb()->Peb->NumberOfProcessors;
 113     if (num_cpus >= sizeof(ULONG_PTR) * 8) return ~(ULONG_PTR)0;
 114     return ((ULONG_PTR)1 << num_cpus) - 1;
 115 }
 116
 117 #if defined(HAVE_MACH_MACH_H)
 118
 119 static void fill_VM_COUNTERS(VM_COUNTERS* pvmi)
 120 {
 121 #if defined(MACH_TASK_BASIC_INFO)
 122     struct mach_task_basic_info info;
 123     mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
 124     if(task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &infoCount) == KERN_SUCCESS)
 125     {
 126         pvmi->VirtualSize = info.resident_size + info.virtual_size;
 127         pvmi->PagefileUsage = info.virtual_size;
 128         pvmi->WorkingSetSize = info.resident_size;
 129         pvmi->PeakWorkingSetSize = info.resident_size_max;
 130     }
 131 #endif
 132 }
 133
 134 #elif defined(linux)
 135
 136 static void fill_VM_COUNTERS(VM_COUNTERS* pvmi)
 137 {
 138     FILE *f;
 139     char line[256];
 140     unsigned long value;
 141
 142     f = fopen("/proc/self/status", "r");
 143     if (!f) return;
 144
 145     while (fgets(line, sizeof(line), f))
 146     {
 147         if (sscanf(line, "VmPeak: %lu", &value))
 148             pvmi->PeakVirtualSize = (ULONG64)value * 1024;
 149         else if (sscanf(line, "VmSize: %lu", &value))
 150             pvmi->VirtualSize = (ULONG64)value * 1024;
 151         else if (sscanf(line, "VmHWM: %lu", &value))
 152             pvmi->PeakWorkingSetSize = (ULONG64)value * 1024;
 153         else if (sscanf(line, "VmRSS: %lu", &value))
 154             pvmi->WorkingSetSize = (ULONG64)value * 1024;
 155         else if (sscanf(line, "RssAnon: %lu", &value))
 156             pvmi->PagefileUsage += (ULONG64)value * 1024;
 157         else if (sscanf(line, "VmSwap: %lu", &value))
 158             pvmi->PagefileUsage += (ULONG64)value * 1024;
 159     }
 160     pvmi->PeakPagefileUsage = pvmi->PagefileUsage;
 161
 162     fclose(f);
 163 }
 164
 165 #else
 166
 167 static void fill_VM_COUNTERS(VM_COUNTERS* pvmi)
 168 {
 169     /* FIXME : real data */
 170 }
 171
 172 #endif
 173
 174 /******************************************************************************
 175 *  NtQueryInformationProcess            [NTDLL.@]
 176 *  ZwQueryInformationProcess            [NTDLL.@]
 177 *
 178 */
 179 NTSTATUS WINAPI NtQueryInformationProcess(
 180         IN HANDLE ProcessHandle,
 181         IN PROCESSINFOCLASS ProcessInformationClass,
 182         OUT PVOID ProcessInformation,
 183         IN ULONG ProcessInformationLength,
 184         OUT PULONG ReturnLength)
 185 {
 186     NTSTATUS ret = STATUS_SUCCESS;
 187     ULONG len = 0;
 188
 189     TRACE("(%p,0x%08x,%p,0x%08x,%p)\n",
 190           ProcessHandle,ProcessInformationClass,
 191           ProcessInformation,ProcessInformationLength,
 192           ReturnLength);
 193
 194     switch (ProcessInformationClass)
 195     {
 196     UNIMPLEMENTED_INFO_CLASS(ProcessQuotaLimits);
 197     UNIMPLEMENTED_INFO_CLASS(ProcessBasePriority);
 198     UNIMPLEMENTED_INFO_CLASS(ProcessRaisePriority);
 199     UNIMPLEMENTED_INFO_CLASS(ProcessExceptionPort);
 200     UNIMPLEMENTED_INFO_CLASS(ProcessAccessToken);
 201     UNIMPLEMENTED_INFO_CLASS(ProcessLdtInformation);
 202     UNIMPLEMENTED_INFO_CLASS(ProcessLdtSize);
 203     UNIMPLEMENTED_INFO_CLASS(ProcessIoPortHandlers);
 204     UNIMPLEMENTED_INFO_CLASS(ProcessPooledUsageAndLimits);
 205     UNIMPLEMENTED_INFO_CLASS(ProcessWorkingSetWatch);
 206     UNIMPLEMENTED_INFO_CLASS(ProcessUserModeIOPL);
 207     UNIMPLEMENTED_INFO_CLASS(ProcessEnableAlignmentFaultFixup);
 208     UNIMPLEMENTED_INFO_CLASS(ProcessWx86Information);
 209     UNIMPLEMENTED_INFO_CLASS(ProcessPriorityBoost);
 210     UNIMPLEMENTED_INFO_CLASS(ProcessDeviceMap);
 211     UNIMPLEMENTED_INFO_CLASS(ProcessSessionInformation);
 212     UNIMPLEMENTED_INFO_CLASS(ProcessForegroundInformation);
 213     UNIMPLEMENTED_INFO_CLASS(ProcessLUIDDeviceMapsEnabled);
 214     UNIMPLEMENTED_INFO_CLASS(ProcessBreakOnTermination);
 215     UNIMPLEMENTED_INFO_CLASS(ProcessHandleTracing);
 216
 217     case ProcessBasicInformation:
 218         {
 219             PROCESS_BASIC_INFORMATION pbi;
 220             const ULONG_PTR affinity_mask = get_system_affinity_mask();
 221
 222             if (ProcessInformationLength >= sizeof(PROCESS_BASIC_INFORMATION))
 223             {
 224                 if (!ProcessInformation)
 225                     ret = STATUS_ACCESS_VIOLATION;
 226                 else if (!ProcessHandle)
 227                     ret = STATUS_INVALID_HANDLE;
 228                 else
 229                 {
 230                     SERVER_START_REQ(get_process_info)
 231                     {
 232                         req->handle = wine_server_obj_handle( ProcessHandle );
 233                         if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 234                         {
 235                             pbi.ExitStatus = reply->exit_code;
 236                             pbi.PebBaseAddress = wine_server_get_ptr( reply->peb );
 237                             pbi.AffinityMask = reply->affinity & affinity_mask;
 238                             pbi.BasePriority = reply->priority;
 239                             pbi.UniqueProcessId = reply->pid;
 240                             pbi.InheritedFromUniqueProcessId = reply->ppid;
 241                         }
 242                     }
 243                     SERVER_END_REQ;
 244
 245                     memcpy(ProcessInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION));
 246
 247                     len = sizeof(PROCESS_BASIC_INFORMATION);
 248                 }
 249
 250                 if (ProcessInformationLength > sizeof(PROCESS_BASIC_INFORMATION))
 251                     ret = STATUS_INFO_LENGTH_MISMATCH;
 252             }
 253             else
 254             {
 255                 len = sizeof(PROCESS_BASIC_INFORMATION);
 256                 ret = STATUS_INFO_LENGTH_MISMATCH;
 257             }
 258         }
 259         break;
 260     case ProcessIoCounters:
 261         {
 262             IO_COUNTERS pii;
 263
 264             if (ProcessInformationLength >= sizeof(IO_COUNTERS))
 265             {
 266                 if (!ProcessInformation)
 267                     ret = STATUS_ACCESS_VIOLATION;
 268                 else if (!ProcessHandle)
 269                     ret = STATUS_INVALID_HANDLE;
 270                 else
 271                 {
 272                     /* FIXME : real data */
 273                     memset(&pii, 0 , sizeof(IO_COUNTERS));
 274
 275                     memcpy(ProcessInformation, &pii, sizeof(IO_COUNTERS));
 276
 277                     len = sizeof(IO_COUNTERS);
 278                 }
 279
 280                 if (ProcessInformationLength > sizeof(IO_COUNTERS))
 281                     ret = STATUS_INFO_LENGTH_MISMATCH;
 282             }
 283             else
 284             {
 285                 len = sizeof(IO_COUNTERS);
 286                 ret = STATUS_INFO_LENGTH_MISMATCH;
 287             }
 288         }
 289         break;
 290     case ProcessVmCounters:
 291         {
 292             VM_COUNTERS pvmi;
 293
 294             /* older Windows versions don't have the PrivatePageCount field */
 295             if (ProcessInformationLength >= FIELD_OFFSET(VM_COUNTERS,PrivatePageCount))
 296             {
 297                 if (!ProcessInformation)
 298                     ret = STATUS_ACCESS_VIOLATION;
 299                 else
 300                 {
 301                     memset(&pvmi, 0 , sizeof(VM_COUNTERS));
 302                     if (ProcessHandle == GetCurrentProcess())
 303                         fill_VM_COUNTERS(&pvmi);
 304                     else
 305                     {
 306                         SERVER_START_REQ(get_process_vm_counters)
 307                         {
 308                             req->handle = wine_server_obj_handle( ProcessHandle );
 309                             if (!(ret = wine_server_call( req )))
 310                             {
 311                                 pvmi.PeakVirtualSize = reply->peak_virtual_size;
 312                                 pvmi.VirtualSize = reply->virtual_size;
 313                                 pvmi.PeakWorkingSetSize = reply->peak_working_set_size;
 314                                 pvmi.WorkingSetSize = reply->working_set_size;
 315                                 pvmi.PagefileUsage = reply->pagefile_usage;
 316                                 pvmi.PeakPagefileUsage = reply->peak_pagefile_usage;
 317                             }
 318                         }
 319                         SERVER_END_REQ;
 320                         if (ret) break;
 321                     }
 322
 323                     len = ProcessInformationLength;
 324                     if (len != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount)) len = sizeof(VM_COUNTERS);
 325
 326                     memcpy(ProcessInformation, &pvmi, min(ProcessInformationLength,sizeof(VM_COUNTERS)));
 327                 }
 328
 329                 if (ProcessInformationLength != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount) &&
 330                     ProcessInformationLength != sizeof(VM_COUNTERS))
 331                     ret = STATUS_INFO_LENGTH_MISMATCH;
 332             }
 333             else
 334             {
 335                 len = sizeof(pvmi);
 336                 ret = STATUS_INFO_LENGTH_MISMATCH;
 337             }
 338         }
 339         break;
 340     case ProcessTimes:
 341         {
 342             KERNEL_USER_TIMES pti;
 343
 344             if (ProcessInformationLength >= sizeof(KERNEL_USER_TIMES))
 345             {
 346                 if (!ProcessInformation)
 347                     ret = STATUS_ACCESS_VIOLATION;
 348                 else if (!ProcessHandle)
 349                     ret = STATUS_INVALID_HANDLE;
 350                 else
 351                 {
 352                     /* FIXME : User- and KernelTime have to be implemented */
 353                     memset(&pti, 0, sizeof(KERNEL_USER_TIMES));
 354
 355                     SERVER_START_REQ(get_process_info)
 356                     {
 357                       req->handle = wine_server_obj_handle( ProcessHandle );
 358                       if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 359                       {
 360                           pti.CreateTime.QuadPart = reply->start_time;
 361                           pti.ExitTime.QuadPart = reply->end_time;
 362                       }
 363                     }
 364                     SERVER_END_REQ;
 365
 366                     memcpy(ProcessInformation, &pti, sizeof(KERNEL_USER_TIMES));
 367                     len = sizeof(KERNEL_USER_TIMES);
 368                 }
 369
 370                 if (ProcessInformationLength > sizeof(KERNEL_USER_TIMES))
 371                     ret = STATUS_INFO_LENGTH_MISMATCH;
 372             }
 373             else
 374             {
 375                 len = sizeof(KERNEL_USER_TIMES);
 376                 ret = STATUS_INFO_LENGTH_MISMATCH;
 377             }
 378         }
 379         break;
 380     case ProcessDebugPort:
 381         len = sizeof(DWORD_PTR);
 382         if (ProcessInformationLength == len)
 383         {
 384             if (!ProcessInformation)
 385                 ret = STATUS_ACCESS_VIOLATION;
 386             else if (!ProcessHandle)
 387                 ret = STATUS_INVALID_HANDLE;
 388             else
 389             {
 390                 SERVER_START_REQ(get_process_info)
 391                 {
 392                     req->handle = wine_server_obj_handle( ProcessHandle );
 393                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 394                     {
 395                         *(DWORD_PTR *)ProcessInformation = reply->debugger_present ? ~(DWORD_PTR)0 : 0;
 396                     }
 397                 }
 398                 SERVER_END_REQ;
 399             }
 400         }
 401         else
 402             ret = STATUS_INFO_LENGTH_MISMATCH;
 403         break;
 404     case ProcessDebugFlags:
 405         len = sizeof(DWORD);
 406         if (ProcessInformationLength == len)
 407         {
 408             if (!ProcessInformation)
 409                 ret = STATUS_ACCESS_VIOLATION;
 410             else if (!ProcessHandle)
 411                 ret = STATUS_INVALID_HANDLE;
 412             else
 413             {
 414                 SERVER_START_REQ(get_process_info)
 415                 {
 416                     req->handle = wine_server_obj_handle( ProcessHandle );
 417                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 418                     {
 419                         *(DWORD *)ProcessInformation = reply->debug_children;
 420                     }
 421                 }
 422                 SERVER_END_REQ;
 423             }
 424         }
 425         else
 426             ret = STATUS_INFO_LENGTH_MISMATCH;
 427         break;
 428     case ProcessDefaultHardErrorMode:
 429         len = sizeof(process_error_mode);
 430         if (ProcessInformationLength == len)
 431             memcpy(ProcessInformation, &process_error_mode, len);
 432         else
 433             ret = STATUS_INFO_LENGTH_MISMATCH;
 434         break;
 435     case ProcessDebugObjectHandle:
 436         /* "These are not the debuggers you are looking for." *
 437          * set it to 0 aka "no debugger" to satisfy copy protections */
 438         len = sizeof(HANDLE);
 439         if (ProcessInformationLength == len)
 440         {
 441             if (!ProcessInformation)
 442                 ret = STATUS_ACCESS_VIOLATION;
 443             else if (!ProcessHandle)
 444                 ret = STATUS_INVALID_HANDLE;
 445             else
 446             {
 447                 memset(ProcessInformation, 0, ProcessInformationLength);
 448                 ret = STATUS_PORT_NOT_SET;
 449             }
 450         }
 451         else
 452             ret = STATUS_INFO_LENGTH_MISMATCH;
 453         break;
 454     case ProcessHandleCount:
 455         if (ProcessInformationLength >= 4)
 456         {
 457             if (!ProcessInformation)
 458                 ret = STATUS_ACCESS_VIOLATION;
 459             else if (!ProcessHandle)
 460                 ret = STATUS_INVALID_HANDLE;
 461             else
 462             {
 463                 memset(ProcessInformation, 0, 4);
 464                 len = 4;
 465             }
 466
 467             if (ProcessInformationLength > 4)
 468                 ret = STATUS_INFO_LENGTH_MISMATCH;
 469         }
 470         else
 471         {
 472             len = 4;
 473             ret = STATUS_INFO_LENGTH_MISMATCH;
 474         }
 475         break;
 476
 477     case ProcessAffinityMask:
 478         len = sizeof(ULONG_PTR);
 479         if (ProcessInformationLength == len)
 480         {
 481             const ULONG_PTR system_mask = get_system_affinity_mask();
 482
 483             SERVER_START_REQ(get_process_info)
 484             {
 485                 req->handle = wine_server_obj_handle( ProcessHandle );
 486                 if (!(ret = wine_server_call( req )))
 487                     *(ULONG_PTR *)ProcessInformation = reply->affinity & system_mask;
 488             }
 489             SERVER_END_REQ;
 490         }
 491         else ret = STATUS_INFO_LENGTH_MISMATCH;
 492         break;
 493
 494     case ProcessWow64Information:
 495         len = sizeof(ULONG_PTR);
 496         if (ProcessInformationLength != len) ret = STATUS_INFO_LENGTH_MISMATCH;
 497         else if (!ProcessInformation) ret = STATUS_ACCESS_VIOLATION;
 498         else if(!ProcessHandle) ret = STATUS_INVALID_HANDLE;
 499         else
 500         {
 501             ULONG_PTR val = 0;
 502
 503             if (ProcessHandle == GetCurrentProcess()) val = is_wow64;
 504             else if (server_cpus & ((1 << CPU_x86_64) | (1 << CPU_ARM64)))
 505             {
 506                 SERVER_START_REQ( get_process_info )
 507                 {
 508                     req->handle = wine_server_obj_handle( ProcessHandle );
 509                     if (!(ret = wine_server_call( req )))
 510                         val = (reply->cpu != CPU_x86_64 && reply->cpu != CPU_ARM64);
 511                 }
 512                 SERVER_END_REQ;
 513             }
 514             *(ULONG_PTR *)ProcessInformation = val;
 515         }
 516         break;
 517     case ProcessImageFileName:
 518         /* FIXME: Should return a device path */
 519     case ProcessImageFileNameWin32:
 520         SERVER_START_REQ(get_dll_info)
 521         {
 522             UNICODE_STRING *image_file_name_str = ProcessInformation;
 523
 524             req->handle = wine_server_obj_handle( ProcessHandle );
 525             req->base_address = 0; /* main module */
 526             wine_server_set_reply( req, image_file_name_str ? image_file_name_str + 1 : NULL,
 527                                    ProcessInformationLength > sizeof(UNICODE_STRING) ? ProcessInformationLength - sizeof(UNICODE_STRING) : 0 );
 528             ret = wine_server_call( req );
 529             if (ret == STATUS_BUFFER_TOO_SMALL) ret = STATUS_INFO_LENGTH_MISMATCH;
 530
 531             len = sizeof(UNICODE_STRING) + reply->filename_len;
 532             if (ret == STATUS_SUCCESS)
 533             {
 534                 image_file_name_str->MaximumLength = image_file_name_str->Length = reply->filename_len;
 535                 image_file_name_str->Buffer = (PWSTR)(image_file_name_str + 1);
 536             }
 537         }
 538         SERVER_END_REQ;
 539         break;
 540     case ProcessExecuteFlags:
 541         len = sizeof(ULONG);
 542         if (ProcessInformationLength == len)
 543             *(ULONG *)ProcessInformation = execute_flags;
 544         else
 545             ret = STATUS_INFO_LENGTH_MISMATCH;
 546         break;
 547     case ProcessPriorityClass:
 548         len = sizeof(PROCESS_PRIORITY_CLASS);
 549         if (ProcessInformationLength == len)
 550         {
 551             if (!ProcessInformation)
 552                 ret = STATUS_ACCESS_VIOLATION;
 553             else if (!ProcessHandle)
 554                 ret = STATUS_INVALID_HANDLE;
 555             else
 556             {
 557                 PROCESS_PRIORITY_CLASS *priority = ProcessInformation;
 558
 559                 SERVER_START_REQ(get_process_info)
 560                 {
 561                     req->handle = wine_server_obj_handle( ProcessHandle );
 562                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 563                     {
 564                         priority->PriorityClass = reply->priority;
 565                         /* FIXME: Not yet supported by the wineserver */
 566                         priority->Foreground = FALSE;
 567                     }
 568                 }
 569                 SERVER_END_REQ;
 570             }
 571         }
 572         else
 573             ret = STATUS_INFO_LENGTH_MISMATCH;
 574         break;
 575     default:
 576         FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
 577               ProcessHandle,ProcessInformationClass,
 578               ProcessInformation,ProcessInformationLength,
 579               ReturnLength);
 580         ret = STATUS_INVALID_INFO_CLASS;
 581         break;
 582     }
 583
 584     if (ReturnLength) *ReturnLength = len;
 585
 586     return ret;
 587 }
 588
 589 /******************************************************************************
 590  * NtSetInformationProcess [NTDLL.@]
 591  * ZwSetInformationProcess [NTDLL.@]
 592  */
 593 NTSTATUS WINAPI NtSetInformationProcess(
 594         IN HANDLE ProcessHandle,
 595         IN PROCESSINFOCLASS ProcessInformationClass,
 596         IN PVOID ProcessInformation,
 597         IN ULONG ProcessInformationLength)
 598 {
 599     NTSTATUS ret = STATUS_SUCCESS;
 600
 601     switch (ProcessInformationClass)
 602     {
 603     case ProcessDefaultHardErrorMode:
 604         if (ProcessInformationLength != sizeof(UINT)) return STATUS_INVALID_PARAMETER;
 605         process_error_mode = *(UINT *)ProcessInformation;
 606         break;
 607     case ProcessAffinityMask:
 608     {
 609         const ULONG_PTR system_mask = get_system_affinity_mask();
 610
 611         if (ProcessInformationLength != sizeof(DWORD_PTR)) return STATUS_INVALID_PARAMETER;
 612         if (*(PDWORD_PTR)ProcessInformation & ~system_mask)
 613             return STATUS_INVALID_PARAMETER;
 614         if (!*(PDWORD_PTR)ProcessInformation)
 615             return STATUS_INVALID_PARAMETER;
 616         SERVER_START_REQ( set_process_info )
 617         {
 618             req->handle   = wine_server_obj_handle( ProcessHandle );
 619             req->affinity = *(PDWORD_PTR)ProcessInformation;
 620             req->mask     = SET_PROCESS_INFO_AFFINITY;
 621             ret = wine_server_call( req );
 622         }
 623         SERVER_END_REQ;
 624         break;
 625     }
 626     case ProcessPriorityClass:
 627         if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
 628             return STATUS_INVALID_PARAMETER;
 629         else
 630         {
 631             PROCESS_PRIORITY_CLASS* ppc = ProcessInformation;
 632
 633             SERVER_START_REQ( set_process_info )
 634             {
 635                 req->handle   = wine_server_obj_handle( ProcessHandle );
 636                 /* FIXME Foreground isn't used */
 637                 req->priority = ppc->PriorityClass;
 638                 req->mask     = SET_PROCESS_INFO_PRIORITY;
 639                 ret = wine_server_call( req );
 640             }
 641             SERVER_END_REQ;
 642         }
 643         break;
 644
 645     case ProcessExecuteFlags:
 646         if (ProcessInformationLength != sizeof(ULONG))
 647             return STATUS_INVALID_PARAMETER;
 648         else if (execute_flags & MEM_EXECUTE_OPTION_PERMANENT)
 649             return STATUS_ACCESS_DENIED;
 650         else
 651         {
 652             BOOL enable;
 653             switch (*(ULONG *)ProcessInformation & (MEM_EXECUTE_OPTION_ENABLE|MEM_EXECUTE_OPTION_DISABLE))
 654             {
 655             case MEM_EXECUTE_OPTION_ENABLE:
 656                 enable = TRUE;
 657                 break;
 658             case MEM_EXECUTE_OPTION_DISABLE:
 659                 enable = FALSE;
 660                 break;
 661             default:
 662                 return STATUS_INVALID_PARAMETER;
 663             }
 664             execute_flags = *(ULONG *)ProcessInformation;
 665             VIRTUAL_SetForceExec( enable );
 666         }
 667         break;
 668
 669     default:
 670         FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
 671               ProcessHandle,ProcessInformationClass,ProcessInformation,
 672               ProcessInformationLength);
 673         ret = STATUS_NOT_IMPLEMENTED;
 674         break;
 675     }
 676     return ret;
 677 }
 678
 679 /******************************************************************************
 680  * NtFlushInstructionCache [NTDLL.@]
 681  * ZwFlushInstructionCache [NTDLL.@]
 682  */
 683 NTSTATUS WINAPI NtFlushInstructionCache( HANDLE handle, const void *addr, SIZE_T size )
 684 {
 685 #if defined(__x86_64__) || defined(__i386__)
 686     /* no-op */
 687 #elif defined(HAVE___CLEAR_CACHE)
 688     if (handle == GetCurrentProcess())
 689     {
 690         __clear_cache( (char *)addr, (char *)addr + size );
 691     }
 692     else
 693     {
 694         static int once;
 695         if (!once++) FIXME( "%p %p %ld other process not supported\n", handle, addr, size );
 696     }
 697 #else
 698     static int once;
 699     if (!once++) FIXME( "%p %p %ld\n", handle, addr, size );
 700 #endif
 701     return STATUS_SUCCESS;
 702 }
 703
 704 /******************************************************************
 705  *              NtOpenProcess [NTDLL.@]
 706  *              ZwOpenProcess [NTDLL.@]
 707  */
 708 NTSTATUS  WINAPI NtOpenProcess(PHANDLE handle, ACCESS_MASK access,
 709                                const OBJECT_ATTRIBUTES* attr, const CLIENT_ID* cid)
 710 {
 711     NTSTATUS    status;
 712
 713     SERVER_START_REQ( open_process )
 714     {
 715         req->pid        = HandleToULong(cid->UniqueProcess);
 716         req->access     = access;
 717         req->attributes = attr ? attr->Attributes : 0;
 718         status = wine_server_call( req );
 719         if (!status) *handle = wine_server_ptr_handle( reply->handle );
 720     }
 721     SERVER_END_REQ;
 722     return status;
 723 }
 724
 725 /******************************************************************************
 726  * NtResumeProcess
 727  * ZwResumeProcess
 728  */
 729 NTSTATUS WINAPI NtResumeProcess( HANDLE handle )
 730 {
 731     FIXME("stub: %p\n", handle);
 732     return STATUS_NOT_IMPLEMENTED;
 733 }
 734
 735 /******************************************************************************
 736  * NtSuspendProcess
 737  * ZwSuspendProcess
 738  */
 739 NTSTATUS WINAPI NtSuspendProcess( HANDLE handle )
 740 {
 741     FIXME("stub: %p\n", handle);
 742     return STATUS_NOT_IMPLEMENTED;
 743 }