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 = kPageSize;
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 = 0;
54 const int seg_not_present = 0;
55 const int useable = 1;
56
57 int entry_number = -1;
58
59 #if defined(__APPLE__)
60 descriptor_table_entry_t entry;
61 memset(&entry, 0, sizeof(entry));
62 entry.limit0 = (limit & 0x0ffff);
63 entry.limit = (limit & 0xf0000) >> 16;
64 entry.base0 = (base & 0x0000ffff);
65 entry.base1 = (base & 0x00ff0000) >> 16;
66 entry.base2 = (base & 0xff000000) >> 24;
67 entry.type = ((read_exec_only ^ 1) << 1) | (contents << 2);
68 entry.s = 1;
69 entry.dpl = 0x3;
70 entry.p = seg_not_present ^ 1;
71 entry.avl = useable;
72 entry.l = 0;
73 entry.d = seg_32bit;
74 entry.g = limit_in_pages;
75
76 entry_number = i386_set_ldt(LDT_AUTO_ALLOC, reinterpret_cast<ldt_entry*>(&entry), 1);
77 if (entry_number == -1) {
78 PLOG(FATAL) << "i386_set_ldt failed";
79 }
80 #else
81 // Read current LDT entries.
82 CHECK_EQ((size_t)LDT_ENTRY_SIZE, sizeof(uint64_t));
83 std::vector<uint64_t> ldt(LDT_ENTRIES);
84 size_t ldt_size(sizeof(uint64_t) * ldt.size());
85 memset(&ldt[0], 0, ldt_size);
86 // TODO: why doesn't this return LDT_ENTRY_SIZE * LDT_ENTRIES for the main thread?
87 syscall(__NR_modify_ldt, 0, &ldt[0], ldt_size);
88
89 // Find the first empty slot.
90 for (entry_number = 0; entry_number < LDT_ENTRIES && ldt[entry_number] != 0; ++entry_number) {
91 }
92 if (entry_number >= LDT_ENTRIES) {
93 LOG(FATAL) << "Failed to find a free LDT slot";
94 }
95
96 // Update LDT entry.
97 user_desc ldt_entry;
98 memset(&ldt_entry, 0, sizeof(ldt_entry));
99 ldt_entry.entry_number = entry_number;
100 ldt_entry.base_addr = base;
101 ldt_entry.limit = limit;
102 ldt_entry.seg_32bit = seg_32bit;
103 ldt_entry.contents = contents;
104 ldt_entry.read_exec_only = read_exec_only;
105 ldt_entry.limit_in_pages = limit_in_pages;
106 ldt_entry.seg_not_present = seg_not_present;
107 ldt_entry.useable = useable;
108 CHECK_EQ(0, syscall(__NR_modify_ldt, 1, &ldt_entry, sizeof(ldt_entry)));
109 entry_number = ldt_entry.entry_number;
110 #endif
111
112 // Change %fs to be new LDT entry.
113 uint16_t table_indicator = 1 << 2; // LDT
114 uint16_t rpl = 3; // Requested privilege level
115 uint16_t selector = (entry_number << 3) | table_indicator | rpl;
116 __asm__ __volatile__("movw %w0, %%fs"
117 : // output
118 : "q"(selector) // input
119 :); // clobber
120
121 // Allow easy indirection back to Thread*.
122 tlsPtr_.self = this;
123
124 // Sanity check that reads from %fs point to this Thread*.
125 Thread* self_check;
126 CHECK_EQ(THREAD_SELF_OFFSET, SelfOffset<4>().Int32Value());
127 __asm__ __volatile__("movl %%fs:(%1), %0"
128 : "=r"(self_check) // output
129 : "r"(THREAD_SELF_OFFSET) // input
130 :); // clobber
131 CHECK_EQ(self_check, this);
132
133 // Sanity check other offsets.
134 CHECK_EQ(THREAD_EXCEPTION_OFFSET, ExceptionOffset<4>().Int32Value());
135 CHECK_EQ(THREAD_CARD_TABLE_OFFSET, CardTableOffset<4>().Int32Value());
136 CHECK_EQ(THREAD_ID_OFFSET, ThinLockIdOffset<4>().Int32Value());
137 }
138
CleanupCpu()139 void Thread::CleanupCpu() {
140 MutexLock mu(this, *Locks::modify_ldt_lock_);
141
142 // Sanity check that reads from %fs point to this Thread*.
143 Thread* self_check;
144 __asm__ __volatile__("movl %%fs:(%1), %0"
145 : "=r"(self_check) // output
146 : "r"(THREAD_SELF_OFFSET) // input
147 :); // clobber
148 CHECK_EQ(self_check, this);
149
150 // Extract the LDT entry number from the FS register.
151 uint16_t selector;
152 __asm__ __volatile__("movw %%fs, %w0"
153 : "=q"(selector) // output
154 : // input
155 :); // clobber
156
157 // Free LDT entry.
158 #if defined(__APPLE__)
159 // TODO: release selectors on OS/X this is a leak which will cause ldt entries to be exhausted
160 // after enough threads are created. However, the following code results in kernel panics in OS/X
161 // 10.9.
162 UNUSED(selector);
163 // i386_set_ldt(selector >> 3, 0, 1);
164 #else
165 user_desc ldt_entry;
166 memset(&ldt_entry, 0, sizeof(ldt_entry));
167 ldt_entry.entry_number = selector >> 3;
168 ldt_entry.contents = MODIFY_LDT_CONTENTS_DATA;
169 ldt_entry.seg_not_present = 1;
170
171 syscall(__NR_modify_ldt, 1, &ldt_entry, sizeof(ldt_entry));
172 #endif
173 }
174
175 } // namespace art
176