1 #define SYSCALL_NO_TLS 1
2 #include <elf.h>
3 #include <limits.h>
4 #include <sys/mman.h>
5 #include <string.h>
6 #include <stddef.h>
7 #include "pthread_impl.h"
8 #include "libc.h"
9 #include "atomic.h"
10 #include "syscall.h"
11 #ifdef __LITEOS_A__
12 #include "stdio_impl.h"
13 #include "lock.h"
14
15 static void *dummy_tsd[1] = { 0 };
16 weak_alias(dummy_tsd, __pthread_tsd_main);
17 static FILE *volatile dummy_file = 0;
18 weak_alias(dummy_file, __stdin_used);
19 weak_alias(dummy_file, __stdout_used);
20 weak_alias(dummy_file, __stderr_used);
21
dummy_0()22 static void dummy_0()
23 {
24 }
25 weak_alias(dummy_0, __membarrier_init);
26
init_file_lock(FILE * f)27 static void init_file_lock(FILE *f)
28 {
29 if (f && f->lock<0) f->lock = 0;
30 }
31 #endif
32 volatile int __thread_list_lock;
33
__init_tp(void * p)34 int __init_tp(void *p)
35 {
36 pthread_t td = p;
37 td->self = td;
38 int r = __set_thread_area(TP_ADJ(p));
39 if (r < 0) return -1;
40 if (!r) libc.can_do_threads = 1;
41 td->detach_state = DT_JOINABLE;
42 td->tid = td->pid = __syscall(SYS_set_tid_address, &__thread_list_lock);
43 td->proc_tid = -1;
44 td->locale = &libc.global_locale;
45 td->robust_list.head = &td->robust_list.head;
46 td->sysinfo = __sysinfo;
47 td->next = td->prev = td;
48 #ifdef __LITEOS_A__
49 libc.threaded = 0;
50 td->tid = __syscall(SYS_gettid);
51 td->pid = __syscall(SYS_getpid);
52 td->tsd = (void **)__pthread_tsd_main;
53 for (FILE *f = *__ofl_lock(); f; f = f->next)
54 init_file_lock(f);
55 __ofl_unlock();
56 init_file_lock(__stdin_used);
57 init_file_lock(__stdout_used);
58 init_file_lock(__stderr_used);
59 __syscall(SYS_rt_sigprocmask, SIG_UNBLOCK, SIGPT_SET, 0, _NSIG/8);
60 libc.threaded = 1;
61 #endif
62 return 0;
63 }
64
65 static struct builtin_tls {
66 char c[8];
67 struct pthread pt;
68 void *space[16];
69 } builtin_tls[1];
70 #define MIN_TLS_ALIGN offsetof(struct builtin_tls, pt)
71
72 static struct tls_module main_tls;
73
74 #ifdef ENABLE_HWASAN
75 __attribute__((no_sanitize("hwaddress")))
76 #endif
__copy_tls(unsigned char * mem)77 void *__copy_tls(unsigned char *mem)
78 {
79 pthread_t td;
80 struct tls_module *p;
81 size_t i;
82 uintptr_t *dtv;
83
84 #ifdef TLS_ABOVE_TP
85 dtv = (uintptr_t*)(mem + libc.tls_size) - (libc.tls_cnt + 1);
86
87 mem += -((uintptr_t)mem + sizeof(struct pthread)) & (libc.tls_align-1);
88 td = (pthread_t)mem;
89 mem += sizeof(struct pthread);
90
91 for (i=1, p=libc.tls_head; p; i++, p=p->next) {
92 dtv[i] = (uintptr_t)(mem + p->offset) + DTP_OFFSET;
93 if (p->image) {
94 memcpy(mem + p->offset, p->image, p->len);
95 }
96 }
97 #else
98 dtv = (uintptr_t *)mem;
99
100 mem += libc.tls_size - sizeof(struct pthread);
101 mem -= (uintptr_t)mem & (libc.tls_align-1);
102 td = (pthread_t)mem;
103
104 for (i=1, p=libc.tls_head; p; i++, p=p->next) {
105 dtv[i] = (uintptr_t)(mem - p->offset) + DTP_OFFSET;
106 if (p->image) {
107 memcpy(mem - p->offset, p->image, p->len);
108 }
109 }
110 #endif
111 dtv[0] = libc.tls_cnt;
112 td->dtv = dtv;
113 return td;
114 }
115
116 #if ULONG_MAX == 0xffffffff
117 typedef Elf32_Phdr Phdr;
118 #else
119 typedef Elf64_Phdr Phdr;
120 #endif
121
122 extern weak hidden const size_t _DYNAMIC[];
123
static_init_tls(size_t * aux)124 static void static_init_tls(size_t *aux)
125 {
126 unsigned char *p;
127 size_t n;
128 Phdr *phdr, *tls_phdr=0;
129 size_t base = 0;
130 void *mem;
131
132 for (p=(void *)aux[AT_PHDR],n=aux[AT_PHNUM]; n; n--,p+=aux[AT_PHENT]) {
133 phdr = (void *)p;
134 if (phdr->p_type == PT_PHDR)
135 base = aux[AT_PHDR] - phdr->p_vaddr;
136 if (phdr->p_type == PT_DYNAMIC && _DYNAMIC)
137 base = (size_t)_DYNAMIC - phdr->p_vaddr;
138 if (phdr->p_type == PT_TLS)
139 tls_phdr = phdr;
140 if (phdr->p_type == PT_GNU_STACK &&
141 phdr->p_memsz > __default_stacksize)
142 __default_stacksize =
143 phdr->p_memsz < DEFAULT_STACK_MAX ?
144 phdr->p_memsz : DEFAULT_STACK_MAX;
145 }
146
147 if (tls_phdr) {
148 main_tls.image = (void *)(base + tls_phdr->p_vaddr);
149 main_tls.len = tls_phdr->p_filesz;
150 main_tls.size = tls_phdr->p_memsz;
151 main_tls.align = tls_phdr->p_align;
152 libc.tls_cnt = 1;
153 libc.tls_head = &main_tls;
154 }
155
156 main_tls.size += (-main_tls.size - (uintptr_t)main_tls.image)
157 & (main_tls.align-1);
158 #ifdef TLS_ABOVE_TP
159 main_tls.offset = GAP_ABOVE_TP;
160 main_tls.offset += (-GAP_ABOVE_TP + (uintptr_t)main_tls.image)
161 & (main_tls.align-1);
162 #else
163 main_tls.offset = main_tls.size;
164 #endif
165 if (main_tls.align < MIN_TLS_ALIGN) main_tls.align = MIN_TLS_ALIGN;
166
167 libc.tls_align = main_tls.align;
168 libc.tls_size = 2*sizeof(void *) + sizeof(struct pthread)
169 #ifdef TLS_ABOVE_TP
170 + main_tls.offset
171 #endif
172 + main_tls.size + main_tls.align
173 + MIN_TLS_ALIGN-1 & -MIN_TLS_ALIGN;
174
175 if (libc.tls_size > sizeof builtin_tls) {
176 #ifndef SYS_mmap2
177 #define SYS_mmap2 SYS_mmap
178 #endif
179 mem = (void *)__syscall(
180 SYS_mmap2,
181 0, libc.tls_size, PROT_READ|PROT_WRITE,
182 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
183 /* -4095...-1 cast to void * will crash on dereference anyway,
184 * so don't bloat the init code checking for error codes and
185 * explicitly calling a_crash(). */
186 } else {
187 mem = builtin_tls;
188 }
189
190 /* Failure to initialize thread pointer is always fatal. */
191 if (__init_tp(__copy_tls(mem)) < 0)
192 a_crash();
193 }
194
195 weak_alias(static_init_tls, __init_tls);
196