1 /*
2 * Server-side process management
3 *
4 * Copyright (C) 1998 Alexandre Julliard
5 *
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.
10 *
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.
15 *
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
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <limits.h>
26 #include <signal.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <sys/time.h>
32 #ifdef HAVE_SYS_SOCKET_H
33 # include <sys/socket.h>
34 #endif
35 #include <unistd.h>
36 #ifdef HAVE_POLL_H
37 #include <poll.h>
38 #endif
39
40 #include "ntstatus.h"
41 #define WIN32_NO_STATUS
42 #include "winternl.h"
43
44 #include "file.h"
45 #include "handle.h"
46 #include "process.h"
47 #include "thread.h"
48 #include "request.h"
49 #include "user.h"
50 #include "security.h"
51
52 /* process structure */
53
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 */
59
60 /* process operations */
61
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 );
67
68 static const struct object_ops process_ops =
69 {
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 */
86 };
87
88 static const struct fd_ops process_fd_ops =
89 {
90 NULL, /* get_poll_events */
91 process_poll_event, /* poll_event */
92 NULL, /* flush */
93 NULL, /* get_fd_type */
94 NULL, /* ioctl */
95 NULL, /* queue_async */
96 NULL, /* reselect_async */
97 NULL /* cancel async */
98 };
99
100 /* process startup info */
101
102 struct startup_info
103 {
104 struct object obj; /* object header */
105 obj_handle_t hstdin; /* handle for stdin */
106 obj_handle_t hstdout; /* handle for stdout */
107 obj_handle_t hstderr; /* handle for stderr */
108 struct file *exe_file; /* file handle for main exe */
109 struct process *process; /* created process */
110 data_size_t data_size; /* size of startup data */
111 void *data; /* data for startup info */
112 };
113
114 static void startup_info_dump( struct object *obj, int verbose );
115 static int startup_info_signaled( struct object *obj, struct thread *thread );
116 static void startup_info_destroy( struct object *obj );
117
118 static const struct object_ops startup_info_ops =
119 {
120 sizeof(struct startup_info), /* size */
121 startup_info_dump, /* dump */
122 no_get_type, /* get_type */
123 add_queue, /* add_queue */
124 remove_queue, /* remove_queue */
125 startup_info_signaled, /* signaled */
126 no_satisfied, /* satisfied */
127 no_signal, /* signal */
128 no_get_fd, /* get_fd */
129 no_map_access, /* map_access */
130 default_get_sd, /* get_sd */
131 default_set_sd, /* set_sd */
132 no_lookup_name, /* lookup_name */
133 no_open_file, /* open_file */
134 no_close_handle, /* close_handle */
135 startup_info_destroy /* destroy */
136 };
137
138
139 struct ptid_entry
140 {
141 void *ptr; /* entry ptr */
142 unsigned int next; /* next free entry */
143 };
144
145 static struct ptid_entry *ptid_entries; /* array of ptid entries */
146 static unsigned int used_ptid_entries; /* number of entries in use */
147 static unsigned int alloc_ptid_entries; /* number of allocated entries */
148 static unsigned int next_free_ptid; /* next free entry */
149 static unsigned int last_free_ptid; /* last free entry */
150
151 static void kill_all_processes(void);
152
153 #define PTID_OFFSET 8 /* offset for first ptid value */
154
155 /* allocate a new process or thread id */
156 unsigned int alloc_ptid( void *ptr )
157 {
158 struct ptid_entry *entry;
159 unsigned int id;
160
161 if (used_ptid_entries < alloc_ptid_entries)
162 {
163 id = used_ptid_entries + PTID_OFFSET;
164 entry = &ptid_entries[used_ptid_entries++];
165 }
166 else if (next_free_ptid)
167 {
168 id = next_free_ptid;
169 entry = &ptid_entries[id - PTID_OFFSET];
170 if (!(next_free_ptid = entry->next)) last_free_ptid = 0;
171 }
172 else /* need to grow the array */
173 {
174 unsigned int count = alloc_ptid_entries + (alloc_ptid_entries / 2);
175 if (!count) count = 64;
176 if (!(entry = realloc( ptid_entries, count * sizeof(*entry) )))
177 {
178 set_error( STATUS_NO_MEMORY );
179 return 0;
180 }
181 ptid_entries = entry;
182 alloc_ptid_entries = count;
183 id = used_ptid_entries + PTID_OFFSET;
184 entry = &ptid_entries[used_ptid_entries++];
185 }
186
187 entry->ptr = ptr;
188 return id;
189 }
190
191 /* free a process or thread id */
192 void free_ptid( unsigned int id )
193 {
194 struct ptid_entry *entry = &ptid_entries[id - PTID_OFFSET];
195
196 entry->ptr = NULL;
197 entry->next = 0;
198
199 /* append to end of free list so that we don't reuse it too early */
200 if (last_free_ptid) ptid_entries[last_free_ptid - PTID_OFFSET].next = id;
201 else next_free_ptid = id;
202
203 last_free_ptid = id;
204 }
205
206 /* retrieve the pointer corresponding to a process or thread id */
207 void *get_ptid_entry( unsigned int id )
208 {
209 if (id < PTID_OFFSET) return NULL;
210 if (id - PTID_OFFSET >= used_ptid_entries) return NULL;
211 return ptid_entries[id - PTID_OFFSET].ptr;
212 }
213
214 /* return the main thread of the process */
215 struct thread *get_process_first_thread( struct process *process )
216 {
217 struct list *ptr = list_head( &process->thread_list );
218 if (!ptr) return NULL;
219 return LIST_ENTRY( ptr, struct thread, proc_entry );
220 }
221
222 /* set the state of the process startup info */
223 static void set_process_startup_state( struct process *process, enum startup_state state )
224 {
225 if (process->startup_state == STARTUP_IN_PROGRESS) process->startup_state = state;
226 if (process->startup_info)
227 {
228 wake_up( &process->startup_info->obj, 0 );
229 release_object( process->startup_info );
230 process->startup_info = NULL;
231 }
232 }
233
234 /* callback for server shutdown */
235 static void server_shutdown_timeout( void *arg )
236 {
237 shutdown_timeout = NULL;
238 if (!running_processes)
239 {
240 close_master_socket( 0 );
241 return;
242 }
243 switch(++shutdown_stage)
244 {
245 case 1: /* signal system processes to exit */
246 if (debug_level) fprintf( stderr, "wineserver: shutting down\n" );
247 if (shutdown_event) set_event( shutdown_event );
248 shutdown_timeout = add_timeout_user( 2 * -TICKS_PER_SEC, server_shutdown_timeout, NULL );
249 close_master_socket( 4 * -TICKS_PER_SEC );
250 break;
251 case 2: /* now forcibly kill all processes (but still wait for SIGKILL timeouts) */
252 kill_all_processes();
253 break;
254 }
255 }
256
257 /* forced shutdown, used for wineserver -k */
258 void shutdown_master_socket(void)
259 {
260 kill_all_processes();
261 shutdown_stage = 2;
262 if (shutdown_timeout)
263 {
264 remove_timeout_user( shutdown_timeout );
265 shutdown_timeout = NULL;
266 }
267 close_master_socket( 2 * -TICKS_PER_SEC ); /* for SIGKILL timeouts */
268 }
269
270 /* final cleanup once we are sure a process is really dead */
271 static void process_died( struct process *process )
272 {
273 if (debug_level) fprintf( stderr, "%04x: *process killed*\n", process->id );
274 if (!process->is_system)
275 {
276 if (!--user_processes && !shutdown_stage && master_socket_timeout != TIMEOUT_INFINITE)
277 shutdown_timeout = add_timeout_user( master_socket_timeout, server_shutdown_timeout, NULL );
278 }
279 release_object( process );
280 if (!--running_processes && shutdown_stage) close_master_socket( 0 );
281 }
282
283 /* callback for process sigkill timeout */
284 static void process_sigkill( void *private )
285 {
286 struct process *process = private;
287
288 process->sigkill_timeout = NULL;
289 kill( process->unix_pid, SIGKILL );
290 process_died( process );
291 }
292
293 /* start the sigkill timer for a process upon exit */
294 static void start_sigkill_timer( struct process *process )
295 {
296 grab_object( process );
297 if (process->unix_pid != -1 && process->msg_fd)
298 process->sigkill_timeout = add_timeout_user( -TICKS_PER_SEC, process_sigkill, process );
299 else
300 process_died( process );
301 }
302
303 /* create a new process and its main thread */
304 /* if the function fails the fd is closed */
305 struct thread *create_process( int fd, struct thread *parent_thread, int inherit_all )
306 {
307 struct process *process;
308 struct thread *thread = NULL;
309 int request_pipe[2];
310
311 if (!(process = alloc_object( &process_ops )))
312 {
313 close( fd );
314 goto error;
315 }
316 process->parent = NULL;
317 process->debugger = NULL;
318 process->handles = NULL;
319 process->msg_fd = NULL;
320 process->sigkill_timeout = NULL;
321 process->unix_pid = -1;
322 process->exit_code = STILL_ACTIVE;
323 process->running_threads = 0;
324 process->priority = PROCESS_PRIOCLASS_NORMAL;
325 process->affinity = ~0;
326 process->suspend = 0;
327 process->is_system = 0;
328 process->create_flags = 0;
329 process->console = NULL;
330 process->startup_state = STARTUP_IN_PROGRESS;
331 process->startup_info = NULL;
332 process->idle_event = NULL;
333 process->queue = NULL;
334 process->peb = NULL;
335 process->ldt_copy = NULL;
336 process->winstation = 0;
337 process->desktop = 0;
338 process->token = NULL;
339 process->trace_data = 0;
340 list_init( &process->thread_list );
341 list_init( &process->locks );
342 list_init( &process->classes );
343 list_init( &process->dlls );
344
345 process->start_time = current_time;
346 process->end_time = 0;
347 list_add_tail( &process_list, &process->entry );
348
349 if (!(process->id = process->group_id = alloc_ptid( process )))
350 {
351 close( fd );
352 goto error;
353 }
354 if (!(process->msg_fd = create_anonymous_fd( &process_fd_ops, fd, &process->obj, 0 ))) goto error;
355
356 /* create the handle table */
357 if (!parent_thread)
358 {
359 process->handles = alloc_handle_table( process, 0 );
360 process->token = token_create_admin();
361 }
362 else
363 {
364 struct process *parent = parent_thread->process;
365 process->parent = (struct process *)grab_object( parent );
366 process->handles = inherit_all ? copy_handle_table( process, parent )
367 : alloc_handle_table( process, 0 );
368 /* Note: for security reasons, starting a new process does not attempt
369 * to use the current impersonation token for the new process */
370 process->token = token_duplicate( parent->token, TRUE, 0 );
371 }
372 if (!process->handles || !process->token) goto error;
373
374 /* create the main thread */
375 if (pipe( request_pipe ) == -1)
376 {
377 file_set_error();
378 goto error;
379 }
380 if (send_client_fd( process, request_pipe[1], 0 ) == -1)
381 {
382 close( request_pipe[0] );
383 close( request_pipe[1] );
384 goto error;
385 }
386 close( request_pipe[1] );
387 if (!(thread = create_thread( request_pipe[0], process ))) goto error;
388
389 set_fd_events( process->msg_fd, POLLIN ); /* start listening to events */
390 release_object( process );
391 return thread;
392
393 error:
394 if (process) release_object( process );
395 /* if we failed to start our first process, close everything down */
396 if (!running_processes) close_master_socket( 0 );
397 return NULL;
398 }
399
400 /* initialize the current process and fill in the request */
401 data_size_t init_process( struct thread *thread )
402 {
403 struct process *process = thread->process;
404 struct startup_info *info = process->startup_info;
405
406 init_process_tracing( process );
407 if (!info) return 0;
408 return info->data_size;
409 }
410
411 /* destroy a process when its refcount is 0 */
412 static void process_destroy( struct object *obj )
413 {
414 struct process *process = (struct process *)obj;
415 assert( obj->ops == &process_ops );
416
417 /* we can't have a thread remaining */
418 assert( list_empty( &process->thread_list ));
419
420 assert( !process->sigkill_timeout ); /* timeout should hold a reference to the process */
421
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->queue) release_object( process->queue );
429 if (process->id) free_ptid( process->id );
430 if (process->token) release_object( process->token );
431 }
432
433 /* dump a process on stdout for debugging purposes */
434 static void process_dump( struct object *obj, int verbose )
435 {
436 struct process *process = (struct process *)obj;
437 assert( obj->ops == &process_ops );
438
439 fprintf( stderr, "Process id=%04x handles=%p\n", process->id, process->handles );
440 }
441
442 static int process_signaled( struct object *obj, struct thread *thread )
443 {
444 struct process *process = (struct process *)obj;
445 return !process->running_threads;
446 }
447
448 static unsigned int process_map_access( struct object *obj, unsigned int access )
449 {
450 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ | SYNCHRONIZE;
451 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | SYNCHRONIZE;
452 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
453 if (access & GENERIC_ALL) access |= PROCESS_ALL_ACCESS;
454 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
455 }
456
457 static void process_poll_event( struct fd *fd, int event )
458 {
459 struct process *process = get_fd_user( fd );
460 assert( process->obj.ops == &process_ops );
461
462 if (event & (POLLERR | POLLHUP))
463 {
464 release_object( process->msg_fd );
465 process->msg_fd = NULL;
466 if (process->sigkill_timeout) /* already waiting for it to die */
467 {
468 remove_timeout_user( process->sigkill_timeout );
469 process->sigkill_timeout = NULL;
470 process_died( process );
471 }
472 else kill_process( process, 0 );
473 }
474 else if (event & POLLIN) receive_fd( process );
475 }
476
477 static void startup_info_destroy( struct object *obj )
478 {
479 struct startup_info *info = (struct startup_info *)obj;
480 assert( obj->ops == &startup_info_ops );
481 free( info->data );
482 if (info->exe_file) release_object( info->exe_file );
483 if (info->process) release_object( info->process );
484 }
485
486 static void startup_info_dump( struct object *obj, int verbose )
487 {
488 struct startup_info *info = (struct startup_info *)obj;
489 assert( obj->ops == &startup_info_ops );
490
491 fprintf( stderr, "Startup info in=%p out=%p err=%p\n",
492 info->hstdin, info->hstdout, info->hstderr );
493 }
494
495 static int startup_info_signaled( struct object *obj, struct thread *thread )
496 {
497 struct startup_info *info = (struct startup_info *)obj;
498 return info->process && info->process->startup_state != STARTUP_IN_PROGRESS;
499 }
500
501 /* get a process from an id (and increment the refcount) */
502 struct process *get_process_from_id( process_id_t id )
503 {
504 struct object *obj = get_ptid_entry( id );
505
506 if (obj && obj->ops == &process_ops) return (struct process *)grab_object( obj );
507 set_error( STATUS_INVALID_PARAMETER );
508 return NULL;
509 }
510
511 /* get a process from a handle (and increment the refcount) */
512 struct process *get_process_from_handle( obj_handle_t handle, unsigned int access )
513 {
514 return (struct process *)get_handle_obj( current->process, handle,
515 access, &process_ops );
516 }
517
518 /* find a dll from its base address */
519 static inline struct process_dll *find_process_dll( struct process *process, void *base )
520 {
521 struct process_dll *dll;
522
523 LIST_FOR_EACH_ENTRY( dll, &process->dlls, struct process_dll, entry )
524 {
525 if (dll->base == base) return dll;
526 }
527 return NULL;
528 }
529
530 /* add a dll to a process list */
531 static struct process_dll *process_load_dll( struct process *process, struct file *file,
532 void *base, const WCHAR *filename, data_size_t name_len )
533 {
534 struct process_dll *dll;
535
536 /* make sure we don't already have one with the same base address */
537 if (find_process_dll( process, base ))
538 {
539 set_error( STATUS_INVALID_PARAMETER );
540 return NULL;
541 }
542
543 if ((dll = mem_alloc( sizeof(*dll) )))
544 {
545 dll->file = NULL;
546 dll->base = base;
547 dll->filename = NULL;
548 dll->namelen = name_len;
549 if (name_len && !(dll->filename = memdup( filename, name_len )))
550 {
551 free( dll );
552 return NULL;
553 }
554 if (file) dll->file = grab_file_unless_removable( file );
555 list_add_tail( &process->dlls, &dll->entry );
556 }
557 return dll;
558 }
559
560 /* remove a dll from a process list */
561 static void process_unload_dll( struct process *process, void *base )
562 {
563 struct process_dll *dll = find_process_dll( process, base );
564
565 if (dll && (&dll->entry != list_head( &process->dlls ))) /* main exe can't be unloaded */
566 {
567 if (dll->file) release_object( dll->file );
568 free( dll->filename );
569 list_remove( &dll->entry );
570 free( dll );
571 generate_debug_event( current, UNLOAD_DLL_DEBUG_EVENT, base );
572 }
573 else set_error( STATUS_INVALID_PARAMETER );
574 }
575
576 /* terminate a process with the given exit code */
577 static void terminate_process( struct process *process, struct thread *skip, int exit_code )
578 {
579 struct list *ptr;
580
581 if (skip && skip->process == process) /* move it to the end of the list */
582 {
583 assert( skip->state != TERMINATED );
584 list_remove( &skip->proc_entry );
585 list_add_tail( &process->thread_list, &skip->proc_entry );
586 }
587
588 grab_object( process ); /* make sure it doesn't get freed when threads die */
589 while ((ptr = list_head( &process->thread_list )))
590 {
591 struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
592
593 if (exit_code) thread->exit_code = exit_code;
594 if (thread == skip) break;
595 kill_thread( thread, 1 );
596 }
597 release_object( process );
598 }
599
600 /* kill all processes */
601 static void kill_all_processes(void)
602 {
603 for (;;)
604 {
605 struct process *process;
606
607 LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
608 {
609 if (process->running_threads) break;
610 }
611 if (&process->entry == &process_list) break; /* no process found */
612 terminate_process( process, NULL, 1 );
613 }
614 }
615
616 /* kill all processes being attached to a console renderer */
617 void kill_console_processes( struct thread *renderer, int exit_code )
618 {
619 for (;;) /* restart from the beginning of the list every time */
620 {
621 struct process *process;
622
623 /* find the first process being attached to 'renderer' and still running */
624 LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
625 {
626 if (process == renderer->process) continue;
627 if (!process->running_threads) continue;
628 if (process->console && console_get_renderer( process->console ) == renderer) break;
629 }
630 if (&process->entry == &process_list) break; /* no process found */
631 terminate_process( process, NULL, exit_code );
632 }
633 }
634
635 /* a process has been killed (i.e. its last thread died) */
636 static void process_killed( struct process *process )
637 {
638 struct handle_table *handles;
639 struct list *ptr;
640
641 assert( list_empty( &process->thread_list ));
642 process->end_time = current_time;
643 if (!process->is_system) close_process_desktop( process );
644 handles = process->handles;
645 process->handles = NULL;
646 if (handles) release_object( handles );
647
648 /* close the console attached to this process, if any */
649 free_console( process );
650
651 while ((ptr = list_head( &process->dlls )))
652 {
653 struct process_dll *dll = LIST_ENTRY( ptr, struct process_dll, entry );
654 if (dll->file) release_object( dll->file );
655 free( dll->filename );
656 list_remove( &dll->entry );
657 free( dll );
658 }
659 destroy_process_classes( process );
660 remove_process_locks( process );
661 set_process_startup_state( process, STARTUP_ABORTED );
662 finish_process_tracing( process );
663 start_sigkill_timer( process );
664 wake_up( &process->obj, 0 );
665 }
666
667 /* add a thread to a process running threads list */
668 void add_process_thread( struct process *process, struct thread *thread )
669 {
670 list_add_tail( &process->thread_list, &thread->proc_entry );
671 if (!process->running_threads++)
672 {
673 running_processes++;
674 if (!process->is_system)
675 {
676 if (!user_processes++ && shutdown_timeout)
677 {
678 remove_timeout_user( shutdown_timeout );
679 shutdown_timeout = NULL;
680 }
681 }
682 }
683 grab_object( thread );
684 }
685
686 /* remove a thread from a process running threads list */
687 void remove_process_thread( struct process *process, struct thread *thread )
688 {
689 assert( process->running_threads > 0 );
690 assert( !list_empty( &process->thread_list ));
691
692 list_remove( &thread->proc_entry );
693
694 if (!--process->running_threads)
695 {
696 /* we have removed the last running thread, exit the process */
697 process->exit_code = thread->exit_code;
698 generate_debug_event( thread, EXIT_PROCESS_DEBUG_EVENT, process );
699 process_killed( process );
700 }
701 else generate_debug_event( thread, EXIT_THREAD_DEBUG_EVENT, thread );
702 release_object( thread );
703 }
704
705 /* suspend all the threads of a process */
706 void suspend_process( struct process *process )
707 {
708 if (!process->suspend++)
709 {
710 struct list *ptr, *next;
711
712 LIST_FOR_EACH_SAFE( ptr, next, &process->thread_list )
713 {
714 struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
715 if (!thread->suspend) stop_thread( thread );
716 }
717 }
718 }
719
720 /* resume all the threads of a process */
721 void resume_process( struct process *process )
722 {
723 assert (process->suspend > 0);
724 if (!--process->suspend)
725 {
726 struct list *ptr, *next;
727
728 LIST_FOR_EACH_SAFE( ptr, next, &process->thread_list )
729 {
730 struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
731 if (!thread->suspend) wake_thread( thread );
732 }
733 }
734 }
735
736 /* kill a process on the spot */
737 void kill_process( struct process *process, int violent_death )
738 {
739 if (violent_death) terminate_process( process, NULL, 1 );
740 else
741 {
742 struct list *ptr;
743
744 grab_object( process ); /* make sure it doesn't get freed when threads die */
745 while ((ptr = list_head( &process->thread_list )))
746 {
747 struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
748 kill_thread( thread, 0 );
749 }
750 release_object( process );
751 }
752 }
753
754 /* kill all processes being debugged by a given thread */
755 void kill_debugged_processes( struct thread *debugger, int exit_code )
756 {
757 for (;;) /* restart from the beginning of the list every time */
758 {
759 struct process *process;
760
761 /* find the first process being debugged by 'debugger' and still running */
762 LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
763 {
764 if (!process->running_threads) continue;
765 if (process->debugger == debugger) break;
766 }
767 if (&process->entry == &process_list) break; /* no process found */
768 process->debugger = NULL;
769 terminate_process( process, NULL, exit_code );
770 }
771 }
772
773
774 /* trigger a breakpoint event in a given process */
775 void break_process( struct process *process )
776 {
777 struct thread *thread;
778
779 suspend_process( process );
780
781 LIST_FOR_EACH_ENTRY( thread, &process->thread_list, struct thread, proc_entry )
782 {
783 if (thread->context) /* inside an exception event already */
784 {
785 break_thread( thread );
786 goto done;
787 }
788 }
789 if ((thread = get_process_first_thread( process ))) thread->debug_break = 1;
790 else set_error( STATUS_ACCESS_DENIED );
791 done:
792 resume_process( process );
793 }
794
795
796 /* detach a debugger from all its debuggees */
797 void detach_debugged_processes( struct thread *debugger )
798 {
799 struct process *process;
800
801 LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
802 {
803 if (process->debugger == debugger && process->running_threads)
804 {
805 debugger_detach( process, debugger );
806 }
807 }
808 }
809
810
811 void enum_processes( int (*cb)(struct process*, void*), void *user )
812 {
813 struct list *ptr, *next;
814
815 LIST_FOR_EACH_SAFE( ptr, next, &process_list )
816 {
817 struct process *process = LIST_ENTRY( ptr, struct process, entry );
818 if ((cb)(process, user)) break;
819 }
820 }
821
822 /* set the debugged flag in the process PEB */
823 int set_process_debug_flag( struct process *process, int flag )
824 {
825 char data = (flag != 0);
826
827 /* BeingDebugged flag is the byte at offset 2 in the PEB */
828 return write_process_memory( process, (char *)process->peb + 2, 1, &data );
829 }
830
831 /* take a snapshot of currently running processes */
832 struct process_snapshot *process_snap( int *count )
833 {
834 struct process_snapshot *snapshot, *ptr;
835 struct process *process;
836
837 if (!running_processes) return NULL;
838 if (!(snapshot = mem_alloc( sizeof(*snapshot) * running_processes )))
839 return NULL;
840 ptr = snapshot;
841 LIST_FOR_EACH_ENTRY( process, &process_list, struct process, entry )
842 {
843 if (!process->running_threads) continue;
844 ptr->process = process;
845 ptr->threads = process->running_threads;
846 ptr->count = process->obj.refcount;
847 ptr->priority = process->priority;
848 ptr->handles = get_handle_table_count(process);
849 grab_object( process );
850 ptr++;
851 }
852
853 if (!(*count = ptr - snapshot))
854 {
855 free( snapshot );
856 snapshot = NULL;
857 }
858 return snapshot;
859 }
860
861 /* take a snapshot of the modules of a process */
862 struct module_snapshot *module_snap( struct process *process, int *count )
863 {
864 struct module_snapshot *snapshot, *ptr;
865 struct process_dll *dll;
866 int total = 0;
867
868 LIST_FOR_EACH_ENTRY( dll, &process->dlls, struct process_dll, entry ) total++;
869 if (!(snapshot = mem_alloc( sizeof(*snapshot) * total ))) return NULL;
870
871 ptr = snapshot;
872 LIST_FOR_EACH_ENTRY( dll, &process->dlls, struct process_dll, entry )
873 {
874 ptr->base = dll->base;
875 ptr->size = dll->size;
876 ptr->namelen = dll->namelen;
877 ptr->filename = memdup( dll->filename, dll->namelen );
878 ptr++;
879 }
880 *count = total;
881 return snapshot;
882 }
883
884
885 /* create a new process */
886 DECL_HANDLER(new_process)
887 {
888 struct startup_info *info;
889 struct thread *thread;
890 struct process *process;
891 struct