nsz Git - musl/blob - src/thread/pthread_create.c

   1 #include "pthread_impl.h"
   2
   3 static void dummy_0()
   4 {
   5 }
   6 weak_alias(dummy_0, __rsyscall_lock);
   7 weak_alias(dummy_0, __rsyscall_unlock);
   8
   9 static void dummy_1(pthread_t self)
  10 {
  11 }
  12 weak_alias(dummy_1, __pthread_tsd_run_dtors);
  13 weak_alias(dummy_1, __sigtimer_handler);
  14
  15 #ifdef __pthread_unwind_next
  16 #undef __pthread_unwind_next
  17 #define __pthread_unwind_next __pthread_unwind_next_3
  18 #endif
  19
  20 void __pthread_unwind_next(struct __ptcb *cb)
  21 {
  22         pthread_t self;
  23
  24         if (cb->__next) longjmp((void *)cb->__next->__jb, 1);
  25
  26         self = pthread_self();
  27
  28         LOCK(&self->exitlock);
  29
  30         __pthread_tsd_run_dtors(self);
  31
  32         /* Mark this thread dead before decrementing count */
  33         self->dead = 1;
  34
  35         if (!a_fetch_add(&libc.threads_minus_1, -1))
  36                 exit(0);
  37
  38         if (self->detached && self->map_base) {
  39                 __syscall(SYS_rt_sigprocmask, SIG_BLOCK, (long)(uint64_t[1]){-1},0,8);
  40                 __unmapself(self->map_base, self->map_size);
  41         }
  42
  43         __syscall(SYS_exit, 0);
  44 }
  45
  46 static void docancel(struct pthread *self)
  47 {
  48         struct __ptcb cb = { .__next = self->cancelbuf };
  49         self->canceldisable = 1;
  50         self->cancelasync = 0;
  51         __pthread_unwind_next(&cb);
  52 }
  53
  54 static void cancel_handler(int sig, siginfo_t *si, void *ctx)
  55 {
  56         struct pthread *self = __pthread_self();
  57         if (si->si_code == SI_TIMER) __sigtimer_handler(self);
  58         if (self->cancel && !self->canceldisable &&
  59             (self->cancelasync || (self->cancelpoint==1 && PC_AT_SYS(ctx))))
  60                 docancel(self);
  61 }
  62
  63 static void cancelpt(int x)
  64 {
  65         struct pthread *self = __pthread_self();
  66         switch (x) {
  67         case 1:
  68                 self->cancelpoint++;
  69         case 0:
  70                 if (self->cancel && self->cancelpoint==1 && !self->canceldisable)
  71                         docancel(self);
  72                 break;
  73         case -1:
  74                 self->cancelpoint--;
  75                 break;
  76         default:
  77                 self->canceldisable += x;
  78         }
  79 }
  80
  81 static void init_threads()
  82 {
  83         struct sigaction sa = { .sa_flags = SA_SIGINFO | SA_RESTART };
  84         libc.lock = __lock;
  85         libc.lockfile = __lockfile;
  86         libc.cancelpt = cancelpt;
  87
  88         sigemptyset(&sa.sa_mask);
  89         sa.sa_sigaction = cancel_handler;
  90         __libc_sigaction(SIGCANCEL, &sa, 0);
  91
  92         sigaddset(&sa.sa_mask, SIGSYSCALL);
  93         sigaddset(&sa.sa_mask, SIGCANCEL);
  94         __libc_sigprocmask(SIG_UNBLOCK, &sa.sa_mask, 0);
  95 }
  96
  97 static int start(void *p)
  98 {
  99         struct pthread *self = p;
 100         if (self->unblock_cancel) {
 101                 sigset_t set;
 102                 sigemptyset(&set);
 103                 sigaddset(&set, SIGCANCEL);
 104                 __libc_sigprocmask(SIG_UNBLOCK, &set, 0);
 105         }
 106         pthread_exit(self->start(self->start_arg));
 107         return 0;
 108 }
 109
 110 int __uniclone(void *, int (*)(), void *);
 111
 112 #define ROUND(x) (((x)+PAGE_SIZE-1)&-PAGE_SIZE)
 113
 114 /* pthread_key_create.c overrides this */
 115 static const size_t dummy = 0;
 116 weak_alias(dummy, __pthread_tsd_size);
 117
 118 int pthread_create(pthread_t *res, const pthread_attr_t *attr, void *(*entry)(void *), void *arg)
 119 {
 120         static int init;
 121         int ret;
 122         size_t size, guard;
 123         struct pthread *self = pthread_self(), *new;
 124         unsigned char *map, *stack, *tsd;
 125         const pthread_attr_t default_attr = { 0 };
 126
 127         if (!self) return ENOSYS;
 128         if (!init && ++init) init_threads();
 129
 130         if (!attr) attr = &default_attr;
 131         guard = ROUND(attr->_a_guardsize + DEFAULT_GUARD_SIZE);
 132         size = guard + ROUND(attr->_a_stacksize + DEFAULT_STACK_SIZE);
 133         size += __pthread_tsd_size;
 134         map = mmap(0, size, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANON, -1, 0);
 135         if (!map) return EAGAIN;
 136         if (guard) mprotect(map, guard, PROT_NONE);
 137
 138         tsd = map + size - __pthread_tsd_size;
 139         new = (void *)(tsd - sizeof *new - PAGE_SIZE%sizeof *new);
 140         new->map_base = map;
 141         new->map_size = size;
 142         new->pid = self->pid;
 143         new->errno_ptr = &new->errno_val;
 144         new->start = entry;
 145         new->start_arg = arg;
 146         new->self = new;
 147         new->tsd = (void *)tsd;
 148         new->detached = attr->_a_detach;
 149         new->attr = *attr;
 150         new->unblock_cancel = self->cancel;
 151         new->result = PTHREAD_CANCELED;
 152         memcpy(new->tlsdesc, self->tlsdesc, sizeof new->tlsdesc);
 153         new->tlsdesc[1] = (uintptr_t)new;
 154         stack = (void *)((uintptr_t)new-1 & ~(uintptr_t)15);
 155
 156         __rsyscall_lock();
 157
 158         a_inc(&libc.threads_minus_1);
 159         ret = __uniclone(stack, start, new);
 160
 161         __rsyscall_unlock();
 162
 163         if (ret < 0) {
 164                 a_dec(&libc.threads_minus_1);
 165                 munmap(map, size);
 166                 return EAGAIN;
 167         }
 168         *res = new;
 169         return 0;
 170 }
 171
 172 void pthread_exit(void *result)
 173 {
 174         struct pthread *self = pthread_self();
 175         self->result = result;
 176         docancel(self);
 177 }