alpha « sysdeps « linuxthreads « libpthread - uclibc-ng.git - Unnamed repository; edit this file 'description' to name the repository.

path: root/libpthread/linuxthreads/sysdeps/alpha

Mode	Name	Size
d---------	elf	41	log plain
-rw-r--r--	pspinlock.c	3139	log plain
-rw-r--r--	pt-machine.h	3491	log plain
-rw-r--r--	tls.h	4170	log plain

hread is moved to the active list. */ struct thread_node * __timer_thread_alloc (const pthread_attr_t *desired_attr, clockid_t clock_id) { struct list_links *node = list_first (&thread_free_list); if (node != list_null (&thread_free_list)) { struct thread_node *thread = thread_links2ptr (node); list_unlink (node); thread_init (thread, desired_attr, clock_id); list_append (&thread_active_list, node); return thread; } return 0; } /* Return a thread structure to the global free list. Global lock must be held by caller. */ void __timer_thread_dealloc (struct thread_node *thread) { thread_deinit (thread); list_unlink (&thread->links); list_append (&thread_free_list, &thread->links); } /* Each of our threads which terminates executes this cleanup handler. We never terminate threads ourselves; if a thread gets here it means that the evil application has killed it. If the thread has timers, these require servicing and so we must hire a replacement thread right away. We must also unblock another thread that may have been waiting for this thread to finish servicing a timer (see timer_delete()). */ static void thread_cleanup (void *val) { if (val != NULL) { struct thread_node *thread = val; /* How did the signal thread get killed? */ assert (thread != &__timer_signal_thread_rclk); pthread_mutex_lock (&__timer_mutex); thread->exists = 0; /* We are no longer processing a timer event. */ thread->current_timer = 0; if (list_isempty (&thread->timer_queue)) __timer_thread_dealloc (thread); else (void) __timer_thread_start (thread); pthread_mutex_unlock (&__timer_mutex); /* Unblock potentially blocked timer_delete(). */ pthread_cond_broadcast (&thread->cond); } } /* Handle a timer which is supposed to go off now. */ static void thread_expire_timer (struct thread_node *self, struct timer_node *timer) { self->current_timer = timer; /* Lets timer_delete know timer is running. */ pthread_mutex_unlock (&__timer_mutex); switch (__builtin_expect (timer->event.sigev_notify, SIGEV_SIGNAL)) { case SIGEV_NONE: break; case SIGEV_SIGNAL: #ifdef __NR_rt_sigqueueinfo { siginfo_t info; /* First, clear the siginfo_t structure, so that we don't pass our stack content to other tasks. */ memset (&info, 0, sizeof (siginfo_t)); /* We must pass the information about the data in a siginfo_t value. */ info.si_signo = timer->event.sigev_signo; info.si_code = SI_TIMER; info.si_pid = timer->creator_pid; info.si_uid = getuid (); info.si_value = timer->event.sigev_value; INLINE_SYSCALL (rt_sigqueueinfo, 3, info.si_pid, info.si_signo, &info); } #else if (pthread_kill (self->captured, timer->event.sigev_signo) != 0) { if (pthread_kill (self->id, timer->event.sigev_signo) != 0) abort (); } #endif break; case SIGEV_THREAD: timer->event.sigev_notify_function (timer->event.sigev_value); break; default: assert (! "unknown event"); break; } pthread_mutex_lock (&__timer_mutex); self->current_timer = 0; pthread_cond_broadcast (&self->cond); } /* Thread function; executed by each timer thread. The job of this function is to wait on the thread's timer queue and expire the timers in chronological order as close to their scheduled time as possible. */ static void __attribute__ ((noreturn)) thread_func (void *arg) { struct thread_node *self = arg; /* Register cleanup handler, in case rogue application terminates this thread. (This cannot happen to __timer_signal_thread, which doesn't invoke application callbacks). */ pthread_cleanup_push (thread_cleanup, self); pthread_mutex_lock (&__timer_mutex); while (1) { struct list_links *first; struct timer_node *timer = NULL; /* While the timer queue is not empty, inspect the first node. */ first = list_first (&self->timer_queue); if (first != list_null (&self->timer_queue)) { struct timespec now; timer = timer_links2ptr (first); /* This assumes that the elements of the list of one thread are all for the same clock. */ clock_gettime (timer->clock, &now); while (1) { /* If the timer is due or overdue, remove it from the queue. If it's a periodic timer, re-compute its new time and requeue it. Either way, perform the timer expiry. */ if (timespec_compare (&now, &timer->expirytime) < 0) break; list_unlink_ip (first); if (__builtin_expect (timer->value.it_interval.tv_sec, 0) != 0 || timer->value.it_interval.tv_nsec != 0) { timer->overrun_count = 0; timespec_add (&timer->expirytime, &timer->expirytime, &timer->value.it_interval); while (timespec_compare (&timer->expirytime, &now) < 0) { timespec_add (&timer->expirytime, &timer->expirytime, &timer->value.it_interval); if (timer->overrun_count < DELAYTIMER_MAX) ++timer->overrun_count; } __timer_thread_queue_timer (self, timer); } thread_expire_timer (self, timer); first = list_first (&self->timer_queue); if (first == list_null (&self->timer_queue)) break; timer = timer_links2ptr (first); } } /* If the queue is not empty, wait until the expiry time of the first node. Otherwise wait indefinitely. Insertions at the head of the queue must wake up the thread by broadcasting this condition variable. */ if (timer != NULL) pthread_cond_timedwait (&self->cond, &__timer_mutex, &timer->expirytime); else pthread_cond_wait (&self->cond, &__timer_mutex); } /* This macro will never be executed since the while loop loops forever - but we have to add it for proper nesting. */ pthread_cleanup_pop (1); } /* Enqueue a timer in wakeup order in the thread's timer queue. Returns 1 if the timer was inserted at the head of the queue, causing the queue's next wakeup time to change. */ int __timer_thread_queue_timer (struct thread_node *thread, struct timer_node *insert) { struct list_links *iter; int athead = 1; for (iter = list_first (&thread->timer_queue); iter != list_null (&thread->timer_queue); iter = list_next (iter)) { struct timer_node *timer = timer_links2ptr (iter); if (timespec_compare (&insert->expirytime, &timer->expirytime) < 0) break; athead = 0; } list_insbefore (iter, &insert->links); return athead; } /* Start a thread and associate it with the given thread node. Global lock must be held by caller. */ int __timer_thread_start (struct thread_node *thread) { int retval = 1; assert (!thread->exists); thread->exists = 1; if (pthread_create (&thread->id, &thread->attr, (void *(*) (void *)) thread_func, thread) != 0) { thread->exists = 0; retval = -1; } return retval; } void __timer_thread_wakeup (struct thread_node *thread) { pthread_cond_broadcast (&thread->cond); } /* Compare two pthread_attr_t thread attributes for exact equality. Returns 1 if they are equal, otherwise zero if they are not equal or contain illegal values. This version is LinuxThreads-specific for performance reason. One could use the access functions to get the values of all the fields of the attribute structure. */ static int thread_attr_compare (const pthread_attr_t *left, const pthread_attr_t *right) { return (left->__detachstate == right->__detachstate && left->__schedpolicy == right->__schedpolicy && left->__guardsize == right->__guardsize && (left->__schedparam.sched_priority == right->__schedparam.sched_priority) && left->__inheritsched == right->__inheritsched && left->__scope == right->__scope && left->__stacksize == right->__stacksize && left->__stackaddr_set == right->__stackaddr_set && (left->__stackaddr_set || left->__stackaddr == right->__stackaddr)); } /* Search the list of active threads and find one which has matching attributes. Global mutex lock must be held by caller. */ struct thread_node * __timer_thread_find_matching (const pthread_attr_t *desired_attr, clockid_t desired_clock_id) { struct list_links *iter = list_first (&thread_active_list); while (iter != list_null (&thread_active_list)) { struct thread_node *candidate = thread_links2ptr (iter); if (thread_attr_compare (desired_attr, &candidate->attr) && desired_clock_id == candidate->clock_id) return candidate; iter = list_next (iter); } return NULL; } /* Grab a free timer structure from the global free list. The global lock must be held by the caller. */ struct timer_node * __timer_alloc (void) { struct list_links *node = list_first (&timer_free_list); if (node != list_null (&timer_free_list)) { struct timer_node *timer = timer_links2ptr (node); list_unlink_ip (node); timer->inuse = TIMER_INUSE; timer->refcount = 1; return timer; } return NULL; } /* Return a timer structure to the global free list. The global lock must be held by the caller. */ void __timer_dealloc (struct timer_node *timer) { assert (timer->refcount == 0); timer->thread = NULL; /* Break association between timer and thread. */ timer->inuse = TIMER_FREE; list_append (&timer_free_list, &timer->links); } /* Thread cancellation handler which unlocks a mutex. */ void __timer_mutex_cancel_handler (void *arg) { pthread_mutex_unlock (arg); }