4 * Copyright 1996, 1998 Alexandre Julliard
12 #include "wine/winbase16.h"
13 #include "wine/exception.h"
29 #include "debugtools.h"
31 DEFAULT_DEBUG_CHANNEL(process)
32 DECLARE_DEBUG_CHANNEL(relay)
33 DECLARE_DEBUG_CHANNEL(win32)
36 /* The initial process PDB */
37 static PDB initial_pdb;
39 static PDB *PROCESS_First = &initial_pdb;
42 /***********************************************************************
45 void PROCESS_WalkProcess(void)
51 MESSAGE( " pid PDB #th modref module \n" );
54 if (pdb == &initial_pdb)
57 name = (pdb->exe_modref) ? pdb->exe_modref->filename : "";
59 MESSAGE( " %8p %8p %5d %8p %s\n", pdb->server_pid, pdb,
60 pdb->threads, pdb->exe_modref, name);
66 /***********************************************************************
69 * Check if a handle is to the current process
71 BOOL PROCESS_IsCurrent( HANDLE handle )
73 struct get_process_info_request *req = get_req_buffer();
75 return (!server_call( REQ_GET_PROCESS_INFO ) &&
76 (req->pid == PROCESS_Current()->server_pid));
80 /***********************************************************************
83 * Convert a process id to a PDB, making sure it is valid.
85 PDB *PROCESS_IdToPDB( DWORD pid )
89 if (!pid) return PROCESS_Current();
93 if ((DWORD)pdb->server_pid == pid) return pdb;
96 SetLastError( ERROR_INVALID_PARAMETER );
101 /***********************************************************************
102 * PROCESS_CallUserSignalProc
104 * FIXME: Some of the signals aren't sent correctly!
106 * The exact meaning of the USER signals is undocumented, but this
107 * should cover the basic idea:
109 * USIG_DLL_UNLOAD_WIN16
110 * This is sent when a 16-bit module is unloaded.
112 * USIG_DLL_UNLOAD_WIN32
113 * This is sent when a 32-bit module is unloaded.
115 * USIG_DLL_UNLOAD_ORPHANS
116 * This is sent after the last Win3.1 module is unloaded,
117 * to allow removal of orphaned menus.
119 * USIG_FAULT_DIALOG_PUSH
120 * USIG_FAULT_DIALOG_POP
121 * These are called to allow USER to prepare for displaying a
122 * fault dialog, even though the fault might have happened while
123 * inside a USER critical section.
126 * This is called from the context of a new thread, as soon as it
127 * has started to run.
130 * This is called, still in its context, just before a thread is
131 * about to terminate.
133 * USIG_PROCESS_CREATE
134 * This is called, in the parent process context, after a new process
138 * This is called in the new process context, just after the main thread
139 * has started execution (after the main thread's USIG_THREAD_INIT has
142 * USIG_PROCESS_LOADED
143 * This is called after the executable file has been loaded into the
144 * new process context.
146 * USIG_PROCESS_RUNNING
147 * This is called immediately before the main entry point is called.
150 * This is called in the context of a process that is about to
151 * terminate (but before the last thread's USIG_THREAD_EXIT has
154 * USIG_PROCESS_DESTROY
155 * This is called after a process has terminated.
158 * The meaning of the dwFlags bits is as follows:
161 * Current process is 32-bit.
164 * Current process is a (Win32) GUI process.
166 * USIG_FLAGS_FEEDBACK
167 * Current process needs 'feedback' (determined from the STARTUPINFO
168 * flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
171 * The signal is being sent due to a fault.
173 void PROCESS_CallUserSignalProc( UINT uCode, DWORD dwThreadId, HMODULE hModule )
175 DWORD flags = PROCESS_Current()->flags;
176 DWORD startup_flags = PROCESS_Current()->env_db->startup_info->dwFlags;
179 /* Determine dwFlags */
181 if ( !(flags & PDB32_WIN16_PROC) ) dwFlags |= USIG_FLAGS_WIN32;
183 if ( !(flags & PDB32_CONSOLE_PROC) ) dwFlags |= USIG_FLAGS_GUI;
185 if ( dwFlags & USIG_FLAGS_GUI )
187 /* Feedback defaults to ON */
188 if ( !(startup_flags & STARTF_FORCEOFFFEEDBACK) )
189 dwFlags |= USIG_FLAGS_FEEDBACK;
193 /* Feedback defaults to OFF */
194 if (startup_flags & STARTF_FORCEONFEEDBACK)
195 dwFlags |= USIG_FLAGS_FEEDBACK;
198 /* Convert module handle to 16-bit */
200 if ( HIWORD( hModule ) )
201 hModule = MapHModuleLS( hModule );
203 /* Call USER signal proc */
205 if ( Callout.UserSignalProc )
207 if ( uCode == USIG_THREAD_INIT || uCode == USIG_THREAD_EXIT )
208 Callout.UserSignalProc( uCode, dwThreadId, dwFlags, hModule );
210 Callout.UserSignalProc( uCode, GetCurrentProcessId(), dwFlags, hModule );
214 /***********************************************************************
215 * PROCESS_CreateEnvDB
217 * Create the env DB for a newly started process.
219 static BOOL PROCESS_CreateEnvDB(void)
221 struct init_process_request *req = get_req_buffer();
222 STARTUPINFOA *startup;
225 PDB *pdb = PROCESS_Current();
227 /* Allocate the env DB */
229 if (!(env_db = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ENVDB) )))
231 pdb->env_db = env_db;
232 InitializeCriticalSection( &env_db->section );
234 /* Allocate and fill the startup info */
235 if (!(startup = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTUPINFOA) )))
237 env_db->startup_info = startup;
239 /* Retrieve startup info from the server */
241 req->ldt_copy = ldt_copy;
242 req->ldt_flags = ldt_flags_copy;
243 if (server_call( REQ_INIT_PROCESS )) return FALSE;
244 pdb->exe_file = req->exe_file;
245 startup->dwFlags = req->start_flags;
246 startup->wShowWindow = req->cmd_show;
247 env_db->hStdin = startup->hStdInput = req->hstdin;
248 env_db->hStdout = startup->hStdOutput = req->hstdout;
249 env_db->hStderr = startup->hStdError = req->hstderr;
250 lstrcpynA( cmd_line, req->cmdline, sizeof(cmd_line) );
252 /* Copy the parent environment */
254 if (!ENV_InheritEnvironment( req->env_ptr )) return FALSE;
256 /* Copy the command line */
258 if (!(pdb->env_db->cmd_line = HEAP_strdupA( GetProcessHeap(), 0, cmd_line )))
265 /***********************************************************************
268 * Free a PDB and all associated storage.
270 void PROCESS_FreePDB( PDB *pdb )
272 PDB **pptr = &PROCESS_First;
274 ENV_FreeEnvironment( pdb );
275 while (*pptr && (*pptr != pdb)) pptr = &(*pptr)->next;
276 if (*pptr) *pptr = pdb->next;
277 HeapFree( SystemHeap, 0, pdb );
281 /***********************************************************************
284 * Allocate and fill a PDB structure.
285 * Runs in the context of the parent process.
287 static PDB *PROCESS_CreatePDB( PDB *parent, BOOL inherit )
289 PDB *pdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(PDB) );
291 if (!pdb) return NULL;
292 pdb->exit_code = STILL_ACTIVE;
294 pdb->running_threads = 1;
295 pdb->ring0_threads = 1;
296 pdb->parent = parent;
298 pdb->priority = 8; /* Normal */
299 pdb->next = PROCESS_First;
300 pdb->winver = 0xffff; /* to be determined */
301 pdb->main_queue = INVALID_HANDLE_VALUE16;
307 /***********************************************************************
310 BOOL PROCESS_Init( BOOL win32 )
315 /* Start the server */
316 server_fd = CLIENT_InitServer();
318 /* Fill the initial process structure */
319 initial_pdb.exit_code = STILL_ACTIVE;
320 initial_pdb.threads = 1;
321 initial_pdb.running_threads = 1;
322 initial_pdb.ring0_threads = 1;
323 initial_pdb.group = &initial_pdb;
324 initial_pdb.priority = 8; /* Normal */
325 initial_pdb.flags = win32? 0 : PDB32_WIN16_PROC;
326 initial_pdb.winver = 0xffff; /* to be determined */
327 initial_pdb.main_queue = INVALID_HANDLE_VALUE16;
329 /* Initialize virtual memory management */
330 if (!VIRTUAL_Init()) return FALSE;
332 /* Create the initial thread structure and socket pair */
333 if (!(teb = THREAD_CreateInitialThread( &initial_pdb, server_fd ))) return FALSE;
335 /* Remember TEB selector of initial process for emergency use */
336 SYSLEVEL_EmergencyTeb = teb->teb_sel;
338 /* Create the system and process heaps */
339 if (!HEAP_CreateSystemHeap()) return FALSE;
340 initial_pdb.heap = HeapCreate( HEAP_GROWABLE, 0, 0 );
342 /* Create the idle event for the initial process
343 FIXME 1: Shouldn't we call UserSignalProc for the initial process too?
344 FIXME 2: It seems to me that the initial pdb becomes never freed, so I don't now
345 where to release the idle event for the initial process.
347 initial_pdb.idle_event = CreateEventA ( NULL, TRUE, FALSE, NULL );
348 initial_pdb.idle_event = ConvertToGlobalHandle ( initial_pdb.idle_event );
350 /* Initialize signal handling */
351 if (!SIGNAL_Init()) return FALSE;
353 /* Create the environment DB of the first process */
354 if (!PROCESS_CreateEnvDB()) return FALSE;
356 /* Create the SEGPTR heap */
357 if (!(SegptrHeap = HeapCreate( HEAP_WINE_SEGPTR, 0, 0 ))) return FALSE;
359 /* Initialize the first process critical section */
360 InitializeCriticalSection( &initial_pdb.crit_section );
366 /***********************************************************************
369 * Startup routine of a new process. Called in the context of the new process.
371 void PROCESS_Start(void)
373 struct init_process_done_request *req = get_req_buffer();
375 UINT cmdShow = SW_SHOWNORMAL;
376 LPTHREAD_START_ROUTINE entry = NULL;
377 PDB *pdb = PROCESS_Current();
378 NE_MODULE *pModule = NE_GetPtr( pdb->module );
379 LPCSTR filename = ((OFSTRUCT *)((char*)(pModule) + (pModule)->fileinfo))->szPathName;
380 IMAGE_OPTIONAL_HEADER *header = !pModule->module32? NULL :
381 &PE_HEADER(pModule->module32)->OptionalHeader;
383 /* Get process type */
384 enum { PROC_DOS, PROC_WIN16, PROC_WIN32 } type;
385 if ( pdb->flags & PDB32_DOS_PROC )
387 else if ( pdb->flags & PDB32_WIN16_PROC )
392 /* Initialize the critical section */
393 InitializeCriticalSection( &pdb->crit_section );
395 /* Create the heap */
396 if (!(pdb->heap = GetProcessHeap()))
398 if (!(pdb->heap = HeapCreate( HEAP_GROWABLE,
399 header? header->SizeOfHeapReserve : 0x10000,
400 header? header->SizeOfHeapCommit : 0 )))
404 /* Create the environment db */
405 if (!PROCESS_CreateEnvDB()) goto error;
407 /* Create a task for this process */
408 if (pdb->env_db->startup_info->dwFlags & STARTF_USESHOWWINDOW)
409 cmdShow = pdb->env_db->startup_info->wShowWindow;
410 if (!TASK_Create( pModule, cmdShow ))
413 /* Load all process modules */
417 if ( !NE_InitProcess( pModule ) )
422 /* Create 32-bit MODREF */
423 if ( !PE_CreateModule( pModule->module32, filename, 0, FALSE ) )
426 /* Increment EXE refcount */
427 assert( pdb->exe_modref );
428 pdb->exe_modref->refCount++;
430 /* Retrieve entry point address */
431 entry = (LPTHREAD_START_ROUTINE)RVA_PTR(pModule->module32,
432 OptionalHeader.AddressOfEntryPoint);
436 /* FIXME: move DOS startup code here */
441 /* Note: The USIG_PROCESS_CREATE signal is supposed to be sent in the
442 * context of the parent process. Actually, the USER signal proc
443 * doesn't really care about that, but it *does* require that the
444 * startup parameters are correctly set up, so that GetProcessDword
445 * works. Furthermore, before calling the USER signal proc the
446 * 16-bit stack must be set up, which it is only after TASK_Create
447 * in the case of a 16-bit process. Thus, we send the signal here.
450 PROCESS_CallUserSignalProc( USIG_PROCESS_CREATE, 0, 0 );
451 PROCESS_CallUserSignalProc( USIG_THREAD_INIT, GetCurrentThreadId(), 0 );
452 PROCESS_CallUserSignalProc( USIG_PROCESS_INIT, 0, 0 );
453 PROCESS_CallUserSignalProc( USIG_PROCESS_LOADED, 0, 0 );
455 /* Signal the parent process to continue */
456 req->module = (void *)pModule->module32;
458 server_call( REQ_INIT_PROCESS_DONE );
459 debugged = req->debugged;
461 if ( (pdb->flags & PDB32_CONSOLE_PROC) || (pdb->flags & PDB32_DOS_PROC) )
464 /* Perform Win32 specific process initialization */
465 if ( type == PROC_WIN32 )
467 EnterCriticalSection( &pdb->crit_section );
470 MODULE_DllProcessAttach( pdb->exe_modref, (LPVOID)1 );
472 LeaveCriticalSection( &pdb->crit_section );
475 /* Call UserSignalProc ( USIG_PROCESS_RUNNING ... ) only for non-GUI win32 apps */
476 if ( type != PROC_WIN16 && (pdb->flags & PDB32_CONSOLE_PROC))
477 PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING, 0, 0 );
482 TRACE_(relay)( "Starting DOS process\n" );
484 ERR_(relay)( "DOSVM_Enter returned; should not happen!\n" );
488 TRACE_(relay)( "Starting Win16 process\n" );
490 ERR_(relay)( "TASK_CallToStart returned; should not happen!\n" );
494 TRACE_(relay)( "Starting Win32 process (entryproc=%p)\n", entry );
495 if (debugged) DbgBreakPoint();
496 /* FIXME: should use _PEB as parameter for NT 3.5 programs !
497 * Dunno about other OSs */
498 ExitProcess( entry(NULL) );
502 ExitProcess( GetLastError() );
506 /***********************************************************************
509 * Create a new process database and associated info.
511 PDB *PROCESS_Create( NE_MODULE *pModule, HFILE hFile, LPCSTR cmd_line, LPCSTR env,
512 LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
513 BOOL inherit, DWORD flags, STARTUPINFOA *startup,
514 PROCESS_INFORMATION *info )
516 HANDLE handles[2], load_done_evt = 0;
517 DWORD exitcode, size;
519 int server_thandle, fd = -1;
520 struct new_process_request *req = get_req_buffer();
522 PDB *parent = PROCESS_Current();
523 PDB *pdb = PROCESS_CreatePDB( parent, inherit );
525 if (!pdb) return NULL;
526 info->hThread = info->hProcess = INVALID_HANDLE_VALUE;
527 if (!(load_done_evt = CreateEventA( NULL, TRUE, FALSE, NULL ))) goto error;
529 /* Create the process on the server side */
531 req->inherit = (psa && (psa->nLength >= sizeof(*psa)) && psa->bInheritHandle);
532 req->inherit_all = inherit;
533 req->create_flags = flags;
534 req->start_flags = startup->dwFlags;
535 req->exe_file = hFile;
536 req->event = load_done_evt;
537 if (startup->dwFlags & STARTF_USESTDHANDLES)
539 req->hstdin = startup->hStdInput;
540 req->hstdout = startup->hStdOutput;
541 req->hstderr = startup->hStdError;
545 req->hstdin = GetStdHandle( STD_INPUT_HANDLE );
546 req->hstdout = GetStdHandle( STD_OUTPUT_HANDLE );
547 req->hstderr = GetStdHandle( STD_ERROR_HANDLE );
549 req->cmd_show = startup->wShowWindow;
550 req->env_ptr = (void*)env; /* FIXME: hack */
551 lstrcpynA( req->cmdline, cmd_line, server_remaining(req->cmdline) );
552 if (server_call_fd( REQ_NEW_PROCESS, -1, &fd )) goto error;
553 fcntl( fd, F_SETFD, 1 ); /* set close on exec flag */
554 pdb->server_pid = req->pid;
555 info->hProcess = req->phandle;
556 info->dwProcessId = (DWORD)req->pid;
557 info->hThread = req->thandle;
558 info->dwThreadId = (DWORD)req->tid;
560 if (pModule->module32) /* Win32 process */
562 IMAGE_OPTIONAL_HEADER *header = &PE_HEADER(pModule->module32)->OptionalHeader;
563 size = header->SizeOfStackReserve;
564 if (header->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
565 pdb->flags |= PDB32_CONSOLE_PROC;
566 alloc_stack16 = TRUE;
568 else if (!pModule->dos_image) /* Win16 process */
570 alloc_stack16 = FALSE;
572 pdb->flags |= PDB32_WIN16_PROC;
574 else /* DOS process */
576 alloc_stack16 = FALSE;
578 pdb->flags |= PDB32_DOS_PROC;
581 /* Create the main thread */
583 if (!(teb = THREAD_Create( pdb, fd, flags & CREATE_SUSPENDED, size,
584 alloc_stack16, tsa, &server_thandle ))) goto error;
585 teb->tid = (void *)info->dwThreadId;
586 teb->startup = PROCESS_Start;
587 fd = -1; /* don't close it */
589 /* Pass module to new process (FIXME: hack) */
590 pdb->module = pModule->self;
591 SYSDEPS_SpawnThread( teb );
593 /* Wait until process is initialized (or initialization failed) */
594 handles[0] = info->hProcess;
595 handles[1] = load_done_evt;
597 switch ( WaitForMultipleObjects( 2, handles, FALSE, INFINITE ) )
600 ERR( "WaitForMultipleObjects failed\n" );
604 /* Child initialization code returns error condition as exitcode */
605 if ( GetExitCodeProcess( info->hProcess, &exitcode ) )
606 SetLastError( exitcode );
610 /* Get 16-bit task up and running */
611 if ( pdb->flags & PDB32_WIN16_PROC )
613 /* Post event to start the task */
614 PostEvent16( pdb->task );
616 /* If we ourselves are a 16-bit task, we Yield() directly. */
617 if ( parent->flags & PDB32_WIN16_PROC )
623 CloseHandle( load_done_evt );
629 if (load_done_evt) CloseHandle( load_done_evt );
630 if (info->hThread != INVALID_HANDLE_VALUE) CloseHandle( info->hThread );
631 if (info->hProcess != INVALID_HANDLE_VALUE) CloseHandle( info->hProcess );
632 PROCESS_FreePDB( pdb );
633 if (fd != -1) close( fd );
638 /***********************************************************************
639 * ExitProcess (KERNEL32.100)
641 void WINAPI ExitProcess( DWORD status )
643 EnterCriticalSection( &PROCESS_Current()->crit_section );
644 MODULE_DllProcessDetach( TRUE, (LPVOID)1 );
645 LeaveCriticalSection( &PROCESS_Current()->crit_section );
648 TerminateProcess( GetCurrentProcess(), status );
651 /***********************************************************************
652 * ExitProcess16 (KERNEL.466)
654 void WINAPI ExitProcess16( WORD status )
656 SYSLEVEL_ReleaseWin16Lock();
657 ExitProcess( status );
660 /******************************************************************************
661 * TerminateProcess (KERNEL32.684)
663 BOOL WINAPI TerminateProcess( HANDLE handle, DWORD exit_code )
665 struct terminate_process_request *req = get_req_buffer();
666 req->handle = handle;
667 req->exit_code = exit_code;
668 return !server_call( REQ_TERMINATE_PROCESS );
672 /***********************************************************************
673 * GetProcessDword (KERNEL32.18) (KERNEL.485)
674 * 'Of course you cannot directly access Windows internal structures'
676 DWORD WINAPI GetProcessDword( DWORD dwProcessID, INT offset )
678 PDB *process = PROCESS_IdToPDB( dwProcessID );
682 TRACE_(win32)("(%ld, %d)\n", dwProcessID, offset );
683 if ( !process ) return 0;
687 case GPD_APP_COMPAT_FLAGS:
688 pTask = (TDB *)GlobalLock16( process->task );
689 return pTask? pTask->compat_flags : 0;
691 case GPD_LOAD_DONE_EVENT:
692 return process->load_done_evt;
694 case GPD_HINSTANCE16:
695 pTask = (TDB *)GlobalLock16( process->task );
696 return pTask? pTask->hInstance : 0;
698 case GPD_WINDOWS_VERSION:
699 pTask = (TDB *)GlobalLock16( process->task );
700 return pTask? pTask->version : 0;
703 if ( process != PROCESS_Current() ) return 0;
704 return (DWORD)NtCurrentTeb() - 0x10 /* FIXME */;
707 return (DWORD)process;
709 case GPD_STARTF_SHELLDATA: /* return stdoutput handle from startupinfo ??? */
710 return process->env_db->startup_info->hStdOutput;
712 case GPD_STARTF_HOTKEY: /* return stdinput handle from startupinfo ??? */
713 return process->env_db->startup_info->hStdInput;
715 case GPD_STARTF_SHOWWINDOW:
716 return process->env_db->startup_info->wShowWindow;
718 case GPD_STARTF_SIZE:
719 x = process->env_db->startup_info->dwXSize;
720 if ( x == CW_USEDEFAULT ) x = CW_USEDEFAULT16;
721 y = process->env_db->startup_info->dwYSize;
722 if ( y == CW_USEDEFAULT ) y = CW_USEDEFAULT16;
723 return MAKELONG( x, y );
725 case GPD_STARTF_POSITION:
726 x = process->env_db->startup_info->dwX;
727 if ( x == CW_USEDEFAULT ) x = CW_USEDEFAULT16;
728 y = process->env_db->startup_info->dwY;
729 if ( y == CW_USEDEFAULT ) y = CW_USEDEFAULT16;
730 return MAKELONG( x, y );
732 case GPD_STARTF_FLAGS:
733 return process->env_db->startup_info->dwFlags;
736 return process->parent? (DWORD)process->parent->server_pid : 0;
739 return process->flags;
742 return process->process_dword;
745 ERR_(win32)("Unknown offset %d\n", offset );
750 /***********************************************************************
751 * SetProcessDword (KERNEL.484)
752 * 'Of course you cannot directly access Windows internal structures'
754 void WINAPI SetProcessDword( DWORD dwProcessID, INT offset, DWORD value )
756 PDB *process = PROCESS_IdToPDB( dwProcessID );
758 TRACE_(win32)("(%ld, %d)\n", dwProcessID, offset );
759 if ( !process ) return;
763 case GPD_APP_COMPAT_FLAGS:
764 case GPD_LOAD_DONE_EVENT:
765 case GPD_HINSTANCE16:
766 case GPD_WINDOWS_VERSION:
769 case GPD_STARTF_SHELLDATA:
770 case GPD_STARTF_HOTKEY:
771 case GPD_STARTF_SHOWWINDOW:
772 case GPD_STARTF_SIZE:
773 case GPD_STARTF_POSITION:
774 case GPD_STARTF_FLAGS:
777 ERR_(win32)("Not allowed to modify offset %d\n", offset );
781 process->process_dword = value;
785 ERR_(win32)("Unknown offset %d\n", offset );
791 /***********************************************************************
792 * GetCurrentProcess (KERNEL32.198)
794 HANDLE WINAPI GetCurrentProcess(void)
796 return CURRENT_PROCESS_PSEUDOHANDLE;
800 /*********************************************************************
801 * OpenProcess (KERNEL32.543)
803 HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
806 struct open_process_request *req = get_req_buffer();
808 req->pid = (void *)id;
809 req->access = access;
810 req->inherit = inherit;
811 if (!server_call( REQ_OPEN_PROCESS )) ret = req->handle;
815 /*********************************************************************
816 * MapProcessHandle (KERNEL.483)
818 DWORD WINAPI MapProcessHandle( HANDLE handle )
821 struct get_process_info_request *req = get_req_buffer();
822 req->handle = handle;
823 if (!server_call( REQ_GET_PROCESS_INFO )) ret = (DWORD)req->pid;
827 /***********************************************************************
828 * GetCurrentProcessId (KERNEL32.199)
830 DWORD WINAPI GetCurrentProcessId(void)
832 return (DWORD)PROCESS_Current()->server_pid;
836 /***********************************************************************
837 * GetThreadLocale (KERNEL32.295)
839 LCID WINAPI GetThreadLocale(void)
841 return PROCESS_Current()->locale;
845 /***********************************************************************
846 * SetPriorityClass (KERNEL32.503)
848 BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
850 struct set_process_info_request *req = get_req_buffer();
851 req->handle = hprocess;
852 req->priority = priorityclass;
853 req->mask = SET_PROCESS_INFO_PRIORITY;
854 return !server_call( REQ_SET_PROCESS_INFO );
858 /***********************************************************************
859 * GetPriorityClass (KERNEL32.250)
861 DWORD WINAPI GetPriorityClass(HANDLE hprocess)
864 struct get_process_info_request *req = get_req_buffer();
865 req->handle = hprocess;
866 if (!server_call( REQ_GET_PROCESS_INFO )) ret = req->priority;
871 /***********************************************************************
872 * SetProcessAffinityMask (KERNEL32.662)
874 BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD affmask )
876 struct set_process_info_request *req = get_req_buffer();
877 req->handle = hProcess;
878 req->affinity = affmask;
879 req->mask = SET_PROCESS_INFO_AFFINITY;
880 return !server_call( REQ_SET_PROCESS_INFO );
883 /**********************************************************************
884 * GetProcessAffinityMask (KERNEL32.373)
886 BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess,
887 LPDWORD lpProcessAffinityMask,
888 LPDWORD lpSystemAffinityMask )
891 struct get_process_info_request *req = get_req_buffer();
892 req->handle = hProcess;
893 if (!server_call( REQ_GET_PROCESS_INFO ))
895 if (lpProcessAffinityMask) *lpProcessAffinityMask = req->process_affinity;
896 if (lpSystemAffinityMask) *lpSystemAffinityMask = req->system_affinity;
903 /***********************************************************************
904 * GetStdHandle (KERNEL32.276)
906 HANDLE WINAPI GetStdHandle( DWORD std_handle )
908 PDB *pdb = PROCESS_Current();
912 case STD_INPUT_HANDLE: return pdb->env_db->hStdin;
913 case STD_OUTPUT_HANDLE: return pdb->env_db->hStdout;
914 case STD_ERROR_HANDLE: return pdb->env_db->hStderr;
916 SetLastError( ERROR_INVALID_PARAMETER );
917 return INVALID_HANDLE_VALUE;
921 /***********************************************************************
922 * SetStdHandle (KERNEL32.506)
924 BOOL WINAPI SetStdHandle( DWORD std_handle, HANDLE handle )
926 PDB *pdb = PROCESS_Current();
927 /* FIXME: should we close the previous handle? */
930 case STD_INPUT_HANDLE:
931 pdb->env_db->hStdin = handle;
933 case STD_OUTPUT_HANDLE:
934 pdb->env_db->hStdout = handle;
936 case STD_ERROR_HANDLE:
937 pdb->env_db->hStderr = handle;
940 SetLastError( ERROR_INVALID_PARAMETER );
944 /***********************************************************************
945 * GetProcessVersion (KERNEL32)
947 DWORD WINAPI GetProcessVersion( DWORD processid )
950 PDB *pdb = PROCESS_IdToPDB( processid );
953 if (!(pTask = (TDB *)GlobalLock16( pdb->task ))) return 0;
954 return (pTask->version&0xff) | (((pTask->version >>8) & 0xff)<<16);
957 /***********************************************************************
958 * GetProcessFlags (KERNEL32)
960 DWORD WINAPI GetProcessFlags( DWORD processid )
962 PDB *pdb = PROCESS_IdToPDB( processid );
967 /***********************************************************************
968 * SetProcessWorkingSetSize [KERNEL32.662]
969 * Sets the min/max working set sizes for a specified process.
972 * hProcess [I] Handle to the process of interest
973 * minset [I] Specifies minimum working set size
974 * maxset [I] Specifies maximum working set size
978 BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,DWORD minset,
981 FIXME("(0x%08x,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
982 if(( minset == -1) && (maxset == -1)) {
983 /* Trim the working set to zero */
984 /* Swap the process out of physical RAM */
989 /***********************************************************************
990 * GetProcessWorkingSetSize (KERNEL32)
992 BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess,LPDWORD minset,
995 FIXME("(0x%08x,%p,%p): stub\n",hProcess,minset,maxset);
996 /* 32 MB working set size */
997 if (minset) *minset = 32*1024*1024;
998 if (maxset) *maxset = 32*1024*1024;
1002 /***********************************************************************
1003 * SetProcessShutdownParameters (KERNEL32)
1005 * CHANGED - James Sutherland (JamesSutherland@gmx.de)
1006 * Now tracks changes made (but does not act on these changes)
1007 * NOTE: the definition for SHUTDOWN_NORETRY was done on guesswork.
1008 * It really shouldn't be here, but I'll move it when it's been checked!
1010 #define SHUTDOWN_NORETRY 1
1011 static unsigned int shutdown_noretry = 0;
1012 static unsigned int shutdown_priority = 0x280L;
1013 BOOL WINAPI SetProcessShutdownParameters(DWORD level,DWORD flags)
1015 if (flags & SHUTDOWN_NORETRY)
1016 shutdown_noretry = 1;
1018 shutdown_noretry = 0;
1019 if (level > 0x100L && level < 0x3FFL)
1020 shutdown_priority = level;
1023 ERR("invalid priority level 0x%08lx\n", level);
1030 /***********************************************************************
1031 * GetProcessShutdownParameters (KERNEL32)
1034 BOOL WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel,
1037 (*lpdwLevel) = shutdown_priority;
1038 (*lpdwFlags) = (shutdown_noretry * SHUTDOWN_NORETRY);
1041 /***********************************************************************
1042 * SetProcessPriorityBoost (KERNEL32)
1044 BOOL WINAPI SetProcessPriorityBoost(HANDLE hprocess,BOOL disableboost)
1046 FIXME("(%d,%d): stub\n",hprocess,disableboost);
1047 /* Say we can do it. I doubt the program will notice that we don't. */
1052 /***********************************************************************
1053 * ReadProcessMemory (KERNEL32)
1055 BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, DWORD size,
1056 LPDWORD bytes_read )
1058 struct read_process_memory_request *req = get_req_buffer();
1059 unsigned int offset = (unsigned int)addr % sizeof(int);
1060 unsigned int max = server_remaining( req->data ); /* max length in one request */
1063 if (bytes_read) *bytes_read = size;
1065 /* first time, read total length to check for permissions */
1066 req->handle = process;
1067 req->addr = (char *)addr - offset;
1068 req->len = (size + offset + sizeof(int) - 1) / sizeof(int);
1069 if (server_call( REQ_READ_PROCESS_MEMORY )) goto error;
1071 if (size <= max - offset)
1073 memcpy( buffer, (char *)req->data + offset, size );
1077 /* now take care of the remaining data */
1078 memcpy( buffer, (char *)req->data + offset, max - offset );
1083 if (max > size) max = size;
1084 req->handle = process;
1085 req->addr = (char *)addr + pos;
1086 req->len = (max + sizeof(int) - 1) / sizeof(int);
1087 if (server_call( REQ_READ_PROCESS_MEMORY )) goto error;
1088 memcpy( (char *)buffer + pos, (char *)req->data, max );
1095 if (bytes_read) *bytes_read = 0;
1100 /***********************************************************************
1101 * WriteProcessMemory (KERNEL32)
1103 BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPVOID buffer, DWORD size,
1104 LPDWORD bytes_written )
1106 unsigned int first_offset, last_offset;
1107 struct write_process_memory_request *req = get_req_buffer();
1108 unsigned int max = server_remaining( req->data ); /* max length in one request */
1109 unsigned int pos, last_mask;
1113 SetLastError( ERROR_INVALID_PARAMETER );
1116 if (bytes_written) *bytes_written = size;
1118 /* compute the mask for the first int */
1119 req->first_mask = ~0;
1120 first_offset = (unsigned int)addr % sizeof(int);
1121 memset( &req->first_mask, 0, first_offset );
1123 /* compute the mask for the last int */
1124 last_offset = (size + first_offset) % sizeof(int);
1126 memset( &last_mask, 0xff, last_offset ? last_offset : sizeof(int) );
1128 req->handle = process;
1129 req->addr = (char *)addr - first_offset;
1130 /* for the first request, use the total length */
1131 req->len = (size + first_offset + sizeof(int) - 1) / sizeof(int);
1133 if (size + first_offset < max) /* we can do it in one round */
1135 memcpy( (char *)req->data + first_offset, buffer, size );
1136 req->last_mask = last_mask;
1137 if (server_call( REQ_WRITE_PROCESS_MEMORY )) goto error;
1141 /* needs multiple server calls */
1143 memcpy( (char *)req->data + first_offset, buffer, max - first_offset );
1144 req->last_mask = ~0;
1145 if (server_call( REQ_WRITE_PROCESS_MEMORY )) goto error;
1146 pos = max - first_offset;
1150 if (size <= max) /* last one */
1152 req->last_mask = last_mask;
1155 req->handle = process;
1156 req->addr = (char *)addr + pos;
1157 req->len = (max + sizeof(int) - 1) / sizeof(int);
1158 req->first_mask = ~0;
1159 memcpy( req->data, (char *) buffer + pos, max );
1160 if (server_call( REQ_WRITE_PROCESS_MEMORY )) goto error;
1167 if (bytes_written) *bytes_written = 0;
1173 /***********************************************************************
1174 * RegisterServiceProcess (KERNEL, KERNEL32)
1176 * A service process calls this function to ensure that it continues to run
1177 * even after a user logged off.
1179 DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
1181 /* I don't think that Wine needs to do anything in that function */
1182 return 1; /* success */
1185 /***********************************************************************
1186 * GetExitCodeProcess [KERNEL32.325]
1188 * Gets termination status of specified process
1194 BOOL WINAPI GetExitCodeProcess(
1195 HANDLE hProcess, /* [I] handle to the process */
1196 LPDWORD lpExitCode) /* [O] address to receive termination status */
1199 struct get_process_info_request *req = get_req_buffer();
1200 req->handle = hProcess;
1201 if (!server_call( REQ_GET_PROCESS_INFO ))
1203 if (lpExitCode) *lpExitCode = req->exit_code;
1210 /***********************************************************************
1211 * SetErrorMode (KERNEL32.486)
1213 UINT WINAPI SetErrorMode( UINT mode )
1215 UINT old = PROCESS_Current()->error_mode;
1216 PROCESS_Current()->error_mode = mode;