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(ProcessPriorityClass);
 209     UNIMPLEMENTED_INFO_CLASS(ProcessWx86Information);
 210     UNIMPLEMENTED_INFO_CLASS(ProcessPriorityBoost);
 211     UNIMPLEMENTED_INFO_CLASS(ProcessDeviceMap);
 212     UNIMPLEMENTED_INFO_CLASS(ProcessSessionInformation);
 213     UNIMPLEMENTED_INFO_CLASS(ProcessForegroundInformation);
 214     UNIMPLEMENTED_INFO_CLASS(ProcessLUIDDeviceMapsEnabled);
 215     UNIMPLEMENTED_INFO_CLASS(ProcessBreakOnTermination);
 216     UNIMPLEMENTED_INFO_CLASS(ProcessHandleTracing);
 217
 218     case ProcessBasicInformation:
 219         {
 220             PROCESS_BASIC_INFORMATION pbi;
 221             const ULONG_PTR affinity_mask = get_system_affinity_mask();
 222
 223             if (ProcessInformationLength >= sizeof(PROCESS_BASIC_INFORMATION))
 224             {
 225                 if (!ProcessInformation)
 226                     ret = STATUS_ACCESS_VIOLATION;
 227                 else if (!ProcessHandle)
 228                     ret = STATUS_INVALID_HANDLE;
 229                 else
 230                 {
 231                     SERVER_START_REQ(get_process_info)
 232                     {
 233                         req->handle = wine_server_obj_handle( ProcessHandle );
 234                         if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 235                         {
 236                             pbi.ExitStatus = reply->exit_code;
 237                             pbi.PebBaseAddress = wine_server_get_ptr( reply->peb );
 238                             pbi.AffinityMask = reply->affinity & affinity_mask;
 239                             pbi.BasePriority = reply->priority;
 240                             pbi.UniqueProcessId = reply->pid;
 241                             pbi.InheritedFromUniqueProcessId = reply->ppid;
 242                         }
 243                     }
 244                     SERVER_END_REQ;
 245
 246                     memcpy(ProcessInformation, &pbi, sizeof(PROCESS_BASIC_INFORMATION));
 247
 248                     len = sizeof(PROCESS_BASIC_INFORMATION);
 249                 }
 250
 251                 if (ProcessInformationLength > sizeof(PROCESS_BASIC_INFORMATION))
 252                     ret = STATUS_INFO_LENGTH_MISMATCH;
 253             }
 254             else
 255             {
 256                 len = sizeof(PROCESS_BASIC_INFORMATION);
 257                 ret = STATUS_INFO_LENGTH_MISMATCH;
 258             }
 259         }
 260         break;
 261     case ProcessIoCounters:
 262         {
 263             IO_COUNTERS pii;
 264
 265             if (ProcessInformationLength >= sizeof(IO_COUNTERS))
 266             {
 267                 if (!ProcessInformation)
 268                     ret = STATUS_ACCESS_VIOLATION;
 269                 else if (!ProcessHandle)
 270                     ret = STATUS_INVALID_HANDLE;
 271                 else
 272                 {
 273                     /* FIXME : real data */
 274                     memset(&pii, 0 , sizeof(IO_COUNTERS));
 275
 276                     memcpy(ProcessInformation, &pii, sizeof(IO_COUNTERS));
 277
 278                     len = sizeof(IO_COUNTERS);
 279                 }
 280
 281                 if (ProcessInformationLength > sizeof(IO_COUNTERS))
 282                     ret = STATUS_INFO_LENGTH_MISMATCH;
 283             }
 284             else
 285             {
 286                 len = sizeof(IO_COUNTERS);
 287                 ret = STATUS_INFO_LENGTH_MISMATCH;
 288             }
 289         }
 290         break;
 291     case ProcessVmCounters:
 292         {
 293             VM_COUNTERS pvmi;
 294
 295             /* older Windows versions don't have the PrivatePageCount field */
 296             if (ProcessInformationLength >= FIELD_OFFSET(VM_COUNTERS,PrivatePageCount))
 297             {
 298                 if (!ProcessInformation)
 299                     ret = STATUS_ACCESS_VIOLATION;
 300                 else
 301                 {
 302                     memset(&pvmi, 0 , sizeof(VM_COUNTERS));
 303                     if (ProcessHandle == GetCurrentProcess())
 304                         fill_VM_COUNTERS(&pvmi);
 305                     else
 306                     {
 307                         SERVER_START_REQ(get_process_vm_counters)
 308                         {
 309                             req->handle = wine_server_obj_handle( ProcessHandle );
 310                             if (!(ret = wine_server_call( req )))
 311                             {
 312                                 pvmi.PeakVirtualSize = reply->peak_virtual_size;
 313                                 pvmi.VirtualSize = reply->virtual_size;
 314                                 pvmi.PeakWorkingSetSize = reply->peak_working_set_size;
 315                                 pvmi.WorkingSetSize = reply->working_set_size;
 316                                 pvmi.PagefileUsage = reply->pagefile_usage;
 317                                 pvmi.PeakPagefileUsage = reply->peak_pagefile_usage;
 318                             }
 319                         }
 320                         SERVER_END_REQ;
 321                         if (ret) break;
 322                     }
 323
 324                     len = ProcessInformationLength;
 325                     if (len != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount)) len = sizeof(VM_COUNTERS);
 326
 327                     memcpy(ProcessInformation, &pvmi, min(ProcessInformationLength,sizeof(VM_COUNTERS)));
 328                 }
 329
 330                 if (ProcessInformationLength != FIELD_OFFSET(VM_COUNTERS,PrivatePageCount) &&
 331                     ProcessInformationLength != sizeof(VM_COUNTERS))
 332                     ret = STATUS_INFO_LENGTH_MISMATCH;
 333             }
 334             else
 335             {
 336                 len = sizeof(pvmi);
 337                 ret = STATUS_INFO_LENGTH_MISMATCH;
 338             }
 339         }
 340         break;
 341     case ProcessTimes:
 342         {
 343             KERNEL_USER_TIMES pti;
 344
 345             if (ProcessInformationLength >= sizeof(KERNEL_USER_TIMES))
 346             {
 347                 if (!ProcessInformation)
 348                     ret = STATUS_ACCESS_VIOLATION;
 349                 else if (!ProcessHandle)
 350                     ret = STATUS_INVALID_HANDLE;
 351                 else
 352                 {
 353                     /* FIXME : User- and KernelTime have to be implemented */
 354                     memset(&pti, 0, sizeof(KERNEL_USER_TIMES));
 355
 356                     SERVER_START_REQ(get_process_info)
 357                     {
 358                       req->handle = wine_server_obj_handle( ProcessHandle );
 359                       if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 360                       {
 361                           pti.CreateTime.QuadPart = reply->start_time;
 362                           pti.ExitTime.QuadPart = reply->end_time;
 363                       }
 364                     }
 365                     SERVER_END_REQ;
 366
 367                     memcpy(ProcessInformation, &pti, sizeof(KERNEL_USER_TIMES));
 368                     len = sizeof(KERNEL_USER_TIMES);
 369                 }
 370
 371                 if (ProcessInformationLength > sizeof(KERNEL_USER_TIMES))
 372                     ret = STATUS_INFO_LENGTH_MISMATCH;
 373             }
 374             else
 375             {
 376                 len = sizeof(KERNEL_USER_TIMES);
 377                 ret = STATUS_INFO_LENGTH_MISMATCH;
 378             }
 379         }
 380         break;
 381     case ProcessDebugPort:
 382         len = sizeof(DWORD_PTR);
 383         if (ProcessInformationLength == len)
 384         {
 385             if (!ProcessInformation)
 386                 ret = STATUS_ACCESS_VIOLATION;
 387             else if (!ProcessHandle)
 388                 ret = STATUS_INVALID_HANDLE;
 389             else
 390             {
 391                 SERVER_START_REQ(get_process_info)
 392                 {
 393                     req->handle = wine_server_obj_handle( ProcessHandle );
 394                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 395                     {
 396                         *(DWORD_PTR *)ProcessInformation = reply->debugger_present ? ~(DWORD_PTR)0 : 0;
 397                     }
 398                 }
 399                 SERVER_END_REQ;
 400             }
 401         }
 402         else
 403             ret = STATUS_INFO_LENGTH_MISMATCH;
 404         break;
 405     case ProcessDebugFlags:
 406         len = sizeof(DWORD);
 407         if (ProcessInformationLength == len)
 408         {
 409             if (!ProcessInformation)
 410                 ret = STATUS_ACCESS_VIOLATION;
 411             else if (!ProcessHandle)
 412                 ret = STATUS_INVALID_HANDLE;
 413             else
 414             {
 415                 SERVER_START_REQ(get_process_info)
 416                 {
 417                     req->handle = wine_server_obj_handle( ProcessHandle );
 418                     if ((ret = wine_server_call( req )) == STATUS_SUCCESS)
 419                     {
 420                         *(DWORD *)ProcessInformation = reply->debug_children;
 421                     }
 422                 }
 423                 SERVER_END_REQ;
 424             }
 425         }
 426         else
 427             ret = STATUS_INFO_LENGTH_MISMATCH;
 428         break;
 429     case ProcessDefaultHardErrorMode:
 430         len = sizeof(process_error_mode);
 431         if (ProcessInformationLength == len)
 432             memcpy(ProcessInformation, &process_error_mode, len);
 433         else
 434             ret = STATUS_INFO_LENGTH_MISMATCH;
 435         break;
 436     case ProcessDebugObjectHandle:
 437         /* "These are not the debuggers you are looking for." *
 438          * set it to 0 aka "no debugger" to satisfy copy protections */
 439         len = sizeof(HANDLE);
 440         if (ProcessInformationLength == len)
 441         {
 442             if (!ProcessInformation)
 443                 ret = STATUS_ACCESS_VIOLATION;
 444             else if (!ProcessHandle)
 445                 ret = STATUS_INVALID_HANDLE;
 446             else
 447             {
 448                 memset(ProcessInformation, 0, ProcessInformationLength);
 449                 ret = STATUS_PORT_NOT_SET;
 450             }
 451         }
 452         else
 453             ret = STATUS_INFO_LENGTH_MISMATCH;
 454         break;
 455     case ProcessHandleCount:
 456         if (ProcessInformationLength >= 4)
 457         {
 458             if (!ProcessInformation)
 459                 ret = STATUS_ACCESS_VIOLATION;
 460             else if (!ProcessHandle)
 461                 ret = STATUS_INVALID_HANDLE;
 462             else
 463             {
 464                 memset(ProcessInformation, 0, 4);
 465                 len = 4;
 466             }
 467
 468             if (ProcessInformationLength > 4)
 469                 ret = STATUS_INFO_LENGTH_MISMATCH;
 470         }
 471         else
 472         {
 473             len = 4;
 474             ret = STATUS_INFO_LENGTH_MISMATCH;
 475         }
 476         break;
 477
 478     case ProcessAffinityMask:
 479         len = sizeof(ULONG_PTR);
 480         if (ProcessInformationLength == len)
 481         {
 482             const ULONG_PTR system_mask = get_system_affinity_mask();
 483
 484             SERVER_START_REQ(get_process_info)
 485             {
 486                 req->handle = wine_server_obj_handle( ProcessHandle );
 487                 if (!(ret = wine_server_call( req )))
 488                     *(ULONG_PTR *)ProcessInformation = reply->affinity & system_mask;
 489             }
 490             SERVER_END_REQ;
 491         }
 492         else ret = STATUS_INFO_LENGTH_MISMATCH;
 493         break;
 494
 495     case ProcessWow64Information:
 496         len = sizeof(ULONG_PTR);
 497         if (ProcessInformationLength != len) ret = STATUS_INFO_LENGTH_MISMATCH;
 498         else if (!ProcessInformation) ret = STATUS_ACCESS_VIOLATION;
 499         else if(!ProcessHandle) ret = STATUS_INVALID_HANDLE;
 500         else
 501         {
 502             ULONG_PTR val = 0;
 503
 504             if (ProcessHandle == GetCurrentProcess()) val = is_wow64;
 505             else if (server_cpus & ((1 << CPU_x86_64) | (1 << CPU_ARM64)))
 506             {
 507                 SERVER_START_REQ( get_process_info )
 508                 {
 509                     req->handle = wine_server_obj_handle( ProcessHandle );
 510                     if (!(ret = wine_server_call( req )))
 511                         val = (reply->cpu != CPU_x86_64 && reply->cpu != CPU_ARM64);
 512                 }
 513                 SERVER_END_REQ;
 514             }
 515             *(ULONG_PTR *)ProcessInformation = val;
 516         }
 517         break;
 518     case ProcessImageFileName:
 519         /* FIXME: this will return a DOS path. Windows returns an NT path. Changing this would require also changing kernel32.QueryFullProcessImageName.
 520          * The latter may be harder because of the lack of RtlNtPathNameToDosPathName. */
 521         SERVER_START_REQ(get_dll_info)
 522         {
 523             UNICODE_STRING *image_file_name_str = ProcessInformation;
 524
 525             req->handle = wine_server_obj_handle( ProcessHandle );
 526             req->base_address = 0; /* main module */
 527             wine_server_set_reply( req, image_file_name_str ? image_file_name_str + 1 : NULL,
 528                                    ProcessInformationLength > sizeof(UNICODE_STRING) ? ProcessInformationLength - sizeof(UNICODE_STRING) : 0 );
 529             ret = wine_server_call( req );
 530             if (ret == STATUS_BUFFER_TOO_SMALL) ret = STATUS_INFO_LENGTH_MISMATCH;
 531
 532             len = sizeof(UNICODE_STRING) + reply->filename_len;
 533             if (ret == STATUS_SUCCESS)
 534             {
 535                 image_file_name_str->MaximumLength = image_file_name_str->Length = reply->filename_len;
 536                 image_file_name_str->Buffer = (PWSTR)(image_file_name_str + 1);
 537             }
 538         }
 539         SERVER_END_REQ;
 540         break;
 541     case ProcessExecuteFlags:
 542         len = sizeof(ULONG);
 543         if (ProcessInformationLength == len)
 544             *(ULONG *)ProcessInformation = execute_flags;
 545         else
 546             ret = STATUS_INFO_LENGTH_MISMATCH;
 547         break;
 548     default:
 549         FIXME("(%p,info_class=%d,%p,0x%08x,%p) Unknown information class\n",
 550               ProcessHandle,ProcessInformationClass,
 551               ProcessInformation,ProcessInformationLength,
 552               ReturnLength);
 553         ret = STATUS_INVALID_INFO_CLASS;
 554         break;
 555     }
 556
 557     if (ReturnLength) *ReturnLength = len;
 558
 559     return ret;
 560 }
 561
 562 /******************************************************************************
 563  * NtSetInformationProcess [NTDLL.@]
 564  * ZwSetInformationProcess [NTDLL.@]
 565  */
 566 NTSTATUS WINAPI NtSetInformationProcess(
 567         IN HANDLE ProcessHandle,
 568         IN PROCESSINFOCLASS ProcessInformationClass,
 569         IN PVOID ProcessInformation,
 570         IN ULONG ProcessInformationLength)
 571 {
 572     NTSTATUS ret = STATUS_SUCCESS;
 573
 574     switch (ProcessInformationClass)
 575     {
 576     case ProcessDefaultHardErrorMode:
 577         if (ProcessInformationLength != sizeof(UINT)) return STATUS_INVALID_PARAMETER;
 578         process_error_mode = *(UINT *)ProcessInformation;
 579         break;
 580     case ProcessAffinityMask:
 581     {
 582         const ULONG_PTR system_mask = get_system_affinity_mask();
 583
 584         if (ProcessInformationLength != sizeof(DWORD_PTR)) return STATUS_INVALID_PARAMETER;
 585         if (*(PDWORD_PTR)ProcessInformation & ~system_mask)
 586             return STATUS_INVALID_PARAMETER;
 587         if (!*(PDWORD_PTR)ProcessInformation)
 588             return STATUS_INVALID_PARAMETER;
 589         SERVER_START_REQ( set_process_info )
 590         {
 591             req->handle   = wine_server_obj_handle( ProcessHandle );
 592             req->affinity = *(PDWORD_PTR)ProcessInformation;
 593             req->mask     = SET_PROCESS_INFO_AFFINITY;
 594             ret = wine_server_call( req );
 595         }
 596         SERVER_END_REQ;
 597         break;
 598     }
 599     case ProcessPriorityClass:
 600         if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
 601             return STATUS_INVALID_PARAMETER;
 602         else
 603         {
 604             PROCESS_PRIORITY_CLASS* ppc = ProcessInformation;
 605
 606             SERVER_START_REQ( set_process_info )
 607             {
 608                 req->handle   = wine_server_obj_handle( ProcessHandle );
 609                 /* FIXME Foreground isn't used */
 610                 req->priority = ppc->PriorityClass;
 611                 req->mask     = SET_PROCESS_INFO_PRIORITY;
 612                 ret = wine_server_call( req );
 613             }
 614             SERVER_END_REQ;
 615         }
 616         break;
 617
 618     case ProcessExecuteFlags:
 619         if (ProcessInformationLength != sizeof(ULONG))
 620             return STATUS_INVALID_PARAMETER;
 621         else if (execute_flags & MEM_EXECUTE_OPTION_PERMANENT)
 622             return STATUS_ACCESS_DENIED;
 623         else
 624         {
 625             BOOL enable;
 626             switch (*(ULONG *)ProcessInformation & (MEM_EXECUTE_OPTION_ENABLE|MEM_EXECUTE_OPTION_DISABLE))
 627             {
 628             case MEM_EXECUTE_OPTION_ENABLE:
 629                 enable = TRUE;
 630                 break;
 631             case MEM_EXECUTE_OPTION_DISABLE:
 632                 enable = FALSE;
 633                 break;
 634             default:
 635                 return STATUS_INVALID_PARAMETER;
 636             }
 637             execute_flags = *(ULONG *)ProcessInformation;
 638             VIRTUAL_SetForceExec( enable );
 639         }
 640         break;
 641
 642     default:
 643         FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
 644               ProcessHandle,ProcessInformationClass,ProcessInformation,
 645               ProcessInformationLength);
 646         ret = STATUS_NOT_IMPLEMENTED;
 647         break;
 648     }
 649     return ret;
 650 }
 651
 652 /******************************************************************************
 653  * NtFlushInstructionCache [NTDLL.@]
 654  * ZwFlushInstructionCache [NTDLL.@]
 655  */
 656 NTSTATUS WINAPI NtFlushInstructionCache( HANDLE handle, const void *addr, SIZE_T size )
 657 {
 658 #if defined(__x86_64__) || defined(__i386__)
 659     /* no-op */
 660 #elif defined(HAVE___CLEAR_CACHE)
 661     if (handle == GetCurrentProcess())
 662     {
 663         __clear_cache( (char *)addr, (char *)addr + size );
 664     }
 665     else
 666     {
 667         static int once;
 668         if (!once++) FIXME( "%p %p %ld other process not supported\n", handle, addr, size );
 669     }
 670 #else
 671     static int once;
 672     if (!once++) FIXME( "%p %p %ld\n", handle, addr, size );
 673 #endif
 674     return STATUS_SUCCESS;
 675 }
 676
 677 /******************************************************************
 678  *              NtOpenProcess [NTDLL.@]
 679  *              ZwOpenProcess [NTDLL.@]
 680  */
 681 NTSTATUS  WINAPI NtOpenProcess(PHANDLE handle, ACCESS_MASK access,
 682                                const OBJECT_ATTRIBUTES* attr, const CLIENT_ID* cid)
 683 {
 684     NTSTATUS    status;
 685
 686     SERVER_START_REQ( open_process )
 687     {
 688         req->pid        = HandleToULong(cid->UniqueProcess);
 689         req->access     = access;
 690         req->attributes = attr ? attr->Attributes : 0;
 691         status = wine_server_call( req );
 692         if (!status) *handle = wine_server_ptr_handle( reply->handle );
 693     }
 694     SERVER_END_REQ;
 695     return status;
 696 }
 697
 698 /******************************************************************************
 699  * NtResumeProcess
 700  * ZwResumeProcess
 701  */
 702 NTSTATUS WINAPI NtResumeProcess( HANDLE handle )
 703 {
 704     FIXME("stub: %p\n", handle);
 705     return STATUS_NOT_IMPLEMENTED;
 706 }
 707
 708 /******************************************************************************
 709  * NtSuspendProcess
 710  * ZwSuspendProcess
 711  */
 712 NTSTATUS WINAPI NtSuspendProcess( HANDLE handle )
 713 {
 714     FIXME("stub: %p\n", handle);
 715     return STATUS_NOT_IMPLEMENTED;
 716 }