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