1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "thread.h"
18
19 #include <sys/syscall.h>
20 #include <sys/types.h>
21
22 #include "asm_support_x86.h"
23 #include "base/macros.h"
24 #include "thread-inl.h"
25 #include "thread_list.h"
26
27 #if defined(__APPLE__)
28 #include <architecture/i386/table.h>
29 #include <i386/user_ldt.h>
30 struct descriptor_table_entry_t {
31 uint16_t limit0;
32 uint16_t base0;
33 unsigned base1: 8, type: 4, s: 1, dpl: 2, p: 1;
34 unsigned limit: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
35 } __attribute__((packed));
36 #define MODIFY_LDT_CONTENTS_DATA 0
37 #else
38 #include <asm/ldt.h>
39 #endif
40
41 namespace art {
42
InitCpu()43 void Thread::InitCpu() {
44 // Take the ldt lock, Thread::Current isn't yet established.
45 MutexLock mu(nullptr, *Locks::modify_ldt_lock_);
46
47 const uintptr_t base = reinterpret_cast<uintptr_t>(this);
48 const size_t limit = sizeof(Thread);
49
50 const int contents = MODIFY_LDT_CONTENTS_DATA;
51 const int seg_32bit = 1;
52 const int read_exec_only = 0;
53 const int limit_in_pages = 1;
54 const int seg_not_present = 0;
55 const int useable = 1;
56
57 int entry_number;
58 uint16_t table_indicator;
59
60 #if defined(__APPLE__)
61 descriptor_table_entry_t entry;
62 memset(&entry, 0, sizeof(entry));
63 entry.limit0 = (limit & 0x0ffff);
64 entry.limit = (limit & 0xf0000) >> 16;
65 entry.base0 = (base & 0x0000ffff);
66 entry.base1 = (base & 0x00ff0000) >> 16;
67 entry.base2 = (base & 0xff000000) >> 24;
68 entry.type = ((read_exec_only ^ 1) << 1) | (contents << 2);
69 entry.s = 1;
70 entry.dpl = 0x3;
71 entry.p = seg_not_present ^ 1;
72 entry.avl = useable;
73 entry.l = 0;
74 entry.d = seg_32bit;
75 entry.g = limit_in_pages;
76
77 entry_number = i386_set_ldt(LDT_AUTO_ALLOC, reinterpret_cast<ldt_entry*>(&entry), 1);
78 if (entry_number == -1) {
79 PLOG(FATAL) << "i386_set_ldt failed";
80 }
81
82 table_indicator = 1 << 2; // LDT
83 #else
84 // We use a GDT entry on Linux.
85 user_desc gdt_entry;
86 memset(&gdt_entry, 0, sizeof(gdt_entry));
87
88 // On Linux, there are 3 TLS GDT entries. We use one of those to to store our segment descriptor
89 // data.
90 //
91 // This entry must be shared, as the kernel only guarantees three TLS entries. For simplicity
92 // (and locality), use this local global, which practically becomes readonly after the first
93 // (startup) thread of the runtime has been initialized (during Runtime::Start()).
94 //
95 // We also share this between all runtimes in the process. This is both for simplicity (one
96 // well-known slot) as well as to avoid the three-slot limitation. Downside is that we cannot
97 // free the slot when it is known that a runtime stops.
98 static unsigned int gdt_entry_number = -1;
99
100 if (gdt_entry_number == static_cast<unsigned int>(-1)) {
101 gdt_entry.entry_number = -1; // Let the kernel choose.
102 } else {
103 gdt_entry.entry_number = gdt_entry_number;
104 }
105 gdt_entry.base_addr = base;
106 gdt_entry.limit = limit;
107 gdt_entry.seg_32bit = seg_32bit;
108 gdt_entry.contents = contents;
109 gdt_entry.read_exec_only = read_exec_only;
110 gdt_entry.limit_in_pages = limit_in_pages;
111 gdt_entry.seg_not_present = seg_not_present;
112 gdt_entry.useable = useable;
113 int rc = syscall(__NR_set_thread_area, &gdt_entry);
114 if (rc != -1) {
115 entry_number = gdt_entry.entry_number;
116 if (gdt_entry_number == static_cast<unsigned int>(-1)) {
117 gdt_entry_number = entry_number; // Save the kernel-assigned entry number.
118 }
119 } else {
120 PLOG(FATAL) << "set_thread_area failed";
121 UNREACHABLE();
122 }
123 table_indicator = 0; // GDT
124 #endif
125
126 // Change %fs to be new DT entry.
127 uint16_t rpl = 3; // Requested privilege level
128 uint16_t selector = (entry_number << 3) | table_indicator | rpl;
129 __asm__ __volatile__("movw %w0, %%fs"
130 : // output
131 : "q"(selector) // input
132 :); // clobber
133
134 // Allow easy indirection back to Thread*.
135 tlsPtr_.self = this;
136
137 // Sanity check that reads from %fs point to this Thread*.
138 Thread* self_check;
139 CHECK_EQ(THREAD_SELF_OFFSET, SelfOffset<4>().Int32Value());
140 __asm__ __volatile__("movl %%fs:(%1), %0"
141 : "=r"(self_check) // output
142 : "r"(THREAD_SELF_OFFSET) // input
143 :); // clobber
144 CHECK_EQ(self_check, this);
145
146 // Sanity check other offsets.
147 CHECK_EQ(THREAD_EXCEPTION_OFFSET, ExceptionOffset<4>().Int32Value());
148 CHECK_EQ(THREAD_CARD_TABLE_OFFSET, CardTableOffset<4>().Int32Value());
149 CHECK_EQ(THREAD_ID_OFFSET, ThinLockIdOffset<4>().Int32Value());
150 }
151
CleanupCpu()152 void Thread::CleanupCpu() {
153 MutexLock mu(this, *Locks::modify_ldt_lock_);
154
155 // Sanity check that reads from %fs point to this Thread*.
156 Thread* self_check;
157 __asm__ __volatile__("movl %%fs:(%1), %0"
158 : "=r"(self_check) // output
159 : "r"(THREAD_SELF_OFFSET) // input
160 :); // clobber
161 CHECK_EQ(self_check, this);
162
163 // Extract the LDT entry number from the FS register.
164 uint16_t selector;
165 __asm__ __volatile__("movw %%fs, %w0"
166 : "=q"(selector) // output
167 : // input
168 :); // clobber
169
170 // Free LDT entry.
171 #if defined(__APPLE__)
172 // TODO: release selectors on OS/X this is a leak which will cause ldt entries to be exhausted
173 // after enough threads are created. However, the following code results in kernel panics in OS/X
174 // 10.9.
175 UNUSED(selector);
176 // i386_set_ldt(selector >> 3, 0, 1);
177 #else
178 // Note if we wanted to clean up the GDT entry, we would do that here, when the *last* thread
179 // is being deleted. But see the comment on gdt_entry_number. Code would look like this:
180 //
181 // user_desc gdt_entry;
182 // memset(&gdt_entry, 0, sizeof(gdt_entry));
183 // gdt_entry.entry_number = selector >> 3;
184 // gdt_entry.contents = MODIFY_LDT_CONTENTS_DATA;
185 // // "Empty" = Delete = seg_not_present==1 && read_exec_only==1.
186 // gdt_entry.seg_not_present = 1;
187 // gdt_entry.read_exec_only = 1;
188 // syscall(__NR_set_thread_area, &gdt_entry);
189 UNUSED(selector);
190 #endif
191 }
192
193 } // namespace art
194