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"
33 #ifdef HAVE_SYS_SOCKET_H
34 # include <sys/socket.h>
42 #define WIN32_NO_STATUS
55 static struct list process_list
= LIST_INIT(process_list
);
56 static int running_processes
, user_processes
;
57 static struct event
*shutdown_event
; /* signaled when shutdown starts */
58 static struct timeout_user
*shutdown_timeout
; /* timeout for server shutdown */
59 static int shutdown_stage
; /* current stage in the shutdown process */
61 static const WCHAR process_name
[] = {'P','r','o','c','e','s','s'};
63 struct type_descr process_type
=
65 { process_name
, sizeof(process_name
) }, /* name */
66 PROCESS_ALL_ACCESS
, /* valid_access */
68 STANDARD_RIGHTS_READ
| PROCESS_VM_READ
| PROCESS_QUERY_INFORMATION
,
69 STANDARD_RIGHTS_WRITE
| PROCESS_SUSPEND_RESUME
| PROCESS_SET_INFORMATION
| PROCESS_SET_QUOTA
70 | PROCESS_CREATE_PROCESS
| PROCESS_DUP_HANDLE
| PROCESS_VM_WRITE
| PROCESS_VM_OPERATION
71 | PROCESS_CREATE_THREAD
,
72 STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE
| PROCESS_QUERY_LIMITED_INFORMATION
| PROCESS_TERMINATE
,
77 static void process_dump( struct object
*obj
, int verbose
);
78 static int process_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
79 static unsigned int process_map_access( struct object
*obj
, unsigned int access
);
80 static struct security_descriptor
*process_get_sd( struct object
*obj
);
81 static void process_poll_event( struct fd
*fd
, int event
);
82 static struct list
*process_get_kernel_obj_list( struct object
*obj
);
83 static void process_destroy( struct object
*obj
);
84 static void terminate_process( struct process
*process
, struct thread
*skip
, int exit_code
);
86 static const struct object_ops process_ops
=
88 sizeof(struct process
), /* size */
89 &process_type
, /* type */
90 process_dump
, /* dump */
91 add_queue
, /* add_queue */
92 remove_queue
, /* remove_queue */
93 process_signaled
, /* signaled */
94 no_satisfied
, /* satisfied */
95 no_signal
, /* signal */
96 no_get_fd
, /* get_fd */
97 process_map_access
, /* map_access */
98 process_get_sd
, /* get_sd */
99 default_set_sd
, /* set_sd */
100 no_get_full_name
, /* get_full_name */
101 no_lookup_name
, /* lookup_name */
102 no_link_name
, /* link_name */
103 NULL
, /* unlink_name */
104 no_open_file
, /* open_file */
105 process_get_kernel_obj_list
, /* get_kernel_obj_list */
106 no_close_handle
, /* close_handle */
107 process_destroy
/* destroy */
110 static const struct fd_ops process_fd_ops
=
112 NULL
, /* get_poll_events */
113 process_poll_event
, /* poll_event */
115 NULL
, /* get_fd_type */
117 NULL
, /* queue_async */
118 NULL
, /* reselect_async */
119 NULL
/* cancel async */
122 /* process startup info */
126 struct object obj
; /* object header */
127 struct process
*process
; /* created process */
128 data_size_t info_size
; /* size of startup info */
129 data_size_t data_size
; /* size of whole startup data */
130 startup_info_t
*data
; /* data for startup info */
133 static void startup_info_dump( struct object
*obj
, int verbose
);
134 static int startup_info_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
135 static void startup_info_destroy( struct object
*obj
);
137 static const struct object_ops startup_info_ops
=
139 sizeof(struct startup_info
), /* size */
141 startup_info_dump
, /* dump */
142 add_queue
, /* add_queue */
143 remove_queue
, /* remove_queue */
144 startup_info_signaled
, /* signaled */
145 no_satisfied
, /* satisfied */
146 no_signal
, /* signal */
147 no_get_fd
, /* get_fd */
148 default_map_access
, /* map_access */
149 default_get_sd
, /* get_sd */
150 default_set_sd
, /* set_sd */
151 no_get_full_name
, /* get_full_name */
152 no_lookup_name
, /* lookup_name */
153 no_link_name
, /* link_name */
154 NULL
, /* unlink_name */
155 no_open_file
, /* open_file */
156 no_kernel_obj_list
, /* get_kernel_obj_list */
157 no_close_handle
, /* close_handle */
158 startup_info_destroy
/* destroy */
163 static const WCHAR job_name
[] = {'J','o','b'};
165 struct type_descr job_type
=
167 { job_name
, sizeof(job_name
) }, /* name */
168 JOB_OBJECT_ALL_ACCESS
, /* valid_access */
170 STANDARD_RIGHTS_READ
| JOB_OBJECT_QUERY
,
171 STANDARD_RIGHTS_WRITE
| JOB_OBJECT_TERMINATE
| JOB_OBJECT_SET_ATTRIBUTES
| JOB_OBJECT_ASSIGN_PROCESS
,
172 STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE
,
173 JOB_OBJECT_ALL_ACCESS
177 static void job_dump( struct object
*obj
, int verbose
);
178 static int job_signaled( struct object
*obj
, struct wait_queue_entry
*entry
);
179 static int job_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
);
180 static void job_destroy( struct object
*obj
);
184 struct object obj
; /* object header */
185 struct list process_list
; /* list of all processes */
186 int num_processes
; /* count of running processes */
187 int total_processes
; /* count of processes which have been assigned */
188 unsigned int limit_flags
; /* limit flags */
189 int terminating
; /* job is terminating */
190 int signaled
; /* job is signaled */
191 struct completion
*completion_port
; /* associated completion port */
192 apc_param_t completion_key
; /* key to send with completion messages */
195 static const struct object_ops job_ops
=
197 sizeof(struct job
), /* size */
198 &job_type
, /* type */
200 add_queue
, /* add_queue */
201 remove_queue
, /* remove_queue */
202 job_signaled
, /* signaled */
203 no_satisfied
, /* satisfied */
204 no_signal
, /* signal */
205 no_get_fd
, /* get_fd */
206 default_map_access
, /* map_access */
207 default_get_sd
, /* get_sd */
208 default_set_sd
, /* set_sd */
209 default_get_full_name
, /* get_full_name */
210 no_lookup_name
, /* lookup_name */
211 directory_link_name
, /* link_name */
212 default_unlink_name
, /* unlink_name */
213 no_open_file
, /* open_file */
214 no_kernel_obj_list
, /* get_kernel_obj_list */
215 job_close_handle
, /* close_handle */
216 job_destroy
/* destroy */
219 static struct job
*create_job_object( struct object
*root
, const struct unicode_str
*name
,
220 unsigned int attr
, const struct security_descriptor
*sd
)
224 if ((job
= create_named_object( root
, &job_ops
, name
, attr
, sd
)))
226 if (get_error() != STATUS_OBJECT_NAME_EXISTS
)
228 /* initialize it if it didn't already exist */
229 list_init( &job
->process_list
);
230 job
->num_processes
= 0;
231 job
->total_processes
= 0;
232 job
->limit_flags
= 0;
233 job
->terminating
= 0;
235 job
->completion_port
= NULL
;
236 job
->completion_key
= 0;
242 static struct job
*get_job_obj( struct process
*process
, obj_handle_t handle
, unsigned int access
)
244 return (struct job
*)get_handle_obj( process
, handle
, access
, &job_ops
);
247 static void add_job_completion( struct job
*job
, apc_param_t msg
, apc_param_t pid
)
249 if (job
->completion_port
)
250 add_completion( job
->completion_port
, job
->completion_key
, pid
, STATUS_SUCCESS
, msg
);
253 static void add_job_process( struct job
*job
, struct process
*process
)
255 process
->job
= (struct job
*)grab_object( job
);
256 list_add_tail( &job
->process_list
, &process
->job_entry
);
257 job
->num_processes
++;
258 job
->total_processes
++;
260 add_job_completion( job
, JOB_OBJECT_MSG_NEW_PROCESS
, get_process_id(process
) );
263 /* called when a process has terminated, allow one additional process */
264 static void release_job_process( struct process
*process
)
266 struct job
*job
= process
->job
;
270 assert( job
->num_processes
);
271 job
->num_processes
--;
273 if (!job
->terminating
)
274 add_job_completion( job
, JOB_OBJECT_MSG_EXIT_PROCESS
, get_process_id(process
) );
276 if (!job
->num_processes
)
277 add_job_completion( job
, JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO
, 0 );
280 static void terminate_job( struct job
*job
, int exit_code
)
282 /* don't report completion events for terminated processes */
283 job
->terminating
= 1;
285 for (;;) /* restart from the beginning of the list every time */
287 struct process
*process
;
289 /* find the first process associated with this job and still running */
290 LIST_FOR_EACH_ENTRY( process
, &job
->process_list
, struct process
, job_entry
)
292 if (process
->running_threads
) break;
294 if (&process
->job_entry
== &job
->process_list
) break; /* no process found */
295 assert( process
->job
== job
);
296 terminate_process( process
, NULL
, exit_code
);
299 job
->terminating
= 0;
301 wake_up( &job
->obj
, 0 );
304 static int job_close_handle( struct object
*obj
, struct process
*process
, obj_handle_t handle
)
306 struct job
*job
= (struct job
*)obj
;
307 assert( obj
->ops
== &job_ops
);
309 if (obj
->handle_count
== 1) /* last handle */
311 if (job
->limit_flags
& JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
)
312 terminate_job( job
, 0 );
317 static void job_destroy( struct object
*obj
)
319 struct job
*job
= (struct job
*)obj
;
320 assert( obj
->ops
== &job_ops
);
322 assert( !job
->num_processes
);
323 assert( list_empty(&job
->process_list
) );
325 if (job
->completion_port
) release_object( job
->completion_port
);
328 static void job_dump( struct object
*obj
, int verbose
)
330 struct job
*job
= (struct job
*)obj
;
331 assert( obj
->ops
== &job_ops
);
332 fprintf( stderr
, "Job processes=%d\n", list_count(&job
->process_list
) );
335 static int job_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
337 struct job
*job
= (struct job
*)obj
;
338 return job
->signaled
;
343 void *ptr
; /* entry ptr */
344 unsigned int next
; /* next free entry */
347 static struct ptid_entry
*ptid_entries
; /* array of ptid entries */
348 static unsigned int used_ptid_entries
; /* number of entries in use */
349 static unsigned int alloc_ptid_entries
; /* number of allocated entries */
350 static unsigned int next_free_ptid
; /* next free entry */
351 static unsigned int last_free_ptid
; /* last free entry */
352 static unsigned int num_free_ptids
; /* number of free ptids */
354 static void kill_all_processes(void);
356 #define PTID_OFFSET 8 /* offset for first ptid value */
358 static unsigned int index_from_ptid(unsigned int id
) { return id
/ 4; }
359 static unsigned int ptid_from_index(unsigned int index
) { return index
* 4; }
361 /* allocate a new process or thread id */
362 unsigned int alloc_ptid( void *ptr
)
364 struct ptid_entry
*entry
;
367 if (used_ptid_entries
< alloc_ptid_entries
)
369 index
= used_ptid_entries
+ PTID_OFFSET
;
370 entry
= &ptid_entries
[used_ptid_entries
++];
372 else if (next_free_ptid
&& num_free_ptids
>= 256)
374 index
= next_free_ptid
;
375 entry
= &ptid_entries
[index
- PTID_OFFSET
];
376 if (!(next_free_ptid
= entry
->next
)) last_free_ptid
= 0;
379 else /* need to grow the array */
381 unsigned int count
= alloc_ptid_entries
+ (alloc_ptid_entries
/ 2);
382 if (!count
) count
= 512;
383 if (!(entry
= realloc( ptid_entries
, count
* sizeof(*entry
) )))
385 set_error( STATUS_NO_MEMORY
);
388 ptid_entries
= entry
;
389 alloc_ptid_entries
= count
;
390 index
= used_ptid_entries
+ PTID_OFFSET
;
391 entry
= &ptid_entries
[used_ptid_entries
++];
395 return ptid_from_index( index
);
398 /* free a process or thread id */
399 void free_ptid( unsigned int id
)
401 unsigned int index
= index_from_ptid( id
);
402 struct ptid_entry
*entry
= &ptid_entries
[index
- PTID_OFFSET
];
407 /* append to end of free list so that we don't reuse it too early */
408 if (last_free_ptid
) ptid_entries
[last_free_ptid
- PTID_OFFSET
].next
= index
;
409 else next_free_ptid
= index
;
410 last_free_ptid
= index
;
414 /* retrieve the pointer corresponding to a process or thread id */
415 void *get_ptid_entry( unsigned int id
)
417 unsigned int index
= index_from_ptid( id
);
418 if (index
< PTID_OFFSET
) return NULL
;
419 if (index
- PTID_OFFSET
>= used_ptid_entries
) return NULL
;
420 return ptid_entries
[index
- PTID_OFFSET
].ptr
;
423 /* return the main thread of the process */
424 struct thread
*get_process_first_thread( struct process
*process
)
426 struct list
*ptr
= list_head( &process
->thread_list
);
427 if (!ptr
) return NULL
;
428 return LIST_ENTRY( ptr
, struct thread
, proc_entry
);
431 /* set the state of the process startup info */
432 static void set_process_startup_state( struct process
*process
, enum startup_state state
)
434 if (process
->startup_state
== STARTUP_IN_PROGRESS
) process
->startup_state
= state
;
435 if (process
->startup_info
)
437 wake_up( &process
->startup_info
->obj
, 0 );
438 release_object( process
->startup_info
);
439 process
->startup_info
= NULL
;
443 /* callback for server shutdown */
444 static void server_shutdown_timeout( void *arg
)
446 shutdown_timeout
= NULL
;
447 if (!running_processes
)
449 close_master_socket( 0 );
452 switch(++shutdown_stage
)
454 case 1: /* signal system processes to exit */
455 if (debug_level
) fprintf( stderr
, "wineserver: shutting down\n" );
456 if (shutdown_event
) set_event( shutdown_event
);
457 shutdown_timeout
= add_timeout_user( 2 * -TICKS_PER_SEC
, server_shutdown_timeout
, NULL
);
458 close_master_socket( 4 * -TICKS_PER_SEC
);
460 case 2: /* now forcibly kill all processes (but still wait for SIGKILL timeouts) */
461 kill_all_processes();
466 /* forced shutdown, used for wineserver -k */
467 void shutdown_master_socket(void)
469 kill_all_processes();
471 if (shutdown_timeout
)
473 remove_timeout_user( shutdown_timeout
);
474 shutdown_timeout
= NULL
;
476 close_master_socket( 2 * -TICKS_PER_SEC
); /* for SIGKILL timeouts */
479 /* final cleanup once we are sure a process is really dead */
480 static void process_died( struct process
*process
)
482 if (debug_level
) fprintf( stderr
, "%04x: *process killed*\n", process
->id
);
483 if (!process
->is_system
)
485 if (!--user_processes
&& !shutdown_stage
&& master_socket_timeout
!= TIMEOUT_INFINITE
)
486 shutdown_timeout
= add_timeout_user( master_socket_timeout
, server_shutdown_timeout
, NULL
);
488 release_object( process
);
489 if (!--running_processes
&& shutdown_stage
) close_master_socket( 0 );
492 /* callback for process sigkill timeout */
493 static void process_sigkill( void *private )
495 struct process
*process
= private;
497 process
->sigkill_timeout
= NULL
;
498 kill( process
->unix_pid
, SIGKILL
);
499 process_died( process
);
502 /* start the sigkill timer for a process upon exit */
503 static void start_sigkill_timer( struct process
*process
)
505 grab_object( process
);
506 if (process
->unix_pid
!= -1)
507 process
->sigkill_timeout
= add_timeout_user( -TICKS_PER_SEC
, process_sigkill
, process
);
509 process_died( process
);
512 /* create a new process */
513 /* if the function fails the fd is closed */
514 struct process
*create_process( int fd
, struct process
*parent
, unsigned int flags
, const startup_info_t
*info
,
515 const struct security_descriptor
*sd
, const obj_handle_t
*handles
,
516 unsigned int handle_count
, struct token
*token
)
518 struct process
*process
;
520 if (!(process
= alloc_object( &process_ops
)))
525 process
->parent_id
= 0;
526 process
->debug_obj
= NULL
;
527 process
->debug_event
= NULL
;
528 process
->handles
= NULL
;
529 process
->msg_fd
= NULL
;
530 process
->sigkill_timeout
= NULL
;
531 process
->unix_pid
= -1;
532 process
->exit_code
= STILL_ACTIVE
;
533 process
->running_threads
= 0;
534 process
->priority
= PROCESS_PRIOCLASS_NORMAL
;
535 process
->suspend
= 0;
536 process
->is_system
= 0;
537 process
->debug_children
= 1;
538 process
->is_terminating
= 0;
539 process
->imagelen
= 0;
540 process
->image
= NULL
;
542 process
->console
= NULL
;
543 process
->startup_state
= STARTUP_IN_PROGRESS
;
544 process
->startup_info
= NULL
;
545 process
->idle_event
= NULL
;
547 process
->ldt_copy
= 0;
548 process
->dir_cache
= NULL
;
549 process
->winstation
= 0;
550 process
->desktop
= 0;
551 process
->token
= NULL
;
552 process
->trace_data
= 0;
553 process
->rawinput_mouse
= NULL
;
554 process
->rawinput_kbd
= NULL
;
555 list_init( &process
->kernel_object
);
556 list_init( &process
->thread_list
);
557 list_init( &process
->locks
);
558 list_init( &process
->asyncs
);
559 list_init( &process
->classes
);
560 list_init( &process
->views
);
561 list_init( &process
->rawinput_devices
);
563 process
->end_time
= 0;
565 if (sd
&& !default_set_sd( &process
->obj
, sd
, OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
|
566 DACL_SECURITY_INFORMATION
| SACL_SECURITY_INFORMATION
))
571 if (!(process
->id
= process
->group_id
= alloc_ptid( process
)))
576 if (!(process
->msg_fd
= create_anonymous_fd( &process_fd_ops
, fd
, &process
->obj
, 0 ))) goto error
;
578 /* create the handle table */
581 process
->handles
= alloc_handle_table( process
, 0 );
582 process
->token
= token_create_admin( TokenElevationTypeFull
);
583 process
->affinity
= ~0;
587 obj_handle_t std_handles
[3];
589 std_handles
[0] = info
->hstdin
;
590 std_handles
[1] = info
->hstdout
;
591 std_handles
[2] = info
->hstderr
;
593 process
->parent_id
= parent
->id
;
594 if (flags
& PROCESS_CREATE_FLAGS_INHERIT_HANDLES
)
595 process
->handles
= copy_handle_table( process
, parent
, handles
, handle_count
, std_handles
);
597 process
->handles
= alloc_handle_table( process
, 0 );
598 /* Note: for security reasons, starting a new process does not attempt
599 * to use the current impersonation token for the new process */
600 process
->token
= token_duplicate( token
? token
: parent
->token
, TRUE
, 0, NULL
, NULL
, 0, NULL
, 0 );
601 process
->affinity
= parent
->affinity
;
603 if (!process
->handles
|| !process
->token
) goto error
;
605 /* Assign a high security label to the token. The default would be medium
606 * but Wine provides admin access to all applications right now so high
607 * makes more sense for the time being. */
608 if (!token_assign_label( process
->token
, security_high_label_sid
))
611 set_fd_events( process
->msg_fd
, POLLIN
); /* start listening to events */
615 if (process
) release_object( process
);
616 /* if we failed to start our first process, close everything down */
617 if (!running_processes
&& master_socket_timeout
!= TIMEOUT_INFINITE
) close_master_socket( 0 );
621 /* get the process data size */
622 data_size_t
get_process_startup_info_size( struct process
*process
)
624 struct startup_info
*info
= process
->startup_info
;
627 return info
->data_size
;
630 /* destroy a process when its refcount is 0 */
631 static void process_destroy( struct object
*obj
)
633 struct process
*process
= (struct process
*)obj
;
634 assert( obj
->ops
== &process_ops
);
636 /* we can't have a thread remaining */
637 assert( list_empty( &process
->thread_list
));
638 assert( list_empty( &process
->asyncs
));
640 assert( !process
->sigkill_timeout
); /* timeout should hold a reference to the process */
642 close_process_handles( process
);
643 set_process_startup_state( process
, STARTUP_ABORTED
);
647 list_remove( &process
->job_entry
);
648 release_object( process
->job
);
650 if (process
->console
) release_object( process
->console
);
651 if (process
->msg_fd
) release_object( process
->msg_fd
);
652 if (process
->idle_event
) release_object( process
->idle_event
);
653 if (process
->id
) free_ptid( process
->id
);
654 if (process
->token
) release_object( process
->token
);
655 free( process
->dir_cache
);
656 free( process
->image
);
659 /* dump a process on stdout for debugging purposes */
660 static void process_dump( struct object
*obj
, int verbose
)
662 struct process
*process
= (struct process
*)obj
;
663 assert( obj
->ops
== &process_ops
);
665 fprintf( stderr
, "Process id=%04x handles=%p\n", process
->id
, process
->handles
);
668 static int process_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
670 struct process
*process
= (struct process
*)obj
;
671 return !process
->running_threads
;
674 static unsigned int process_map_access( struct object
*obj
, unsigned int access
)
676 access
= default_map_access( obj
, access
);
677 if (access
& PROCESS_QUERY_INFORMATION
) access
|= PROCESS_QUERY_LIMITED_INFORMATION
;
678 if (access
& PROCESS_SET_INFORMATION
) access
|= PROCESS_SET_LIMITED_INFORMATION
;
682 static struct list
*process_get_kernel_obj_list( struct object
*obj
)
684 struct process
*process
= (struct process
*)obj
;
685 return &process
->kernel_object
;
688 static struct security_descriptor
*process_get_sd( struct object
*obj
)
690 static struct security_descriptor
*process_default_sd
;
692 if (obj
->sd
) return obj
->sd
;
694 if (!process_default_sd
)
696 size_t users_sid_len
= security_sid_len( security_domain_users_sid
);
697 size_t admins_sid_len
= security_sid_len( security_builtin_admins_sid
);
698 size_t dacl_len
= sizeof(ACL
) + 2 * offsetof( ACCESS_ALLOWED_ACE
, SidStart
)
699 + users_sid_len
+ admins_sid_len
;
700 ACCESS_ALLOWED_ACE
*aaa
;
703 process_default_sd
= mem_alloc( sizeof(*process_default_sd
) + admins_sid_len
+ users_sid_len
705 process_default_sd
->control
= SE_DACL_PRESENT
;
706 process_default_sd
->owner_len
= admins_sid_len
;
707 process_default_sd
->group_len
= users_sid_len
;
708 process_default_sd
->sacl_len
= 0;
709 process_default_sd
->dacl_len
= dacl_len
;
710 memcpy( process_default_sd
+ 1, security_builtin_admins_sid
, admins_sid_len
);
711 memcpy( (char *)(process_default_sd
+ 1) + admins_sid_len
, security_domain_users_sid
, users_sid_len
);
713 dacl
= (ACL
*)((char *)(process_default_sd
+ 1) + admins_sid_len
+ users_sid_len
);
714 dacl
->AclRevision
= ACL_REVISION
;
716 dacl
->AclSize
= dacl_len
;
719 aaa
= (ACCESS_ALLOWED_ACE
*)(dacl
+ 1);
720 aaa
->Header
.AceType
= ACCESS_ALLOWED_ACE_TYPE
;
721 aaa
->Header
.AceFlags
= INHERIT_ONLY_ACE
| CONTAINER_INHERIT_ACE
;
722 aaa
->Header
.AceSize
= offsetof( ACCESS_ALLOWED_ACE
, SidStart
) + users_sid_len
;
723 aaa
->Mask
= GENERIC_READ
;
724 memcpy( &aaa
->SidStart
, security_domain_users_sid
, users_sid_len
);
725 aaa
= (ACCESS_ALLOWED_ACE
*)((char *)aaa
+ aaa
->Header
.AceSize
);
726 aaa
->Header
.AceType
= ACCESS_ALLOWED_ACE_TYPE
;
727 aaa
->Header
.AceFlags
= 0;
728 aaa
->Header
.AceSize
= offsetof( ACCESS_ALLOWED_ACE
, SidStart
) + admins_sid_len
;
729 aaa
->Mask
= PROCESS_ALL_ACCESS
;
730 memcpy( &aaa
->SidStart
, security_builtin_admins_sid
, admins_sid_len
);
732 return process_default_sd
;
735 static void process_poll_event( struct fd
*fd
, int event
)
737 struct process
*process
= get_fd_user( fd
);
738 assert( process
->obj
.ops
== &process_ops
);
740 if (event
& (POLLERR
| POLLHUP
)) kill_process( process
, 0 );
741 else if (event
& POLLIN
) receive_fd( process
);
744 static void startup_info_destroy( struct object
*obj
)
746 struct startup_info
*info
= (struct startup_info
*)obj
;
747 assert( obj
->ops
== &startup_info_ops
);
749 if (info
->process
) release_object( info
->process
);
752 static void startup_info_dump( struct object
*obj
, int verbose
)
754 struct startup_info
*info
= (struct startup_info
*)obj
;
755 assert( obj
->ops
== &startup_info_ops
);
757 fputs( "Startup info", stderr
);
759 fprintf( stderr
, " in=%04x out=%04x err=%04x",
760 info
->data
->hstdin
, info
->data
->hstdout
, info
->data
->hstderr
);
761 fputc( '\n', stderr
);
764 static int startup_info_signaled( struct object
*obj
, struct wait_queue_entry
*entry
)
766 struct startup_info
*info
= (struct startup_info
*)obj
;
767 return info
->process
&& info
->process
->startup_state
!= STARTUP_IN_PROGRESS
;
770 /* get a process from an id (and increment the refcount) */
771 struct process
*get_process_from_id( process_id_t id
)
773 struct object
*obj
= get_ptid_entry( id
);
775 if (obj
&& obj
->ops
== &process_ops
) return (struct process
*)grab_object( obj
);
776 set_error( STATUS_INVALID_CID
);
780 /* get a process from a handle (and increment the refcount) */
781 struct process
*get_process_from_handle( obj_handle_t handle
, unsigned int access
)
783 return (struct process
*)get_handle_obj( current
->process
, handle
,
784 access
, &process_ops
);
787 /* terminate a process with the given exit code */
788 static void terminate_process( struct process
*process
, struct thread
*skip
, int exit_code
)
790 struct thread
*thread
;
792 grab_object( process
); /* make sure it doesn't get freed when threads die */
793 process
->is_terminating
= 1;
796 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
798 if (exit_code
) thread
->exit_code
= exit_code
;
799 if (thread
== skip
) continue;
800 if (thread
->state
== TERMINATED
) continue;
801 kill_thread( thread
, 1 );
804 release_object( process
);
807 /* kill all processes */
808 static void kill_all_processes(void)
812 while ((ptr
= list_head( &process_list
)))
814 struct process
*process
= LIST_ENTRY( ptr
, struct process
, entry
);
815 terminate_process( process
, NULL
, 1 );
819 /* kill all processes being attached to a console renderer */
820 void kill_console_processes( struct thread
*renderer
, int exit_code
)
822 for (;;) /* restart from the beginning of the list every time */
824 struct process
*process
;
826 /* find the first process being attached to 'renderer' and still running */
827 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
829 if (process
== renderer
->process
) continue;
830 if (process
->console
&& console_get_renderer( process
->console
) == renderer
) break;
832 if (&process
->entry
== &process_list
) break; /* no process found */
833 terminate_process( process
, NULL
, exit_code
);
837 /* a process has been killed (i.e. its last thread died) */
838 static void process_killed( struct process
*process
)
842 assert( list_empty( &process
->thread_list
));
843 process
->end_time
= current_time
;
844 close_process_desktop( process
);
845 process
->winstation
= 0;
846 process
->desktop
= 0;
847 cancel_process_asyncs( process
);
848 close_process_handles( process
);
849 if (process
->idle_event
) release_object( process
->idle_event
);
850 process
->idle_event
= NULL
;
851 assert( !process
->console
);
853 while ((ptr
= list_head( &process
->rawinput_devices
)))
855 struct rawinput_device_entry
*entry
= LIST_ENTRY( ptr
, struct rawinput_device_entry
, entry
);
856 list_remove( &entry
->entry
);
859 destroy_process_classes( process
);
860 free_mapped_views( process
);
861 free_process_user_handles( process
);
862 remove_process_locks( process
);
863 set_process_startup_state( process
, STARTUP_ABORTED
);
864 finish_process_tracing( process
);
865 release_job_process( process
);
866 start_sigkill_timer( process
);
867 wake_up( &process
->obj
, 0 );
870 /* add a thread to a process running threads list */
871 void add_process_thread( struct process
*process
, struct thread
*thread
)
873 list_add_tail( &process
->thread_list
, &thread
->proc_entry
);
874 if (!process
->running_threads
++)
876 list_add_tail( &process_list
, &process
->entry
);
878 if (!process
->is_system
)
880 if (!user_processes
++ && shutdown_timeout
)
882 remove_timeout_user( shutdown_timeout
);
883 shutdown_timeout
= NULL
;
887 grab_object( thread
);
890 /* remove a thread from a process running threads list */
891 void remove_process_thread( struct process
*process
, struct thread
*thread
)
893 assert( process
->running_threads
> 0 );
894 assert( !list_empty( &process
->thread_list
));
896 list_remove( &thread
->proc_entry
);
898 if (!--process
->running_threads
)
900 /* we have removed the last running thread, exit the process */
901 process
->exit_code
= thread
->exit_code
;
902 generate_debug_event( thread
, DbgExitProcessStateChange
, process
);
903 list_remove( &process
->entry
);
904 process_killed( process
);
906 else generate_debug_event( thread
, DbgExitThreadStateChange
, thread
);
907 release_object( thread
);
910 /* suspend all the threads of a process */
911 void suspend_process( struct process
*process
)
913 if (!process
->suspend
++)
915 struct list
*ptr
, *next
;
917 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
919 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
920 if (!thread
->suspend
) stop_thread( thread
);
925 /* resume all the threads of a process */
926 void resume_process( struct process
*process
)
928 assert (process
->suspend
> 0);
929 if (!--process
->suspend
)
931 struct list
*ptr
, *next
;
933 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
935 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
936 if (!thread
->suspend
) wake_thread( thread
);
941 /* kill a process on the spot */
942 void kill_process( struct process
*process
, int violent_death
)
944 if (!violent_death
&& process
->msg_fd
) /* normal termination on pipe close */
946 release_object( process
->msg_fd
);
947 process
->msg_fd
= NULL
;
950 if (process
->sigkill_timeout
) return; /* already waiting for it to die */
952 if (violent_death
) terminate_process( process
, NULL
, 1 );
957 grab_object( process
); /* make sure it doesn't get freed when threads die */
958 while ((ptr
= list_head( &process
->thread_list
)))
960 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
961 kill_thread( thread
, 0 );
963 release_object( process
);
967 /* detach all processes being debugged by a given thread */
968 void detach_debugged_processes( struct debug_obj
*debug_obj
, int exit_code
)
970 for (;;) /* restart from the beginning of the list every time */
972 struct process
*process
;
974 /* find the first process being debugged by 'debugger' and still running */
975 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
976 if (process
->debug_obj
== debug_obj
) break;
978 if (&process
->entry
== &process_list
) break; /* no process found */
981 process
->debug_obj
= NULL
;
982 terminate_process( process
, NULL
, exit_code
);
984 else debugger_detach( process
, debug_obj
);
989 void enum_processes( int (*cb
)(struct process
*, void*), void *user
)
991 struct list
*ptr
, *next
;
993 LIST_FOR_EACH_SAFE( ptr
, next
, &process_list
)
995 struct process
*process
= LIST_ENTRY( ptr
, struct process
, entry
);
996 if ((cb
)(process
, user
)) break;
1000 /* set the debugged flag in the process PEB */
1001 int set_process_debug_flag( struct process
*process
, int flag
)
1003 char data
= (flag
!= 0);
1005 /* BeingDebugged flag is the byte at offset 2 in the PEB */
1006 return write_process_memory( process
, process
->peb
+ 2, 1, &data
);
1009 /* create a new process */
1010 DECL_HANDLER(new_process
)
1012 struct startup_info
*info
;
1013 const void *info_ptr
;
1014 struct unicode_str name
;
1015 const struct security_descriptor
*sd
;
1016 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &name
, NULL
);
1017 struct process
*process
= NULL
;
1018 struct token
*token
= NULL
;
1019 struct debug_obj
*debug_obj
= NULL
;
1020 struct process
*parent
;
1021 struct thread
*parent_thread
= current
;
1022 int socket_fd
= thread_get_inflight_fd( current
, req
->socket_fd
);
1023 const obj_handle_t
*handles
= NULL
;
1025 if (socket_fd
== -1)
1027 set_error( STATUS_INVALID_PARAMETER
);
1032 set_error( STATUS_INVALID_PARAMETER
);
1036 if (fcntl( socket_fd
, F_SETFL
, O_NONBLOCK
) == -1)
1038 set_error( STATUS_INVALID_HANDLE
);
1044 set_error( STATUS_SHUTDOWN_IN_PROGRESS
);
1048 if (!is_cpu_supported( req
->cpu
))
1054 if (req
->parent_process
)
1056 if (!(parent
= get_process_from_handle( req
->parent_process
, PROCESS_CREATE_PROCESS
)))
1061 parent_thread
= NULL
;
1063 else parent
= (struct process
*)grab_object( current
->process
);
1065 if (parent
->job
&& (req
->flags
& PROCESS_CREATE_FLAGS_BREAKAWAY
) &&
1066 !(parent
->job
->limit_flags
& (JOB_OBJECT_LIMIT_BREAKAWAY_OK
| JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK
)))
1068 set_error( STATUS_ACCESS_DENIED
);
1070 release_object( parent
);
1074 /* build the startup info for a new process */
1075 if (!(info
= alloc_object( &startup_info_ops
)))
1078 release_object( parent
);
1081 info
->process
= NULL
;
1084 info_ptr
= get_req_data_after_objattr( objattr
, &info
->data_size
);
1086 if ((req
->handles_size
& 3) || req
->handles_size
> info
->data_size
)
1088 set_error( STATUS_INVALID_PARAMETER
);
1092 if (req
->handles_size
)
1095 info_ptr
= (const char *)info_ptr
+ req
->handles_size
;
1096 info
->data_size
-= req
->handles_size
;
1098 info
->info_size
= min( req
->info_size
, info
->data_size
);
1100 if (req
->info_size
< sizeof(*info
->data
))
1102 /* make sure we have a full startup_info_t structure */
1103 data_size_t env_size
= info
->data_size
- info
->info_size
;
1104 data_size_t info_size
= min( req
->info_size
, FIELD_OFFSET( startup_info_t
, curdir_len
));
1106 if (!(info
->data
= mem_alloc( sizeof(*info
->data
) + env_size
)))
1111 memcpy( info
->data
, info_ptr
, info_size
);
1112 memset( (char *)info
->data
+ info_size
, 0, sizeof(*info
->data
) - info_size
);
1113 memcpy( info
->data
+ 1, (const char *)info_ptr
+ req
->info_size
, env_size
);
1114 info
->info_size
= sizeof(startup_info_t
);
1115 info
->data_size
= info
->info_size
+ env_size
;
1119 data_size_t pos
= sizeof(*info
->data
);
1121 if (!(info
->data
= memdup( info_ptr
, info
->data_size
)))
1126 #define FIXUP_LEN(len) do { (len) = min( (len), info->info_size - pos ); pos += (len); } while(0)
1127 FIXUP_LEN( info
->data
->curdir_len
);
1128 FIXUP_LEN( info
->data
->dllpath_len
);
1129 FIXUP_LEN( info
->data
->imagepath_len
);
1130 FIXUP_LEN( info
->data
->cmdline_len
);
1131 FIXUP_LEN( info
->data
->title_len
);
1132 FIXUP_LEN( info
->data
->desktop_len
);
1133 FIXUP_LEN( info
->data
->shellinfo_len
);
1134 FIXUP_LEN( info
->data
->runtime_len
);
1138 if (req
->token
&& !(token
= get_token_obj( current
->process
, req
->token
, TOKEN_QUERY
| TOKEN_ASSIGN_PRIMARY
)))
1143 if (req
->debug
&& !(debug_obj
= get_debug_obj( current
->process
, req
->debug
, DEBUG_PROCESS_ASSIGN
)))
1149 if (!(process
= create_process( socket_fd
, parent
, req
->flags
, info
->data
, sd
,
1150 handles
, req
->handles_size
/ sizeof(*handles
), token
)))
1153 process
->startup_info
= (struct startup_info
*)grab_object( info
);
1156 && !(req
->flags
& PROCESS_CREATE_FLAGS_BREAKAWAY
)
1157 && !(parent
->job
->limit_flags
& JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK
))
1159 add_job_process( parent
->job
, process
);
1162 /* connect to the window station */
1163 connect_process_winstation( process
, parent_thread
, parent
);
1165 /* set the process console */
1166 if (info
->data
->console
> 3)
1167 info
->data
->console
= duplicate_handle( parent
, info
->data
->console
, process
,
1168 0, 0, DUPLICATE_SAME_ACCESS
);
1170 if (!(req
->flags
& PROCESS_CREATE_FLAGS_INHERIT_HANDLES
) && info
->data
->console
!= 1)
1172 info
->data
->hstdin
= duplicate_handle( parent
, info
->data
->hstdin
, process
,
1173 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
1174 info
->data
->hstdout
= duplicate_handle( parent
, info
->data
->hstdout
, process
,
1175 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
1176 info
->data
->hstderr
= duplicate_handle( parent
, info
->data
->hstderr
, process
,
1177 0, OBJ_INHERIT
, DUPLICATE_SAME_ACCESS
);
1178 /* some handles above may have been invalid; this is not an error */
1179 if (get_error() == STATUS_INVALID_HANDLE
||
1180 get_error() == STATUS_OBJECT_TYPE_MISMATCH
) clear_error();
1183 /* attach to the debugger */
1186 process
->debug_obj
= debug_obj
;
1187 process
->debug_children
= !(req
->flags
& PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT
);
1189 else if (parent
->debug_children
)
1191 process
->debug_obj
= parent
->debug_obj
;
1192 /* debug_children is set to 1 by default */
1195 if (!info
->data
->console_flags
) process
->group_id
= parent
->group_id
;
1197 info
->process
= (struct process
*)grab_object( process
);
1198 reply
->info
= alloc_handle( current
->process
, info
, SYNCHRONIZE
, 0 );
1199 reply
->pid
= get_process_id( process
);
1200 reply
->handle
= alloc_handle_no_access_check( current
->process
, process
, req
->access
, objattr
->attributes
);
1203 if (process
) release_object( process
);
1204 if (debug_obj
) release_object( debug_obj
);
1205 if (token
) release_object( token
);
1206 release_object( parent
);
1207 release_object( info
);
1210 /* Retrieve information about a newly started process */
1211 DECL_HANDLER(get_new_process_info
)
1213 struct startup_info
*info
;
1215 if ((info
= (struct startup_info
*)get_handle_obj( current
->process
, req
->info
,
1216 0, &startup_info_ops
)))
1218 reply
->success
= is_process_init_done( info
->process
);
1219 reply
->exit_code
= info
->process
->exit_code
;
1220 release_object( info
);
1224 /* Retrieve the new process startup info */
1225 DECL_HANDLER(get_startup_info
)
1227 struct process
*process
= current
->process
;
1228 struct startup_info
*info
= process
->startup_info
;
1233 /* we return the data directly without making a copy so this can only be called once */
1234 reply
->info_size
= info
->info_size
;
1235 size
= info
->data_size
;
1236 if (size
> get_reply_max_size()) size
= get_reply_max_size();
1237 set_reply_data_ptr( info
->data
, size
);
1239 info
->data_size
= 0;
1242 /* signal the end of the process initialization */
1243 DECL_HANDLER(init_process_done
)
1245 struct process
*process
= current
->process
;
1246 struct memory_view
*view
;
1248 const pe_image_info_t
*image_info
;
1250 if (is_process_init_done(process
))
1252 set_error( STATUS_INVALID_PARAMETER
);
1255 if (!(view
= get_exe_view( process
)))
1257 set_error( STATUS_DLL_NOT_FOUND
);
1260 if (!(image_info
= get_view_image_info( view
, &base
))) return;
1262 process
->start_time
= current_time
;
1263 current
->entry_point
= image_info
->entry_point
;
1265 init_process_tracing( process
);
1266 generate_startup_debug_events( process
);
1267 set_process_startup_state( process
, STARTUP_DONE
);
1269 if (image_info
->subsystem
!= IMAGE_SUBSYSTEM_WINDOWS_CUI
)
1270 process
->idle_event
= create_event( NULL
, NULL
, 0, 1, 0, NULL
);
1271 if (process
->debug_obj
) set_process_debug_flag( process
, 1 );
1272 reply
->entry
= image_info
->entry_point
;
1273 reply
->suspend
= (current
->suspend
|| process
->suspend
);
1276 /* open a handle to a process */
1277 DECL_HANDLER(open_process
)
1279 struct process
*process
= get_process_from_id( req
->pid
);
1283 reply
->handle
= alloc_handle( current
->process
, process
, req
->access
, req
->attributes
);
1284 release_object( process
);
1288 /* terminate a process */
1289 DECL_HANDLER(terminate_process
)
1291 struct process
*process
;
1295 process
= get_process_from_handle( req
->handle
, PROCESS_TERMINATE
);
1296 if (!process
) return;
1298 else process
= (struct process
*)grab_object( current
->process
);
1300 reply
->self
= (current
->process
== process
);
1301 terminate_process( process
, current
, req
->exit_code
);
1302 release_object( process
);
1305 /* fetch information about a process */
1306 DECL_HANDLER(get_process_info
)
1308 struct process
*process
;
1310 if ((process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_LIMITED_INFORMATION
)))
1312 reply
->pid
= get_process_id( process
);
1313 reply
->ppid
= process
->parent_id
;
1314 reply
->exit_code
= process
->exit_code
;
1315 reply
->priority
= process
->priority
;
1316 reply
->affinity
= process
->affinity
;
1317 reply
->peb
= process
->peb
;
1318 reply
->start_time
= process
->start_time
;
1319 reply
->end_time
= process
->end_time
;
1320 reply
->machine
= process
->machine
;
1321 if (get_reply_max_size())
1324 const pe_image_info_t
*info
;
1325 struct memory_view
*view
= get_exe_view( process
);
1328 if ((info
= get_view_image_info( view
, &base
)))
1329 set_reply_data( info
, min( sizeof(*info
), get_reply_max_size() ));
1331 else set_error( STATUS_PROCESS_IS_TERMINATING
);
1333 release_object( process
);
1337 /* retrieve debug information about a process */
1338 DECL_HANDLER(get_process_debug_info
)
1340 struct process
*process
;
1342 if (!(process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_LIMITED_INFORMATION
))) return;
1344 reply
->debug_children
= process
->debug_children
;
1345 if (!process
->debug_obj
) set_error( STATUS_PORT_NOT_SET
);
1346 else reply
->debug
= alloc_handle( current
->process
, process
->debug_obj
, DEBUG_ALL_ACCESS
, 0 );
1347 release_object( process
);
1350 /* fetch the name of the process image */
1351 DECL_HANDLER(get_process_image_name
)
1353 struct process
*process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_LIMITED_INFORMATION
);
1355 if (!process
) return;
1358 struct unicode_str name
= { process
->image
, process
->imagelen
};
1359 /* skip the \??\ prefix */
1360 if (req
->win32
&& name
.len
> 6 * sizeof(WCHAR
) && name
.str
[5] == ':')
1363 name
.len
-= 4 * sizeof(WCHAR
);
1365 /* FIXME: else resolve symlinks in NT path */
1367 reply
->len
= name
.len
;
1368 if (name
.len
<= get_reply_max_size())
1370 WCHAR
*ptr
= set_reply_data( name
.str
, name
.len
);
1371 /* change \??\ to \\?\ */
1372 if (req
->win32
&& name
.len
> sizeof(WCHAR
) && ptr
[1] == '?') ptr
[1] = '\\';
1374 else set_error( STATUS_BUFFER_TOO_SMALL
);
1376 release_object( process
);
1379 /* retrieve information about a process memory usage */
1380 DECL_HANDLER(get_process_vm_counters
)
1382 struct process
*process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_LIMITED_INFORMATION
);
1384 if (!process
) return;
1386 if (process
->unix_pid
!= -1)
1389 char proc_path
[32], line
[256];
1390 unsigned long value
;
1392 sprintf( proc_path
, "/proc/%u/status", process
->unix_pid
);
1393 if ((f
= fopen( proc_path
, "r" )))
1395 while (fgets( line
, sizeof(line
), f
))
1397 if (sscanf( line
, "VmPeak: %lu", &value
))
1398 reply
->peak_virtual_size
= (mem_size_t
)value
* 1024;
1399 else if (sscanf( line
, "VmSize: %lu", &value
))
1400 reply
->virtual_size
= (mem_size_t
)value
* 1024;
1401 else if (sscanf( line
, "VmHWM: %lu", &value
))
1402 reply
->peak_working_set_size
= (mem_size_t
)value
* 1024;
1403 else if (sscanf( line
, "VmRSS: %lu", &value
))
1404 reply
->working_set_size
= (mem_size_t
)value
* 1024;
1405 else if (sscanf( line
, "RssAnon: %lu", &value
))
1406 reply
->pagefile_usage
+= (mem_size_t
)value
* 1024;
1407 else if (sscanf( line
, "VmSwap: %lu", &value
))
1408 reply
->pagefile_usage
+= (mem_size_t
)value
* 1024;
1410 reply
->peak_pagefile_usage
= reply
->pagefile_usage
;
1413 else set_error( STATUS_ACCESS_DENIED
);
1415 else set_error( STATUS_ACCESS_DENIED
);
1417 release_object( process
);
1420 static void set_process_affinity( struct process
*process
, affinity_t affinity
)
1422 struct thread
*thread
;
1424 if (!process
->running_threads
)
1426 set_error( STATUS_PROCESS_IS_TERMINATING
);
1430 process
->affinity
= affinity
;
1432 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
1434 set_thread_affinity( thread
, affinity
);
1438 /* set information about a process */
1439 DECL_HANDLER(set_process_info
)
1441 struct process
*process
;
1443 if ((process
= get_process_from_handle( req
->handle
, PROCESS_SET_INFORMATION
)))
1445 if (req
->mask
& SET_PROCESS_INFO_PRIORITY
) process
->priority
= req
->priority
;
1446 if (req
->mask
& SET_PROCESS_INFO_AFFINITY
) set_process_affinity( process
, req
->affinity
);
1447 release_object( process
);
1451 /* read data from a process address space */
1452 DECL_HANDLER(read_process_memory
)
1454 struct process
*process
;
1455 data_size_t len
= get_reply_max_size();
1457 if (!(process
= get_process_from_handle( req
->handle
, PROCESS_VM_READ
))) return;
1461 char *buffer
= mem_alloc( len
);
1464 if (read_process_memory( process
, req
->addr
, len
, buffer
))
1465 set_reply_data_ptr( buffer
, len
);
1470 release_object( process
);
1473 /* write data to a process address space */
1474 DECL_HANDLER(write_process_memory
)
1476 struct process
*process
;
1478 if ((process
= get_process_from_handle( req
->handle
, PROCESS_VM_WRITE
)))
1480 data_size_t len
= get_req_data_size();
1481 if (len
) write_process_memory( process
, req
->addr
, len
, get_req_data() );
1482 else set_error( STATUS_INVALID_PARAMETER
);
1483 release_object( process
);
1487 /* retrieve the process idle event */
1488 DECL_HANDLER(get_process_idle_event
)
1490 struct process
*process
;
1493 if ((process
= get_process_from_handle( req
->handle
, PROCESS_QUERY_INFORMATION
)))
1495 if (process
->idle_event
&& process
!= current
->process
)
1496 reply
->event
= alloc_handle( current
->process
, process
->idle_event
,
1497 EVENT_ALL_ACCESS
, 0 );
1498 release_object( process
);
1502 /* make the current process a system process */
1503 DECL_HANDLER(make_process_system
)
1505 struct process
*process
= current
->process
;
1506 struct thread
*thread
;
1508 if (!shutdown_event
)
1510 if (!(shutdown_event
= create_event( NULL
, NULL
, OBJ_PERMANENT
, 1, 0, NULL
))) return;
1511 release_object( shutdown_event
);
1514 if (!(reply
->event
= alloc_handle( current
->process
, shutdown_event
, SYNCHRONIZE
, 0 )))
1517 if (!process
->is_system
)
1519 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
1520 release_thread_desktop( thread
, 0 );
1521 process
->is_system
= 1;
1522 if (!--user_processes
&& !shutdown_stage
&& master_socket_timeout
!= TIMEOUT_INFINITE
)
1523 shutdown_timeout
= add_timeout_user( master_socket_timeout
, server_shutdown_timeout
, NULL
);
1527 /* create a new job object */
1528 DECL_HANDLER(create_job
)
1531 struct unicode_str name
;
1532 struct object
*root
;
1533 const struct security_descriptor
*sd
;
1534 const struct object_attributes
*objattr
= get_req_object_attributes( &sd
, &name
, &root
);
1536 if (!objattr
) return;
1538 if ((job
= create_job_object( root
, &name
, objattr
->attributes
, sd
)))
1540 if (get_error() == STATUS_OBJECT_NAME_EXISTS
)
1541 reply
->handle
= alloc_handle( current
->process
, job
, req
->access
, objattr
->attributes
);
1543 reply
->handle
= alloc_handle_no_access_check( current
->process
, job
,
1544 req
->access
, objattr
->attributes
);
1545 release_object( job
);
1547 if (root
) release_object( root
);
1550 /* open a job object */
1551 DECL_HANDLER(open_job
)
1553 struct unicode_str name
= get_req_unicode_str();
1555 reply
->handle
= open_object( current
->process
, req
->rootdir
, req
->access
,
1556 &job_ops
, &name
, req
->attributes
);
1559 /* assign a job object to a process */
1560 DECL_HANDLER(assign_job
)
1562 struct process
*process
;
1563 struct job
*job
= get_job_obj( current
->process
, req
->job
, JOB_OBJECT_ASSIGN_PROCESS
);
1567 if ((process
= get_process_from_handle( req
->process
, PROCESS_SET_QUOTA
| PROCESS_TERMINATE
)))
1569 if (!process
->running_threads
)
1570 set_error( STATUS_PROCESS_IS_TERMINATING
);
1571 else if (process
->job
)
1572 set_error( STATUS_ACCESS_DENIED
);
1574 add_job_process( job
, process
);
1575 release_object( process
);
1577 release_object( job
);
1581 /* check if a process is associated with a job */
1582 DECL_HANDLER(process_in_job
)
1584 struct process
*process
;
1587 if (!(process
= get_process_from_handle( req
->process
, PROCESS_QUERY_INFORMATION
)))
1592 set_error( process
->job
? STATUS_PROCESS_IN_JOB
: STATUS_PROCESS_NOT_IN_JOB
);
1594 else if ((job
= get_job_obj( current
->process
, req
->job
, JOB_OBJECT_QUERY
)))
1596 set_error( process
->job
== job
? STATUS_PROCESS_IN_JOB
: STATUS_PROCESS_NOT_IN_JOB
);
1597 release_object( job
);
1599 release_object( process
);
1602 /* retrieve information about a job */
1603 DECL_HANDLER(get_job_info
)
1605 struct job
*job
= get_job_obj( current
->process
, req
->handle
, JOB_OBJECT_QUERY
);
1609 reply
->total_processes
= job
->total_processes
;
1610 reply
->active_processes
= job
->num_processes
;
1611 release_object( job
);
1614 /* terminate all processes associated with the job */
1615 DECL_HANDLER(terminate_job
)
1617 struct job
*job
= get_job_obj( current
->process
, req
->handle
, JOB_OBJECT_TERMINATE
);
1621 terminate_job( job
, req
->status
);
1622 release_object( job
);
1625 /* update limits of the job object */
1626 DECL_HANDLER(set_job_limits
)
1628 struct job
*job
= get_job_obj( current
->process
, req
->handle
, JOB_OBJECT_SET_ATTRIBUTES
);
1632 job
->limit_flags
= req
->limit_flags
;
1633 release_object( job
);
1636 /* set the jobs completion port */
1637 DECL_HANDLER(set_job_completion_port
)
1639 struct job
*job
= get_job_obj( current
->process
, req
->job
, JOB_OBJECT_SET_ATTRIBUTES
);
1643 if (!job
->completion_port
)
1645 job
->completion_port
= get_completion_obj( current
->process
, req
->port
, IO_COMPLETION_MODIFY_STATE
);
1646 job
->completion_key
= req
->key
;
1649 set_error( STATUS_INVALID_PARAMETER
);
1651 release_object( job
);
1654 /* Suspend a process */
1655 DECL_HANDLER(suspend_process
)
1657 struct process
*process
;
1659 if ((process
= get_process_from_handle( req
->handle
, PROCESS_SUSPEND_RESUME
)))
1661 struct list
*ptr
, *next
;
1663 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
1665 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
1666 suspend_thread( thread
);
1669 release_object( process
);
1673 /* Resume a process */
1674 DECL_HANDLER(resume_process
)
1676 struct process
*process
;
1678 if ((process
= get_process_from_handle( req
->handle
, PROCESS_SUSPEND_RESUME
)))
1680 struct list
*ptr
, *next
;
1682 LIST_FOR_EACH_SAFE( ptr
, next
, &process
->thread_list
)
1684 struct thread
*thread
= LIST_ENTRY( ptr
, struct thread
, proc_entry
);
1685 resume_thread( thread
);
1688 release_object( process
);
1692 /* Get a list of processes and threads currently running */
1693 DECL_HANDLER(list_processes
)
1695 struct process
*process
;
1696 struct thread
*thread
;
1697 unsigned int pos
= 0;
1700 reply
->process_count
= 0;
1701 reply
->info_size
= 0;
1703 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
1705 reply
->info_size
= (reply
->info_size
+ 7) & ~7;
1706 reply
->info_size
+= sizeof(struct process_info
) + process
->imagelen
;
1707 reply
->info_size
= (reply
->info_size
+ 7) & ~7;
1708 reply
->info_size
+= process
->running_threads
* sizeof(struct thread_info
);
1709 reply
->process_count
++;
1712 if (reply
->info_size
> get_reply_max_size())
1714 set_error( STATUS_INFO_LENGTH_MISMATCH
);
1718 if (!(buffer
= set_reply_data_size( reply
->info_size
))) return;
1720 memset( buffer
, 0, reply
->info_size
);
1721 LIST_FOR_EACH_ENTRY( process
, &process_list
, struct process
, entry
)
1723 struct process_info
*process_info
;
1725 pos
= (pos
+ 7) & ~7;
1726 process_info
= (struct process_info
*)(buffer
+ pos
);
1727 process_info
->start_time
= process
->start_time
;
1728 process_info
->name_len
= process
->imagelen
;
1729 process_info
->thread_count
= process
->running_threads
;
1730 process_info
->priority
= process
->priority
;
1731 process_info
->pid
= process
->id
;
1732 process_info
->parent_pid
= process
->parent_id
;
1733 process_info
->handle_count
= get_handle_table_count(process
);
1734 process_info
->unix_pid
= process
->unix_pid
;
1735 pos
+= sizeof(*process_info
);
1736 memcpy( buffer
+ pos
, process
->image
, process
->imagelen
);
1737 pos
+= process
->imagelen
;
1738 pos
= (pos
+ 7) & ~7;
1739 LIST_FOR_EACH_ENTRY( thread
, &process
->thread_list
, struct thread
, proc_entry
)
1741 struct thread_info
*thread_info
= (struct thread_info
*)(buffer
+ pos
);
1743 thread_info
->start_time
= thread
->creation_time
;
1744 thread_info
->tid
= thread
->id
;
1745 thread_info
->base_priority
= thread
->priority
;
1746 thread_info
->current_priority
= thread
->priority
; /* FIXME */
1747 thread_info
->unix_tid
= thread
->unix_tid
;
1748 pos
+= sizeof(*thread_info
);