2 * Server-side process management
4 * Copyright (C) 1998 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
32 #ifdef HAVE_SYS_SOCKET_H
33 # include <sys/socket.h>
41 #define WIN32_NO_STATUS
52 /* process structure */
54 static struct list process_list
= LIST_INIT(process_list
);
55 static int running_processes
, user_processes
;
56 static struct event
*shutdown_event
; /* signaled when shutdown starts */
57 static struct timeout_user
*shutdown_timeout
; /* timeout for server shutdown */
58 static int shutdown_stage
; /* current stage in the shutdown process */
60 /* process operations */
62 static void process_dump( struct object
*obj
, int verbose
);
63 static int process_signaled( struct object
*obj
, struct thread
*thread
);
64 static unsigned int process_map_access( struct object
*obj
, unsigned int access
);
65 static void process_poll_event( struct fd
*fd
, int event
);
66 static void process_destroy( struct object
*obj
);
68 static const struct object_ops process_ops
=
70 sizeof(struct process
), /* size */
71 process_dump
, /* dump */
72 no_get_type
, /* get_type */
73 add_queue
, /* add_queue */
74 remove_queue
, /* remove_queue */
75 process_signaled
, /* signaled */
76 no_satisfied
, /* satisfied */
77 no_signal
, /* signal */
78 no_get_fd
, /* get_fd */
79 process_map_access
, /* map_access */
80 default_get_sd
, /* get_sd */
81 default_set_sd
, /* set_sd */
82 no_lookup_name
, /* lookup_name */
83 no_open_file
, /* open_file */
84 no_close_handle
, /* close_handle */
85 process_destroy
/* destroy */
88 static const struct fd_ops process_fd_ops
=
90 NULL
, /* get_poll_events */
91 process_poll_event
, /* poll_event */
93 NULL
, /* get_fd_type */
95 NULL
, /* queue_async */
96 NULL
, /* reselect_async */
97 NULL
/* cancel async */
100 /* process startup info */
104 struct object obj
; /* object header */
105 struct file
*exe_file
; /* file handle for main exe */
106 struct process
*process
; /* created process */
107 data_size_t info_size
; /* size of startup info */
108 data_size_t data_size
; /* size of whole startup data */
109 startup_info_t
*data
; /* data for startup info */
112 static void startup_info_dump( struct object
*obj
, int verbose
);
113 static int startup_info_signaled( struct object
*obj
, struct thread
*thread
);
114 static void startup_info_destroy( struct object
*obj
);
116 static const struct object_ops startup_info_ops
=
118 sizeof(struct startup_info
), /* size */
119 startup_info_dump
, /* dump */
120 no_get_type
, /* get_type */
121 add_queue
, /* add_queue */
122 remove_queue
, /* remove_queue */
123 startup_info_signaled
, /* signaled */
124 no_satisfied
, /* satisfied */
125 no_signal
, /* signal */
126 no_get_fd
, /* get_fd */
127 no_map_access
, /* map_access */
128 default_get_sd
, /* get_sd */
129 default_set_sd
, /* set_sd */
130 no_lookup_name
, /* lookup_name */
131 no_open_file
, /* open_file */
132 no_close_handle
, /* close_handle */
133 startup_info_destroy
/* destroy */
139 void *ptr
; /* entry ptr */
140 unsigned int next
; /* next free entry */
143 static struct ptid_entry
*ptid_entries
; /* array of ptid entries */
144 static unsigned int used_ptid_entries
; /* number of entries in use */
145 static unsigned int alloc_ptid_entries
; /* number of allocated entries */
146 static unsigned int next_free_ptid
; /* next free entry */
147 static unsigned int last_free_ptid
; /* last free entry */
149 static void kill_all_processes(void);
151 #define PTID_OFFSET 8 /* offset for first ptid value */
153 /* allocate a new process or thread id */
154 unsigned int alloc_ptid( void *ptr
)
156 struct ptid_entry
*entry
;
159 if (used_ptid_entries
< alloc_ptid_entries
)
161 id
= used_ptid_entries
+ PTID_OFFSET
;
162 entry
= &ptid_entries
[used_ptid_entries
++];
164 else if (next_free_ptid
)
167 entry
= &ptid_entries
[id
- PTID_OFFSET
];
168 if (!(next_free_ptid
= entry
->next
)) last_free_ptid
= 0;
170 else /* need to grow the array */
172 unsigned int count
= alloc_ptid_entries
+ (alloc_ptid_entries
/ 2);
173 if (!count
) count
= 64;
174 if (!(entry
= realloc( ptid_entries
, count
* sizeof(*entry
) )))
176 set_error( STATUS_NO_MEMORY
);
179 ptid_entries
= entry
;
180 alloc_ptid_entries
= count
;
181 id
= used_ptid_entries
+ PTID_OFFSET
;
182 entry
= &ptid_entries
[used_ptid_entries
++];
189 /* free a process or thread id */
190 void free_ptid( unsigned int id
)
192 struct ptid_entry
*entry
= &ptid_entries
[id
- PTID_OFFSET
];
197 /* append to end of free list so that we don't reuse it too early */
198 if (last_free_ptid
) ptid_entries
[last_free_ptid
- PTID_OFFSET
].next
= id
;
199 else next_free_ptid
= id
;
204 /* retrieve the pointer corresponding to a process or thread id */
205 void *get_ptid_entry( unsigned int id
)
207 if (id
< PTID_OFFSET
) return NULL
;
208 if (id
- PTID_OFFSET
>= used_ptid_entries
) return NULL
;
209 return ptid_entries
[id
- PTID_OFFSET
].ptr
;
212 /* return the main thread of the process */
213 struct thread
*get_process_first_thread( struct process
*process
)
215 struct list
*ptr
= list_head( &process
->thread_list
);
216 if (!ptr
) return NULL
;
217 return LIST_ENTRY( ptr
, struct thread
, proc_entry
);
220 /* set the state of the process startup info */
221 static void set_process_startup_state( struct process
*process
, enum startup_state state
)
223 if (process
->startup_state
== STARTUP_IN_PROGRESS
) process
->startup_state
= state
;
224 if (process
->startup_info
)
226 wake_up( &process
->startup_info
->obj
, 0 );
227 release_object( process
->startup_info
);
228 process
->startup_info
= NULL
;
232 /* callback for server shutdown */
233 static void server_shutdown_timeout( void *arg
)
235 shutdown_timeout
= NULL
;
236 if (!running_processes
)
238 close_master_socket( 0 );
241 switch(++shutdown_stage
)
243 case 1: /* signal system processes to exit */
244 if (debug_level
) fprintf( stderr
, "wineserver: shutting down\n" );
245 if (shutdown_event
) set_event( shutdown_event
);
246 shutdown_timeout
= add_timeout_user( 2 * -TICKS_PER_SEC
, server_shutdown_timeout
, NULL
);
247 close_master_socket( 4 * -TICKS_PER_SEC
);
249 case 2: /* now forcibly kill all processes (but still wait for SIGKILL timeouts) */
250 kill_all_processes();
255 /* forced shutdown, used for wineserver -k */
256 void shutdown_master_socket(void)
258 kill_all_processes();
260 if (shutdown_timeout
)
262 remove_timeout_user( shutdown_timeout
);
263 shutdown_timeout
= NULL
;
265 close_master_socket( 2 * -TICKS_PER_SEC
); /* for SIGKILL timeouts */
268 /* final cleanup once we are sure a process is really dead */
269 static void process_died( struct process
*process
)
271 if (debug_level
) fprintf( stderr
, "%04x: *process killed*\n", process
->id
);
272 if (!process
->is_system
)
274 if (!--user_processes
&& !shutdown_stage
&& master_socket_timeout
!= TIMEOUT_INFINITE
)
275 shutdown_timeout
= add_timeout_user( master_socket_timeout
, server_shutdown_timeout
, NULL
);
277 release_object( process
);
278 if (!--running_processes
&& shutdown_stage
) close_master_socket( 0 );
281 /* callback for process sigkill timeout */
282 static void process_sigkill( void *private )
284 struct process
*process
= private;
286 process
->sigkill_timeout
= NULL
;
287 kill( process
->unix_pid
, SIGKILL
);
288 process_died( process
);
291 /* start the sigkill timer for a process upon exit */
292 static void start_sigkill_timer( struct process
*process
)
294 grab_object( process
);
295 if (process
->unix_pid
!= -1 && process
->msg_fd
)
296 process
->sigkill_timeout
= add_timeout_user( -TICKS_PER_SEC
, process_sigkill
, process
);
298 process_died( process
);
301 /* create a new process and its main thread */
302 /* if the function fails the fd is closed */
303 struct thread
*create_process( int fd
, struct thread
*parent_thread
, int inherit_all
)
305 struct process
*process
;
306 struct thread
*thread
= NULL
;
309 if (!(process
= alloc_object( &process_ops
)))
314 process
->parent
= NULL
;
315 process
->debugger
= NULL
;
316 process
->handles
= NULL
;
317 process
->msg_fd
= NULL
;
318 process
->sigkill_timeout
= NULL
;
319 process
->unix_pid
= -1;
320 process
->exit_code
= STILL_ACTIVE
;
321 process
->running_threads
= 0;
322 process
->priority
= PROCESS_PRIOCLASS_NORMAL
;
323 process
->suspend
= 0;
324 process
->is_system
= 0;
325 process
->debug_children
= 0;
326 process
->console
= NULL
;
327 process
->startup_state
= STARTUP_IN_PROGRESS
;
328 process
->startup_info
= NULL
;
329 process
->idle_event
= NULL
;
331 process
->ldt_copy
= 0;
332 process
->winstation
= 0;
333 process
->desktop
= 0;
334 process
->token
= NULL
;
335 process
->trace_data
= 0;
336 list_init( &process
->thread_list
);
337 list_init( &process
->locks
);
338 list_init( &process
->classes
);
339 list_init( &process
->dlls
);
340 list_init( &process
->rawinput_devices
);
342 process
->start_time
= current_time
;
343 process
->end_time
= 0;
344 list_add_tail( &process_list
, &process
->entry
);
346 if (!(process
->id
= process
->group_id
= alloc_ptid( process
)))
351 if (!(process
->msg_fd
= create_anonymous_fd( &process_fd_ops
, fd
, &process
->obj
, 0 ))) goto error
;
353 /* create the handle table */
356 process
->handles
= alloc_handle_table( process
, 0 );
357 process
->token
= token_create_admin();
358 process
->affinity
= ~0;
362 struct process
*parent
= parent_thread
->process
;
363 process
->parent
= (struct process
*)grab_object( parent
);
364 process
->handles
= inherit_all
? copy_handle_table( process
, parent
)
365 : alloc_handle_table( process
, 0 );
366 /* Note: for security reasons, starting a new process does not attempt
367 * to use the current impersonation token for the new process */
368 process
->token
= token_duplicate( parent
->token
, TRUE
, 0 );
369 process
->affinity
= parent
->affinity
;
371 if (!process
->handles
|| !process
->token
) goto error
;
373 /* create the main thread */
374 if (pipe( request_pipe
) == -1)
379 if (send_client_fd( process
, request_pipe
[1], SERVER_PROTOCOL_VERSION
) == -1)
381 close( request_pipe
[0] );
382 close( request_pipe
[1] );
385 close( request_pipe
[1] );
386 if (!(thread
= create_thread( request_pipe
[0], process
))) goto error
;
388 set_fd_events( process
->msg_fd
, POLLIN
); /* start listening to events */
389 release_object( process
);
393 if (process
) release_object( process
);
394 /* if we failed to start our first process, close everything down */
395 if (!running_processes
) close_master_socket( 0 );
399 /* initialize the current process and fill in the request */
400 data_size_t
init_process( struct thread
*thread
)
402 struct process
*process
= thread
->process
;
403 struct startup_info
*info
= process
->startup_info
;
405 init_process_tracing( process
);
407 return info
->data_size
;
410 /* destroy a process when its refcount is 0 */
411 static void process_destroy( struct object
*obj
)
413 struct process
*process
= (struct process
*)obj
;
414 assert( obj
->ops
== &process_ops
);
416 /* we can't have a thread remaining */
417 assert( list_empty( &process
->thread_list
));
419 assert( !process
->sigkill_timeout
); /* timeout should hold a reference to the process */
421 close_process_handles( process
);
422 set_process_startup_state( process
, STARTUP_ABORTED
);
423 if (process
->console
) release_object( process
->console
);
424 if (process
->parent
) release_object( process
->parent
);
425 if (process
->msg_fd
) release_object( process
->msg_fd
);
426 list_remove( &process
->entry
);
427 if (process
->idle_event
) release_object( process
->idle_event
);
428 if (process
->id
) free_ptid( process
->id
);
429 if (process
->token
) release_object( process
->token
);
432 /* dump a process on stdout for debugging purposes */
433 static void process_dump( struct object
*obj
, int verbose
)
435 struct process
*process
= (struct process
*)obj
;
436 assert( obj
->ops
== &process_ops
);
438 fprintf( stderr
, "Process id=%04x handles=%p\n", process
->id
, process
->handles
);
441 static int process_signaled( struct object
*obj
, struct thread
*thread
)
443 struct process
*process
= (struct process
*)obj
;
444 return !process
->running_threads
;
447 static unsigned int process_map_access( struct object
*obj
, unsigned int access
)
449 if (access
& GENERIC_READ
) access
|= STANDARD_RIGHTS_READ
| SYNCHRONIZE
;
450 if (access
& GENERIC_WRITE
) access
|= STANDARD_RIGHTS_WRITE
| SYNCHRONIZE
;
451 if (access
& GENERIC_EXECUTE
) access
|= STANDARD_RIGHTS_EXECUTE
;
452 if (access
& GENERIC_ALL
) access
|= PROCESS_ALL_ACCESS
;
453 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
456 static void process_poll_event( struct fd
*fd
, int event
)
458 struct process
*process
= get_fd_user( fd
);
459 assert( process
->obj
.ops
== &process_ops
);
461 if (event
& (POLLERR
| POLLHUP
)) kill_process( process
, 0 );
462 else if (event
& POLLIN
) receive_fd( process
);
465 static void startup_info_destroy( struct object
*obj
)
467 struct startup_info
*info
= (struct startup_info
*)obj
;
468 assert( obj
->ops
== &startup_info_ops
);
470 if (info
->exe_file
) release_object( info
->exe_file
);
471 if (info
->process
) release_object( info
->process
);
474 static void startup_info_dump( struct object
*obj
, int verbose
)
476 struct startup_info
*info
= (struct startup_info
*)obj
;
477 assert( obj
->ops
== &startup_info_ops
);
479 fprintf( stderr
, "Startup info in=%04x out=%04x err=%04x\n",
480 info
->data
->hstdin
, info
->data
->hstdout
, info
->data
->hstderr
);
483 static int startup_info_signaled( struct object
*obj
, struct thread
*thread
)
485 struct startup_info
*info
= (struct startup_info
*)obj
;
486 return info
->process
&& info
->process
->startup_state
!= STARTUP_IN_PROGRESS
;
489 /* get a process from an id (and increment the refcount) */
490 struct process
*get_process_from_id( process_id_t id
)
492 struct object
*obj
= get_ptid_entry( id
);
494 if (obj
&& obj
->ops
== &process_ops
) return (struct process
*)grab_object( obj
);
495 set_error( STATUS_INVALID_PARAMETER
);
499 /* get a process from a handle (and increment the refcount) */
500 struct process
*get_process_from_handle( obj_handle_t handle
, unsigned int access
)
502 return (struct process
*)get_handle_obj( current
->process
, handle
,
503 access
, &process_ops
);
506 /* find a dll from its base address */
507 static inline struct process_dll
*find_process_dll( struct process
*process
, mod_handle_t base
)
509 struct process_dll
*dll
;
511 LIST_FOR_EACH_ENTRY( dll
, &process
->dlls
, struct process_dll
, entry
)
513 if (dll
->base
== base
) return dll
;
518 /* add a dll to a process list */
519 static struct process_dll
*process_load_dll( struct process
*process
, struct mapping
*mapping
,
520 mod_handle_t base
, const WCHAR
*filename
,
521 data_size_t name_len
)
523 struct process_dll
*dll
;
525 /* make sure we don't already have one with the same base address */
526 if (find_process_dll( process
, base
))
528 set_error( STATUS_INVALID_PARAMETER
);
532 if ((dll
= mem_alloc( sizeof(*dll
) )))
536 dll
->filename
= NULL
;
537 dll
->namelen
= name_len
;
538 if (name_len
&& !(dll
->filename
= memdup( filename
, name_len
)))
543 if (mapping
) dll
->mapping
= grab_mapping_unless_removable( mapping
);
544 list_add_tail( &process
->dlls
, &dll
->entry
);
549 /* remove a dll from a process list */
550 static void process_unload_dll( struct process
*process
, mod_handle_t base
)
552 struct process_dll
*dll
= find_process_dll( process
, base
);
554 if (dll
&& (&dll
->entry
!= list_head( &process
->dlls
))) /* main exe can't be unloaded */
556 if (dll
->mapping
) release_object( dll
->mapping
);
557 free( dll
->filename
);
558 list_remove( &dll
->entry
);
560 generate_debug_event( current
, UNLOAD_DLL_DEBUG_EVENT
, &base
);
562 else set_error( STATUS_INVALID_PARAMETER
);
565 /* terminate a process with the given exit code */
566 static void terminate_process( struct process
*process
, struct thread
*skip
, int exit_code
)
568 struct thread
*thread
;
570 grab_object( process
); /* make sure it doesn't get freed when threads die */
572 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
574 if (exit_code
) thread
->exit_code
= exit_code
;
575 if (thread
== skip
) continue;
576 if (thread
->state
== TERMINATED
) continue;
577 kill_thread( thread
, 1 );
580 release_object( process
);
583 /* kill all processes */
584 static void kill_all_processes(void)
588 struct process
*process
;
590 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
592 if (process
->running_threads
) break;
594 if (&process
->entry
== &process_list
) break; /* no process found */
595 terminate_process( process
, NULL
, 1 );
599 /* kill all processes being attached to a console renderer */
600 void kill_console_processes( struct thread
*renderer
, int exit_code
)
602 for (;;) /* restart from the beginning of the list every time */
604 struct process
*process
;
606 /* find the first process being attached to 'renderer' and still running */
607 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
609 if (process
== renderer
->process
) continue;
610 if (!process
->running_threads
) continue;
611 if (process
->console
&& console_get_renderer( process
->console
) == renderer
) break;
613 if (&process
->entry
== &process_list
) break; /* no process found */
614 terminate_process( process
, NULL
, exit_code
);
618 /* a process has been killed (i.e. its last thread died) */
619 static void process_killed( struct process
*process
)
623 assert( list_empty( &process
->thread_list
));
624 process
->end_time
= current_time
;
625 if (!process
->is_system
) close_process_desktop( process
);
626 close_process_handles( process
);
627 process
->winstation
= 0;
628 process
->desktop
= 0;
629 if (process
->idle_event
)
631 release_object( process
->idle_event
);
632 process
->idle_event
= NULL
;
635 /* close the console attached to this process, if any */
636 free_console( process
);
638 while ((ptr
= list_head( &process
->rawinput_devices
)))
640 struct rawinput_device_entry
*entry
= LIST_ENTRY( ptr
, struct rawinput_device_entry
, entry
);
641 list_remove( &entry
->entry
);
644 while ((ptr
= list_head( &process
->dlls
)))
646 struct process_dll
*dll
= LIST_ENTRY( ptr
, struct process_dll
, entry
);
647 if (dll
->mapping
) release_object( dll
->mapping
);
648 free( dll
->filename
);
649 list_remove( &dll
->entry
);
652 destroy_process_classes( process
);
653 free_process_user_handles( process
);
654 remove_process_locks( process
);
655 set_process_startup_state( process
, STARTUP_ABORTED
);
656 finish_process_tracing( process
);
657 start_sigkill_timer( process
);
658 wake_up( &process
->obj
, 0 );
661 /* add a thread to a process running threads list */
662 void add_process_thread( struct process
*process
, struct thread
*thread
)
664 list_add_tail( &process
->thread_list
, &thread
->proc_entry
);
665 if (!process
->running_threads
++)
668 if (!process
->is_system
)
670 if (!user_processes
++ && shutdown_timeout
)
672 remove_timeout_user( shutdown_timeout
);
673 shutdown_timeout
= NULL
;
677 grab_object( thread
);
680 /* remove a thread from a process running threads list */
681 void remove_process_thread( struct process
*process
, struct thread
*thread
)
683 assert( process
->running_threads
> 0 );
684 assert( !list_empty( &process
->thread_list
));
686 list_remove( &thread
->proc_entry
);
688 if (!--process
->running_threads
)
690 /* we have removed the last running thread, exit the process */
691 process
->exit_code
= thread
->exit_code
;
692 generate_debug_event( thread
, EXIT_PROCESS_DEBUG_EVENT
, process
);
693 process_killed( process
);
695 else generate_debug_event( thread
, EXIT_THREAD_DEBUG_EVENT
, thread
);
696 release_object( thread
);
699 /* suspend all the threads of a process */
700 void suspend_process( struct process
*process
)
702 if (!process
->suspend
++)
704 struct list
*ptr
, *next
;
706 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
708 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
709 if (!thread
->suspend
) stop_thread( thread
);
714 /* resume all the threads of a process */
715 void resume_process( struct process
*process
)
717 assert (process
->suspend
> 0);
718 if (!--process
->suspend
)
720 struct list
*ptr
, *next
;
722 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
724 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
725 if (!thread
->suspend
) wake_thread( thread
);
730 /* kill a process on the spot */
731 void kill_process( struct process
*process
, int violent_death
)
733 if (!violent_death
&& process
->msg_fd
) /* normal termination on pipe close */
735 release_object( process
->msg_fd
);
736 process
->msg_fd
= NULL
;
739 if (process
->sigkill_timeout
) /* already waiting for it to die */
741 remove_timeout_user( process
->sigkill_timeout
);
742 process
->sigkill_timeout
= NULL
;
743 process_died( process
);
747 if (violent_death
) terminate_process( process
, NULL
, 1 );
752 grab_object( process
); /* make sure it doesn't get freed when threads die */
753 while ((ptr
= list_head( &process
->thread_list
)))
755 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
756 kill_thread( thread
, 0 );
758 release_object( process
);
762 /* kill all processes being debugged by a given thread */
763 void kill_debugged_processes( struct thread
*debugger
, int exit_code
)
765 for (;;) /* restart from the beginning of the list every time */
767 struct process
*process
;
769 /* find the first process being debugged by 'debugger' and still running */
770 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
772 if (!process
->running_threads
) continue;
773 if (process
->debugger
== debugger
) break;
775 if (&process
->entry
== &process_list
) break; /* no process found */
776 process
->debugger
= NULL
;
777 terminate_process( process
, NULL
, exit_code
);
782 /* trigger a breakpoint event in a given process */
783 void break_process( struct process
*process
)
785 struct thread
*thread
;
787 suspend_process( process
);
789 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
791 if (thread
->context
) /* inside an exception event already */
793 break_thread( thread
);
797 if ((thread
= get_process_first_thread( process
))) thread
->debug_break
= 1;
798 else set_error( STATUS_ACCESS_DENIED
);
800 resume_process( process
);
804 /* detach a debugger from all its debuggees */
805 void detach_debugged_processes( struct thread
*debugger
)
807 struct process
*process
;
809 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
811 if (process
->debugger
== debugger
&& process
->running_threads
)
813 debugger_detach( process
, debugger
);
819 void enum_processes( int (*cb
)(struct process
*, void*), void *user
)
821 struct list
*ptr
, *next
;
823 LIST_FOR_EACH_SAFE( ptr
, next
, &process_list
)
825 struct process
*process
= LIST_ENTRY( ptr
, struct process
, entry
);
826 if ((cb
)(process
, user
)) break;
830 /* set the debugged flag in the process PEB */
831 int set_process_debug_flag( struct process
*process
, int flag
)
833 char data
= (flag
!= 0);
835 /* BeingDebugged flag is the byte at offset 2 in the PEB */
836 return write_process_memory( process
, process
->peb
+ 2, 1, &data
);
839 /* take a snapshot of currently running processes */
840 struct process_snapshot
*process_snap( int *count
)
842 struct process_snapshot
*snapshot
, *ptr
;
843 struct process
*process
;
845 if (!running_processes
) return NULL
;
846 if (!(snapshot
= mem_alloc( sizeof(*snapshot
) * running_processes
)))
849 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
851 if (!process
->running_threads
) continue;
852 ptr
->process
= process
;
853 ptr
->threads
= process
->running_threads
;
854 ptr
->count
= process
->obj
.refcount
;
855 ptr
->priority
= process
->priority
;
856 ptr
->handles
= get_handle_table_count(process
);
857 ptr
->unix_pid
= process
->unix_pid
;
858 grab_object( process
);
862 if (!(*count
= ptr
- snapshot
))
870 /* create a new process */
871 DECL_HANDLER(new_process
)
873 struct startup_info
*info
;
874 struct thread
*thread
;
875 struct process
*process
;
876 struct process
*parent
= current
->process
;
877 int socket_fd
= thread_get_inflight_fd( current
, req
->socket_fd
);
881 set_error( STATUS_INVALID_PARAMETER
);
884 if (fcntl( socket_fd
, F_SETFL
, O_NONBLOCK
) == -1)
886 set_error( STATUS_INVALID_HANDLE
);
892 set_error( STATUS_SHUTDOWN_IN_PROGRESS
);
897 if (!req
->info_size
) /* create an orphaned process */
899 create_process( socket_fd
, NULL
, 0 );
903 /* build the startup info for a new process */
904 if (!(info
= alloc_object( &startup_info_ops
))) return;
905 info
->exe_file
= NULL
;
906 info
->process
= NULL
;
910 !(info
->exe_file
= get_file_obj( current
->process
, req
->exe_file
, FILE_READ_DATA
)))
913 info
->data_size
= get_req_data_size();
914 info
->info_size
= min( req
->info_size
, info
->data_size
);
916 if (req
->info_size
< sizeof(*info
->data
))
918 /* make sure we have a full startup_info_t structure */
919 data_size_t env_size
= info
->data_size
- info
->info_size
;
920 data_size_t info_size
= min( req
->info_size
, FIELD_OFFSET( startup_info_t
, curdir_len
));
922 if (!(info
->data
= mem_alloc( sizeof(*info
->data
) + env_size
))) goto done
;
923 memcpy( info
->data
, get_req_data(), info_size
);
924 memset( (char *)info
->data
+ info_size
, 0, sizeof(*info
->data
) - info_size
);
925 memcpy( info
->data
+ 1, (const char *)get_req_data() + req
->info_size
, env_size
);
926 info
->info_size
= sizeof(startup_info_t
);
927 info
->data_size
= info
->info_size
+ env_size
;
931 data_size_t pos
= sizeof(*info
->data
);
933 if (!(info
->data
= memdup( get_req_data(), info
->data_size
))) goto done
;
934 #define FIXUP_LEN(len) do { (len) = min( (len), info->info_size - pos ); pos += (len); } while(0)
935 FIXUP_LEN( info
->data
->curdir_len
);
936 FIXUP_LEN( info
->data
->dllpath_len
);
937 FIXUP_LEN( info
->data
->imagepath_len
);
938 FIXUP_LEN( info
->data
->cmdline_len
);
939 FIXUP_LEN( info
->data
->title_len
);
940 FIXUP_LEN( info
->data
->desktop_len
);
941 FIXUP_LEN( info
->data
->shellinfo_len
);
942 FIXUP_LEN( info
->data
->runtime_len
);
946 if (!(thread
= create_process( socket_fd
, current
, req
->inherit_all
))) goto done
;
947 process
= thread
->process
;
948 process
->debug_children
= !(req
->create_flags
& DEBUG_ONLY_THIS_PROCESS
);
949 process
->startup_info
= (struct startup_info
*)grab_object( info
);
951 /* connect to the window station */
952 connect_process_winstation( process
, current
);
954 /* thread will be actually suspended in init_done */
955 if (req
->create_flags
& CREATE_SUSPENDED
) thread
->suspend
++;
957 /* set the process console */
958 if (!(req
->create_flags
& (DETACHED_PROCESS
| CREATE_NEW_CONSOLE
)))
960 /* FIXME: some better error checking should be done...
961 * like if hConOut and hConIn are console handles, then they should be on the same
964 inherit_console( current
, process
, req
->inherit_all
? info
->data
->hstdin
: 0 );
967 if (!req
->inherit_all
&& !(req
->create_flags
& CREATE_NEW_CONSOLE
))
969 info
->data
->hstdin
= duplicate_handle( parent
, info
->data
->hstdin
, process
,
970 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
971 info
->data
->hstdout
= duplicate_handle( parent
, info
->data
->hstdout
, process
,
972 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
973 info
->data
->hstderr
= duplicate_handle( parent
, info
->data
->hstderr
, process
,
974 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
975 /* some handles above may have been invalid; this is not an error */
976 if (get_error() == STATUS_INVALID_HANDLE
||
977 get_error() == STATUS_OBJECT_TYPE_MISMATCH
) clear_error();
980 /* attach to the debugger if requested */
981 if (req
->create_flags
& (DEBUG_PROCESS
| DEBUG_ONLY_THIS_PROCESS
))
982 set_process_debugger( process
, current
);
983 else if (parent
->debugger
&& parent
->debug_children
)
984 set_process_debugger( process
, parent
->debugger
);
986 if (!(req
->create_flags
& CREATE_NEW_PROCESS_GROUP
))
987 process
->group_id
= parent
->group_id
;
989 info
->process
= (struct process
*)grab_object( process
);
990 reply
->info
= alloc_handle( current
->process
, info
, SYNCHRONIZE
, 0 );
991 reply
->pid
= get_process_id( process
);
992 reply
->tid
= get_thread_id( thread
);
993 reply
->phandle
= alloc_handle( parent
, process
, req
->process_access
, req
->process_attr
);
994 reply
->thandle
= alloc_handle( parent
, thread
, req
->thread_access
, req
->thread_attr
);
997 release_object( info
);
1000 /* Retrieve information about a newly started process */
1001 DECL_HANDLER(get_new_process_info
)
1003 struct startup_info
*info
;
1005 if ((info
= (struct startup_info
*)get_handle_obj( current
->process
, req
->info
,
1006 0, &startup_info_ops
)))
1008 reply
->success
= is_process_init_done( info
->process
);
1009 reply
->exit_code
= info
->process
->exit_code
;
1010 release_object( info
);
1014 /* Retrieve the new process startup info */
1015 DECL_HANDLER(get_startup_info
)
1017 struct process
*process
= current
->process
;
1018 struct startup_info
*info
= process
->startup_info
;
1023 if (info
->exe_file
&&
1024 !(reply
->exe_file
= alloc_handle( process
, info
->exe_file
, GENERIC_READ
, 0 ))) return;
1026 /* we return the data directly without making a copy so this can only be called once */
1027 reply
->info_size
= info
->info_size
;
1028 size
= info
->data_size
;
1029 if (size
> get_reply_max_size()) size
= get_reply_max_size();
1030 set_reply_data_ptr( info
->data
, size
);
1032 info
->data_size
= 0;
1035 /* signal the end of the process initialization */
1036 DECL_HANDLER(init_process_done
)
1038 struct process_dll
*dll
;
1039 struct process
*process
= current
->process
;
1041 if (is_process_init_done(process
))
1043 set_error( STATUS_INVALID_PARAMETER
);
1046 if (!(dll
= find_process_dll( process
, req
->module
)))
1048 set_error( STATUS_DLL_NOT_FOUND
);
1052 /* main exe is the first in the dll list */
1053 list_remove( &dll
->entry
);
1054 list_add_head( &process
->dlls
, &dll
->entry
);
1056 process
->ldt_copy
= req
->ldt_copy
;
1058 generate_startup_debug_events( process
, req
->entry
);
1059 set_process_startup_state( process
, STARTUP_DONE
);
1061 if (req
->gui
) process
->idle_event
= create_event( NULL
, NULL
, 0, 1, 0, NULL
);
1062 stop_thread_if_suspended( current
);
1063 if (process
->debugger
) set_process_debug_flag( process
, 1 );
1066 /* open a handle to a process */
1067 DECL_HANDLER(open_process
)
1069 struct process
*process
= get_process_from_id( req
->pid
);
1073 reply
->handle
= alloc_handle( current
->process
, process
, req
->access
, req
->attributes
);
1074 release_object( process
);
1078 /* terminate a process */
1079 DECL_HANDLER(terminate_process
)
1081 struct process
*process
;
1083 if ((process
= get_process_from_handle( req
->handle
, PROCESS_TERMINATE
)))
1085 reply
->self
= (current
->process
== process
);
1086 terminate_process( process
, current
, req
->exit_code
);
1087 release_object( process
);
1091 /* fetch information about a process */
1092 DECL_HANDLER(get_process_info
)
1094 struct process
*process
;
1096 if ((process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_INFORMATION
)))
1098 reply
->pid
= get_process_id( process
);
1099 reply
->ppid
= process
->parent
? get_process_id( process
->parent
) : 0;
1100 reply
->exit_code
= process
->exit_code
;
1101 reply
->priority
= process
->priority
;
1102 reply
->affinity
= process
->affinity
;
1103 reply
->peb
= process
->peb
;
1104 reply
->start_time
= process
->start_time
;
1105 reply
->end_time
= process
->end_time
;
1106 reply
->cpu
= process
->cpu
;
1107 reply
->debugger_present
= !!process
->debugger
;
1108 release_object( process
);
1112 static void set_process_affinity( struct process
*process
, affinity_t affinity
)
1114 struct thread
*thread
;
1116 process
->affinity
= affinity
;
1118 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
1120 set_thread_affinity( thread
, affinity
);
1124 /* set information about a process */
1125 DECL_HANDLER(set_process_info
)
1127 struct process
*process
;
1129 if ((process
= get_process_from_handle( req
->handle
, PROCESS_SET_INFORMATION
)))
1131 if (req
->mask
& SET_PROCESS_INFO_PRIORITY
) process
->priority
= req
->priority
;
1132 if (req
->mask
& SET_PROCESS_INFO_AFFINITY
) set_process_affinity( process
, req
->affinity
);
1133 release_object( process
);
1137 /* read data from a process address space */
1138 DECL_HANDLER(read_process_memory
)
1140 struct process
*process
;
1141 data_size_t len
= get_reply_max_size();
1143 if (!(process
= get_process_from_handle( req
->handle
, PROCESS_VM_READ
))) return;
1147 char *buffer
= mem_alloc( len
);
1150 if (read_process_memory( process
, req
->addr
, len
, buffer
))
1151 set_reply_data_ptr( buffer
, len
);
1156 release_object( process
);
1159 /* write data to a process address space */
1160 DECL_HANDLER(write_process_memory
)
1162 struct process
*process
;
1164 if ((process
= get_process_from_handle( req
->handle
, PROCESS_VM_WRITE
)))
1166 data_size_t len
= get_req_data_size();
1167 if (len
) write_process_memory( process
, req
->addr
, len
, get_req_data() );
1168 else set_error( STATUS_INVALID_PARAMETER
);
1169 release_object( process
);
1173 /* notify the server that a dll has been loaded */
1174 DECL_HANDLER(load_dll
)
1176 struct process_dll
*dll
;
1177 struct mapping
*mapping
= NULL
;
1179 if (req
->mapping
&& !(mapping
= get_mapping_obj( current
->process
, req
->mapping
, SECTION_QUERY
)))
1182 if ((dll
= process_load_dll( current
->process
, mapping
, req
->base
,
1183 get_req_data(), get_req_data_size() )))
1185 dll
->size
= req
->size
;
1186 dll
->dbg_offset
= req
->dbg_offset
;
1187 dll
->dbg_size
= req
->dbg_size
;
1188 dll
->name
= req
->name
;
1189 /* only generate event if initialization is done */
1190 if (is_process_init_done( current
->process
))
1191 generate_debug_event( current
, LOAD_DLL_DEBUG_EVENT
, dll
);
1193 if (mapping
) release_object( mapping
);
1196 /* notify the server that a dll is being unloaded */
1197 DECL_HANDLER(unload_dll
)
1199 process_unload_dll( current
->process
, req
->base
);
1202 /* retrieve information about a module in a process */
1203 DECL_HANDLER(get_dll_info
)
1205 struct process
*process
;
1207 if ((process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_INFORMATION
)))
1209 struct process_dll
*dll
;
1211 if (req
->base_address
)
1212 dll
= find_process_dll( process
, req
->base_address
);
1213 else /* NULL means main module */
1214 dll
= list_head( &process
->dlls
) ?
1215 LIST_ENTRY(list_head( &process
->dlls
), struct process_dll
, entry
) : NULL
;
1219 reply
->size
= dll
->size
;
1220 reply
->entry_point
= 0; /* FIXME */
1221 reply
->filename_len
= dll
->namelen
;
1224 if (dll
->namelen
<= get_reply_max_size())
1225 set_reply_data( dll
->filename
, dll
->namelen
);
1227 set_error( STATUS_BUFFER_TOO_SMALL
);
1231 set_error( STATUS_DLL_NOT_FOUND
);
1233 release_object( process
);
1237 /* retrieve the process idle event */
1238 DECL_HANDLER(get_process_idle_event
)
1240 struct process
*process
;
1243 if ((process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_INFORMATION
)))
1245 if (process
->idle_event
&& process
!= current
->process
)
1246 reply
->event
= alloc_handle( current
->process
, process
->idle_event
,
1247 EVENT_ALL_ACCESS
, 0 );
1248 release_object( process
);
1252 /* make the current process a system process */
1253 DECL_HANDLER(make_process_system
)
1255 struct process
*process
= current
->process
;
1257 if (!shutdown_event
)
1259 if (!(shutdown_event
= create_event( NULL
, NULL
, 0, 1, 0, NULL
))) return;
1260 make_object_static( (struct object
*)shutdown_event
);
1263 if (!(reply
->event
= alloc_handle( current
->process
, shutdown_event
, SYNCHRONIZE
, 0 )))
1266 if (!process
->is_system
)
1268 process
->is_system
= 1;
1269 close_process_desktop( process
);
1270 if (!--user_processes
&& !shutdown_stage
&& master_socket_timeout
!= TIMEOUT_INFINITE
)
1271 shutdown_timeout
= add_timeout_user( master_socket_timeout
, server_shutdown_timeout
, NULL
);