git.oblomov.eu Git - wine/blob - server/process.c

   1 /*
   2  * Server-side process management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <limits.h>
   9 #include <signal.h>
  10 #include <string.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <sys/time.h>
  14 #include <unistd.h>
  15
  16 #include "winerror.h"
  17 #include "winbase.h"
  18 #include "winnt.h"
  19
  20 #include "server.h"
  21 #include "handle.h"
  22 #include "process.h"
  23 #include "thread.h"
  24
  25 /* process structure */
  26
  27 static struct process *first_process;
  28 static int running_processes;
  29
  30 /* process operations */
  31
  32 static void process_dump( struct object *obj, int verbose );
  33 static int process_signaled( struct object *obj, struct thread *thread );
  34 static void process_destroy( struct object *obj );
  35
  36 static const struct object_ops process_ops =
  37 {
  38     process_dump,
  39     add_queue,
  40     remove_queue,
  41     process_signaled,
  42     no_satisfied,
  43     no_read_fd,
  44     no_write_fd,
  45     no_flush,
  46     no_get_file_info,
  47     process_destroy
  48 };
  49
  50
  51 /* create a new process */
  52 static struct process *create_process( struct process *parent,
  53                                        struct new_process_request *req, const char *cmd_line )
  54 {
  55     struct process *process;
  56
  57     if (!(process = alloc_object( sizeof(*process), &process_ops, NULL ))) return NULL;
  58     process->next            = NULL;
  59     process->prev            = NULL;
  60     process->thread_list     = NULL;
  61     process->debug_next      = NULL;
  62     process->debug_prev      = NULL;
  63     process->debugger        = NULL;
  64     process->handles         = NULL;
  65     process->exit_code       = 0x103;  /* STILL_ACTIVE */
  66     process->running_threads = 0;
  67     process->priority        = NORMAL_PRIORITY_CLASS;
  68     process->affinity        = 1;
  69     process->suspend         = 0;
  70     process->console_in      = NULL;
  71     process->console_out     = NULL;
  72     process->info            = NULL;
  73     gettimeofday( &process->start_time, NULL );
  74
  75     if (req->inherit_all)
  76         process->handles = copy_handle_table( process, parent );
  77     else
  78         process->handles = alloc_handle_table( process, 0 );
  79     if (!process->handles) goto error;
  80
  81     /* alloc a handle for the process itself */
  82     alloc_handle( process, process, PROCESS_ALL_ACCESS, 0 );
  83
  84     if (!(process->info = mem_alloc( sizeof(*process->info) + strlen(cmd_line) + 1 ))) goto error;
  85     memcpy( process->info, req, sizeof(*req) );
  86     strcpy( process->info->cmd_line, cmd_line );
  87
  88     /* set the process console */
  89     if (req->create_flags & CREATE_NEW_CONSOLE)
  90     {
  91         if (!alloc_console( process )) goto error;
  92     }
  93     else if (!(req->create_flags & DETACHED_PROCESS))
  94     {
  95         if (parent->console_in) process->console_in = grab_object( parent->console_in );
  96         if (parent->console_out) process->console_out = grab_object( parent->console_out );
  97     }
  98
  99     if (!req->inherit_all && !(req->start_flags & STARTF_USESTDHANDLES))
 100     {
 101         process->info->hstdin  = duplicate_handle( parent, req->hstdin, process,
 102                                                    0, TRUE, DUPLICATE_SAME_ACCESS );
 103         process->info->hstdout = duplicate_handle( parent, req->hstdout, process,
 104                                                    0, TRUE, DUPLICATE_SAME_ACCESS );
 105         process->info->hstderr = duplicate_handle( parent, req->hstderr, process,
 106                                                    0, TRUE, DUPLICATE_SAME_ACCESS );
 107     }
 108
 109     /* attach to the debugger if requested */
 110     if (req->create_flags & DEBUG_PROCESS)
 111         debugger_attach( process, current );
 112     else if (parent && parent->debugger && !(req->create_flags & DEBUG_ONLY_THIS_PROCESS))
 113         debugger_attach( process, parent->debugger );
 114
 115     if ((process->next = first_process) != NULL) process->next->prev = process;
 116     first_process = process;
 117     return process;
 118
 119  error:
 120     free_console( process );
 121     if (process->info) free( process->info );
 122     if (process->handles) release_object( process->handles );
 123     release_object( process );
 124     return NULL;
 125 }
 126
 127 /* create the initial process */
 128 struct process *create_initial_process(void)
 129 {
 130     struct process *process;
 131     struct new_process_request req;
 132
 133     req.inherit      = 0;
 134     req.inherit_all  = 0;
 135     req.create_flags = CREATE_NEW_CONSOLE;
 136     req.start_flags  = STARTF_USESTDHANDLES;
 137     req.hstdin       = -1;
 138     req.hstdout      = -1;
 139     req.hstderr      = -1;
 140     req.cmd_show     = 0;
 141     req.env_ptr      = NULL;
 142     if ((process = create_process( NULL, &req, "" )))
 143     {
 144         process->info->hstdin  = alloc_handle( process, process->console_in,
 145                                                GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
 146         process->info->hstdout = alloc_handle( process, process->console_out,
 147                                                GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
 148         process->info->hstderr = alloc_handle( process, process->console_out,
 149                                                GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE, 1 );
 150     }
 151     return process;
 152 }
 153
 154 /* destroy a process when its refcount is 0 */
 155 static void process_destroy( struct object *obj )
 156 {
 157     struct process *process = (struct process *)obj;
 158     assert( obj->ops == &process_ops );
 159
 160     /* we can't have a thread remaining */
 161     assert( !process->thread_list );
 162     if (process->next) process->next->prev = process->prev;
 163     if (process->prev) process->prev->next = process->next;
 164     else first_process = process->next;
 165     if (process->info) free( process->info );
 166     if (debug_level) memset( process, 0xbb, sizeof(process) );  /* catch errors */
 167     free( process );
 168 }
 169
 170 /* dump a process on stdout for debugging purposes */
 171 static void process_dump( struct object *obj, int verbose )
 172 {
 173     struct process *process = (struct process *)obj;
 174     assert( obj->ops == &process_ops );
 175
 176     fprintf( stderr, "Process next=%p prev=%p console=%p/%p handles=%p\n",
 177              process->next, process->prev, process->console_in, process->console_out,
 178              process->handles );
 179 }
 180
 181 static int process_signaled( struct object *obj, struct thread *thread )
 182 {
 183     struct process *process = (struct process *)obj;
 184     return !process->running_threads;
 185 }
 186
 187
 188 /* get a process from an id (and increment the refcount) */
 189 struct process *get_process_from_id( void *id )
 190 {
 191     struct process *p = first_process;
 192     while (p && (p != id)) p = p->next;
 193     if (p) grab_object( p );
 194     else SET_ERROR( ERROR_INVALID_PARAMETER );
 195     return p;
 196 }
 197
 198 /* get a process from a handle (and increment the refcount) */
 199 struct process *get_process_from_handle( int handle, unsigned int access )
 200 {
 201     return (struct process *)get_handle_obj( current->process, handle,
 202                                              access, &process_ops );
 203 }
 204
 205 /* a process has been killed (i.e. its last thread died) */
 206 static void process_killed( struct process *process, int exit_code )
 207 {
 208     assert( !process->thread_list );
 209     process->exit_code = exit_code;
 210     gettimeofday( &process->end_time, NULL );
 211     release_object( process->handles );
 212     process->handles = NULL;
 213     free_console( process );
 214     wake_up( &process->obj, 0 );
 215     if (!--running_processes)
 216     {
 217         /* last process died, close global handles */
 218         close_global_handles();
 219     }
 220 }
 221
 222 /* add a thread to a process running threads list */
 223 void add_process_thread( struct process *process, struct thread *thread )
 224 {
 225     thread->proc_next = process->thread_list;
 226     thread->proc_prev = NULL;
 227     if (thread->proc_next) thread->proc_next->proc_prev = thread;
 228     process->thread_list = thread;
 229     if (!process->running_threads++) running_processes++;
 230     grab_object( thread );
 231 }
 232
 233 /* remove a thread from a process running threads list */
 234 void remove_process_thread( struct process *process, struct thread *thread )
 235 {
 236     assert( process->running_threads > 0 );
 237     assert( process->thread_list );
 238
 239     if (thread->proc_next) thread->proc_next->proc_prev = thread->proc_prev;
 240     if (thread->proc_prev) thread->proc_prev->proc_next = thread->proc_next;
 241     else process->thread_list = thread->proc_next;
 242
 243     if (!--process->running_threads)
 244     {
 245         /* we have removed the last running thread, exit the process */
 246         process_killed( process, thread->exit_code );
 247     }
 248     release_object( thread );
 249 }
 250
 251 /* suspend all the threads of a process */
 252 void suspend_process( struct process *process )
 253 {
 254     if (!process->suspend++)
 255     {
 256         struct thread *thread = process->thread_list;
 257         for (; thread; thread = thread->proc_next)
 258         {
 259             if (!thread->suspend && thread->unix_pid)
 260                 kill( thread->unix_pid, SIGSTOP );
 261         }
 262     }
 263 }
 264
 265 /* resume all the threads of a process */
 266 void resume_process( struct process *process )
 267 {
 268     assert (process->suspend > 0);
 269     if (!--process->suspend)
 270     {
 271         struct thread *thread = process->thread_list;
 272         for (; thread; thread = thread->proc_next)
 273         {
 274             if (!thread->suspend && thread->unix_pid)
 275                 kill( thread->unix_pid, SIGCONT );
 276         }
 277     }
 278 }
 279
 280 /* kill a process on the spot */
 281 void kill_process( struct process *process, int exit_code )
 282 {
 283     while (process->thread_list)
 284         kill_thread( process->thread_list, exit_code );
 285 }
 286
 287 /* get all information about a process */
 288 static void get_process_info( struct process *process,
 289                               struct get_process_info_reply *reply )
 290 {
 291     reply->pid              = process;
 292     reply->exit_code        = process->exit_code;
 293     reply->priority         = process->priority;
 294     reply->process_affinity = process->affinity;
 295     reply->system_affinity  = 1;
 296 }
 297
 298 /* set all information about a process */
 299 static void set_process_info( struct process *process,
 300                               struct set_process_info_request *req )
 301 {
 302     if (req->mask & SET_PROCESS_INFO_PRIORITY)
 303         process->priority = req->priority;
 304     if (req->mask & SET_PROCESS_INFO_AFFINITY)
 305     {
 306         if (req->affinity != 1) SET_ERROR( ERROR_INVALID_PARAMETER );
 307         else process->affinity = req->affinity;
 308     }
 309 }
 310
 311 /* take a snapshot of currently running processes */
 312 struct process_snapshot *process_snap( int *count )
 313 {
 314     struct process_snapshot *snapshot, *ptr;
 315     struct process *process;
 316     if (!running_processes) return NULL;
 317     if (!(snapshot = mem_alloc( sizeof(*snapshot) * running_processes )))
 318         return NULL;
 319     ptr = snapshot;
 320     for (process = first_process; process; process = process->next)
 321     {
 322         if (!process->running_threads) continue;
 323         ptr->process  = process;
 324         ptr->threads  = process->running_threads;
 325         ptr->priority = process->priority;
 326         grab_object( process );
 327         ptr++;
 328     }
 329     *count = running_processes;
 330     return snapshot;
 331 }
 332
 333 /* create a new process */
 334 DECL_HANDLER(new_process)
 335 {
 336     struct new_process_reply reply;
 337     struct process *process;
 338     char *cmd_line = (char *)data;
 339
 340     CHECK_STRING( "new_process", cmd_line, len );
 341     if ((process = create_process( current->process, req, cmd_line )))
 342     {
 343         reply.pid    = process;
 344         reply.handle = alloc_handle( current->process, process,
 345                                      PROCESS_ALL_ACCESS, req->inherit );
 346         release_object( process );
 347     }
 348     else
 349     {
 350         reply.handle = -1;
 351         reply.pid    = NULL;
 352     }
 353     send_reply( current, -1, 1, &reply, sizeof(reply) );
 354 }
 355
 356 /* initialize a new process */
 357 DECL_HANDLER(init_process)
 358 {
 359     struct init_process_reply reply;
 360     struct new_process_request *info;
 361
 362     if (current->state != RUNNING)
 363     {
 364         fatal_protocol_error( "init_process: init_thread not called yet\n" );
 365         return;
 366     }
 367     if (!(info = current->process->info))
 368     {
 369         fatal_protocol_error( "init_process: called twice\n" );
 370         return;
 371     }
 372     current->process->info = NULL;
 373     reply.start_flags = info->start_flags;
 374     reply.hstdin      = info->hstdin;
 375     reply.hstdout     = info->hstdout;
 376     reply.hstderr     = info->hstderr;
 377     reply.cmd_show    = info->cmd_show;
 378     reply.env_ptr     = info->env_ptr;
 379     send_reply( current, -1, 2, &reply, sizeof(reply),
 380                 info->cmd_line, strlen(info->cmd_line) + 1 );
 381     free( info );
 382 }
 383
 384 /* open a handle to a process */
 385 DECL_HANDLER(open_process)
 386 {
 387     struct open_process_reply reply = { -1 };
 388     struct process *process = get_process_from_id( req->pid );
 389     if (process)
 390     {
 391         reply.handle = alloc_handle( current->process, process,
 392                                      req->access, req->inherit );
 393         release_object( process );
 394     }
 395     send_reply( current, -1, 1, &reply, sizeof(reply) );
 396 }
 397
 398 /* terminate a process */
 399 DECL_HANDLER(terminate_process)
 400 {
 401     struct process *process;
 402
 403     if ((process = get_process_from_handle( req->handle, PROCESS_TERMINATE )))
 404     {
 405         kill_process( process, req->exit_code );
 406         release_object( process );
 407     }
 408     if (current) send_reply( current, -1, 0 );
 409 }
 410
 411 /* fetch information about a process */
 412 DECL_HANDLER(get_process_info)
 413 {
 414     struct process *process;
 415     struct get_process_info_reply reply = { 0, 0, 0 };
 416
 417     if ((process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION )))
 418     {
 419         get_process_info( process, &reply );
 420         release_object( process );
 421     }
 422     send_reply( current, -1, 1, &reply, sizeof(reply) );
 423 }
 424
 425 /* set information about a process */
 426 DECL_HANDLER(set_process_info)
 427 {
 428     struct process *process;
 429
 430     if ((process = get_process_from_handle( req->handle, PROCESS_SET_INFORMATION )))
 431     {
 432         set_process_info( process, req );
 433         release_object( process );
 434     }
 435     send_reply( current, -1, 0 );
 436 }