1 /* 2 * Copyright (C) 2005 Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it> 3 * Licensed under the GPL 4 */ 5 6 #include <linux/percpu.h> 7 #include <linux/sched.h> 8 #include <linux/syscalls.h> 9 #include <linux/uaccess.h> 10 #include <asm/ptrace-abi.h> 11 #include <os.h> 12 #include <skas.h> 13 #include <sysdep/tls.h> 14 #include <asm/desc.h> 15 16 /* 17 * If needed we can detect when it's uninitialized. 18 * 19 * These are initialized in an initcall and unchanged thereafter. 20 */ 21 static int host_supports_tls = -1; 22 int host_gdt_entry_tls_min; 23 24 static int do_set_thread_area(struct user_desc *info) 25 { 26 int ret; 27 u32 cpu; 28 29 cpu = get_cpu(); 30 ret = os_set_thread_area(info, userspace_pid[cpu]); 31 put_cpu(); 32 33 if (ret) 34 printk(KERN_ERR "PTRACE_SET_THREAD_AREA failed, err = %d, " 35 "index = %d\n", ret, info->entry_number); 36 37 return ret; 38 } 39 40 /* 41 * sys_get_thread_area: get a yet unused TLS descriptor index. 42 * XXX: Consider leaving one free slot for glibc usage at first place. This must 43 * be done here (and by changing GDT_ENTRY_TLS_* macros) and nowhere else. 44 * 45 * Also, this must be tested when compiling in SKAS mode with dynamic linking 46 * and running against NPTL. 47 */ 48 static int get_free_idx(struct task_struct* task) 49 { 50 struct thread_struct *t = &task->thread; 51 int idx; 52 53 for (idx = 0; idx < GDT_ENTRY_TLS_ENTRIES; idx++) 54 if (!t->arch.tls_array[idx].present) 55 return idx + GDT_ENTRY_TLS_MIN; 56 return -ESRCH; 57 } 58 59 static inline void clear_user_desc(struct user_desc* info) 60 { 61 /* Postcondition: LDT_empty(info) returns true. */ 62 memset(info, 0, sizeof(*info)); 63 64 /* 65 * Check the LDT_empty or the i386 sys_get_thread_area code - we obtain 66 * indeed an empty user_desc. 67 */ 68 info->read_exec_only = 1; 69 info->seg_not_present = 1; 70 } 71 72 #define O_FORCE 1 73 74 static int load_TLS(int flags, struct task_struct *to) 75 { 76 int ret = 0; 77 int idx; 78 79 for (idx = GDT_ENTRY_TLS_MIN; idx < GDT_ENTRY_TLS_MAX; idx++) { 80 struct uml_tls_struct* curr = 81 &to->thread.arch.tls_array[idx - GDT_ENTRY_TLS_MIN]; 82 83 /* 84 * Actually, now if it wasn't flushed it gets cleared and 85 * flushed to the host, which will clear it. 86 */ 87 if (!curr->present) { 88 if (!curr->flushed) { 89 clear_user_desc(&curr->tls); 90 curr->tls.entry_number = idx; 91 } else { 92 WARN_ON(!LDT_empty(&curr->tls)); 93 continue; 94 } 95 } 96 97 if (!(flags & O_FORCE) && curr->flushed) 98 continue; 99 100 ret = do_set_thread_area(&curr->tls); 101 if (ret) 102 goto out; 103 104 curr->flushed = 1; 105 } 106 out: 107 return ret; 108 } 109 110 /* 111 * Verify if we need to do a flush for the new process, i.e. if there are any 112 * present desc's, only if they haven't been flushed. 113 */ 114 static inline int needs_TLS_update(struct task_struct *task) 115 { 116 int i; 117 int ret = 0; 118 119 for (i = GDT_ENTRY_TLS_MIN; i < GDT_ENTRY_TLS_MAX; i++) { 120 struct uml_tls_struct* curr = 121 &task->thread.arch.tls_array[i - GDT_ENTRY_TLS_MIN]; 122 123 /* 124 * Can't test curr->present, we may need to clear a descriptor 125 * which had a value. 126 */ 127 if (curr->flushed) 128 continue; 129 ret = 1; 130 break; 131 } 132 return ret; 133 } 134 135 /* 136 * On a newly forked process, the TLS descriptors haven't yet been flushed. So 137 * we mark them as such and the first switch_to will do the job. 138 */ 139 void clear_flushed_tls(struct task_struct *task) 140 { 141 int i; 142 143 for (i = GDT_ENTRY_TLS_MIN; i < GDT_ENTRY_TLS_MAX; i++) { 144 struct uml_tls_struct* curr = 145 &task->thread.arch.tls_array[i - GDT_ENTRY_TLS_MIN]; 146 147 /* 148 * Still correct to do this, if it wasn't present on the host it 149 * will remain as flushed as it was. 150 */ 151 if (!curr->present) 152 continue; 153 154 curr->flushed = 0; 155 } 156 } 157 158 /* 159 * In SKAS0 mode, currently, multiple guest threads sharing the same ->mm have a 160 * common host process. So this is needed in SKAS0 too. 161 * 162 * However, if each thread had a different host process (and this was discussed 163 * for SMP support) this won't be needed. 164 * 165 * And this will not need be used when (and if) we'll add support to the host 166 * SKAS patch. 167 */ 168 169 int arch_switch_tls(struct task_struct *to) 170 { 171 if (!host_supports_tls) 172 return 0; 173 174 /* 175 * We have no need whatsoever to switch TLS for kernel threads; beyond 176 * that, that would also result in us calling os_set_thread_area with 177 * userspace_pid[cpu] == 0, which gives an error. 178 */ 179 if (likely(to->mm)) 180 return load_TLS(O_FORCE, to); 181 182 return 0; 183 } 184 185 static int set_tls_entry(struct task_struct* task, struct user_desc *info, 186 int idx, int flushed) 187 { 188 struct thread_struct *t = &task->thread; 189 190 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) 191 return -EINVAL; 192 193 t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].tls = *info; 194 t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].present = 1; 195 t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].flushed = flushed; 196 197 return 0; 198 } 199 200 int arch_set_tls(struct task_struct *new, unsigned long tls) 201 { 202 struct user_desc info; 203 int idx, ret = -EFAULT; 204 205 if (copy_from_user(&info, (void __user *) tls, sizeof(info))) 206 goto out; 207 208 ret = -EINVAL; 209 if (LDT_empty(&info)) 210 goto out; 211 212 idx = info.entry_number; 213 214 ret = set_tls_entry(new, &info, idx, 0); 215 out: 216 return ret; 217 } 218 219 static int get_tls_entry(struct task_struct *task, struct user_desc *info, 220 int idx) 221 { 222 struct thread_struct *t = &task->thread; 223 224 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX) 225 return -EINVAL; 226 227 if (!t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].present) 228 goto clear; 229 230 *info = t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].tls; 231 232 out: 233 /* 234 * Temporary debugging check, to make sure that things have been 235 * flushed. This could be triggered if load_TLS() failed. 236 */ 237 if (unlikely(task == current && 238 !t->arch.tls_array[idx - GDT_ENTRY_TLS_MIN].flushed)) { 239 printk(KERN_ERR "get_tls_entry: task with pid %d got here " 240 "without flushed TLS.", current->pid); 241 } 242 243 return 0; 244 clear: 245 /* 246 * When the TLS entry has not been set, the values read to user in the 247 * tls_array are 0 (because it's cleared at boot, see 248 * arch/i386/kernel/head.S:cpu_gdt_table). Emulate that. 249 */ 250 clear_user_desc(info); 251 info->entry_number = idx; 252 goto out; 253 } 254 255 SYSCALL_DEFINE1(set_thread_area, struct user_desc __user *, user_desc) 256 { 257 struct user_desc info; 258 int idx, ret; 259 260 if (!host_supports_tls) 261 return -ENOSYS; 262 263 if (copy_from_user(&info, user_desc, sizeof(info))) 264 return -EFAULT; 265 266 idx = info.entry_number; 267 268 if (idx == -1) { 269 idx = get_free_idx(current); 270 if (idx < 0) 271 return idx; 272 info.entry_number = idx; 273 /* Tell the user which slot we chose for him.*/ 274 if (put_user(idx, &user_desc->entry_number)) 275 return -EFAULT; 276 } 277 278 ret = do_set_thread_area(&info); 279 if (ret) 280 return ret; 281 return set_tls_entry(current, &info, idx, 1); 282 } 283 284 /* 285 * Perform set_thread_area on behalf of the traced child. 286 * Note: error handling is not done on the deferred load, and this differ from 287 * i386. However the only possible error are caused by bugs. 288 */ 289 int ptrace_set_thread_area(struct task_struct *child, int idx, 290 struct user_desc __user *user_desc) 291 { 292 struct user_desc info; 293 294 if (!host_supports_tls) 295 return -EIO; 296 297 if (copy_from_user(&info, user_desc, sizeof(info))) 298 return -EFAULT; 299 300 return set_tls_entry(child, &info, idx, 0); 301 } 302 303 SYSCALL_DEFINE1(get_thread_area, struct user_desc __user *, user_desc) 304 { 305 struct user_desc info; 306 int idx, ret; 307 308 if (!host_supports_tls) 309 return -ENOSYS; 310 311 if (get_user(idx, &user_desc->entry_number)) 312 return -EFAULT; 313 314 ret = get_tls_entry(current, &info, idx); 315 if (ret < 0) 316 goto out; 317 318 if (copy_to_user(user_desc, &info, sizeof(info))) 319 ret = -EFAULT; 320 321 out: 322 return ret; 323 } 324 325 /* 326 * Perform get_thread_area on behalf of the traced child. 327 */ 328 int ptrace_get_thread_area(struct task_struct *child, int idx, 329 struct user_desc __user *user_desc) 330 { 331 struct user_desc info; 332 int ret; 333 334 if (!host_supports_tls) 335 return -EIO; 336 337 ret = get_tls_entry(child, &info, idx); 338 if (ret < 0) 339 goto out; 340 341 if (copy_to_user(user_desc, &info, sizeof(info))) 342 ret = -EFAULT; 343 out: 344 return ret; 345 } 346 347 /* 348 * This code is really i386-only, but it detects and logs x86_64 GDT indexes 349 * if a 32-bit UML is running on a 64-bit host. 350 */ 351 static int __init __setup_host_supports_tls(void) 352 { 353 check_host_supports_tls(&host_supports_tls, &host_gdt_entry_tls_min); 354 if (host_supports_tls) { 355 printk(KERN_INFO "Host TLS support detected\n"); 356 printk(KERN_INFO "Detected host type: "); 357 switch (host_gdt_entry_tls_min) { 358 case GDT_ENTRY_TLS_MIN_I386: 359 printk(KERN_CONT "i386"); 360 break; 361 case GDT_ENTRY_TLS_MIN_X86_64: 362 printk(KERN_CONT "x86_64"); 363 break; 364 } 365 printk(KERN_CONT " (GDT indexes %d to %d)\n", 366 host_gdt_entry_tls_min, 367 host_gdt_entry_tls_min + GDT_ENTRY_TLS_ENTRIES); 368 } else 369 printk(KERN_ERR " Host TLS support NOT detected! " 370 "TLS support inside UML will not work\n"); 371 return 0; 372 } 373 374 __initcall(__setup_host_supports_tls); 375