po: Update Norwegian translation.
[wine.git] / server / thread.c
blob2cf5054738aa2461dfedf08956d7e172e046d22d
1 /*
2 * Server-side thread management
4 * Copyright (C) 1998 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include "config.h"
22 #include "wine/port.h"
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
42 #include "ntstatus.h"
43 #define WIN32_NO_STATUS
44 #include "windef.h"
45 #include "winternl.h"
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"
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
70 /* thread queues */
72 struct thread_wait
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 timeout_t timeout;
83 struct timeout_user *user;
84 struct wait_queue_entry queues[1];
87 /* asynchronous procedure calls */
89 struct thread_apc
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 */
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 );
105 static const struct object_ops thread_apc_ops =
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_lookup_name, /* lookup_name */
120 no_link_name, /* link_name */
121 NULL, /* unlink_name */
122 no_open_file, /* open_file */
123 no_close_handle, /* close_handle */
124 thread_apc_destroy /* destroy */
128 /* thread operations */
130 static void dump_thread( struct object *obj, int verbose );
131 static int thread_signaled( struct object *obj, struct wait_queue_entry *entry );
132 static unsigned int thread_map_access( struct object *obj, unsigned int access );
133 static void thread_poll_event( struct fd *fd, int event );
134 static void destroy_thread( struct object *obj );
136 static const struct object_ops thread_ops =
138 sizeof(struct thread), /* size */
139 dump_thread, /* dump */
140 no_get_type, /* get_type */
141 add_queue, /* add_queue */
142 remove_queue, /* remove_queue */
143 thread_signaled, /* signaled */
144 no_satisfied, /* satisfied */
145 no_signal, /* signal */
146 no_get_fd, /* get_fd */
147 thread_map_access, /* map_access */
148 default_get_sd, /* get_sd */
149 default_set_sd, /* set_sd */
150 no_lookup_name, /* lookup_name */
151 no_link_name, /* link_name */
152 NULL, /* unlink_name */
153 no_open_file, /* open_file */
154 no_close_handle, /* close_handle */
155 destroy_thread /* destroy */
158 static const struct fd_ops thread_fd_ops =
160 NULL, /* get_poll_events */
161 thread_poll_event, /* poll_event */
162 NULL, /* flush */
163 NULL, /* get_fd_type */
164 NULL, /* ioctl */
165 NULL, /* queue_async */
166 NULL /* reselect_async */
169 static struct list thread_list = LIST_INIT(thread_list);
171 /* initialize the structure for a newly allocated thread */
172 static inline void init_thread_structure( struct thread *thread )
174 int i;
176 thread->unix_pid = -1; /* not known yet */
177 thread->unix_tid = -1; /* not known yet */
178 thread->context = NULL;
179 thread->suspend_context = NULL;
180 thread->teb = 0;
181 thread->entry_point = 0;
182 thread->debug_ctx = NULL;
183 thread->debug_event = NULL;
184 thread->debug_break = 0;
185 thread->system_regs = 0;
186 thread->queue = NULL;
187 thread->wait = NULL;
188 thread->error = 0;
189 thread->req_data = NULL;
190 thread->req_toread = 0;
191 thread->reply_data = NULL;
192 thread->reply_towrite = 0;
193 thread->request_fd = NULL;
194 thread->reply_fd = NULL;
195 thread->wait_fd = NULL;
196 thread->state = RUNNING;
197 thread->exit_code = 0;
198 thread->priority = 0;
199 thread->suspend = 0;
200 thread->desktop_users = 0;
201 thread->token = NULL;
203 thread->creation_time = current_time;
204 thread->exit_time = 0;
206 list_init( &thread->mutex_list );
207 list_init( &thread->system_apc );
208 list_init( &thread->user_apc );
210 for (i = 0; i < MAX_INFLIGHT_FDS; i++)
211 thread->inflight[i].server = thread->inflight[i].client = -1;
214 /* check if address looks valid for a client-side data structure (TEB etc.) */
215 static inline int is_valid_address( client_ptr_t addr )
217 return addr && !(addr % sizeof(int));
220 /* create a new thread */
221 struct thread *create_thread( int fd, struct process *process )
223 struct thread *thread;
225 if (process->is_terminating)
227 close( fd );
228 set_error( STATUS_PROCESS_IS_TERMINATING );
229 return NULL;
232 if (!(thread = alloc_object( &thread_ops )))
234 close( fd );
235 return NULL;
238 init_thread_structure( thread );
240 thread->process = (struct process *)grab_object( process );
241 thread->desktop = process->desktop;
242 thread->affinity = process->affinity;
243 if (!current) current = thread;
245 list_add_head( &thread_list, &thread->entry );
247 if (!(thread->id = alloc_ptid( thread )))
249 close( fd );
250 release_object( thread );
251 return NULL;
253 if (!(thread->request_fd = create_anonymous_fd( &thread_fd_ops, fd, &thread->obj, 0 )))
255 release_object( thread );
256 return NULL;
259 set_fd_events( thread->request_fd, POLLIN ); /* start listening to events */
260 add_process_thread( thread->process, thread );
261 return thread;
264 /* handle a client event */
265 static void thread_poll_event( struct fd *fd, int event )
267 struct thread *thread = get_fd_user( fd );
268 assert( thread->obj.ops == &thread_ops );
270 grab_object( thread );
271 if (event & (POLLERR | POLLHUP)) kill_thread( thread, 0 );
272 else if (event & POLLIN) read_request( thread );
273 else if (event & POLLOUT) write_reply( thread );
274 release_object( thread );
277 /* cleanup everything that is no longer needed by a dead thread */
278 /* used by destroy_thread and kill_thread */
279 static void cleanup_thread( struct thread *thread )
281 int i;
283 clear_apc_queue( &thread->system_apc );
284 clear_apc_queue( &thread->user_apc );
285 free( thread->req_data );
286 free( thread->reply_data );
287 if (thread->request_fd) release_object( thread->request_fd );
288 if (thread->reply_fd) release_object( thread->reply_fd );
289 if (thread->wait_fd) release_object( thread->wait_fd );
290 free( thread->suspend_context );
291 cleanup_clipboard_thread(thread);
292 destroy_thread_windows( thread );
293 free_msg_queue( thread );
294 close_thread_desktop( thread );
295 for (i = 0; i < MAX_INFLIGHT_FDS; i++)
297 if (thread->inflight[i].client != -1)
299 close( thread->inflight[i].server );
300 thread->inflight[i].client = thread->inflight[i].server = -1;
303 thread->req_data = NULL;
304 thread->reply_data = NULL;
305 thread->request_fd = NULL;
306 thread->reply_fd = NULL;
307 thread->wait_fd = NULL;
308 thread->context = NULL;
309 thread->suspend_context = NULL;
310 thread->desktop = 0;
313 /* destroy a thread when its refcount is 0 */
314 static void destroy_thread( struct object *obj )
316 struct thread *thread = (struct thread *)obj;
317 assert( obj->ops == &thread_ops );
319 assert( !thread->debug_ctx ); /* cannot still be debugging something */
320 list_remove( &thread->entry );
321 cleanup_thread( thread );
322 release_object( thread->process );
323 if (thread->id) free_ptid( thread->id );
324 if (thread->token) release_object( thread->token );
327 /* dump a thread on stdout for debugging purposes */
328 static void dump_thread( struct object *obj, int verbose )
330 struct thread *thread = (struct thread *)obj;
331 assert( obj->ops == &thread_ops );
333 fprintf( stderr, "Thread id=%04x unix pid=%d unix tid=%d state=%d\n",
334 thread->id, thread->unix_pid, thread->unix_tid, thread->state );
337 static int thread_signaled( struct object *obj, struct wait_queue_entry *entry )
339 struct thread *mythread = (struct thread *)obj;
340 return (mythread->state == TERMINATED);
343 static unsigned int thread_map_access( struct object *obj, unsigned int access )
345 if (access & GENERIC_READ) access |= STANDARD_RIGHTS_READ | THREAD_QUERY_INFORMATION | THREAD_GET_CONTEXT;
346 if (access & GENERIC_WRITE) access |= STANDARD_RIGHTS_WRITE | THREAD_SET_INFORMATION | THREAD_SET_CONTEXT |
347 THREAD_TERMINATE | THREAD_SUSPEND_RESUME;
348 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | THREAD_QUERY_LIMITED_INFORMATION;
349 if (access & GENERIC_ALL) access |= THREAD_ALL_ACCESS;
351 if (access & THREAD_QUERY_INFORMATION) access |= THREAD_QUERY_LIMITED_INFORMATION;
352 if (access & THREAD_SET_INFORMATION) access |= THREAD_SET_LIMITED_INFORMATION;
354 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
357 static void dump_thread_apc( struct object *obj, int verbose )
359 struct thread_apc *apc = (struct thread_apc *)obj;
360 assert( obj->ops == &thread_apc_ops );
362 fprintf( stderr, "APC owner=%p type=%u\n", apc->owner, apc->call.type );
365 static int thread_apc_signaled( struct object *obj, struct wait_queue_entry *entry )
367 struct thread_apc *apc = (struct thread_apc *)obj;
368 return apc->executed;
371 static void thread_apc_destroy( struct object *obj )
373 struct thread_apc *apc = (struct thread_apc *)obj;
374 if (apc->caller) release_object( apc->caller );
375 if (apc->owner) release_object( apc->owner );
378 /* queue an async procedure call */
379 static struct thread_apc *create_apc( struct object *owner, const apc_call_t *call_data )
381 struct thread_apc *apc;
383 if ((apc = alloc_object( &thread_apc_ops )))
385 apc->call = *call_data;
386 apc->caller = NULL;
387 apc->owner = owner;
388 apc->executed = 0;
389 apc->result.type = APC_NONE;
390 if (owner) grab_object( owner );
392 return apc;
395 /* get a thread pointer from a thread id (and increment the refcount) */
396 struct thread *get_thread_from_id( thread_id_t id )
398 struct object *obj = get_ptid_entry( id );
400 if (obj && obj->ops == &thread_ops) return (struct thread *)grab_object( obj );
401 set_error( STATUS_INVALID_CID );
402 return NULL;
405 /* get a thread from a handle (and increment the refcount) */
406 struct thread *get_thread_from_handle( obj_handle_t handle, unsigned int access )
408 return (struct thread *)get_handle_obj( current->process, handle,
409 access, &thread_ops );
412 /* find a thread from a Unix tid */
413 struct thread *get_thread_from_tid( int tid )
415 struct thread *thread;
417 LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
419 if (thread->unix_tid == tid) return thread;
421 return NULL;
424 /* find a thread from a Unix pid */
425 struct thread *get_thread_from_pid( int pid )
427 struct thread *thread;
429 LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
431 if (thread->unix_pid == pid) return thread;
433 return NULL;
436 int set_thread_affinity( struct thread *thread, affinity_t affinity )
438 int ret = 0;
439 #ifdef HAVE_SCHED_SETAFFINITY
440 if (thread->unix_tid != -1)
442 cpu_set_t set;
443 int i;
444 affinity_t mask;
446 CPU_ZERO( &set );
447 for (i = 0, mask = 1; mask; i++, mask <<= 1)
448 if (affinity & mask) CPU_SET( i, &set );
450 ret = sched_setaffinity( thread->unix_tid, sizeof(set), &set );
452 #endif
453 if (!ret) thread->affinity = affinity;
454 return ret;
457 affinity_t get_thread_affinity( struct thread *thread )
459 affinity_t mask = 0;
460 #ifdef HAVE_SCHED_SETAFFINITY
461 if (thread->unix_tid != -1)
463 cpu_set_t set;
464 unsigned int i;
466 if (!sched_getaffinity( thread->unix_tid, sizeof(set), &set ))
467 for (i = 0; i < 8 * sizeof(mask); i++)
468 if (CPU_ISSET( i, &set )) mask |= (affinity_t)1 << i;
470 #endif
471 if (!mask) mask = ~(affinity_t)0;
472 return mask;
475 #define THREAD_PRIORITY_REALTIME_HIGHEST 6
476 #define THREAD_PRIORITY_REALTIME_LOWEST -7
478 /* set all information about a thread */
479 static void set_thread_info( struct thread *thread,
480 const struct set_thread_info_request *req )
482 if (req->mask & SET_THREAD_INFO_PRIORITY)
484 int max = THREAD_PRIORITY_HIGHEST;
485 int min = THREAD_PRIORITY_LOWEST;
486 if (thread->process->priority == PROCESS_PRIOCLASS_REALTIME)
488 max = THREAD_PRIORITY_REALTIME_HIGHEST;
489 min = THREAD_PRIORITY_REALTIME_LOWEST;
491 if ((req->priority >= min && req->priority <= max) ||
492 req->priority == THREAD_PRIORITY_IDLE ||
493 req->priority == THREAD_PRIORITY_TIME_CRITICAL)
494 thread->priority = req->priority;
495 else
496 set_error( STATUS_INVALID_PARAMETER );
498 if (req->mask & SET_THREAD_INFO_AFFINITY)
500 if ((req->affinity & thread->process->affinity) != req->affinity)
501 set_error( STATUS_INVALID_PARAMETER );
502 else if (thread->state == TERMINATED)
503 set_error( STATUS_THREAD_IS_TERMINATING );
504 else if (set_thread_affinity( thread, req->affinity ))
505 file_set_error();
507 if (req->mask & SET_THREAD_INFO_TOKEN)
508 security_set_thread_token( thread, req->token );
509 if (req->mask & SET_THREAD_INFO_ENTRYPOINT)
510 thread->entry_point = req->entry_point;
513 /* stop a thread (at the Unix level) */
514 void stop_thread( struct thread *thread )
516 if (thread->context) return; /* already inside a debug event, no need for a signal */
517 /* can't stop a thread while initialisation is in progress */
518 if (is_process_init_done(thread->process)) send_thread_signal( thread, SIGUSR1 );
521 /* stop a thread if it's supposed to be suspended */
522 void stop_thread_if_suspended( struct thread *thread )
524 if (thread->suspend + thread->process->suspend > 0) stop_thread( thread );
527 /* suspend a thread */
528 static int suspend_thread( struct thread *thread )
530 int old_count = thread->suspend;
531 if (thread->suspend < MAXIMUM_SUSPEND_COUNT)
533 if (!(thread->process->suspend + thread->suspend++)) stop_thread( thread );
535 else set_error( STATUS_SUSPEND_COUNT_EXCEEDED );
536 return old_count;
539 /* resume a thread */
540 static int resume_thread( struct thread *thread )
542 int old_count = thread->suspend;
543 if (thread->suspend > 0)
545 if (!(--thread->suspend + thread->process->suspend)) wake_thread( thread );
547 return old_count;
550 /* add a thread to an object wait queue; return 1 if OK, 0 on error */
551 int add_queue( struct object *obj, struct wait_queue_entry *entry )
553 grab_object( obj );
554 entry->obj = obj;
555 list_add_tail( &obj->wait_queue, &entry->entry );
556 return 1;
559 /* remove a thread from an object wait queue */
560 void remove_queue( struct object *obj, struct wait_queue_entry *entry )
562 list_remove( &entry->entry );
563 release_object( obj );
566 struct thread *get_wait_queue_thread( struct wait_queue_entry *entry )
568 return entry->wait->thread;
571 enum select_op get_wait_queue_select_op( struct wait_queue_entry *entry )
573 return entry->wait->select;
576 client_ptr_t get_wait_queue_key( struct wait_queue_entry *entry )
578 return entry->wait->key;
581 void make_wait_abandoned( struct wait_queue_entry *entry )
583 entry->wait->abandoned = 1;
586 /* finish waiting */
587 static unsigned int end_wait( struct thread *thread, unsigned int status )
589 struct thread_wait *wait = thread->wait;
590 struct wait_queue_entry *entry;
591 int i;
593 assert( wait );
594 thread->wait = wait->next;
596 if (status < wait->count) /* wait satisfied, tell it to the objects */
598 if (wait->select == SELECT_WAIT_ALL)
600 for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
601 entry->obj->ops->satisfied( entry->obj, entry );
603 else
605 entry = wait->queues + status;
606 entry->obj->ops->satisfied( entry->obj, entry );
608 if (wait->abandoned) status += STATUS_ABANDONED_WAIT_0;
610 for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
611 entry->obj->ops->remove_queue( entry->obj, entry );
612 if (wait->user) remove_timeout_user( wait->user );
613 free( wait );
614 return status;
617 /* build the thread wait structure */
618 static int wait_on( const select_op_t *select_op, unsigned int count, struct object *objects[],
619 int flags, timeout_t timeout )
621 struct thread_wait *wait;
622 struct wait_queue_entry *entry;
623 unsigned int i;
625 if (!(wait = mem_alloc( FIELD_OFFSET(struct thread_wait, queues[count]) ))) return 0;
626 wait->next = current->wait;
627 wait->thread = current;
628 wait->count = count;
629 wait->flags = flags;
630 wait->select = select_op->op;
631 wait->cookie = 0;
632 wait->user = NULL;
633 wait->timeout = timeout;
634 wait->abandoned = 0;
635 current->wait = wait;
637 for (i = 0, entry = wait->queues; i < count; i++, entry++)
639 struct object *obj = objects[i];
640 entry->wait = wait;
641 if (!obj->ops->add_queue( obj, entry ))
643 wait->count = i;
644 end_wait( current, get_error() );
645 return 0;
648 return 1;
651 static int wait_on_handles( const select_op_t *select_op, unsigned int count, const obj_handle_t *handles,
652 int flags, timeout_t timeout )
654 struct object *objects[MAXIMUM_WAIT_OBJECTS];
655 unsigned int i;
656 int ret = 0;
658 assert( count <= MAXIMUM_WAIT_OBJECTS );
660 for (i = 0; i < count; i++)
661 if (!(objects[i] = get_handle_obj( current->process, handles[i], SYNCHRONIZE, NULL )))
662 break;
664 if (i == count) ret = wait_on( select_op, count, objects, flags, timeout );
666 while (i > 0) release_object( objects[--i] );
667 return ret;
670 /* check if the thread waiting condition is satisfied */
671 static int check_wait( struct thread *thread )
673 int i;
674 struct thread_wait *wait = thread->wait;
675 struct wait_queue_entry *entry;
677 assert( wait );
679 if ((wait->flags & SELECT_INTERRUPTIBLE) && !list_empty( &thread->system_apc ))
680 return STATUS_USER_APC;
682 /* Suspended threads may not acquire locks, but they can run system APCs */
683 if (thread->process->suspend + thread->suspend > 0) return -1;
685 if (wait->select == SELECT_WAIT_ALL)
687 int not_ok = 0;
688 /* Note: we must check them all anyway, as some objects may
689 * want to do something when signaled, even if others are not */
690 for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
691 not_ok |= !entry->obj->ops->signaled( entry->obj, entry );
692 if (!not_ok) return STATUS_WAIT_0;
694 else
696 for (i = 0, entry = wait->queues; i < wait->count; i++, entry++)
697 if (entry->obj->ops->signaled( entry->obj, entry )) return i;
700 if ((wait->flags & SELECT_ALERTABLE) && !list_empty(&thread->user_apc)) return STATUS_USER_APC;
701 if (wait->timeout <= current_time) return STATUS_TIMEOUT;
702 return -1;
705 /* send the wakeup signal to a thread */
706 static int send_thread_wakeup( struct thread *thread, client_ptr_t cookie, int signaled )
708 struct wake_up_reply reply;
709 int ret;
711 memset( &reply, 0, sizeof(reply) );
712 reply.cookie = cookie;
713 reply.signaled = signaled;
714 if ((ret = write( get_unix_fd( thread->wait_fd ), &reply, sizeof(reply) )) == sizeof(reply))
715 return 0;
716 if (ret >= 0)
717 fatal_protocol_error( thread, "partial wakeup write %d\n", ret );
718 else if (errno == EPIPE)
719 kill_thread( thread, 0 ); /* normal death */
720 else
721 fatal_protocol_error( thread, "write: %s\n", strerror( errno ));
722 return -1;
725 /* attempt to wake up a thread */
726 /* return >0 if OK, 0 if the wait condition is still not satisfied and -1 on error */
727 int wake_thread( struct thread *thread )
729 int signaled, count;
730 client_ptr_t cookie;
732 for (count = 0; thread->wait; count++)
734 if ((signaled = check_wait( thread )) == -1) break;
736 cookie = thread->wait->cookie;
737 signaled = end_wait( thread, signaled );
738 if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=%d\n", thread->id, signaled );
739 if (cookie && send_thread_wakeup( thread, cookie, signaled ) == -1) /* error */
741 if (!count) count = -1;
742 break;
745 return count;
748 /* attempt to wake up a thread from a wait queue entry, assuming that it is signaled */
749 int wake_thread_queue_entry( struct wait_queue_entry *entry )
751 struct thread_wait *wait = entry->wait;
752 struct thread *thread = wait->thread;
753 int signaled;
754 client_ptr_t cookie;
756 if (thread->wait != wait) return 0; /* not the current wait */
757 if (thread->process->suspend + thread->suspend > 0) return 0; /* cannot acquire locks */
759 assert( wait->select != SELECT_WAIT_ALL );
761 cookie = wait->cookie;
762 signaled = end_wait( thread, entry - wait->queues );
763 if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=%d\n", thread->id, signaled );
765 if (!cookie || send_thread_wakeup( thread, cookie, signaled ) != -1)
766 wake_thread( thread ); /* check other waits too */
768 return 1;
771 /* thread wait timeout */
772 static void thread_timeout( void *ptr )
774 struct thread_wait *wait = ptr;
775 struct thread *thread = wait->thread;
776 client_ptr_t cookie = wait->cookie;
778 wait->user = NULL;
779 if (thread->wait != wait) return; /* not the top-level wait, ignore it */
780 if (thread->suspend + thread->process->suspend > 0) return; /* suspended, ignore it */
782 if (debug_level) fprintf( stderr, "%04x: *wakeup* signaled=TIMEOUT\n", thread->id );
783 end_wait( thread, STATUS_TIMEOUT );
785 assert( cookie );
786 if (send_thread_wakeup( thread, cookie, STATUS_TIMEOUT ) == -1) return;
787 /* check if other objects have become signaled in the meantime */
788 wake_thread( thread );
791 /* try signaling an event flag, a semaphore or a mutex */
792 static int signal_object( obj_handle_t handle )
794 struct object *obj;
795 int ret = 0;
797 obj = get_handle_obj( current->process, handle, 0, NULL );
798 if (obj)
800 ret = obj->ops->signal( obj, get_handle_access( current->process, handle ));
801 release_object( obj );
803 return ret;
806 /* select on a list of handles */
807 static timeout_t select_on( const select_op_t *select_op, data_size_t op_size, client_ptr_t cookie,
808 int flags, timeout_t timeout )
810 int ret;
811 unsigned int count;
812 struct object *object;
814 if (timeout <= 0) timeout = current_time - timeout;
816 switch (select_op->op)
818 case SELECT_NONE:
819 if (!wait_on( select_op, 0, NULL, flags, timeout )) return timeout;
820 break;
822 case SELECT_WAIT:
823 case SELECT_WAIT_ALL:
824 count = (op_size - offsetof( select_op_t, wait.handles )) / sizeof(select_op->wait.handles[0]);
825 if (op_size < offsetof( select_op_t, wait.handles ) || count > MAXIMUM_WAIT_OBJECTS)
827 set_error( STATUS_INVALID_PARAMETER );
828 return 0;
830 if (!wait_on_handles( select_op, count, select_op->wait.handles, flags, timeout ))
831 return timeout;
832 break;
834 case SELECT_SIGNAL_AND_WAIT:
835 if (!wait_on_handles( select_op, 1, &select_op->signal_and_wait.wait, flags, timeout ))
836 return timeout;
837 if (select_op->signal_and_wait.signal)
839 if (!signal_object( select_op->signal_and_wait.signal ))
841 end_wait( current, get_error() );
842 return timeout;
844 /* check if we woke ourselves up */
845 if (!current->wait) return timeout;
847 break;
849 case SELECT_KEYED_EVENT_WAIT:
850 case SELECT_KEYED_EVENT_RELEASE:
851 object = (struct object *)get_keyed_event_obj( current->process, select_op->keyed_event.handle,
852 select_op->op == SELECT_KEYED_EVENT_WAIT ? KEYEDEVENT_WAIT : KEYEDEVENT_WAKE );
853 if (!object) return timeout;
854 ret = wait_on( select_op, 1, &object, flags, timeout );
855 release_object( object );
856 if (!ret) return timeout;
857 current->wait->key = select_op->keyed_event.key;
858 break;
860 default:
861 set_error( STATUS_INVALID_PARAMETER );
862 return 0;
865 if ((ret = check_wait( current )) != -1)
867 /* condition is already satisfied */
868 set_error( end_wait( current, ret ));
869 return timeout;
872 /* now we need to wait */
873 if (current->wait->timeout != TIMEOUT_INFINITE)
875 if (!(current->wait->user = add_timeout_user( current->wait->timeout,
876 thread_timeout, current->wait )))
878 end_wait( current, get_error() );
879 return timeout;
882 current->wait->cookie = cookie;
883 set_error( STATUS_PENDING );
884 return timeout;
887 /* attempt to wake threads sleeping on the object wait queue */
888 void wake_up( struct object *obj, int max )
890 struct list *ptr;
891 int ret;
893 LIST_FOR_EACH( ptr, &obj->wait_queue )
895 struct wait_queue_entry *entry = LIST_ENTRY( ptr, struct wait_queue_entry, entry );
896 if (!(ret = wake_thread( get_wait_queue_thread( entry )))) continue;
897 if (ret > 0 && max && !--max) break;
898 /* restart at the head of the list since a wake up can change the object wait queue */
899 ptr = &obj->wait_queue;
903 /* return the apc queue to use for a given apc type */
904 static inline struct list *get_apc_queue( struct thread *thread, enum apc_type type )
906 switch(type)
908 case APC_NONE:
909 case APC_USER:
910 case APC_TIMER:
911 return &thread->user_apc;
912 default:
913 return &thread->system_apc;
917 /* check if thread is currently waiting for a (system) apc */
918 static inline int is_in_apc_wait( struct thread *thread )
920 return (thread->process->suspend || thread->suspend ||
921 (thread->wait && (thread->wait->flags & SELECT_INTERRUPTIBLE)));
924 /* queue an existing APC to a given thread */
925 static int queue_apc( struct process *process, struct thread *thread, struct thread_apc *apc )
927 struct list *queue;
929 if (thread && thread->state == TERMINATED && process)
930 thread = NULL;
932 if (!thread) /* find a suitable thread inside the process */
934 struct thread *candidate;
936 /* first try to find a waiting thread */
937 LIST_FOR_EACH_ENTRY( candidate, &process->thread_list, struct thread, proc_entry )
939 if (candidate->state == TERMINATED) continue;
940 if (is_in_apc_wait( candidate ))
942 thread = candidate;
943 break;
946 if (!thread)
948 /* then use the first one that accepts a signal */
949 LIST_FOR_EACH_ENTRY( candidate, &process->thread_list, struct thread, proc_entry )
951 if (send_thread_signal( candidate, SIGUSR1 ))
953 thread = candidate;
954 break;
958 if (!thread) return 0; /* nothing found */
959 queue = get_apc_queue( thread, apc->call.type );
961 else
963 if (thread->state == TERMINATED) return 0;
964 queue = get_apc_queue( thread, apc->call.type );
965 /* send signal for system APCs if needed */
966 if (queue == &thread->system_apc && list_empty( queue ) && !is_in_apc_wait( thread ))
968 if (!send_thread_signal( thread, SIGUSR1 )) return 0;
970 /* cancel a possible previous APC with the same owner */
971 if (apc->owner) thread_cancel_apc( thread, apc->owner, apc->call.type );
974 grab_object( apc );
975 list_add_tail( queue, &apc->entry );
976 if (!list_prev( queue, &apc->entry )) /* first one */
977 wake_thread( thread );
979 return 1;
982 /* queue an async procedure call */
983 int thread_queue_apc( struct process *process, struct thread *thread, struct object *owner, const apc_call_t *call_data )
985 struct thread_apc *apc;
986 int ret = 0;
988 if ((apc = create_apc( owner, call_data )))
990 ret = queue_apc( process, thread, apc );
991 release_object( apc );
993 return ret;
996 /* cancel the async procedure call owned by a specific object */
997 void thread_cancel_apc( struct thread *thread, struct object *owner, enum apc_type type )
999 struct thread_apc *apc;
1000 struct list *queue = get_apc_queue( thread, type );
1002 LIST_FOR_EACH_ENTRY( apc, queue, struct thread_apc, entry )
1004 if (apc->owner != owner) continue;
1005 list_remove( &apc->entry );
1006 apc->executed = 1;
1007 wake_up( &apc->obj, 0 );
1008 release_object( apc );
1009 return;
1013 /* remove the head apc from the queue; the returned object must be released by the caller */
1014 static struct thread_apc *thread_dequeue_apc( struct thread *thread, int system_only )
1016 struct thread_apc *apc = NULL;
1017 struct list *ptr = list_head( &thread->system_apc );
1019 if (!ptr && !system_only) ptr = list_head( &thread->user_apc );
1020 if (ptr)
1022 apc = LIST_ENTRY( ptr, struct thread_apc, entry );
1023 list_remove( ptr );
1025 return apc;
1028 /* clear an APC queue, cancelling all the APCs on it */
1029 static void clear_apc_queue( struct list *queue )
1031 struct list *ptr;
1033 while ((ptr = list_head( queue )))
1035 struct thread_apc *apc = LIST_ENTRY( ptr, struct thread_apc, entry );
1036 list_remove( &apc->entry );
1037 apc->executed = 1;
1038 wake_up( &apc->obj, 0 );
1039 release_object( apc );
1043 /* add an fd to the inflight list */
1044 /* return list index, or -1 on error */
1045 int thread_add_inflight_fd( struct thread *thread, int client, int server )
1047 int i;
1049 if (server == -1) return -1;
1050 if (client == -1)
1052 close( server );
1053 return -1;
1056 /* first check if we already have an entry for this fd */
1057 for (i = 0; i < MAX_INFLIGHT_FDS; i++)
1058 if (thread->inflight[i].client == client)
1060 close( thread->inflight[i].server );
1061 thread->inflight[i].server = server;
1062 return i;
1065 /* now find a free spot to store it */
1066 for (i = 0; i < MAX_INFLIGHT_FDS; i++)
1067 if (thread->inflight[i].client == -1)
1069 thread->inflight[i].client = client;
1070 thread->inflight[i].server = server;
1071 return i;
1074 close( server );
1075 return -1;
1078 /* get an inflight fd and purge it from the list */
1079 /* the fd must be closed when no longer used */
1080 int thread_get_inflight_fd( struct thread *thread, int client )
1082 int i, ret;
1084 if (client == -1) return -1;
1088 for (i = 0; i < MAX_INFLIGHT_FDS; i++)
1090 if (thread->inflight[i].client == client)
1092 ret = thread->inflight[i].server;
1093 thread->inflight[i].server = thread->inflight[i].client = -1;
1094 return ret;
1097 } while (!receive_fd( thread->process )); /* in case it is still in the socket buffer */
1098 return -1;
1101 /* kill a thread on the spot */
1102 void kill_thread( struct thread *thread, int violent_death )
1104 if (thread->state == TERMINATED) return; /* already killed */
1105 thread->state = TERMINATED;
1106 thread->exit_time = current_time;
1107 if (current == thread) current = NULL;
1108 if (debug_level)
1109 fprintf( stderr,"%04x: *killed* exit_code=%d\n",
1110 thread->id, thread->exit_code );
1111 if (thread->wait)
1113 while (thread->wait) end_wait( thread, STATUS_THREAD_IS_TERMINATING );
1114 send_thread_wakeup( thread, 0, thread->exit_code );
1115 /* if it is waiting on the socket, we don't need to send a SIGQUIT */
1116 violent_death = 0;
1118 kill_console_processes( thread, 0 );
1119 debug_exit_thread( thread );
1120 abandon_mutexes( thread );
1121 wake_up( &thread->obj, 0 );
1122 if (violent_death) send_thread_signal( thread, SIGQUIT );
1123 cleanup_thread( thread );
1124 remove_process_thread( thread->process, thread );
1125 release_object( thread );
1128 /* copy parts of a context structure */
1129 static void copy_context( context_t *to, const context_t *from, unsigned int flags )
1131 assert( to->cpu == from->cpu );
1132 to->flags |= flags;
1133 if (flags & SERVER_CTX_CONTROL) to->ctl = from->ctl;
1134 if (flags & SERVER_CTX_INTEGER) to->integer = from->integer;
1135 if (flags & SERVER_CTX_SEGMENTS) to->seg = from->seg;
1136 if (flags & SERVER_CTX_FLOATING_POINT) to->fp = from->fp;
1137 if (flags & SERVER_CTX_DEBUG_REGISTERS) to->debug = from->debug;
1138 if (flags & SERVER_CTX_EXTENDED_REGISTERS) to->ext = from->ext;
1141 /* return the context flags that correspond to system regs */
1142 /* (system regs are the ones we can't access on the client side) */
1143 static unsigned int get_context_system_regs( enum cpu_type cpu )
1145 switch (cpu)
1147 case CPU_x86: return SERVER_CTX_DEBUG_REGISTERS;
1148 case CPU_x86_64: return SERVER_CTX_DEBUG_REGISTERS;
1149 case CPU_POWERPC: return 0;
1150 case CPU_ARM: return SERVER_CTX_DEBUG_REGISTERS;
1151 case CPU_ARM64: return SERVER_CTX_DEBUG_REGISTERS;
1153 return 0;
1156 /* trigger a breakpoint event in a given thread */
1157 void break_thread( struct thread *thread )
1159 debug_event_t data;
1161 assert( thread->context );
1163 memset( &data, 0, sizeof(data) );
1164 data.exception.first = 1;
1165 data.exception.exc_code = STATUS_BREAKPOINT;
1166 data.exception.flags = EXCEPTION_CONTINUABLE;
1167 switch (thread->context->cpu)
1169 case CPU_x86:
1170 data.exception.address = thread->context->ctl.i386_regs.eip;
1171 break;
1172 case CPU_x86_64:
1173 data.exception.address = thread->context->ctl.x86_64_regs.rip;
1174 break;
1175 case CPU_POWERPC:
1176 data.exception.address = thread->context->ctl.powerpc_regs.iar;
1177 break;
1178 case CPU_ARM:
1179 data.exception.address = thread->context->ctl.arm_regs.pc;
1180 break;
1181 case CPU_ARM64:
1182 data.exception.address = thread->context->ctl.arm64_regs.pc;
1183 break;
1185 generate_debug_event( thread, EXCEPTION_DEBUG_EVENT, &data );
1186 thread->debug_break = 0;
1189 /* take a snapshot of currently running threads */
1190 struct thread_snapshot *thread_snap( int *count )
1192 struct thread_snapshot *snapshot, *ptr;
1193 struct thread *thread;
1194 int total = 0;
1196 LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
1197 if (thread->state != TERMINATED) total++;
1198 if (!total || !(snapshot = mem_alloc( sizeof(*snapshot) * total ))) return NULL;
1199 ptr = snapshot;
1200 LIST_FOR_EACH_ENTRY( thread, &thread_list, struct thread, entry )
1202 if (thread->state == TERMINATED) continue;
1203 ptr->thread = thread;
1204 ptr->count = thread->obj.refcount;
1205 ptr->priority = thread->priority;
1206 grab_object( thread );
1207 ptr++;
1209 *count = total;
1210 return snapshot;
1213 /* gets the current impersonation token */
1214 struct token *thread_get_impersonation_token( struct thread *thread )
1216 if (thread->token)
1217 return thread->token;
1218 else
1219 return thread->process->token;
1222 /* check if a cpu type can be supported on this server */
1223 int is_cpu_supported( enum cpu_type cpu )
1225 unsigned int prefix_cpu_mask = get_prefix_cpu_mask();
1227 if (supported_cpus & prefix_cpu_mask & CPU_FLAG(cpu)) return 1;
1228 if (!(supported_cpus & prefix_cpu_mask))
1229 set_error( STATUS_NOT_SUPPORTED );
1230 else if (supported_cpus & CPU_FLAG(cpu))
1231 set_error( STATUS_INVALID_IMAGE_WIN_64 ); /* server supports it but not the prefix */
1232 else
1233 set_error( STATUS_INVALID_IMAGE_FORMAT );
1234 return 0;
1237 /* return the cpu mask for supported cpus */
1238 unsigned int get_supported_cpu_mask(void)
1240 return supported_cpus & get_prefix_cpu_mask();
1243 /* create a new thread */
1244 DECL_HANDLER(new_thread)
1246 struct thread *thread;
1247 int request_fd = thread_get_inflight_fd( current, req->request_fd );
1249 if (request_fd == -1 || fcntl( request_fd, F_SETFL, O_NONBLOCK ) == -1)
1251 if (request_fd != -1) close( request_fd );
1252 set_error( STATUS_INVALID_HANDLE );
1253 return;
1256 if ((thread = create_thread( request_fd, current->process )))
1258 thread->system_regs = current->system_regs;
1259 if (req->suspend) thread->suspend++;
1260 reply->tid = get_thread_id( thread );
1261 if ((reply->handle = alloc_handle( current->process, thread, req->access, req->attributes )))
1263 /* thread object will be released when the thread gets killed */
1264 return;
1266 kill_thread( thread, 1 );
1270 /* initialize a new thread */
1271 DECL_HANDLER(init_thread)
1273 struct process *process = current->process;
1274 int wait_fd, reply_fd;
1276 if ((reply_fd = thread_get_inflight_fd( current, req->reply_fd )) == -1)
1278 set_error( STATUS_TOO_MANY_OPENED_FILES );
1279 return;
1281 if ((wait_fd = thread_get_inflight_fd( current, req->wait_fd )) == -1)
1283 set_error( STATUS_TOO_MANY_OPENED_FILES );
1284 goto error;
1287 if (current->reply_fd) /* already initialised */
1289 set_error( STATUS_INVALID_PARAMETER );
1290 goto error;
1293 if (fcntl( reply_fd, F_SETFL, O_NONBLOCK ) == -1) goto error;
1295 current->reply_fd = create_anonymous_fd( &thread_fd_ops, reply_fd, &current->obj, 0 );
1296 current->wait_fd = create_anonymous_fd( &thread_fd_ops, wait_fd, &current->obj, 0 );
1297 if (!current->reply_fd || !current->wait_fd) return;
1299 if (!is_valid_address(req->teb))
1301 set_error( STATUS_INVALID_PARAMETER );
1302 return;
1305 current->unix_pid = req->unix_pid;
1306 current->unix_tid = req->unix_tid;
1307 current->teb = req->teb;
1308 current->entry_point = process->peb ? req->entry : 0;
1310 if (!process->peb) /* first thread, initialize the process too */
1312 if (!is_cpu_supported( req->cpu )) return;
1313 process->unix_pid = current->unix_pid;
1314 process->peb = req->entry;
1315 process->cpu = req->cpu;
1316 reply->info_size = init_process( current );
1317 if (!process->parent_id)
1318 process->affinity = current->affinity = get_thread_affinity( current );
1319 else
1320 set_thread_affinity( current, current->affinity );
1322 else
1324 if (req->cpu != process->cpu)
1326 set_error( STATUS_INVALID_PARAMETER );
1327 return;
1329 if (process->unix_pid != current->unix_pid)
1330 process->unix_pid = -1; /* can happen with linuxthreads */
1331 init_thread_context( current );
1332 generate_debug_event( current, CREATE_THREAD_DEBUG_EVENT, &req->entry );
1333 set_thread_affinity( current, current->affinity );
1335 debug_level = max( debug_level, req->debug_level );
1337 reply->pid = get_process_id( process );
1338 reply->tid = get_thread_id( current );
1339 reply->version = SERVER_PROTOCOL_VERSION;
1340 reply->server_start = server_start_time;
1341 reply->all_cpus = supported_cpus & get_prefix_cpu_mask();
1342 reply->suspend = (current->suspend || process->suspend);
1343 return;
1345 error:
1346 if (reply_fd != -1) close( reply_fd );
1347 if (wait_fd != -1) close( wait_fd );
1350 /* terminate a thread */
1351 DECL_HANDLER(terminate_thread)
1353 struct thread *thread;
1355 reply->self = 0;
1356 reply->last = 0;
1357 if ((thread = get_thread_from_handle( req->handle, THREAD_TERMINATE )))
1359 thread->exit_code = req->exit_code;
1360 if (thread != current) kill_thread( thread, 1 );
1361 else
1363 reply->self = 1;
1364 reply->last = (thread->process->running_threads == 1);
1366 release_object( thread );
1370 /* open a handle to a thread */
1371 DECL_HANDLER(open_thread)
1373 struct thread *thread = get_thread_from_id( req->tid );
1375 reply->handle = 0;
1376 if (thread)
1378 reply->handle = alloc_handle( current->process, thread, req->access, req->attributes );
1379 release_object( thread );
1383 /* fetch information about a thread */
1384 DECL_HANDLER(get_thread_info)
1386 struct thread *thread;
1387 obj_handle_t handle = req->handle;
1389 if (!handle) thread = get_thread_from_id( req->tid_in );
1390 else thread = get_thread_from_handle( req->handle, THREAD_QUERY_LIMITED_INFORMATION );
1392 if (thread)
1394 reply->pid = get_process_id( thread->process );
1395 reply->tid = get_thread_id( thread );
1396 reply->teb = thread->teb;
1397 reply->entry_point = thread->entry_point;
1398 reply->exit_code = (thread->state == TERMINATED) ? thread->exit_code : STATUS_PENDING;
1399 reply->priority = thread->priority;
1400 reply->affinity = thread->affinity;
1401 reply->last = thread->process->running_threads == 1;
1403 release_object( thread );
1407 /* fetch information about thread times */
1408 DECL_HANDLER(get_thread_times)
1410 struct thread *thread;
1412 if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
1414 reply->creation_time = thread->creation_time;
1415 reply->exit_time = thread->exit_time;
1417 release_object( thread );
1421 /* set information about a thread */
1422 DECL_HANDLER(set_thread_info)
1424 struct thread *thread;
1426 if ((thread = get_thread_from_handle( req->handle, THREAD_SET_INFORMATION )))
1428 set_thread_info( thread, req );
1429 release_object( thread );
1433 /* suspend a thread */
1434 DECL_HANDLER(suspend_thread)
1436 struct thread *thread;
1438 if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
1440 if (thread->state == TERMINATED) set_error( STATUS_ACCESS_DENIED );
1441 else reply->count = suspend_thread( thread );
1442 release_object( thread );
1446 /* resume a thread */
1447 DECL_HANDLER(resume_thread)
1449 struct thread *thread;
1451 if ((thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME )))
1453 reply->count = resume_thread( thread );
1454 release_object( thread );
1458 /* select on a handle list */
1459 DECL_HANDLER(select)
1461 select_op_t select_op;
1462 data_size_t op_size;
1463 struct thread_apc *apc;
1464 const apc_result_t *result = get_req_data();
1466 if (get_req_data_size() < sizeof(*result))
1468 set_error( STATUS_INVALID_PARAMETER );
1469 return;
1471 if (!req->cookie)
1473 set_error( STATUS_INVALID_PARAMETER );
1474 return;
1477 op_size = min( get_req_data_size() - sizeof(*result), sizeof(select_op) );
1478 memset( &select_op, 0, sizeof(select_op) );
1479 memcpy( &select_op, result + 1, op_size );
1481 /* first store results of previous apc */
1482 if (req->prev_apc)
1484 if (!(apc = (struct thread_apc *)get_handle_obj( current->process, req->prev_apc,
1485 0, &thread_apc_ops ))) return;
1486 apc->result = *result;
1487 apc->executed = 1;
1488 if (apc->result.type == APC_CREATE_THREAD) /* transfer the handle to the caller process */
1490 obj_handle_t handle = duplicate_handle( current->process, apc->result.create_thread.handle,
1491 apc->caller->process, 0, 0, DUP_HANDLE_SAME_ACCESS );
1492 close_handle( current->process, apc->result.create_thread.handle );
1493 apc->result.create_thread.handle = handle;
1494 clear_error(); /* ignore errors from the above calls */
1496 else if (apc->result.type == APC_ASYNC_IO)
1498 if (apc->owner)
1499 async_set_result( apc->owner, apc->result.async_io.status, apc->result.async_io.total );
1501 wake_up( &apc->obj, 0 );
1502 close_handle( current->process, req->prev_apc );
1503 release_object( apc );
1506 reply->timeout = select_on( &select_op, op_size, req->cookie, req->flags, req->timeout );
1508 if (get_error() == STATUS_USER_APC)
1510 for (;;)
1512 if (!(apc = thread_dequeue_apc( current, !(req->flags & SELECT_ALERTABLE) )))
1513 break;
1514 /* Optimization: ignore APC_NONE calls, they are only used to
1515 * wake up a thread, but since we got here the thread woke up already.
1517 if (apc->call.type != APC_NONE &&
1518 (reply->apc_handle = alloc_handle( current->process, apc, SYNCHRONIZE, 0 )))
1520 reply->call = apc->call;
1521 release_object( apc );
1522 break;
1524 apc->executed = 1;
1525 wake_up( &apc->obj, 0 );
1526 release_object( apc );
1531 /* queue an APC for a thread or process */
1532 DECL_HANDLER(queue_apc)
1534 struct thread *thread = NULL;
1535 struct process *process = NULL;
1536 struct thread_apc *apc;
1538 if (!(apc = create_apc( NULL, &req->call ))) return;
1540 switch (apc->call.type)
1542 case APC_NONE:
1543 case APC_USER:
1544 thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT );
1545 break;
1546 case APC_VIRTUAL_ALLOC:
1547 case APC_VIRTUAL_FREE:
1548 case APC_VIRTUAL_PROTECT:
1549 case APC_VIRTUAL_FLUSH:
1550 case APC_VIRTUAL_LOCK:
1551 case APC_VIRTUAL_UNLOCK:
1552 case APC_UNMAP_VIEW:
1553 process = get_process_from_handle( req->handle, PROCESS_VM_OPERATION );
1554 break;
1555 case APC_VIRTUAL_QUERY:
1556 process = get_process_from_handle( req->handle, PROCESS_QUERY_INFORMATION );
1557 break;
1558 case APC_MAP_VIEW:
1559 process = get_process_from_handle( req->handle, PROCESS_VM_OPERATION );
1560 if (process && process != current->process)
1562 /* duplicate the handle into the target process */
1563 obj_handle_t handle = duplicate_handle( current->process, apc->call.map_view.handle,
1564 process, 0, 0, DUP_HANDLE_SAME_ACCESS );
1565 if (handle) apc->call.map_view.handle = handle;
1566 else
1568 release_object( process );
1569 process = NULL;
1572 break;
1573 case APC_CREATE_THREAD:
1574 process = get_process_from_handle( req->handle, PROCESS_CREATE_THREAD );
1575 break;
1576 default:
1577 set_error( STATUS_INVALID_PARAMETER );
1578 break;
1581 if (thread)
1583 if (!queue_apc( NULL, thread, apc )) set_error( STATUS_THREAD_IS_TERMINATING );
1584 release_object( thread );
1586 else if (process)
1588 reply->self = (process == current->process);
1589 if (!reply->self)
1591 obj_handle_t handle = alloc_handle( current->process, apc, SYNCHRONIZE, 0 );
1592 if (handle)
1594 if (queue_apc( process, NULL, apc ))
1596 apc->caller = (struct thread *)grab_object( current );
1597 reply->handle = handle;
1599 else
1601 close_handle( current->process, handle );
1602 set_error( STATUS_PROCESS_IS_TERMINATING );
1606 release_object( process );
1609 release_object( apc );
1612 /* Get the result of an APC call */
1613 DECL_HANDLER(get_apc_result)
1615 struct thread_apc *apc;
1617 if (!(apc = (struct thread_apc *)get_handle_obj( current->process, req->handle,
1618 0, &thread_apc_ops ))) return;
1620 if (apc->executed) reply->result = apc->result;
1621 else set_error( STATUS_PENDING );
1623 /* close the handle directly to avoid an extra round-trip */
1624 close_handle( current->process, req->handle );
1625 release_object( apc );
1628 /* retrieve the current context of a thread */
1629 DECL_HANDLER(get_thread_context)
1631 struct thread *thread;
1632 context_t *context;
1634 if (get_reply_max_size() < sizeof(context_t))
1636 set_error( STATUS_INVALID_PARAMETER );
1637 return;
1639 if (!(thread = get_thread_from_handle( req->handle, THREAD_GET_CONTEXT ))) return;
1640 reply->self = (thread == current);
1642 if (thread != current && !thread->context)
1644 /* thread is not suspended, retry (if it's still running) */
1645 if (thread->state == RUNNING)
1647 set_error( STATUS_PENDING );
1648 if (req->suspend)
1650 release_object( thread );
1651 /* make sure we have suspend access */
1652 if (!(thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME ))) return;
1653 suspend_thread( thread );
1656 else set_error( STATUS_UNSUCCESSFUL );
1658 else if ((context = set_reply_data_size( sizeof(context_t) )))
1660 unsigned int flags = get_context_system_regs( thread->process->cpu );
1662 memset( context, 0, sizeof(context_t) );
1663 context->cpu = thread->process->cpu;
1664 if (thread->context) copy_context( context, thread->context, req->flags & ~flags );
1665 if (req->flags & flags) get_thread_context( thread, context, req->flags & flags );
1667 release_object( thread );
1670 /* set the current context of a thread */
1671 DECL_HANDLER(set_thread_context)
1673 struct thread *thread;
1674 const context_t *context = get_req_data();
1676 if (get_req_data_size() < sizeof(context_t))
1678 set_error( STATUS_INVALID_PARAMETER );
1679 return;
1681 if (!(thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT ))) return;
1682 reply->self = (thread == current);
1684 if (thread != current && !thread->context)
1686 /* thread is not suspended, retry (if it's still running) */
1687 if (thread->state == RUNNING)
1689 set_error( STATUS_PENDING );
1690 if (req->suspend)
1692 release_object( thread );
1693 /* make sure we have suspend access */
1694 if (!(thread = get_thread_from_handle( req->handle, THREAD_SUSPEND_RESUME ))) return;
1695 suspend_thread( thread );
1698 else set_error( STATUS_UNSUCCESSFUL );
1700 else if (context->cpu == thread->process->cpu)
1702 unsigned int system_flags = get_context_system_regs(context->cpu) & context->flags;
1703 unsigned int client_flags = context->flags & ~system_flags;
1705 if (system_flags) set_thread_context( thread, context, system_flags );
1706 if (thread->context && !get_error()) copy_context( thread->context, context, client_flags );
1708 else set_error( STATUS_INVALID_PARAMETER );
1710 release_object( thread );
1713 /* retrieve the suspended context of a thread */
1714 DECL_HANDLER(get_suspend_context)
1716 if (get_reply_max_size() < sizeof(context_t))
1718 set_error( STATUS_INVALID_PARAMETER );
1719 return;
1722 if (current->suspend_context)
1724 if (current->suspend_context->flags)
1725 set_reply_data_ptr( current->suspend_context, sizeof(context_t) );
1726 else
1727 free( current->suspend_context );
1728 if (current->context == current->suspend_context)
1730 current->context = NULL;
1731 stop_thread_if_suspended( current );
1733 current->suspend_context = NULL;
1735 else set_error( STATUS_INVALID_PARAMETER ); /* not suspended, shouldn't happen */
1738 /* store the suspended context of a thread */
1739 DECL_HANDLER(set_suspend_context)
1741 const context_t *context = get_req_data();
1743 if (get_req_data_size() < sizeof(context_t))
1745 set_error( STATUS_INVALID_PARAMETER );
1746 return;
1749 if (current->context || context->cpu != current->process->cpu)
1751 /* nested suspend or exception, shouldn't happen */
1752 set_error( STATUS_INVALID_PARAMETER );
1754 else if ((current->suspend_context = mem_alloc( sizeof(context_t) )))
1756 memcpy( current->suspend_context, get_req_data(), sizeof(context_t) );
1757 current->suspend_context->flags = 0; /* to keep track of what is modified */
1758 current->context = current->suspend_context;
1759 if (current->debug_break) break_thread( current );
1763 /* fetch a selector entry for a thread */
1764 DECL_HANDLER(get_selector_entry)
1766 struct thread *thread;
1767 if ((thread = get_thread_from_handle( req->handle, THREAD_QUERY_INFORMATION )))
1769 get_selector_entry( thread, req->entry, &reply->base, &reply->limit, &reply->flags );
1770 release_object( thread );