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

   1 /*
   2  * Server-side thread management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <assert.h>
  10 #include <fcntl.h>
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #ifdef HAVE_SYS_MMAN_H
  16 #include <sys/mman.h>
  17 #endif
  18 #include <sys/types.h>
  19 #include <sys/uio.h>
  20 #include <unistd.h>
  21 #include <stdarg.h>
  22
  23
  24 #include "winbase.h"
  25 #include "winerror.h"
  26
  27 #include "handle.h"
  28 #include "process.h"
  29 #include "thread.h"
  30 #include "request.h"
  31
  32
  33 /* thread queues */
  34
  35 struct wait_queue_entry
  36 {
  37     struct wait_queue_entry *next;
  38     struct wait_queue_entry *prev;
  39     struct object           *obj;
  40     struct thread           *thread;
  41 };
  42
  43 struct thread_wait
  44 {
  45     int                     count;      /* count of objects */
  46     int                     flags;
  47     struct timeval          timeout;
  48     struct timeout_user    *user;
  49     struct wait_queue_entry queues[1];
  50 };
  51
  52 /* asynchronous procedure calls */
  53
  54 struct thread_apc
  55 {
  56     void                   *func;    /* function to call in client */
  57     void                   *param;   /* function param */
  58 };
  59 #define MAX_THREAD_APC  16  /* Max outstanding APCs for a thread */
  60
  61
  62 /* thread operations */
  63
  64 static void dump_thread( struct object *obj, int verbose );
  65 static int thread_signaled( struct object *obj, struct thread *thread );
  66 static void destroy_thread( struct object *obj );
  67
  68 static const struct object_ops thread_ops =
  69 {
  70     sizeof(struct thread),
  71     dump_thread,
  72     add_queue,
  73     remove_queue,
  74     thread_signaled,
  75     no_satisfied,
  76     no_read_fd,
  77     no_write_fd,
  78     no_flush,
  79     no_get_file_info,
  80     destroy_thread
  81 };
  82
  83 static struct thread *first_thread;
  84
  85 /* allocate the buffer for the communication with the client */
  86 static int alloc_client_buffer( struct thread *thread )
  87 {
  88     int fd;
  89
  90     if ((fd = create_anonymous_file()) == -1) return -1;
  91     if (ftruncate( fd, MAX_REQUEST_LENGTH ) == -1) goto error;
  92     if ((thread->buffer = mmap( 0, MAX_REQUEST_LENGTH, PROT_READ | PROT_WRITE,
  93                                 MAP_SHARED, fd, 0 )) == (void*)-1) goto error;
  94     return fd;
  95
  96  error:
  97     file_set_error();
  98     if (fd != -1) close( fd );
  99     return -1;
 100 }
 101
 102 /* create a new thread */
 103 static struct thread *create_thread( int fd, struct process *process, int suspend )
 104 {
 105     struct thread *thread;
 106     int buf_fd;
 107
 108     if (!(thread = alloc_object( &thread_ops ))) return NULL;
 109
 110     thread->client      = NULL;
 111     thread->unix_pid    = 0;  /* not known yet */
 112     thread->teb         = NULL;
 113     thread->mutex       = NULL;
 114     thread->debug_ctx   = NULL;
 115     thread->debug_event = NULL;
 116     thread->exit_event  = NULL;
 117     thread->wait        = NULL;
 118     thread->apc         = NULL;
 119     thread->apc_count   = 0;
 120     thread->error       = 0;
 121     thread->state       = RUNNING;
 122     thread->attached    = 0;
 123     thread->exit_code   = 0x103;  /* STILL_ACTIVE */
 124     thread->next        = NULL;
 125     thread->prev        = NULL;
 126     thread->priority    = THREAD_PRIORITY_NORMAL;
 127     thread->affinity    = 1;
 128     thread->suspend     = (suspend != 0);
 129     thread->buffer      = (void *)-1;
 130     thread->last_req    = REQ_GET_THREAD_BUFFER;
 131
 132     if (!first_thread)  /* creating the first thread */
 133     {
 134         current = thread;
 135         thread->process = process = create_initial_process();
 136         assert( process );
 137     }
 138     else thread->process = (struct process *)grab_object( process );
 139
 140     if ((thread->next = first_thread) != NULL) thread->next->prev = thread;
 141     first_thread = thread;
 142     add_process_thread( process, thread );
 143
 144     if ((buf_fd = alloc_client_buffer( thread )) == -1) goto error;
 145     if (!(thread->client = add_client( fd, thread )))
 146     {
 147         close( buf_fd );
 148         goto error;
 149     }
 150     set_reply_fd( thread, buf_fd );  /* send the fd to the client */
 151     send_reply( thread );
 152     return thread;
 153
 154  error:
 155     remove_process_thread( process, thread );
 156     release_object( thread );
 157     return NULL;
 158 }
 159
 160 /* create the initial thread and start the main server loop */
 161 void create_initial_thread( int fd )
 162 {
 163     create_thread( fd, NULL, 0 );
 164     select_loop();
 165 }
 166
 167 /* destroy a thread when its refcount is 0 */
 168 static void destroy_thread( struct object *obj )
 169 {
 170     struct thread *thread = (struct thread *)obj;
 171     assert( obj->ops == &thread_ops );
 172
 173     assert( !thread->debug_ctx );  /* cannot still be debugging something */
 174     release_object( thread->process );
 175     if (thread->next) thread->next->prev = thread->prev;
 176     if (thread->prev) thread->prev->next = thread->next;
 177     else first_thread = thread->next;
 178     if (thread->apc) free( thread->apc );
 179     if (thread->buffer != (void *)-1) munmap( thread->buffer, MAX_REQUEST_LENGTH );
 180 }
 181
 182 /* dump a thread on stdout for debugging purposes */
 183 static void dump_thread( struct object *obj, int verbose )
 184 {
 185     struct thread *thread = (struct thread *)obj;
 186     assert( obj->ops == &thread_ops );
 187
 188     fprintf( stderr, "Thread pid=%d teb=%p state=%d\n",
 189              thread->unix_pid, thread->teb, thread->state );
 190 }
 191
 192 static int thread_signaled( struct object *obj, struct thread *thread )
 193 {
 194     struct thread *mythread = (struct thread *)obj;
 195     return (mythread->state == TERMINATED);
 196 }
 197
 198 /* get a thread pointer from a thread id (and increment the refcount) */
 199 struct thread *get_thread_from_id( void *id )
 200 {
 201     struct thread *t = first_thread;
 202     while (t && (t != id)) t = t->next;
 203     if (t) grab_object( t );
 204     return t;
 205 }
 206
 207 /* get a thread from a handle (and increment the refcount) */
 208 struct thread *get_thread_from_handle( int handle, unsigned int access )
 209 {
 210     return (struct thread *)get_handle_obj( current->process, handle,
 211                                             access, &thread_ops );
 212 }
 213
 214 /* find a thread from a Unix pid */
 215 struct thread *get_thread_from_pid( int pid )
 216 {
 217     struct thread *t = first_thread;
 218     while (t && (t->unix_pid != pid)) t = t->next;
 219     return t;
 220 }
 221
 222 /* set all information about a thread */
 223 static void set_thread_info( struct thread *thread,
 224                              struct set_thread_info_request *req )
 225 {
 226     if (req->mask & SET_THREAD_INFO_PRIORITY)
 227         thread->priority = req->priority;
 228     if (req->mask & SET_THREAD_INFO_AFFINITY)
 229     {
 230         if (req->affinity != 1) set_error( ERROR_INVALID_PARAMETER );
 231         else thread->affinity = req->affinity;
 232     }
 233 }
 234
 235 /* suspend a thread */
 236 int suspend_thread( struct thread *thread, int check_limit )
 237 {
 238     int old_count = thread->suspend;
 239     if (thread->suspend < MAXIMUM_SUSPEND_COUNT || !check_limit)
 240     {
 241         if (!(thread->process->suspend + thread->suspend++)) stop_thread( thread );
 242     }
 243     else set_error( ERROR_SIGNAL_REFUSED );
 244     return old_count;
 245 }
 246
 247 /* resume a thread */
 248 int resume_thread( struct thread *thread )
 249 {
 250     int old_count = thread->suspend;
 251     if (thread->suspend > 0)
 252     {
 253         if (!(--thread->suspend + thread->process->suspend)) continue_thread( thread );
 254     }
 255     return old_count;
 256 }
 257
 258 /* suspend all threads but the current */
 259 void suspend_all_threads( void )
 260 {
 261     struct thread *thread;
 262     for ( thread = first_thread; thread; thread = thread->next )
 263         if ( thread != current )
 264             suspend_thread( thread, 0 );
 265 }
 266
 267 /* resume all threads but the current */
 268 void resume_all_threads( void )
 269 {
 270     struct thread *thread;
 271     for ( thread = first_thread; thread; thread = thread->next )
 272         if ( thread != current )
 273             resume_thread( thread );
 274 }
 275
 276 /* add a thread to an object wait queue; return 1 if OK, 0 on error */
 277 int add_queue( struct object *obj, struct wait_queue_entry *entry )
 278 {
 279     grab_object( obj );
 280     entry->obj    = obj;
 281     entry->prev   = obj->tail;
 282     entry->next   = NULL;
 283     if (obj->tail) obj->tail->next = entry;
 284     else obj->head = entry;
 285     obj->tail = entry;
 286     return 1;
 287 }
 288
 289 /* remove a thread from an object wait queue */
 290 void remove_queue( struct object *obj, struct wait_queue_entry *entry )
 291 {
 292     if (entry->next) entry->next->prev = entry->prev;
 293     else obj->tail = entry->prev;
 294     if (entry->prev) entry->prev->next = entry->next;
 295     else obj->head = entry->next;
 296     release_object( obj );
 297 }
 298
 299 /* finish waiting */
 300 static void end_wait( struct thread *thread )
 301 {
 302     struct thread_wait *wait = thread->wait;
 303     struct wait_queue_entry *entry;
 304     int i;
 305
 306     assert( wait );
 307     for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
 308         entry->obj->ops->remove_queue( entry->obj, entry );
 309     if (wait->user) remove_timeout_user( wait->user );
 310     free( wait );
 311     thread->wait = NULL;
 312 }
 313
 314 /* build the thread wait structure */
 315 static int wait_on( struct thread *thread, int count,
 316                     int *handles, int flags, int timeout )
 317 {
 318     struct thread_wait *wait;
 319     struct wait_queue_entry *entry;
 320     struct object *obj;
 321     int i;
 322
 323     if ((count < 0) || (count > MAXIMUM_WAIT_OBJECTS))
 324     {
 325         set_error( ERROR_INVALID_PARAMETER );
 326         return 0;
 327     }
 328     if (!(wait = mem_alloc( sizeof(*wait) + (count-1) * sizeof(*entry) ))) return 0;
 329     thread->wait  = wait;
 330     wait->count   = count;
 331     wait->flags   = flags;
 332     wait->user    = NULL;
 333     if (flags & SELECT_TIMEOUT)
 334     {
 335         gettimeofday( &wait->timeout, 0 );
 336         add_timeout( &wait->timeout, timeout );
 337     }
 338
 339     for (i = 0, entry = wait->queues; i < count; i++, entry++)
 340     {
 341         if (!(obj = get_handle_obj( thread->process, handles[i],
 342                                     SYNCHRONIZE, NULL )))
 343         {
 344             wait->count = i - 1;
 345             end_wait( thread );
 346             return 0;
 347         }
 348         entry->thread = thread;
 349         if (!obj->ops->add_queue( obj, entry ))
 350         {
 351             wait->count = i - 1;
 352             end_wait( thread );
 353             return 0;
 354         }
 355         release_object( obj );
 356     }
 357     return 1;
 358 }
 359
 360 /* check if the thread waiting condition is satisfied */
 361 static int check_wait( struct thread *thread, int *signaled )
 362 {
 363     int i;
 364     struct thread_wait *wait = thread->wait;
 365     struct wait_queue_entry *entry = wait->queues;
 366
 367     assert( wait );
 368     if (wait->flags & SELECT_ALL)
 369     {
 370         int not_ok = 0;
 371         /* Note: we must check them all anyway, as some objects may
 372          * want to do something when signaled, even if others are not */
 373         for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
 374             not_ok |= !entry->obj->ops->signaled( entry->obj, thread );
 375         if (not_ok) goto other_checks;
 376         /* Wait satisfied: tell it to all objects */
 377         *signaled = 0;
 378         for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
 379             if (entry->obj->ops->satisfied( entry->obj, thread ))
 380                 *signaled = STATUS_ABANDONED_WAIT_0;
 381         return 1;
 382     }
 383     else
 384     {
 385         for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
 386         {
 387             if (!entry->obj->ops->signaled( entry->obj, thread )) continue;
 388             /* Wait satisfied: tell it to the object */
 389             *signaled = i;
 390             if (entry->obj->ops->satisfied( entry->obj, thread ))
 391                 *signaled = i + STATUS_ABANDONED_WAIT_0;
 392             return 1;
 393         }
 394     }
 395
 396  other_checks:
 397     if ((wait->flags & SELECT_ALERTABLE) && thread->apc)
 398     {
 399         *signaled = STATUS_USER_APC;
 400         return 1;
 401     }
 402     if (wait->flags & SELECT_TIMEOUT)
 403     {
 404         struct timeval now;
 405         gettimeofday( &now, NULL );
 406         if (!time_before( &now, &wait->timeout ))
 407         {
 408             *signaled = STATUS_TIMEOUT;
 409             return 1;
 410         }
 411     }
 412     return 0;
 413 }
 414
 415 /* attempt to wake up a thread */
 416 /* return 1 if OK, 0 if the wait condition is still not satisfied */
 417 static int wake_thread( struct thread *thread )
 418 {
 419     struct select_request *req = get_req_ptr( thread );
 420
 421     if (!check_wait( thread, &req->signaled )) return 0;
 422     end_wait( thread );
 423     return 1;
 424 }
 425
 426 /* sleep on a list of objects */
 427 static void sleep_on( struct thread *thread, int count, int *handles, int flags, int timeout )
 428 {
 429     struct select_request *req;
 430     assert( !thread->wait );
 431     if (!wait_on( thread, count, handles, flags, timeout )) goto error;
 432     if (wake_thread( thread )) return;
 433     /* now we need to wait */
 434     if (flags & SELECT_TIMEOUT)
 435     {
 436         if (!(thread->wait->user = add_timeout_user( &thread->wait->timeout,
 437                                                      call_timeout_handler, thread )))
 438             goto error;
 439     }
 440     thread->state = SLEEPING;
 441     return;
 442
 443  error:
 444     req = get_req_ptr( thread );
 445     req->signaled = -1;
 446 }
 447
 448 /* timeout for the current thread */
 449 void thread_timeout(void)
 450 {
 451     struct select_request *req = get_req_ptr( current );
 452
 453     assert( current->wait );
 454     current->wait->user = NULL;
 455     end_wait( current );
 456     req->signaled = STATUS_TIMEOUT;
 457     send_reply( current );
 458 }
 459
 460 /* attempt to wake threads sleeping on the object wait queue */
 461 void wake_up( struct object *obj, int max )
 462 {
 463     struct wait_queue_entry *entry = obj->head;
 464
 465     while (entry)
 466     {
 467         struct thread *thread = entry->thread;
 468         entry = entry->next;
 469         if (wake_thread( thread ))
 470         {
 471             send_reply( thread );
 472             if (max && !--max) break;
 473         }
 474     }
 475 }
 476
 477 /* queue an async procedure call */
 478 static int thread_queue_apc( struct thread *thread, void *func, void *param )
 479 {
 480     struct thread_apc *apc;
 481     if (!thread->apc)
 482     {
 483         if (!(thread->apc = mem_alloc( MAX_THREAD_APC * sizeof(*apc) )))
 484             return 0;
 485         thread->apc_count = 0;
 486     }
 487     else if (thread->apc_count >= MAX_THREAD_APC) return 0;
 488     thread->apc[thread->apc_count].func  = func;
 489     thread->apc[thread->apc_count].param = param;
 490     thread->apc_count++;
 491     if (thread->wait)
 492     {
 493         if (wake_thread( thread )) send_reply( thread );
 494     }
 495     return 1;
 496 }
 497
 498 /* kill a thread on the spot */
 499 void kill_thread( struct thread *thread, int exit_code )
 500 {
 501     if (thread->state == TERMINATED) return;  /* already killed */
 502     remove_client( thread->client, exit_code ); /* this will call thread_killed */
 503 }
 504
 505 /* a thread has been killed */
 506 void thread_killed( struct thread *thread, int exit_code )
 507 {
 508     thread->state = TERMINATED;
 509     thread->exit_code = exit_code;
 510     thread->client = NULL;
 511     if (thread->wait) end_wait( thread );
 512     debug_exit_thread( thread, exit_code );
 513     abandon_mutexes( thread );
 514     remove_process_thread( thread->process, thread );
 515     wake_up( &thread->obj, 0 );
 516     detach_thread( thread );
 517     release_object( thread );
 518 }
 519
 520 /* create a new thread */
 521 DECL_HANDLER(new_thread)
 522 {
 523     struct thread *thread;
 524     struct process *process;
 525
 526     if ((process = get_process_from_id( req->pid )))
 527     {
 528         if ((fd = dup(fd)) != -1)
 529         {
 530             if ((thread = create_thread( fd, process, req->suspend )))
 531             {
 532                 req->tid = thread;
 533                 if ((req->handle = alloc_handle( current->process, thread,
 534                                                  THREAD_ALL_ACCESS, req->inherit )) == -1)
 535                     release_object( thread );
 536                 /* else will be released when the thread gets killed */
 537             }
 538             else close( fd );
 539         }
 540         else file_set_error();
 541         release_object( process );
 542     }
 543 }
 544
 545 /* retrieve the thread buffer file descriptor */
 546 DECL_HANDLER(get_thread_buffer)
 547 {
 548     fatal_protocol_error( current, "get_thread_buffer: should never get called directly\n" );
 549 }
 550
 551 /* initialize a new thread */
 552 DECL_HANDLER(init_thread)
 553 {
 554     if (current->unix_pid)
 555     {
 556         fatal_protocol_error( current, "init_thread: already running\n" );
 557         return;
 558     }
 559     current->unix_pid = req->unix_pid;
 560     current->teb      = req->teb;
 561     if (current->suspend + current->process->suspend > 0) stop_thread( current );
 562     req->pid = current->process;
 563     req->tid = current;
 564 }
 565
 566 /* terminate a thread */
 567 DECL_HANDLER(terminate_thread)
 568 {
 569     struct thread *thread;
 570
 571     if ((thread = get_thread_from_handle( req->handle, THREAD_TERMINATE )))
 572     {
 573         kill_thread( thread, req->exit_code );
 574         release_object( thread );
 575     }
 576 }
 577
 578 /* fetch information about a thread */
 579 DECL_HANDLER(get_thread_info)
 580 {
 581     struct thread *thread;
 582
 583     if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
 584     {
 585         req->tid       = thread;
 586         req->exit_code = thread->exit_code;
 587         req->priority  = thread->priority;
 588         release_object( thread );
 589     }
 590 }
 591
 592 /* set information about a thread */
 593 DECL_HANDLER(set_thread_info)
 594 {
 595     struct thread *thread;
 596
 597     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_INFORMATION )))
 598     {
 599         set_thread_info( thread, req );
 600         release_object( thread );
 601     }
 602 }
 603
 604 /* suspend a thread */
 605 DECL_HANDLER(suspend_thread)
 606 {
 607     struct thread *thread;
 608
 609     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 610     {
 611         req->count = suspend_thread( thread, 1 );
 612         release_object( thread );
 613     }
 614 }
 615
 616 /* resume a thread */
 617 DECL_HANDLER(resume_thread)
 618 {
 619     struct thread *thread;
 620
 621     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 622     {
 623         req->count = resume_thread( thread );
 624         release_object( thread );
 625     }
 626 }
 627
 628 /* select on a handle list */
 629 DECL_HANDLER(select)
 630 {
 631     sleep_on( current, req->count, req->handles, req->flags, req->timeout );
 632 }
 633
 634 /* queue an APC for a thread */
 635 DECL_HANDLER(queue_apc)
 636 {
 637     struct thread *thread;
 638     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT )))
 639     {
 640         thread_queue_apc( thread, req->func, req->param );
 641         release_object( thread );
 642     }
 643 }
 644
 645 /* get list of APC to call */
 646 DECL_HANDLER(get_apcs)
 647 {
 648     if ((req->count = current->apc_count))
 649     {
 650         memcpy( req->apcs, current->apc, current->apc_count * sizeof(*current->apc) );
 651         free( current->apc );
 652         current->apc = NULL;
 653         current->apc_count = 0;
 654     }
 655 }