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> 30struct 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 41namespace art { 42 43void 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 139void 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