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-current-inl.h"
26 #include "thread_list.h"
27 
28 #if defined(__APPLE__)
29 #include <architecture/i386/table.h>
30 #include <i386/user_ldt.h>
31 struct 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 
42 namespace art {
43 
InitCpu()44 void 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 
CleanupCpu()153 void 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