/* Linuxthreads - a simple clone()-based implementation of Posix */
/* threads for Linux. */
/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU Library General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Library General Public License for more details. */
/* Thread creation, initialization, and basic low-level routines */
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "pthread.h"
#include "internals.h"
#include "spinlock.h"
#include "restart.h"
/* Descriptor of the initial thread */
/* Dla każdego procesu tworzone są dwa dodatkowe wątki */
/* - wątek początkowy - */
/* ten wątek nie jest tworzony fizycznie - to tylko */
/* sposób opisu procesu - ojca wszystkich wątków */
/* - menedżer - odpowiedzialny za tworzenie i niszczenie wątków */
struct _pthread_descr_struct __pthread_initial_thread = {
&__pthread_initial_thread, /* pthread_descr p_nextlive */
&__pthread_initial_thread, /* pthread_descr p_prevlive */
NULL, /* pthread_descr p_nextwaiting */
PTHREAD_THREADS_MAX, /* pthread_t p_tid */
0, /* int p_pid */
0, /* int p_priority */
&__pthread_handles[0].h_spinlock, /* int * p_spinlock */
0, /* int p_signal */
NULL, /* sigjmp_buf * p_signal_buf */
NULL, /* sigjmp_buf * p_cancel_buf */
0, /* char p_terminated */
0, /* char p_detached */
0, /* char p_exited */
NULL, /* void * p_retval */
0, /* int p_retval */
NULL, /* pthread_descr p_joining */
NULL, /* struct _pthread_cleanup_buffer * p_cleanup */
0, /* char p_cancelstate */
0, /* char p_canceltype */
0, /* char p_canceled */
0, /* int p_errno */
0, /* int p_h_errno */
PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
{NULL} /* void ** p_specific[PTHREAD_KEY_1STLEVEL] */
};
/* Descriptor of the manager thread; none of this is used but the error
variables and the address for identification. */
struct _pthread_descr_struct __pthread_manager_thread = {
NULL, /* pthread_descr p_nextlive */
NULL, /* pthread_descr p_prevlive */
NULL, /* pthread_descr p_nextwaiting */
0, /* int p_tid */
0, /* int p_pid */
0, /* int p_priority */
NULL, /* int * p_spinlock */
0, /* int p_signal */
NULL, /* sigjmp_buf * p_signal_buf */
NULL, /* sigjmp_buf * p_cancel_buf */
0, /* char p_terminated */
0, /* char p_detached */
0, /* char p_exited */
NULL, /* void * p_retval */
0, /* int p_retval */
NULL, /* pthread_descr p_joining */
NULL, /* struct _pthread_cleanup_buffer * p_cleanup */
0, /* char p_cancelstate */
0, /* char p_canceltype */
0, /* char p_canceled */
0, /* int p_errno */
0, /* int p_h_errno */
PTHREAD_START_ARGS_INITIALIZER, /* struct pthread_start_args p_start_args */
{NULL} /* void ** p_specific[PTHREAD_KEY_1STLEVEL] */
};
/* Pointer to the main thread (the father of the thread manager thread) */
/* Originally, this is the initial thread, but this changes after fork() */
pthread_descr __pthread_main_thread = &__pthread_initial_thread;
/* Limit between the stack of the initial thread (above) and the
stacks of other threads (below). Aligned on a STACK_SIZE boundary. */
char * __pthread_initial_thread_bos = NULL;
/* File descriptor for sending requests to the thread manager. */
/* Initially -1, meaning that the thread manager is not running. */
/* Cała komunikacja do i od menedżera odbywa się przez łącza nienazwane (pipe) */
int __pthread_manager_request = -1;
/* Other end of the pipe for sending requests to the thread manager. */
int __pthread_manager_reader;
/* PID of thread manager */
static int __pthread_manager_pid;
/* Limits of the thread manager stack */
char * __pthread_manager_thread_bos = NULL; /* dno stosu (bottom) */
char * __pthread_manager_thread_tos = NULL; /* wierzchołek (top) */
/* For process-wide exit() */
int __pthread_exit_requested = 0; /* czy proces wywołał exit */
int __pthread_exit_code = 0; /* kod wyjścia */
/* Forward declarations */
static void pthread_exit_process(int retcode, void * arg);
static void pthread_handle_sigcancel(int sig);
/* Initialize the pthread library.
Initialization is split in two functions:
- a constructor function that blocks the PTHREAD_SIG_RESTART signal
(must do this very early, since the program could capture the signal
mask with e.g. sigsetjmp before creating the first thread);
- a regular function called from pthread_create when needed. */
static void pthread_initialize(void) __attribute__((constructor));
static void pthread_initialize(void) /* inicjalizacja początkowego wątku */
{
struct sigaction sa;
sigset_t mask;
/* If already done (e.g. by a constructor called earlier!), bail out */
if (__pthread_initial_thread_bos != NULL) return;
/* For the initial stack, reserve at least STACK_SIZE bytes of stack
below the current stack address, and align that on a
STACK_SIZE boundary. */
__pthread_initial_thread_bos =
(char *)(((long)CURRENT_STACK_FRAME - 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
/* Update the descriptor for the initial thread. */
__pthread_initial_thread.p_pid = __getpid();
/* If we have special thread_self processing, initialize that for the
main thread now. */
#ifdef INIT_THREAD_SELF
INIT_THREAD_SELF(&__pthread_initial_thread);
#endif
/* Setup signal handlers for the initial thread.
Since signal handlers are shared between threads, these settings
will be inherited by all other threads. */
/* zablokuj wszystkie sygnały z wyjątkiem PTHREAD_SIG_RESTART */
sa.sa_handler = __pthread_sighandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART; /* does not matter for regular threads, but
better for the thread manager */
sigaction(PTHREAD_SIG_RESTART, &sa, NULL);
sa.sa_handler = pthread_handle_sigcancel;
sa.sa_flags = 0;
sigaction(PTHREAD_SIG_CANCEL, &sa, NULL);
/* Initially, block PTHREAD_SIG_RESTART. Will be unblocked on demand. */
sigemptyset(&mask);
sigaddset(&mask, PTHREAD_SIG_RESTART);
sigprocmask(SIG_BLOCK, &mask, NULL);
/* Register an exit function to kill all other threads. */
/* Do it early so that user-registered atexit functions are called
before pthread_exit_process. */
on_exit(pthread_exit_process, NULL);
}
static int pthread_initialize_manager(void) /* inicjalizacja menedżera */
{
int manager_pipe[2];
/* If basic initialization not done yet (e.g. we're called from a
constructor run before our constructor), do it now */
if (__pthread_initial_thread_bos == NULL) pthread_initialize();
/* Setup stack for thread manager */
__pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);
if (__pthread_manager_thread_bos == NULL) return -1;
__pthread_manager_thread_tos =
__pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;
/* Setup pipe to communicate with thread manager */
if (pipe(manager_pipe) == -1) {
free(__pthread_manager_thread_bos);
return -1;
}
__pthread_manager_request = manager_pipe[1]; /* writing end */ /* tutaj będą wysyłane żądania */
__pthread_manager_reader = manager_pipe[0]; /* reading end */ /* stąd będą odbierane */
/* Start the thread manager */
__pthread_manager_pid =
__clone(__pthread_manager, (void **) __pthread_manager_thread_tos,
CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,
(void *) manager_pipe[0]);
/* utworzenie wątku menedżera - jest on odłączony od listy wątków danego procesu */
/* ciało menedżera to funkcja __pthread_manager */
if (__pthread_manager_pid == -1) { /* funkcja clone się nie powiodła */
free(__pthread_manager_thread_bos);
close(manager_pipe[0]);
close(manager_pipe[1]);
__pthread_manager_request = -1; /* oznacza brak menedżera */
return -1;
}
return 0;
}
/* Thread creation */
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void * (*start_routine)(void *), void *arg)
{
pthread_descr self = thread_self();
struct pthread_request request;
if (__pthread_manager_request < 0) { /* jeśli nie ma jeszcze menedżera - stwórzmy go */
if (pthread_initialize_manager() < 0) return EAGAIN; /* próba się nie powiodła */
}
/* utwórz żądanie dla menedżera */
request.req_thread = self;
request.req_kind = REQ_CREATE;
request.req_args.create.attr = attr;
request.req_args.create.fn = start_routine;
request.req_args.create.arg = arg;
sigprocmask(SIG_SETMASK, (const sigset_t *) NULL,
&request.req_args.create.mask);
write(__pthread_manager_request, (char *) &request, sizeof(request));
/* zawieś się w oczekiwaniu na sygnał od menedżera */
suspend(self);
/* jeśli inicjalizacja się udała, to ustaw identyfikator wątku */
if (self->p_retcode == 0) *thread = (pthread_t) self->p_retval;
/* zwróć kod wyjścia ustawiony przez menedżera */
return self->p_retcode;
}
/* Simple operations on thread identifiers */
pthread_t pthread_self(void)
/* zwróć tid (thread ID) wątku */
{
pthread_descr self = thread_self();
return self->p_tid;
}
int pthread_equal(pthread_t thread1, pthread_t thread2)
/* porównaj identyfikatory wątków */
{
return thread1 == thread2;
}
/* Thread scheduling */
int pthread_setschedparam(pthread_t thread, int policy,
const struct sched_param *param)
/* bezpieczna (wielowejściowa) obudowa funkcji __sched_setscheduler */
/* wykonywana w sekcji krytycznej (funkcje acquire i release) */
{
pthread_handle handle = thread_handle(thread);
pthread_descr th;
acquire(&handle->h_spinlock);
if (invalid_handle(handle, thread)) {
release(&handle->h_spinlock);
return ESRCH; /* zły identyfikator wątku */
}
th = handle->h_descr;
if (__sched_setscheduler(th->p_pid, policy, param) == -1) {
release(&handle->h_spinlock);
return errno;
}
th->p_priority = policy == SCHED_OTHER ? 0 : param->sched_priority;
release(&handle->h_spinlock);
return 0;
}
int pthread_getschedparam(pthread_t thread, int *policy,
struct sched_param *param)
/* bezpieczna (wielowejściowa) obudowa funkcji __sched_getscheduler */
/* wykonywana w sekcji krytycznej (funkcje acquire i release) */
{
pthread_handle handle = thread_handle(thread);
int pid, pol;
acquire(&handle->h_spinlock);
if (invalid_handle(handle, thread)) {
release(&handle->h_spinlock);
return ESRCH; /* zły identyfikator wątku */
}
pid = handle->h_descr->p_pid;
release(&handle->h_spinlock);
pol = __sched_getscheduler(pid);
if (pol == -1) return errno;
if (__sched_getparam(pid, param) == -1) return errno;
*policy = pol;
return 0;
}
/* Process-wide exit() request */
static void pthread_exit_process(int retcode, void * arg)
/* wywoływana przez system przy wywołaniu exit() */
/* zainicjalizowana w pthread_initialize */
{
struct pthread_request request;
pthread_descr self = thread_self();
if (__pthread_manager_request >= 0) { /* jeśli istnieje menedżer */
request.req_thread = self;
request.req_kind = REQ_PROCESS_EXIT;
request.req_args.exit.code = retcode;
write(__pthread_manager_request, (char *) &request, sizeof(request));
suspend(self); /* zawieś się czekając na sygnał od menedżera */
/* Main thread should accumulate times for thread manager and its
children, so that timings for main thread account for all threads. */
if (self == __pthread_main_thread)
waitpid(__pthread_manager_pid, NULL, __WCLONE);
}
}
/* The handler for the RESTART signal just records the signal received
in the thread descriptor, and optionally performs a siglongjmp
(for pthread_cond_timedwait). Also used in sigwait.
For the thread manager thread, redirect the signal to
__pthread_manager_sighandler. */
void __pthread_sighandler(int sig)
/** obsługa sygnału PTHREAD_SIG_RESTART */
{
pthread_descr self = thread_self();
if (self == &__pthread_manager_thread) { /* dla menedżera */
__pthread_manager_sighandler(sig);
} else {
self->p_signal = sig;
if (self->p_signal_jmp != NULL) siglongjmp(*self->p_signal_jmp, 1);
}
}
/* The handler for the CANCEL signal checks for cancellation
(in asynchronous mode) and for process-wide exit and exec requests. */
static void pthread_handle_sigcancel(int sig)
/* obsługa sygnału PTHREAD_SIG_CANCEL */
{
pthread_descr self = thread_self();
sigjmp_buf * jmpbuf;
if (__pthread_exit_requested) {
/* Main thread should accumulate times for thread manager and its
children, so that timings for main thread account for all threads. */
if (self == __pthread_main_thread)
waitpid(__pthread_manager_pid, NULL, __WCLONE);
_exit(__pthread_exit_code);
}
if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
if (self->p_canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)
pthread_exit(PTHREAD_CANCELED);
jmpbuf = self->p_cancel_jmp;
if (jmpbuf != NULL) {
self->p_cancel_jmp = NULL;
siglongjmp(*jmpbuf, 1);
}
}
}
/* Reset the state of the thread machinery after a fork().
Close the pipe used for requests and set the main thread to the forked
thread.
Notice that we can't free the stack segments, as the forked thread
may hold pointers into them. */
void __pthread_reset_main_thread()
/* Po wykonaniu przez proces fork() należy dla jego dziecka utworzyć nową kopię */
/* menedżera i wątku początkowego - zamykamy odziedziczone łącza (pipe'y) */
/* i ustawiamy wszystkie wskażniki na stan początkowy */
{
pthread_descr self = thread_self();
if (__pthread_manager_request != -1) {
/* Free the thread manager stack */
free(__pthread_manager_thread_bos);
__pthread_manager_thread_bos = __pthread_manager_thread_tos = NULL;
/* Close the two ends of the pipe */
close(__pthread_manager_request);
close(__pthread_manager_reader);
__pthread_manager_request = __pthread_manager_reader = -1; /* brak menedżera */
/* zostanie utworzony przy tworzeniu pierwszego wątku */
}
/* Update the pid of the main thread */
self->p_pid = __getpid();
/* Make the forked thread the main thread */
__pthread_main_thread = self;
self->p_nextlive = self;
self->p_prevlive = self;
/* początkowym wątkiem dla dziecka jest ono samo */
}
/* Process-wide exec() request */
void __pthread_kill_other_threads_np(void)
/* zabij wszystkie wątki przed wykonaniem exec() - inaczej mogłyby się */
/* znaleźć w nieprzewidywalnym stanie - exec() zmieniłby współdzielony kod */
/* w trakcie jego wykonywania */
{
/* Terminate all other threads and thread manager */
pthread_exit_process(0, NULL);
/* Make current thread the main thread in case the calling thread
changes its mind, does not exec(), and creates new threads instead. */
__pthread_reset_main_thread();
}
weak_alias(__pthread_kill_other_threads_np, pthread_kill_other_threads_np);
/* Debugging aid */
#ifdef DEBUG
void __pthread_message(char * fmt, long arg)
/* funkcja używana tylko przy debugowaniu biblioteki */
{
char buffer[1024];
sprintf(buffer, "%05d : ", __getpid());
sprintf(buffer + 8, fmt, arg);
write(2, buffer, strlen(buffer));
}
#endif
Autor: Karol Gołąb