"Fossies" - the Fresh Open Source Software Archive

Member "wine-6.0.1/server/thread.c" (7 Jun 2021, 61613 Bytes) of package /linux/misc/wine-6.0.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "thread.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 6.0_vs_6.0.1.

    1 /*
    2  * Server-side thread 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 <errno.h>
   26 #include <fcntl.h>
   27 #include <signal.h>
   28 #include <stdarg.h>
   29 #include <stdio.h>
   30 #include <stdlib.h>
   31 #include <string.h>
   32 #include <sys/types.h>
   33 #include <unistd.h>
   34 #include <time.h>
   35 #ifdef HAVE_POLL_H
   36 #include <poll.h>
   37 #endif
   38 #ifdef HAVE_SCHED_H
   39 #include <sched.h>
   40 #endif
   41 
   42 #include "ntstatus.h"
   43 #define WIN32_NO_STATUS
   44 #include "windef.h"
   45 #include "winternl.h"
   46 
   47 #include "file.h"
   48 #include "handle.h"
   49 #include "process.h"
   50 #include "thread.h"
   51 #include "request.h"
   52 #include "user.h"
   53 #include "security.h"
   54 
   55 
   56 #ifdef __i386__
   57 static const unsigned int supported_cpus = CPU_FLAG(CPU_x86);
   58 #elif defined(__x86_64__)
   59 static const unsigned int supported_cpus = CPU_FLAG(CPU_x86_64) | CPU_FLAG(CPU_x86);
   60 #elif defined(__powerpc__)
   61 static const unsigned int supported_cpus = CPU_FLAG(CPU_POWERPC);
   62 #elif defined(__arm__)
   63 static const unsigned int supported_cpus = CPU_FLAG(CPU_ARM);
   64 #elif defined(__aarch64__)
   65 static const unsigned int supported_cpus = CPU_FLAG(CPU_ARM64) | CPU_FLAG(CPU_ARM);
   66 #else
   67 #error Unsupported CPU
   68 #endif
   69 
   70 /* thread queues */
   71 
   72 struct thread_wait
   73 {
   74     struct thread_wait     *next;       /* next wait structure for this thread */
   75     struct thread          *thread;     /* owner thread */
   76     int                     count;      /* count of objects */
   77     int                     flags;
   78     int                     abandoned;
   79     enum select_op          select;
   80     client_ptr_t            key;        /* wait key for keyed events */
   81     client_ptr_t            cookie;     /* magic cookie to return to client */
   82     abstime_t               when;
   83     struct timeout_user    *user;
   84     struct wait_queue_entry queues[1];
   85 };
   86 
   87 /* asynchronous procedure calls */
   88 
   89 struct thread_apc
   90 {
   91     struct object       obj;      /* object header */
   92     struct list         entry;    /* queue linked list */
   93     struct thread      *caller;   /* thread that queued this apc */
   94     struct object      *owner;    /* object that queued this apc */
   95     int                 executed; /* has it been executed by the client? */
   96     apc_call_t          call;     /* call arguments */
   97     apc_result_t        result;   /* call results once executed */
   98 };
   99 
  100 static void dump_thread_apc( struct object *obj, int verbose );
  101 static int thread_apc_signaled( struct object *obj, struct wait_queue_entry *entry );
  102 static void thread_apc_destroy( struct object *obj );
  103 static void clear_apc_queue( struct list *queue );
  104 
  105 static const struct object_ops thread_apc_ops =
  106 {
  107     sizeof(struct thread_apc),  /* size */
  108     dump_thread_apc,            /* dump */
  109     no_get_type,                /* get_type */
  110     add_queue,                  /* add_queue */
  111     remove_queue,               /* remove_queue */
  112     thread_apc_signaled,        /* signaled */
  113     no_satisfied,               /* satisfied */
  114     no_signal,                  /* signal */
  115     no_get_fd,                  /* get_fd */
  116     no_map_access,              /* map_access */
  117     default_get_sd,             /* get_sd */
  118     default_set_sd,             /* set_sd */
  119     no_get_full_name,           /* get_full_name */
  120     no_lookup_name,             /* lookup_name */
  121     no_link_name,               /* link_name */
  122     NULL,                       /* unlink_name */
  123     no_open_file,               /* open_file */
  124     no_kernel_obj_list,         /* get_kernel_obj_list */
  125     no_close_handle,            /* close_handle */
  126     thread_apc_destroy          /* destroy */
  127 };
  128 
  129 
  130 /* thread CPU context */
  131 
  132 struct context
  133 {
  134     struct object   obj;        /* object header */
  135     unsigned int    status;     /* status of the context */
  136     context_t       regs;       /* context data */
  137 };
  138 
  139 static void dump_context( struct object *obj, int verbose );
  140 static int context_signaled( struct object *obj, struct wait_queue_entry *entry );
  141 
  142 static const struct object_ops context_ops =
  143 {
  144     sizeof(struct context),     /* size */
  145     dump_context,               /* dump */
  146     no_get_type,                /* get_type */
  147     add_queue,                  /* add_queue */
  148     remove_queue,               /* remove_queue */
  149     context_signaled,           /* signaled */
  150     no_satisfied,               /* satisfied */
  151     no_signal,                  /* signal */
  152     no_get_fd,                  /* get_fd */
  153     no_map_access,              /* map_access */
  154     default_get_sd,             /* get_sd */
  155     default_set_sd,             /* set_sd */
  156     no_get_full_name,           /* get_full_name */
  157     no_lookup_name,             /* lookup_name */
  158     no_link_name,               /* link_name */
  159     NULL,                       /* unlink_name */
  160     no_open_file,               /* open_file */
  161     no_kernel_obj_list,         /* get_kernel_obj_list */
  162     no_close_handle,            /* close_handle */
  163     no_destroy                  /* destroy */
  164 };
  165 
  166 
  167 /* thread operations */
  168 
  169 static void dump_thread( struct object *obj, int verbose );
  170 static struct object_type *thread_get_type( struct object *obj );
  171 static int thread_signaled( struct object *obj, struct wait_queue_entry *entry );
  172 static unsigned int thread_map_access( struct object *obj, unsigned int access );
  173 static void thread_poll_event( struct fd *fd, int event );
  174 static struct list *thread_get_kernel_obj_list( struct object *obj );
  175 static void destroy_thread( struct object *obj );
  176 
  177 static const struct object_ops thread_ops =
  178 {
  179     sizeof(struct thread),      /* size */
  180     dump_thread,                /* dump */
  181     thread_get_type,            /* get_type */
  182     add_queue,                  /* add_queue */
  183     remove_queue,               /* remove_queue */
  184     thread_signaled,            /* signaled */
  185     no_satisfied,               /* satisfied */
  186     no_signal,                  /* signal */
  187     no_get_fd,                  /* get_fd */
  188     thread_map_access,          /* map_access */
  189     default_get_sd,             /* get_sd */
  190     default_set_sd,             /* set_sd */
  191     no_get_full_name,           /* get_full_name */
  192     no_lookup_name,             /* lookup_name */
  193     no_link_name,               /* link_name */
  194     NULL,                       /* unlink_name */
  195     no_open_file,               /* open_file */
  196     thread_get_kernel_obj_list, /* get_kernel_obj_list */
  197     no_close_handle,            /* close_handle */
  198     destroy_thread              /* destroy */
  199 };
  200 
  201 static const struct fd_ops thread_fd_ops =
  202 {
  203     NULL,                       /* get_poll_events */
  204     thread_poll_event,          /* poll_event */
  205     NULL,                       /* flush */
  206     NULL,                       /* get_fd_type */
  207     NULL,                       /* ioctl */
  208     NULL,                       /* queue_async */
  209     NULL                        /* reselect_async */
  210 };
  211 
  212 static struct list thread_list = LIST_INIT(thread_list);
  213 
  214 /* initialize the structure for a newly allocated thread */
  215 static inline void init_thread_structure( struct thread *thread )
  216 {
  217     int i;
  218 
  219     thread->unix_pid        = -1;  /* not known yet */
  220     thread->unix_tid        = -1;  /* not known yet */
  221     thread->context         = NULL;
  222     thread->teb             = 0;
  223     thread->entry_point     = 0;
  224     thread->debug_ctx       = NULL;
  225     thread->system_regs     = 0;
  226     thread->queue           = NULL;
  227     thread->wait            = NULL;
  228     thread->error           = 0;
  229     thread->req_data        = NULL;
  230     thread->req_toread      = 0;
  231     thread->reply_data      = NULL;
  232     thread->reply_towrite   = 0;
  233     thread->request_fd      = NULL;
  234     thread->reply_fd        = NULL;
  235     thread->wait_fd         = NULL;
  236     thread->state           = RUNNING;
  237     thread->exit_code       = 0;
  238     thread->priority        = 0;
  239     thread->suspend         = 0;
  240     thread->dbg_hidden      = 0;
  241     thread->desktop_users   = 0;
  242     thread->token           = NULL;
  243     thread->desc            = NULL;
  244     thread->desc_len        = 0;
  245 
  246     thread->creation_time = current_time;
  247     thread->exit_time     = 0;
  248 
  249     list_init( &thread->mutex_list );
  250     list_init( &thread->system_apc );
  251     list_init( &thread->user_apc );
  252     list_init( &thread->kernel_object );
  253 
  254     for (i = 0; i < MAX_INFLIGHT_FDS; i++)
  255         thread->inflight[i].server = thread->inflight[i].client = -1;
  256 }
  257 
  258 /* check if address looks valid for a client-side data structure (TEB etc.) */
  259 static inline int is_valid_address( client_ptr_t addr )
  260 {
  261     return addr && !(addr % sizeof(int));
  262 }
  263 
  264 
  265 /* dump a context on stdout for debugging purposes */
  266 static void dump_context( struct object *obj, int verbose )
  267 {
  268     struct context *context = (struct context *)obj;
  269     assert( obj->ops == &context_ops );
  270 
  271     fprintf( stderr, "context flags=%x\n", context->regs.flags );
  272 }
  273 
  274 
  275 static int context_signaled( struct object *obj, struct wait_queue_entry *entry )
  276 {
  277     struct context *context = (struct context *)obj;
  278     return context->status != STATUS_PENDING;
  279 }
  280 
  281 
  282 static struct context *create_thread_context( struct thread *thread )
  283 {
  284     struct context *context;
  285     if (!(context = alloc_object( &context_ops ))) return NULL;
  286     context->status = STATUS_PENDING;
  287     memset( &context->regs, 0, sizeof(context->regs) );
  288     context->regs.cpu = thread->process->cpu;
  289     return context;
  290 }
  291 
  292 
  293 /* create a new thread */
  294 struct thread *create_thread( int fd, struct process *process, const struct security_descriptor *sd )
  295 {
  296     struct thread *thread;
  297     int request_pipe[2];
  298 
  299     if (fd == -1)
  300     {
  301         if (pipe( request_pipe ) == -1)
  302         {
  303             file_set_error();
  304             return NULL;
  305         }
  306         if (send_client_fd( process, request_pipe[1], SERVER_PROTOCOL_VERSION ) == -1)
  307         {
  308             close( request_pipe[0] );
  309             close( request_pipe[1] );
  310             return NULL;
  311         }
  312         close( request_pipe[1] );
  313         fd = request_pipe[0];
  314     }
  315 
  316     if (process->is_terminating)
  317     {
  318         close( fd );
  319         set_error( STATUS_PROCESS_IS_TERMINATING );
  320         return NULL;
  321     }
  322 
  323     if (!(thread = alloc_object( &thread_ops )))
  324     {
  325         close( fd );
  326         return NULL;
  327     }
  328 
  329     init_thread_structure( thread );
  330 
  331     thread->process = (struct process *)grab_object( process );
  332     thread->desktop = process->desktop;
  333     thread->affinity = process->affinity;
  334     if (!current) current = thread;
  335 
  336     list_add_tail( &thread_list, &thread->entry );
  337 
  338     if (sd && !set_sd_defaults_from_token( &thread->obj, sd,
  339                                            OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
  340                                            DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION,
  341                                            process->token ))
  342     {
  343         close( fd );
  344         release_object( thread );
  345         return NULL;
  346     }
  347     if (!(thread->id = alloc_ptid( thread )))
  348     {
  349         close( fd );
  350         release_object( thread );
  351         return NULL;
  352     }
  353     if (!(thread->request_fd = create_anonymous_fd( &thread_fd_ops, fd, &thread->obj, 0 )))
  354     {
  355         release_object( thread );
  356         return NULL;
  357     }
  358 
  359     set_fd_events( thread->request_fd, POLLIN );  /* start listening to events */
  360     add_process_thread( thread->process, thread );
  361     return thread;
  362 }
  363 
  364 /* handle a client event */
  365 static void thread_poll_event( struct fd *fd, int event )
  366 {
  367     struct thread *thread = get_fd_user( fd );
  368     assert( thread->obj.ops == &thread_ops );
  369 
  370     grab_object( thread );
  371     if (event & (POLLERR | POLLHUP)) kill_thread( thread, 0 );
  372     else if (event & POLLIN) read_request( thread );
  373     else if (event & POLLOUT) write_reply( thread );
  374     release_object( thread );
  375 }
  376 
  377 static struct list *thread_get_kernel_obj_list( struct object *obj )
  378 {
  379     struct thread *thread = (struct thread *)obj;
  380     return &thread->kernel_object;
  381 }
  382 
  383 /* cleanup everything that is no longer needed by a dead thread */
  384 /* used by destroy_thread and kill_thread */
  385 static void cleanup_thread( struct thread *thread )
  386 {
  387     int i;
  388 
  389     if (thread->context)
  390     {
  391         thread->context->status = STATUS_ACCESS_DENIED;
  392         wake_up( &thread->context->obj, 0 );
  393         release_object( thread->context );
  394         thread->context = NULL;
  395     }
  396     clear_apc_queue( &thread->system_apc );
  397     clear_apc_queue( &thread->user_apc );
  398     free( thread->req_data );
  399     free( thread->reply_data );
  400     if (thread->request_fd) release_object( thread->request_fd );
  401     if (thread->reply_fd) release_object( thread->reply_fd );
  402     if (thread->wait_fd) release_object( thread->wait_fd );
  403     cleanup_clipboard_thread(thread);
  404     destroy_thread_windows( thread );
  405     free_msg_queue( thread );
  406     close_thread_desktop( thread );
  407     for (i = 0; i < MAX_INFLIGHT_FDS; i++)
  408     {
  409         if (thread->inflight[i].client != -1)
  410         {
  411             close( thread->inflight[i].server );
  412             thread->inflight[i].client = thread->inflight[i].server = -1;
  413         }
  414     }
  415     free( thread->desc );
  416     thread->req_data = NULL;
  417     thread->reply_data = NULL;
  418     thread->request_fd = NULL;
  419     thread->reply_fd = NULL;
  420     thread->wait_fd = NULL;
  421     thread->desktop = 0;
  422     thread->desc = NULL;
  423     thread->desc_len = 0;
  424 }
  425 
  426 /* destroy a thread when its refcount is 0 */
  427 static void destroy_thread( struct object *obj )
  428 {
  429     struct thread *thread = (struct thread *)obj;
  430     assert( obj->ops == &thread_ops );
  431 
  432     assert( !thread->debug_ctx );  /* cannot still be debugging something */
  433     list_remove( &thread->entry );
  434     cleanup_thread( thread );
  435     release_object( thread->process );
  436     if (thread->id) free_ptid( thread->id );
  437     if (thread->token) release_object( thread->token );
  438 }
  439 
  440 /* dump a thread on stdout for debugging purposes */
  441 static void dump_thread( struct object *obj, int verbose )
  442 {
  443     struct thread *thread = (struct thread *)obj;
  444     assert( obj->ops == &thread_ops );
  445 
  446     fprintf( stderr, "Thread id=%04x unix pid=%d unix tid=%d state=%d\n",
  447              thread->id, thread->unix_pid, thread->unix_tid, thread->state );
  448 }
  449 
  450 static struct object_type *thread_get_type( struct object *obj )
  451 {
  452     static const WCHAR name[] = {'T','h','r','e','a','d'};
  453     static const struct unicode_str str = { name, sizeof(name) };
  454     return get_object_type( &str );
  455 }
  456 
  457 static int thread_signaled( struct object *obj, struct wait_queue_entry *entry )
  458 {
  459     struct thread *mythread = (struct thread *)obj;
  460     return (mythread->state == TERMINATED);
  461 }
  462 
  463 static unsigned int thread_map_access( struct object *obj, unsigned int access )
  464 {
  465     if (access & GENERIC_READ)    access |= STANDARD_RIGHTS_READ | THREAD_QUERY_INFORMATION | THREAD_GET_CONTEXT;
  466     if (access & GENERIC_WRITE)   access |= STANDARD_RIGHTS_WRITE | THREAD_SET_INFORMATION | THREAD_SET_CONTEXT |
  467                                             THREAD_TERMINATE | THREAD_SUSPEND_RESUME;
  468     if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | THREAD_QUERY_LIMITED_INFORMATION;
  469     if (access & GENERIC_ALL)     access |= THREAD_ALL_ACCESS;
  470 
  471     if (access & THREAD_QUERY_INFORMATION) access |= THREAD_QUERY_LIMITED_INFORMATION;
  472     if (access & THREAD_SET_INFORMATION) access |= THREAD_SET_LIMITED_INFORMATION;
  473 
  474     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
  475 }
  476 
  477 static void dump_thread_apc( struct object *obj, int verbose )
  478 {
  479     struct thread_apc *apc = (struct thread_apc *)obj;
  480     assert( obj->ops == &thread_apc_ops );
  481 
  482     fprintf( stderr, "APC owner=%p type=%u\n", apc->owner, apc->call.type );
  483 }
  484 
  485 static int thread_apc_signaled( struct object *obj, struct wait_queue_entry *entry )
  486 {
  487     struct thread_apc *apc = (struct thread_apc *)obj;
  488     return apc->executed;
  489 }
  490 
  491 static void thread_apc_destroy( struct object *obj )
  492 {
  493     struct thread_apc *apc = (struct thread_apc *)obj;
  494     if (apc->caller) release_object( apc->caller );
  495     if (apc->owner) release_object( apc->owner );
  496 }
  497 
  498 /* queue an async procedure call */
  499 static struct thread_apc *create_apc( struct object *owner, const apc_call_t *call_data )
  500 {
  501     struct thread_apc *apc;
  502 
  503     if ((apc = alloc_object( &thread_apc_ops )))
  504     {
  505         apc->call        = *call_data;
  506         apc->caller      = NULL;
  507         apc->owner       = owner;
  508         apc->executed    = 0;
  509         apc->result.type = APC_NONE;
  510         if (owner) grab_object( owner );
  511     }
  512     return apc;
  513 }
  514 
  515 /* get a thread pointer from a thread id (and increment the refcount) */
  516 struct thread *get_thread_from_id( thread_id_t id )
  517 {
  518     struct object *obj = get_ptid_entry( id );
  519 
  520     if (obj && obj->ops == &thread_ops) return (struct thread *)grab_object( obj );
  521     set_error( STATUS_INVALID_CID );
  522     return NULL;
  523 }
  524 
  525 /* get a thread from a handle (and increment the refcount) */
  526 struct thread *get_thread_from_handle( obj_handle_t handle, unsigned int access )
  527 {
  528     return (struct thread *)get_handle_obj( current->process, handle,
  529                                             access, &thread_ops );
  530 }
  531 
  532 /* find a thread from a Unix tid */
  533 struct thread *get_thread_from_tid( int tid )
  534 {
  535     struct thread *thread;
  536 
  537     LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
  538     {
  539         if (thread->unix_tid == tid) return thread;
  540     }
  541     return NULL;
  542 }
  543 
  544 /* find a thread from a Unix pid */
  545 struct thread *get_thread_from_pid( int pid )
  546 {
  547     struct thread *thread;
  548 
  549     LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
  550     {
  551         if (thread->unix_pid == pid) return thread;
  552     }
  553     return NULL;
  554 }
  555 
  556 int set_thread_affinity( struct thread *thread, affinity_t affinity )
  557 {
  558     int ret = 0;
  559 #ifdef HAVE_SCHED_SETAFFINITY
  560     if (thread->unix_tid != -1)
  561     {
  562         cpu_set_t set;
  563         int i;
  564         affinity_t mask;
  565 
  566         CPU_ZERO( &set );
  567         for (i = 0, mask = 1; mask; i++, mask <<= 1)
  568             if (affinity & mask) CPU_SET( i, &set );
  569 
  570         ret = sched_setaffinity( thread->unix_tid, sizeof(set), &set );
  571     }
  572 #endif
  573     if (!ret) thread->affinity = affinity;
  574     return ret;
  575 }
  576 
  577 affinity_t get_thread_affinity( struct thread *thread )
  578 {
  579     affinity_t mask = 0;
  580 #ifdef HAVE_SCHED_SETAFFINITY
  581     if (thread->unix_tid != -1)
  582     {
  583         cpu_set_t set;
  584         unsigned int i;
  585 
  586         if (!sched_getaffinity( thread->unix_tid, sizeof(set), &set ))
  587             for (i = 0; i < 8 * sizeof(mask); i++)
  588                 if (CPU_ISSET( i, &set )) mask |= (affinity_t)1 << i;
  589     }
  590 #endif
  591     if (!mask) mask = ~(affinity_t)0;
  592     return mask;
  593 }
  594 
  595 #define THREAD_PRIORITY_REALTIME_HIGHEST 6
  596 #define THREAD_PRIORITY_REALTIME_LOWEST -7
  597 
  598 /* set all information about a thread */
  599 static void set_thread_info( struct thread *thread,
  600                              const struct set_thread_info_request *req )
  601 {
  602     if (req->mask & SET_THREAD_INFO_PRIORITY)
  603     {
  604         int max = THREAD_PRIORITY_HIGHEST;
  605         int min = THREAD_PRIORITY_LOWEST;
  606         if (thread->process->priority == PROCESS_PRIOCLASS_REALTIME)
  607         {
  608             max = THREAD_PRIORITY_REALTIME_HIGHEST;
  609             min = THREAD_PRIORITY_REALTIME_LOWEST;
  610         }
  611         if ((req->priority >= min && req->priority <= max) ||
  612             req->priority == THREAD_PRIORITY_IDLE ||
  613             req->priority == THREAD_PRIORITY_TIME_CRITICAL)
  614             thread->priority = req->priority;
  615         else
  616             set_error( STATUS_INVALID_PARAMETER );
  617     }
  618     if (req->mask & SET_THREAD_INFO_AFFINITY)
  619     {
  620         if ((req->affinity & thread->process->affinity) != req->affinity)
  621             set_error( STATUS_INVALID_PARAMETER );
  622         else if (thread->state == TERMINATED)
  623             set_error( STATUS_THREAD_IS_TERMINATING );
  624         else if (set_thread_affinity( thread, req->affinity ))
  625             file_set_error();
  626     }
  627     if (req->mask & SET_THREAD_INFO_TOKEN)
  628         security_set_thread_token( thread, req->token );
  629     if (req->mask & SET_THREAD_INFO_ENTRYPOINT)
  630         thread->entry_point = req->entry_point;
  631     if (req->mask & SET_THREAD_INFO_DBG_HIDDEN)
  632         thread->dbg_hidden = 1;
  633     if (req->mask & SET_THREAD_INFO_DESCRIPTION)
  634     {
  635         WCHAR *desc;
  636         data_size_t desc_len = get_req_data_size();
  637 
  638         if (desc_len)
  639         {
  640             if ((desc = mem_alloc( desc_len )))
  641             {
  642                 memcpy( desc, get_req_data(), desc_len );
  643                 free( thread->desc );
  644                 thread->desc = desc;
  645                 thread->desc_len = desc_len;
  646             }
  647         }
  648         else
  649         {
  650             free( thread->desc );
  651             thread->desc = NULL;
  652             thread->desc_len = 0;
  653         }
  654     }
  655 }
  656 
  657 /* stop a thread (at the Unix level) */
  658 void stop_thread( struct thread *thread )
  659 {
  660     if (thread->context) return;  /* already suspended, no need for a signal */
  661     if (!(thread->context = create_thread_context( thread ))) return;
  662     /* can't stop a thread while initialisation is in progress */
  663     if (is_process_init_done(thread->process)) send_thread_signal( thread, SIGUSR1 );
  664 }
  665 
  666 /* suspend a thread */
  667 int suspend_thread( struct thread *thread )
  668 {
  669     int old_count = thread->suspend;
  670     if (thread->suspend < MAXIMUM_SUSPEND_COUNT)
  671     {
  672         if (!(thread->process->suspend + thread->suspend++)) stop_thread( thread );
  673     }
  674     else set_error( STATUS_SUSPEND_COUNT_EXCEEDED );
  675     return old_count;
  676 }
  677 
  678 /* resume a thread */
  679 int resume_thread( struct thread *thread )
  680 {
  681     int old_count = thread->suspend;
  682     if (thread->suspend > 0)
  683     {
  684         if (!(--thread->suspend)) resume_delayed_debug_events( thread );
  685         if (!(thread->suspend + thread->process->suspend)) wake_thread( thread );
  686     }
  687     return old_count;
  688 }
  689 
  690 /* add a thread to an object wait queue; return 1 if OK, 0 on error */
  691 int add_queue( struct object *obj, struct wait_queue_entry *entry )
  692 {
  693     grab_object( obj );
  694     entry->obj = obj;
  695     list_add_tail( &obj->wait_queue, &entry->entry );
  696     return 1;
  697 }
  698 
  699 /* remove a thread from an object wait queue */
  700 void remove_queue( struct object *obj, struct wait_queue_entry *entry )
  701 {
  702     list_remove( &entry->entry );
  703     release_object( obj );
  704 }
  705 
  706 struct thread *get_wait_queue_thread( struct wait_queue_entry *entry )
  707 {
  708     return entry->wait->thread;
  709 }
  710 
  711 enum select_op get_wait_queue_select_op( struct wait_queue_entry *entry )
  712 {
  713     return entry->wait->select;
  714 }
  715 
  716 client_ptr_t get_wait_queue_key( struct wait_queue_entry *entry )
  717 {
  718     return entry->wait->key;
  719 }
  720 
  721 void make_wait_abandoned( struct wait_queue_entry *entry )
  722 {
  723     entry->wait->abandoned = 1;
  724 }
  725 
  726 /* finish waiting */
  727 static unsigned int end_wait( struct thread *thread, unsigned int status )
  728 {
  729     struct thread_wait *wait = thread->wait;
  730     struct wait_queue_entry *entry;
  731     int i;
  732 
  733     assert( wait );
  734     thread->wait = wait->next;
  735 
  736     if (status < wait->count)  /* wait satisfied, tell it to the objects */
  737     {
  738         if (wait->select == SELECT_WAIT_ALL)
  739         {
  740             for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
  741                 entry->obj->ops->satisfied( entry->obj, entry );
  742         }
  743         else
  744         {
  745             entry = wait->queues + status;
  746             entry->obj->ops->satisfied( entry->obj, entry );
  747         }
  748         if (wait->abandoned) status += STATUS_ABANDONED_WAIT_0;
  749     }
  750     for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
  751         entry->obj->ops->remove_queue( entry->obj, entry );
  752     if (wait->user) remove_timeout_user( wait->user );
  753     free( wait );
  754     return status;
  755 }
  756 
  757 /* build the thread wait structure */
  758 static int wait_on( const select_op_t *select_op, unsigned int count, struct object *objects[],
  759                     int flags, abstime_t when )
  760 {
  761     struct thread_wait *wait;
  762     struct wait_queue_entry *entry;
  763     unsigned int i;
  764 
  765     if (!(wait = mem_alloc( FIELD_OFFSET(struct thread_wait, queues[count]) ))) return 0;
  766     wait->next    = current->wait;
  767     wait->thread  = current;
  768     wait->count   = count;
  769     wait->flags   = flags;
  770     wait->select  = select_op->op;
  771     wait->cookie  = 0;
  772     wait->user    = NULL;
  773     wait->when = when;
  774     wait->abandoned = 0;
  775     current->wait = wait;
  776 
  777     for (i = 0, entry = wait->queues; i < count; i++, entry++)
  778     {
  779         struct object *obj = objects[i];
  780         entry->wait = wait;
  781         if (!obj->ops->add_queue( obj, entry ))
  782         {
  783             wait->count = i;
  784             end_wait( current, get_error() );
  785             return 0;
  786         }
  787     }
  788     return 1;
  789 }
  790 
  791 static int wait_on_handles( const select_op_t *select_op, unsigned int count, const obj_handle_t *handles,
  792                             int flags, abstime_t when )
  793 {
  794     struct object *objects[MAXIMUM_WAIT_OBJECTS];
  795     unsigned int i;
  796     int ret = 0;
  797 
  798     assert( count <= MAXIMUM_WAIT_OBJECTS );
  799 
  800     for (i = 0; i < count; i++)
  801         if (!(objects[i] = get_handle_obj( current->process, handles[i], SYNCHRONIZE, NULL )))
  802             break;
  803 
  804     if (i == count) ret = wait_on( select_op, count, objects, flags, when );
  805 
  806     while (i > 0) release_object( objects[--i] );
  807     return ret;
  808 }
  809 
  810 /* check if the thread waiting condition is satisfied */
  811 static int check_wait( struct thread *thread )
  812 {
  813     int i;
  814     struct thread_wait *wait = thread->wait;
  815     struct wait_queue_entry *entry;
  816 
  817     assert( wait );
  818 
  819     if ((wait->flags & SELECT_INTERRUPTIBLE) && !list_empty( &thread->system_apc ))
  820         return STATUS_KERNEL_APC;
  821 
  822     /* Suspended threads may not acquire locks, but they can run system APCs */
  823     if (thread->process->suspend + thread->suspend > 0) return -1;
  824 
  825     if (wait->select == SELECT_WAIT_ALL)
  826     {
  827         int not_ok = 0;
  828         /* Note: we must check them all anyway, as some objects may
  829          * want to do something when signaled, even if others are not */
  830         for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
  831             not_ok |= !entry->obj->ops->signaled( entry->obj, entry );
  832         if (!not_ok) return STATUS_WAIT_0;
  833     }
  834     else
  835     {
  836         for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
  837             if (entry->obj->ops->signaled( entry->obj, entry )) return i;
  838     }
  839 
  840     if ((wait->flags & SELECT_ALERTABLE) && !list_empty(&thread->user_apc)) return STATUS_USER_APC;
  841     if (wait->when >= 0 && wait->when <= current_time) return STATUS_TIMEOUT;
  842     if (wait->when < 0 && -wait->when <= monotonic_time) return STATUS_TIMEOUT;
  843     return -1;
  844 }
  845 
  846 /* send the wakeup signal to a thread */
  847 static int send_thread_wakeup( struct thread *thread, client_ptr_t cookie, int signaled )
  848 {
  849     struct wake_up_reply reply;
  850     int ret;
  851 
  852     /* check if we're waking current suspend wait */
  853     if (thread->context && thread->suspend_cookie == cookie
  854         && signaled != STATUS_KERNEL_APC && signaled != STATUS_USER_APC)
  855     {
  856         if (!thread->context->regs.flags)
  857         {
  858             release_object( thread->context );
  859             thread->context = NULL;
  860         }
  861         else signaled = STATUS_KERNEL_APC; /* signal a fake APC so that client calls select to get a new context */
  862     }
  863 
  864     memset( &reply, 0, sizeof(reply) );
  865     reply.cookie   = cookie;
  866     reply.signaled = signaled;
  867     if ((ret = write( get_unix_fd( thread->wait_fd ), &reply, sizeof(reply) )) == sizeof(reply))
  868         return 0;
  869     if (ret >= 0)
  870         fatal_protocol_error( thread, "partial wakeup write %d\n", ret );
  871     else if (errno == EPIPE)
  872         kill_thread( thread, 0 );  /* normal death */
  873     else
  874         fatal_protocol_error( thread, "write: %s\n", strerror( errno ));
  875     return -1;
  876 }
  877 
  878 /* attempt to wake up a thread */
  879 /* return >0 if OK, 0 if the wait condition is still not satisfied and -1 on error */
  880 int wake_thread( struct thread *thread )
  881 {
  882     int signaled, count;
  883     client_ptr_t cookie;
  884 
  885     for (count = 0; thread->wait; count++)
  886     {
  887         if ((signaled = check_wait( thread )) == -1) break;
  888 
  889         cookie = thread->wait->cookie;
  890         signaled = end_wait( thread, signaled );
  891         if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=%d\n", thread->id, signaled );
  892         if (cookie && send_thread_wakeup( thread, cookie, signaled ) == -1) /* error */
  893         {
  894             if (!count) count = -1;
  895             break;
  896         }
  897     }
  898     return count;
  899 }
  900 
  901 /* attempt to wake up a thread from a wait queue entry, assuming that it is signaled */
  902 int wake_thread_queue_entry( struct wait_queue_entry *entry )
  903 {
  904     struct thread_wait *wait = entry->wait;
  905     struct thread *thread = wait->thread;
  906     int signaled;
  907     client_ptr_t cookie;
  908 
  909     if (thread->wait != wait) return 0;  /* not the current wait */
  910     if (thread->process->suspend + thread->suspend > 0) return 0;  /* cannot acquire locks */
  911 
  912     assert( wait->select != SELECT_WAIT_ALL );
  913 
  914     cookie = wait->cookie;
  915     signaled = end_wait( thread, entry - wait->queues );
  916     if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=%d\n", thread->id, signaled );
  917 
  918     if (!cookie || send_thread_wakeup( thread, cookie, signaled ) != -1)
  919         wake_thread( thread );  /* check other waits too */
  920 
  921     return 1;
  922 }
  923 
  924 /* thread wait timeout */
  925 static void thread_timeout( void *ptr )
  926 {
  927     struct thread_wait *wait = ptr;
  928     struct thread *thread = wait->thread;
  929     client_ptr_t cookie = wait->cookie;
  930 
  931     wait->user = NULL;
  932     if (thread->wait != wait) return; /* not the top-level wait, ignore it */
  933     if (thread->suspend + thread->process->suspend > 0) return;  /* suspended, ignore it */
  934 
  935     if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=TIMEOUT\n", thread->id );
  936     end_wait( thread, STATUS_TIMEOUT );
  937 
  938     assert( cookie );
  939     if (send_thread_wakeup( thread, cookie, STATUS_TIMEOUT ) == -1) return;
  940     /* check if other objects have become signaled in the meantime */
  941     wake_thread( thread );
  942 }
  943 
  944 /* try signaling an event flag, a semaphore or a mutex */
  945 static int signal_object( obj_handle_t handle )
  946 {
  947     struct object *obj;
  948     int ret = 0;
  949 
  950     obj = get_handle_obj( current->process, handle, 0, NULL );
  951     if (obj)
  952     {
  953         ret = obj->ops->signal( obj, get_handle_access( current->process, handle ));
  954         release_object( obj );
  955     }
  956     return ret;
  957 }
  958 
  959 /* select on a list of handles */
  960 static void select_on( const select_op_t *select_op, data_size_t op_size, client_ptr_t cookie,
  961                             int flags, abstime_t when )
  962 {
  963     int ret;
  964     unsigned int count;
  965     struct object *object;
  966 
  967     switch (select_op->op)
  968     {
  969     case SELECT_NONE:
  970         if (!wait_on( select_op, 0, NULL, flags, when )) return;
  971         break;
  972 
  973     case SELECT_WAIT:
  974     case SELECT_WAIT_ALL:
  975         count = (op_size - offsetof( select_op_t, wait.handles )) / sizeof(select_op->wait.handles[0]);
  976         if (op_size < offsetof( select_op_t, wait.handles ) || count > MAXIMUM_WAIT_OBJECTS)
  977         {
  978             set_error( STATUS_INVALID_PARAMETER );
  979             return;
  980         }
  981         if (!wait_on_handles( select_op, count, select_op->wait.handles, flags, when ))
  982             return;
  983         break;
  984 
  985     case SELECT_SIGNAL_AND_WAIT:
  986         if (!wait_on_handles( select_op, 1, &select_op->signal_and_wait.wait, flags, when ))
  987             return;
  988         if (select_op->signal_and_wait.signal)
  989         {
  990             if (!signal_object( select_op->signal_and_wait.signal ))
  991             {
  992                 end_wait( current, get_error() );
  993                 return;
  994             }
  995             /* check if we woke ourselves up */
  996             if (!current->wait) return;
  997         }
  998         break;
  999 
 1000     case SELECT_KEYED_EVENT_WAIT:
 1001     case SELECT_KEYED_EVENT_RELEASE:
 1002         object = (struct object *)get_keyed_event_obj( current->process, select_op->keyed_event.handle,
 1003                          select_op->op == SELECT_KEYED_EVENT_WAIT ? KEYEDEVENT_WAIT : KEYEDEVENT_WAKE );
 1004         if (!object) return;
 1005         ret = wait_on( select_op, 1, &object, flags, when );
 1006         release_object( object );
 1007         if (!ret) return;
 1008         current->wait->key = select_op->keyed_event.key;
 1009         break;
 1010 
 1011     default:
 1012         set_error( STATUS_INVALID_PARAMETER );
 1013         return;
 1014     }
 1015 
 1016     if ((ret = check_wait( current )) != -1)
 1017     {
 1018         /* condition is already satisfied */
 1019         set_error( end_wait( current, ret ));
 1020         return;
 1021     }
 1022 
 1023     /* now we need to wait */
 1024     if (current->wait->when != TIMEOUT_INFINITE)
 1025     {
 1026         if (!(current->wait->user = add_timeout_user( abstime_to_timeout(current->wait->when),
 1027                                                       thread_timeout, current->wait )))
 1028         {
 1029             end_wait( current, get_error() );
 1030             return;
 1031         }
 1032     }
 1033     current->wait->cookie = cookie;
 1034     set_error( STATUS_PENDING );
 1035     return;
 1036 }
 1037 
 1038 /* attempt to wake threads sleeping on the object wait queue */
 1039 void wake_up( struct object *obj, int max )
 1040 {
 1041     struct list *ptr;
 1042     int ret;
 1043 
 1044     LIST_FOR_EACH( ptr, &obj->wait_queue )
 1045     {
 1046         struct wait_queue_entry *entry = LIST_ENTRY( ptr, struct wait_queue_entry, entry );
 1047         if (!(ret = wake_thread( get_wait_queue_thread( entry )))) continue;
 1048         if (ret > 0 && max && !--max) break;
 1049         /* restart at the head of the list since a wake up can change the object wait queue */
 1050         ptr = &obj->wait_queue;
 1051     }
 1052 }
 1053 
 1054 /* return the apc queue to use for a given apc type */
 1055 static inline struct list *get_apc_queue( struct thread *thread, enum apc_type type )
 1056 {
 1057     switch(type)
 1058     {
 1059     case APC_NONE:
 1060     case APC_USER:
 1061     case APC_TIMER:
 1062         return &thread->user_apc;
 1063     default:
 1064         return &thread->system_apc;
 1065     }
 1066 }
 1067 
 1068 /* check if thread is currently waiting for a (system) apc */
 1069 static inline int is_in_apc_wait( struct thread *thread )
 1070 {
 1071     return (thread->process->suspend || thread->suspend ||
 1072             (thread->wait && (thread->wait->flags & SELECT_INTERRUPTIBLE)));
 1073 }
 1074 
 1075 /* queue an existing APC to a given thread */
 1076 static int queue_apc( struct process *process, struct thread *thread, struct thread_apc *apc )
 1077 {
 1078     struct list *queue;
 1079 
 1080     if (thread && thread->state == TERMINATED && process)
 1081         thread = NULL;
 1082 
 1083     if (!thread)  /* find a suitable thread inside the process */
 1084     {
 1085         struct thread *candidate;
 1086 
 1087         /* first try to find a waiting thread */
 1088         LIST_FOR_EACH_ENTRY( candidate, &process->thread_list, struct thread, proc_entry )
 1089         {
 1090             if (candidate->state == TERMINATED) continue;
 1091             if (is_in_apc_wait( candidate ))
 1092             {
 1093                 thread = candidate;
 1094                 break;
 1095             }
 1096         }
 1097         if (!thread)
 1098         {
 1099             /* then use the first one that accepts a signal */
 1100             LIST_FOR_EACH_ENTRY( candidate, &process->thread_list, struct thread, proc_entry )
 1101             {
 1102                 if (send_thread_signal( candidate, SIGUSR1 ))
 1103                 {
 1104                     thread = candidate;
 1105                     break;
 1106                 }
 1107             }
 1108         }
 1109         if (!thread) return 0;  /* nothing found */
 1110         queue = get_apc_queue( thread, apc->call.type );
 1111     }
 1112     else
 1113     {
 1114         if (thread->state == TERMINATED) return 0;
 1115         queue = get_apc_queue( thread, apc->call.type );
 1116         /* send signal for system APCs if needed */
 1117         if (queue == &thread->system_apc && list_empty( queue ) && !is_in_apc_wait( thread ))
 1118         {
 1119             if (!send_thread_signal( thread, SIGUSR1 )) return 0;
 1120         }
 1121         /* cancel a possible previous APC with the same owner */
 1122         if (apc->owner) thread_cancel_apc( thread, apc->owner, apc->call.type );
 1123     }
 1124 
 1125     grab_object( apc );
 1126     list_add_tail( queue, &apc->entry );
 1127     if (!list_prev( queue, &apc->entry ))  /* first one */
 1128         wake_thread( thread );
 1129 
 1130     return 1;
 1131 }
 1132 
 1133 /* queue an async procedure call */
 1134 int thread_queue_apc( struct process *process, struct thread *thread, struct object *owner, const apc_call_t *call_data )
 1135 {
 1136     struct thread_apc *apc;
 1137     int ret = 0;
 1138 
 1139     if ((apc = create_apc( owner, call_data )))
 1140     {
 1141         ret = queue_apc( process, thread, apc );
 1142         release_object( apc );
 1143     }
 1144     return ret;
 1145 }
 1146 
 1147 /* cancel the async procedure call owned by a specific object */
 1148 void thread_cancel_apc( struct thread *thread, struct object *owner, enum apc_type type )
 1149 {
 1150     struct thread_apc *apc;
 1151     struct list *queue = get_apc_queue( thread, type );
 1152 
 1153     LIST_FOR_EACH_ENTRY( apc, queue, struct thread_apc, entry )
 1154     {
 1155         if (apc->owner != owner) continue;
 1156         list_remove( &apc->entry );
 1157         apc->executed = 1;
 1158         wake_up( &apc->obj, 0 );
 1159         release_object( apc );
 1160         return;
 1161     }
 1162 }
 1163 
 1164 /* remove the head apc from the queue; the returned object must be released by the caller */
 1165 static struct thread_apc *thread_dequeue_apc( struct thread *thread, int system )
 1166 {
 1167     struct thread_apc *apc = NULL;
 1168     struct list *ptr = list_head( system ? &thread->system_apc : &thread->user_apc );
 1169 
 1170     if (ptr)
 1171     {
 1172         apc = LIST_ENTRY( ptr, struct thread_apc, entry );
 1173         list_remove( ptr );
 1174     }
 1175     return apc;
 1176 }
 1177 
 1178 /* clear an APC queue, cancelling all the APCs on it */
 1179 static void clear_apc_queue( struct list *queue )
 1180 {
 1181     struct list *ptr;
 1182 
 1183     while ((ptr = list_head( queue )))
 1184     {
 1185         struct thread_apc *apc = LIST_ENTRY( ptr, struct thread_apc, entry );
 1186         list_remove( &apc->entry );
 1187         apc->executed = 1;
 1188         wake_up( &apc->obj, 0 );
 1189         release_object( apc );
 1190     }
 1191 }
 1192 
 1193 /* add an fd to the inflight list */
 1194 /* return list index, or -1 on error */
 1195 int thread_add_inflight_fd( struct thread *thread, int client, int server )
 1196 {
 1197     int i;
 1198 
 1199     if (server == -1) return -1;
 1200     if (client == -1)
 1201     {
 1202         close( server );
 1203         return -1;
 1204     }
 1205 
 1206     /* first check if we already have an entry for this fd */
 1207     for (i = 0; i < MAX_INFLIGHT_FDS; i++)
 1208         if (thread->inflight[i].client == client)
 1209         {
 1210             close( thread->inflight[i].server );
 1211             thread->inflight[i].server = server;
 1212             return i;
 1213         }
 1214 
 1215     /* now find a free spot to store it */
 1216     for (i = 0; i < MAX_INFLIGHT_FDS; i++)
 1217         if (thread->inflight[i].client == -1)
 1218         {
 1219             thread->inflight[i].client = client;
 1220             thread->inflight[i].server = server;
 1221             return i;
 1222         }
 1223 
 1224     close( server );
 1225     return -1;
 1226 }
 1227 
 1228 /* get an inflight fd and purge it from the list */
 1229 /* the fd must be closed when no longer used */
 1230 int thread_get_inflight_fd( struct thread *thread, int client )
 1231 {
 1232     int i, ret;
 1233 
 1234     if (client == -1) return -1;
 1235 
 1236     do
 1237     {
 1238         for (i = 0; i < MAX_INFLIGHT_FDS; i++)
 1239         {
 1240             if (thread->inflight[i].client == client)
 1241             {
 1242                 ret = thread->inflight[i].server;
 1243                 thread->inflight[i].server = thread->inflight[i].client = -1;
 1244                 return ret;
 1245             }
 1246         }
 1247     } while (!receive_fd( thread->process ));  /* in case it is still in the socket buffer */
 1248     return -1;
 1249 }
 1250 
 1251 /* kill a thread on the spot */
 1252 void kill_thread( struct thread *thread, int violent_death )
 1253 {
 1254     if (thread->state == TERMINATED) return;  /* already killed */
 1255     thread->state = TERMINATED;
 1256     thread->exit_time = current_time;
 1257     if (current == thread) current = NULL;
 1258     if (debug_level)
 1259         fprintf( stderr,"%04x: *killed* exit_code=%d\n",
 1260                  thread->id, thread->exit_code );
 1261     if (thread->wait)
 1262     {
 1263         while (thread->wait) end_wait( thread, STATUS_THREAD_IS_TERMINATING );
 1264         send_thread_wakeup( thread, 0, thread->exit_code );
 1265         /* if it is waiting on the socket, we don't need to send a SIGQUIT */
 1266         violent_death = 0;
 1267     }
 1268     kill_console_processes( thread, 0 );
 1269     debug_exit_thread( thread );
 1270     abandon_mutexes( thread );
 1271     wake_up( &thread->obj, 0 );
 1272     if (violent_death) send_thread_signal( thread, SIGQUIT );
 1273     cleanup_thread( thread );
 1274     remove_process_thread( thread->process, thread );
 1275     release_object( thread );
 1276 }
 1277 
 1278 /* copy parts of a context structure */
 1279 static void copy_context( context_t *to, const context_t *from, unsigned int flags )
 1280 {
 1281     assert( to->cpu == from->cpu );
 1282     if (flags & SERVER_CTX_CONTROL) to->ctl = from->ctl;
 1283     if (flags & SERVER_CTX_INTEGER) to->integer = from->integer;
 1284     if (flags & SERVER_CTX_SEGMENTS) to->seg = from->seg;
 1285     if (flags & SERVER_CTX_FLOATING_POINT) to->fp = from->fp;
 1286     if (flags & SERVER_CTX_DEBUG_REGISTERS) to->debug = from->debug;
 1287     if (flags & SERVER_CTX_EXTENDED_REGISTERS) to->ext = from->ext;
 1288     if (flags & SERVER_CTX_YMM_REGISTERS) to->ymm = from->ymm;
 1289 }
 1290 
 1291 /* return the context flags that correspond to system regs */
 1292 /* (system regs are the ones we can't access on the client side) */
 1293 static unsigned int get_context_system_regs( enum cpu_type cpu )
 1294 {
 1295     switch (cpu)
 1296     {
 1297     case CPU_x86:     return SERVER_CTX_DEBUG_REGISTERS;
 1298     case CPU_x86_64:  return SERVER_CTX_DEBUG_REGISTERS;
 1299     case CPU_POWERPC: return 0;
 1300     case CPU_ARM:     return SERVER_CTX_DEBUG_REGISTERS;
 1301     case CPU_ARM64:   return SERVER_CTX_DEBUG_REGISTERS;
 1302     }
 1303     return 0;
 1304 }
 1305 
 1306 /* gets the current impersonation token */
 1307 struct token *thread_get_impersonation_token( struct thread *thread )
 1308 {
 1309     if (thread->token)
 1310         return thread->token;
 1311     else
 1312         return thread->process->token;
 1313 }
 1314 
 1315 /* check if a cpu type can be supported on this server */
 1316 int is_cpu_supported( enum cpu_type cpu )
 1317 {
 1318     unsigned int prefix_cpu_mask = get_prefix_cpu_mask();
 1319 
 1320     if (supported_cpus & prefix_cpu_mask & CPU_FLAG(cpu)) return 1;
 1321     if (!(supported_cpus & prefix_cpu_mask))
 1322         set_error( STATUS_NOT_SUPPORTED );
 1323     else if (supported_cpus & CPU_FLAG(cpu))
 1324         set_error( STATUS_INVALID_IMAGE_WIN_64 );  /* server supports it but not the prefix */
 1325     else
 1326         set_error( STATUS_INVALID_IMAGE_FORMAT );
 1327     return 0;
 1328 }
 1329 
 1330 /* return the cpu mask for supported cpus */
 1331 unsigned int get_supported_cpu_mask(void)
 1332 {
 1333     return supported_cpus & get_prefix_cpu_mask();
 1334 }
 1335 
 1336 /* create a new thread */
 1337 DECL_HANDLER(new_thread)
 1338 {
 1339     struct thread *thread;
 1340     struct process *process;
 1341     struct unicode_str name;
 1342     const struct security_descriptor *sd;
 1343     const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, NULL );
 1344     int request_fd = thread_get_inflight_fd( current, req->request_fd );
 1345 
 1346     if (!(process = get_process_from_handle( req->process, PROCESS_CREATE_THREAD )))
 1347     {
 1348         if (request_fd != -1) close( request_fd );
 1349         return;
 1350     }
 1351 
 1352     if (process != current->process)
 1353     {
 1354         if (request_fd != -1)  /* can't create a request fd in a different process */
 1355         {
 1356             close( request_fd );
 1357             set_error( STATUS_INVALID_PARAMETER );
 1358             goto done;
 1359         }
 1360         if (process->running_threads)  /* only the initial thread can be created in another process */
 1361         {
 1362             set_error( STATUS_ACCESS_DENIED );
 1363             goto done;
 1364         }
 1365     }
 1366     else if (request_fd == -1 || fcntl( request_fd, F_SETFL, O_NONBLOCK ) == -1)
 1367     {
 1368         if (request_fd != -1) close( request_fd );
 1369         set_error( STATUS_INVALID_HANDLE );
 1370         goto done;
 1371     }
 1372 
 1373     if ((thread = create_thread( request_fd, process, sd )))
 1374     {
 1375         thread->system_regs = current->system_regs;
 1376         if (req->suspend) thread->suspend++;
 1377         reply->tid = get_thread_id( thread );
 1378         if ((reply->handle = alloc_handle_no_access_check( current->process, thread,
 1379                                                            req->access, objattr->attributes )))
 1380         {
 1381             /* thread object will be released when the thread gets killed */
 1382             goto done;
 1383         }
 1384         kill_thread( thread, 1 );
 1385     }
 1386 done:
 1387     release_object( process );
 1388 }
 1389 
 1390 /* initialize a new thread */
 1391 DECL_HANDLER(init_thread)
 1392 {
 1393     struct process *process = current->process;
 1394     int wait_fd, reply_fd;
 1395 
 1396     if ((reply_fd = thread_get_inflight_fd( current, req->reply_fd )) == -1)
 1397     {
 1398         set_error( STATUS_TOO_MANY_OPENED_FILES );
 1399         return;
 1400     }
 1401     if ((wait_fd = thread_get_inflight_fd( current, req->wait_fd )) == -1)
 1402     {
 1403         set_error( STATUS_TOO_MANY_OPENED_FILES );
 1404         goto error;
 1405     }
 1406 
 1407     if (current->reply_fd)  /* already initialised */
 1408     {
 1409         set_error( STATUS_INVALID_PARAMETER );
 1410         goto error;
 1411     }
 1412 
 1413     if (fcntl( reply_fd, F_SETFL, O_NONBLOCK ) == -1) goto error;
 1414 
 1415     current->reply_fd = create_anonymous_fd( &thread_fd_ops, reply_fd, &current->obj, 0 );
 1416     current->wait_fd  = create_anonymous_fd( &thread_fd_ops, wait_fd, &current->obj, 0 );
 1417     if (!current->reply_fd || !current->wait_fd) return;
 1418 
 1419     if (!is_valid_address(req->teb))
 1420     {
 1421         set_error( STATUS_INVALID_PARAMETER );
 1422         return;
 1423     }
 1424 
 1425     current->unix_pid = req->unix_pid;
 1426     current->unix_tid = req->unix_tid;
 1427     current->teb      = req->teb;
 1428     current->entry_point = process->peb ? req->entry : 0;
 1429 
 1430     if (!process->peb)  /* first thread, initialize the process too */
 1431     {
 1432         if (!is_cpu_supported( req->cpu )) return;
 1433         process->unix_pid = current->unix_pid;
 1434         process->peb      = req->entry;
 1435         process->cpu      = req->cpu;
 1436         reply->info_size  = init_process( current );
 1437         if (!process->parent_id)
 1438             process->affinity = current->affinity = get_thread_affinity( current );
 1439         else
 1440             set_thread_affinity( current, current->affinity );
 1441     }
 1442     else
 1443     {
 1444         if (req->cpu != process->cpu)
 1445         {
 1446             set_error( STATUS_INVALID_PARAMETER );
 1447             return;
 1448         }
 1449         if (process->unix_pid != current->unix_pid)
 1450             process->unix_pid = -1;  /* can happen with linuxthreads */
 1451         init_thread_context( current );
 1452         generate_debug_event( current, CREATE_THREAD_DEBUG_EVENT, &req->entry );
 1453         set_thread_affinity( current, current->affinity );
 1454     }
 1455     debug_level = max( debug_level, req->debug_level );
 1456 
 1457     reply->pid     = get_process_id( process );
 1458     reply->tid     = get_thread_id( current );
 1459     reply->version = SERVER_PROTOCOL_VERSION;
 1460     reply->server_start = server_start_time;
 1461     reply->all_cpus     = supported_cpus & get_prefix_cpu_mask();
 1462     reply->suspend      = (current->suspend || process->suspend || current->context != NULL);
 1463     return;
 1464 
 1465  error:
 1466     if (reply_fd != -1) close( reply_fd );
 1467     if (wait_fd != -1) close( wait_fd );
 1468 }
 1469 
 1470 /* terminate a thread */
 1471 DECL_HANDLER(terminate_thread)
 1472 {
 1473     struct thread *thread;
 1474 
 1475     if ((thread = get_thread_from_handle( req->handle, THREAD_TERMINATE )))
 1476     {
 1477         thread->exit_code = req->exit_code;
 1478         if (thread != current) kill_thread( thread, 1 );
 1479         else reply->self = 1;
 1480         release_object( thread );
 1481     }
 1482 }
 1483 
 1484 /* open a handle to a thread */
 1485 DECL_HANDLER(open_thread)
 1486 {
 1487     struct thread *thread = get_thread_from_id( req->tid );
 1488 
 1489     reply->handle = 0;
 1490     if (thread)
 1491     {
 1492         reply->handle = alloc_handle( current->process, thread, req->access, req->attributes );
 1493         release_object( thread );
 1494     }
 1495 }
 1496 
 1497 /* fetch information about a thread */
 1498 DECL_HANDLER(get_thread_info)
 1499 {
 1500     struct thread *thread;
 1501     unsigned int access = req->access & (THREAD_QUERY_INFORMATION | THREAD_QUERY_LIMITED_INFORMATION);
 1502 
 1503     if (!access) access = THREAD_QUERY_LIMITED_INFORMATION;
 1504     thread = get_thread_from_handle( req->handle, access );
 1505     if (thread)
 1506     {
 1507         reply->pid            = get_process_id( thread->process );
 1508         reply->tid            = get_thread_id( thread );
 1509         reply->teb            = thread->teb;
 1510         reply->entry_point    = thread->entry_point;
 1511         reply->exit_code      = (thread->state == TERMINATED) ? thread->exit_code : STATUS_PENDING;
 1512         reply->priority       = thread->priority;
 1513         reply->affinity       = thread->affinity;
 1514         reply->last           = thread->process->running_threads == 1;
 1515         reply->suspend_count  = thread->suspend;
 1516         reply->dbg_hidden     = thread->dbg_hidden;
 1517         reply->desc_len       = thread->desc_len;
 1518 
 1519         if (thread->desc && get_reply_max_size())
 1520         {
 1521             if (thread->desc_len <= get_reply_max_size())
 1522                 set_reply_data( thread->desc, thread->desc_len );
 1523             else
 1524                 set_error( STATUS_BUFFER_TOO_SMALL );
 1525         }
 1526 
 1527         release_object( thread );
 1528     }
 1529 }
 1530 
 1531 /* fetch information about thread times */
 1532 DECL_HANDLER(get_thread_times)
 1533 {
 1534     struct thread *thread;
 1535 
 1536     if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_LIMITED_INFORMATION )))
 1537     {
 1538         reply->creation_time  = thread->creation_time;
 1539         reply->exit_time      = thread->exit_time;
 1540         reply->unix_pid       = thread->unix_pid;
 1541         reply->unix_tid       = thread->unix_tid;
 1542 
 1543         release_object( thread );
 1544     }
 1545 }
 1546 
 1547 /* set information about a thread */
 1548 DECL_HANDLER(set_thread_info)
 1549 {
 1550     struct thread *thread;
 1551 
 1552     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_INFORMATION )))
 1553     {
 1554         set_thread_info( thread, req );
 1555         release_object( thread );
 1556     }
 1557 }
 1558 
 1559 /* suspend a thread */
 1560 DECL_HANDLER(suspend_thread)
 1561 {
 1562     struct thread *thread;
 1563 
 1564     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 1565     {
 1566         if (thread->state == TERMINATED) set_error( STATUS_ACCESS_DENIED );
 1567         else reply->count = suspend_thread( thread );
 1568         release_object( thread );
 1569     }
 1570 }
 1571 
 1572 /* resume a thread */
 1573 DECL_HANDLER(resume_thread)
 1574 {
 1575     struct thread *thread;
 1576 
 1577     if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
 1578     {
 1579         reply->count = resume_thread( thread );
 1580         release_object( thread );
 1581     }
 1582 }
 1583 
 1584 /* select on a handle list */
 1585 DECL_HANDLER(select)
 1586 {
 1587     select_op_t select_op;
 1588     data_size_t op_size;
 1589     struct thread_apc *apc;
 1590     const apc_result_t *result = get_req_data();
 1591 
 1592     if (get_req_data_size() < sizeof(*result) ||
 1593         get_req_data_size() - sizeof(*result) < req->size ||
 1594         req->size & 3)
 1595     {
 1596         set_error( STATUS_INVALID_PARAMETER );
 1597         return;
 1598     }
 1599 
 1600     if (get_req_data_size() - sizeof(*result) - req->size == sizeof(context_t))
 1601     {
 1602         const context_t *context = (const context_t *)((const char *)(result + 1) + req->size);
 1603         if ((current->context && current->context->status != STATUS_PENDING) || context->cpu != current->process->cpu)
 1604         {
 1605             set_error( STATUS_INVALID_PARAMETER );
 1606             return;
 1607         }
 1608 
 1609         if (!current->context && !(current->context = create_thread_context( current ))) return;
 1610         copy_context( &current->context->regs, context,
 1611                       context->flags & ~(current->context->regs.flags | get_context_system_regs(current->process->cpu)) );
 1612         current->context->status = STATUS_SUCCESS;
 1613         current->suspend_cookie = req->cookie;
 1614         wake_up( &current->context->obj, 0 );
 1615     }
 1616 
 1617     if (!req->cookie)
 1618     {
 1619         set_error( STATUS_INVALID_PARAMETER );
 1620         return;
 1621     }
 1622 
 1623     op_size = min( req->size, sizeof(select_op) );
 1624     memset( &select_op, 0, sizeof(select_op) );
 1625     memcpy( &select_op, result + 1, op_size );
 1626 
 1627     /* first store results of previous apc */
 1628     if (req->prev_apc)
 1629     {
 1630         if (!(apc = (struct thread_apc *)get_handle_obj( current->process, req->prev_apc,
 1631                                                          0, &thread_apc_ops ))) return;
 1632         apc->result = *result;
 1633         apc->executed = 1;
 1634         if (apc->result.type == APC_CREATE_THREAD)  /* transfer the handle to the caller process */
 1635         {
 1636             obj_handle_t handle = duplicate_handle( current->process, apc->result.create_thread.handle,
 1637                                                     apc->caller->process, 0, 0, DUP_HANDLE_SAME_ACCESS );
 1638             close_handle( current->process, apc->result.create_thread.handle );
 1639             apc->result.create_thread.handle = handle;
 1640             clear_error();  /* ignore errors from the above calls */
 1641         }
 1642         else if (apc->result.type == APC_ASYNC_IO)
 1643         {
 1644             if (apc->owner)
 1645                 async_set_result( apc->owner, apc->result.async_io.status, apc->result.async_io.total );
 1646         }
 1647         wake_up( &apc->obj, 0 );
 1648         close_handle( current->process, req->prev_apc );
 1649         release_object( apc );
 1650     }
 1651 
 1652     select_on( &select_op, op_size, req->cookie, req->flags, req->timeout );
 1653 
 1654     while (get_error() == STATUS_USER_APC)
 1655     {
 1656         if (!(apc = thread_dequeue_apc( current, 0 )))
 1657             break;
 1658         /* Optimization: ignore APC_NONE calls, they are only used to
 1659          * wake up a thread, but since we got here the thread woke up already.
 1660          */
 1661         if (apc->call.type != APC_NONE &&
 1662             (reply->apc_handle = alloc_handle( current->process, apc, SYNCHRONIZE, 0 )))
 1663         {
 1664             reply->call = apc->call;
 1665             release_object( apc );
 1666             break;
 1667         }
 1668         apc->executed = 1;
 1669         wake_up( &apc->obj, 0 );
 1670         release_object( apc );
 1671     }
 1672 
 1673     if (get_error() == STATUS_KERNEL_APC)
 1674     {
 1675         apc = thread_dequeue_apc( current, 1 );
 1676         if ((reply->apc_handle = alloc_handle( current->process, apc, SYNCHRONIZE, 0 )))
 1677             reply->call = apc->call;
 1678         else
 1679         {
 1680             apc->executed = 1;
 1681             wake_up( &apc->obj, 0 );
 1682         }
 1683         release_object( apc );
 1684     }
 1685     else if (get_error() != STATUS_PENDING && get_reply_max_size() == sizeof(context_t) &&
 1686              current->context && current->suspend_cookie == req->cookie)
 1687     {
 1688         if (current->context->regs.flags)
 1689         {
 1690             unsigned int system_flags = get_context_system_regs(current->process->cpu) &
 1691                                         current->context->regs.flags;
 1692             if (system_flags) set_thread_context( current, &current->context->regs, system_flags );
 1693             set_reply_data( &current->context->regs, sizeof(context_t) );
 1694         }
 1695         release_object( current->context );
 1696         current->context = NULL;
 1697     }
 1698 }
 1699 
 1700 /* queue an APC for a thread or process */
 1701 DECL_HANDLER(queue_apc)
 1702 {
 1703     struct thread *thread = NULL;
 1704     struct process *process = NULL;
 1705     struct thread_apc *apc;
 1706 
 1707     if (!(apc = create_apc( NULL, &req->call ))) return;
 1708 
 1709     switch (apc->call.type)
 1710     {
 1711     case APC_NONE:
 1712     case APC_USER:
 1713         thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT );
 1714         break;
 1715     case APC_VIRTUAL_ALLOC:
 1716     case APC_VIRTUAL_FREE:
 1717     case APC_VIRTUAL_PROTECT:
 1718     case APC_VIRTUAL_FLUSH:
 1719     case APC_VIRTUAL_LOCK:
 1720     case APC_VIRTUAL_UNLOCK:
 1721     case APC_UNMAP_VIEW:
 1722         process = get_process_from_handle( req->handle, PROCESS_VM_OPERATION );
 1723         break;
 1724     case APC_VIRTUAL_QUERY:
 1725         process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION );
 1726         break;
 1727     case APC_MAP_VIEW:
 1728         process = get_process_from_handle( req->handle, PROCESS_VM_OPERATION );
 1729         if (process && process != current->process)
 1730         {
 1731             /* duplicate the handle into the target process */
 1732             obj_handle_t handle = duplicate_handle( current->process, apc->call.map_view.handle,
 1733                                                     process, 0, 0, DUP_HANDLE_SAME_ACCESS );
 1734             if (handle) apc->call.map_view.handle = handle;
 1735             else
 1736             {
 1737                 release_object( process );
 1738                 process = NULL;
 1739             }
 1740         }
 1741         break;
 1742     case APC_CREATE_THREAD:
 1743     case APC_BREAK_PROCESS:
 1744         process = get_process_from_handle( req->handle, PROCESS_CREATE_THREAD );
 1745         break;
 1746     default:
 1747         set_error( STATUS_INVALID_PARAMETER );
 1748         break;
 1749     }
 1750 
 1751     if (thread)
 1752     {
 1753         if (!queue_apc( NULL, thread, apc )) set_error( STATUS_UNSUCCESSFUL );
 1754         release_object( thread );
 1755     }
 1756     else if (process)
 1757     {
 1758         reply->self = (process == current->process);
 1759         if (!reply->self)
 1760         {
 1761             obj_handle_t handle = alloc_handle( current->process, apc, SYNCHRONIZE, 0 );
 1762             if (handle)
 1763             {
 1764                 if (queue_apc( process, NULL, apc ))
 1765                 {
 1766                     apc->caller = (struct thread *)grab_object( current );
 1767                     reply->handle = handle;
 1768                 }
 1769                 else
 1770                 {
 1771                     close_handle( current->process, handle );
 1772                     set_error( STATUS_PROCESS_IS_TERMINATING );
 1773                 }
 1774             }
 1775         }
 1776         release_object( process );
 1777     }
 1778 
 1779     release_object( apc );
 1780 }
 1781 
 1782 /* Get the result of an APC call */
 1783 DECL_HANDLER(get_apc_result)
 1784 {
 1785     struct thread_apc *apc;
 1786 
 1787     if (!(apc = (struct thread_apc *)get_handle_obj( current->process, req->handle,
 1788                                                      0, &thread_apc_ops ))) return;
 1789 
 1790     if (apc->executed) reply->result = apc->result;
 1791     else set_error( STATUS_PENDING );
 1792 
 1793     /* close the handle directly to avoid an extra round-trip */
 1794     close_handle( current->process, req->handle );
 1795     release_object( apc );
 1796 }
 1797 
 1798 /* retrieve the current context of a thread */
 1799 DECL_HANDLER(get_thread_context)
 1800 {
 1801     struct context *thread_context = NULL;
 1802     unsigned int system_flags;
 1803     struct thread *thread;
 1804     context_t *context;
 1805 
 1806     if (get_reply_max_size() < sizeof(context_t))
 1807     {
 1808         set_error( STATUS_INVALID_PARAMETER );
 1809         return;
 1810     }
 1811 
 1812     if ((thread_context = (struct context *)get_handle_obj( current->process, req->handle, 0, &context_ops )))
 1813     {
 1814         close_handle( current->process, req->handle ); /* avoid extra server call */
 1815         system_flags = get_context_system_regs( thread_context->regs.cpu );
 1816     }
 1817     else if ((thread = get_thread_from_handle( req->handle, THREAD_GET_CONTEXT )))
 1818     {
 1819         clear_error();
 1820         system_flags = get_context_system_regs( thread->process->cpu );
 1821         if (thread->state == RUNNING)
 1822         {
 1823             reply->self = (thread == current);
 1824             if (thread != current) stop_thread( thread );
 1825             if (thread->context)
 1826             {
 1827                 /* make sure that system regs are valid in thread context */
 1828                 if (thread->unix_tid != -1 && (req->flags & system_flags & ~thread->context->regs.flags))
 1829                     get_thread_context( thread, &thread->context->regs, req->flags & system_flags );
 1830                 if (!get_error()) thread_context = (struct context *)grab_object( thread->context );
 1831             }
 1832             else if (!get_error() && (context = set_reply_data_size( sizeof(context_t) )))
 1833             {
 1834                 assert( reply->self );
 1835                 memset( context, 0, sizeof(context_t) );
 1836                 context->cpu = thread->process->cpu;
 1837                 if (req->flags & system_flags)
 1838                 {
 1839                     get_thread_context( thread, context, req->flags & system_flags );
 1840                     context->flags |= req->flags & system_flags;
 1841                 }
 1842             }
 1843         }
 1844         else set_error( STATUS_UNSUCCESSFUL );
 1845         release_object( thread );
 1846     }
 1847     if (get_error() || !thread_context) return;
 1848 
 1849     set_error( thread_context->status );
 1850     if (!thread_context->status && (context = set_reply_data_size( sizeof(context_t) )))
 1851     {
 1852         memset( context, 0, sizeof(context_t) );
 1853         context->cpu = thread_context->regs.cpu;
 1854         copy_context( context, &thread_context->regs, req->flags );
 1855         context->flags = req->flags;
 1856     }
 1857     else if (thread_context->status == STATUS_PENDING)
 1858     {
 1859         reply->handle = alloc_handle( current->process, thread_context, SYNCHRONIZE, 0 );
 1860     }
 1861 
 1862     release_object( thread_context );
 1863 }
 1864 
 1865 /* set the current context of a thread */
 1866 DECL_HANDLER(set_thread_context)
 1867 {
 1868     struct thread *thread;
 1869     const context_t *context = get_req_data();
 1870 
 1871     if (get_req_data_size() < sizeof(context_t))
 1872     {
 1873         set_error( STATUS_INVALID_PARAMETER );
 1874         return;
 1875     }
 1876     if (!(thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT ))) return;
 1877     reply->self = (thread == current);
 1878 
 1879     if (thread->state == TERMINATED) set_error( STATUS_UNSUCCESSFUL );
 1880     else if (context->cpu != thread->process->cpu) set_error( STATUS_INVALID_PARAMETER );
 1881     else
 1882     {
 1883         unsigned int system_flags = get_context_system_regs(context->cpu) & context->flags;
 1884 
 1885         if (thread != current) stop_thread( thread );
 1886         else if (system_flags) set_thread_context( thread, context, system_flags );
 1887         if (thread->context && !get_error())
 1888         {
 1889             copy_context( &thread->context->regs, context, context->flags );
 1890             thread->context->regs.flags |= context->flags;
 1891         }
 1892     }
 1893 
 1894     release_object( thread );
 1895 }
 1896 
 1897 /* fetch a selector entry for a thread */
 1898 DECL_HANDLER(get_selector_entry)
 1899 {
 1900     struct thread *thread;
 1901     if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
 1902     {
 1903         get_selector_entry( thread, req->entry, &reply->base, &reply->limit, &reply->flags );
 1904         release_object( thread );
 1905     }
 1906 }