1 /* 2 * Copyright (C) 1995 Linus Torvalds 3 * 4 * Pentium III FXSR, SSE support 5 * Gareth Hughes <gareth@valinux.com>, May 2000 6 * 7 * X86-64 port 8 * Andi Kleen. 9 * 10 * CPU hotplug support - ashok.raj@intel.com 11 */ 12 13 /* 14 * This file handles the architecture-dependent parts of process handling.. 15 */ 16 17 #include <stdarg.h> 18 19 #include <linux/cpu.h> 20 #include <linux/errno.h> 21 #include <linux/sched.h> 22 #include <linux/fs.h> 23 #include <linux/kernel.h> 24 #include <linux/mm.h> 25 #include <linux/elfcore.h> 26 #include <linux/smp.h> 27 #include <linux/slab.h> 28 #include <linux/user.h> 29 #include <linux/interrupt.h> 30 #include <linux/utsname.h> 31 #include <linux/delay.h> 32 #include <linux/module.h> 33 #include <linux/ptrace.h> 34 #include <linux/random.h> 35 #include <linux/notifier.h> 36 #include <linux/kprobes.h> 37 #include <linux/kdebug.h> 38 #include <linux/tick.h> 39 #include <linux/prctl.h> 40 #include <linux/uaccess.h> 41 #include <linux/io.h> 42 43 #include <asm/pgtable.h> 44 #include <asm/system.h> 45 #include <asm/processor.h> 46 #include <asm/i387.h> 47 #include <asm/mmu_context.h> 48 #include <asm/pda.h> 49 #include <asm/prctl.h> 50 #include <asm/desc.h> 51 #include <asm/proto.h> 52 #include <asm/ia32.h> 53 #include <asm/idle.h> 54 #include <asm/syscalls.h> 55 56 asmlinkage extern void ret_from_fork(void); 57 58 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED; 59 60 static ATOMIC_NOTIFIER_HEAD(idle_notifier); 61 62 void idle_notifier_register(struct notifier_block *n) 63 { 64 atomic_notifier_chain_register(&idle_notifier, n); 65 } 66 EXPORT_SYMBOL_GPL(idle_notifier_register); 67 68 void idle_notifier_unregister(struct notifier_block *n) 69 { 70 atomic_notifier_chain_unregister(&idle_notifier, n); 71 } 72 EXPORT_SYMBOL_GPL(idle_notifier_unregister); 73 74 void enter_idle(void) 75 { 76 write_pda(isidle, 1); 77 atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL); 78 } 79 80 static void __exit_idle(void) 81 { 82 if (test_and_clear_bit_pda(0, isidle) == 0) 83 return; 84 atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL); 85 } 86 87 /* Called from interrupts to signify idle end */ 88 void exit_idle(void) 89 { 90 /* idle loop has pid 0 */ 91 if (current->pid) 92 return; 93 __exit_idle(); 94 } 95 96 #ifndef CONFIG_SMP 97 static inline void play_dead(void) 98 { 99 BUG(); 100 } 101 #endif 102 103 /* 104 * The idle thread. There's no useful work to be 105 * done, so just try to conserve power and have a 106 * low exit latency (ie sit in a loop waiting for 107 * somebody to say that they'd like to reschedule) 108 */ 109 void cpu_idle(void) 110 { 111 current_thread_info()->status |= TS_POLLING; 112 /* endless idle loop with no priority at all */ 113 while (1) { 114 tick_nohz_stop_sched_tick(1); 115 while (!need_resched()) { 116 117 rmb(); 118 119 if (cpu_is_offline(smp_processor_id())) 120 play_dead(); 121 /* 122 * Idle routines should keep interrupts disabled 123 * from here on, until they go to idle. 124 * Otherwise, idle callbacks can misfire. 125 */ 126 local_irq_disable(); 127 enter_idle(); 128 /* Don't trace irqs off for idle */ 129 stop_critical_timings(); 130 pm_idle(); 131 start_critical_timings(); 132 /* In many cases the interrupt that ended idle 133 has already called exit_idle. But some idle 134 loops can be woken up without interrupt. */ 135 __exit_idle(); 136 } 137 138 tick_nohz_restart_sched_tick(); 139 preempt_enable_no_resched(); 140 schedule(); 141 preempt_disable(); 142 } 143 } 144 145 /* Prints also some state that isn't saved in the pt_regs */ 146 void __show_regs(struct pt_regs *regs, int all) 147 { 148 unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs; 149 unsigned long d0, d1, d2, d3, d6, d7; 150 unsigned int fsindex, gsindex; 151 unsigned int ds, cs, es; 152 153 printk("\n"); 154 print_modules(); 155 printk(KERN_INFO "Pid: %d, comm: %.20s %s %s %.*s\n", 156 current->pid, current->comm, print_tainted(), 157 init_utsname()->release, 158 (int)strcspn(init_utsname()->version, " "), 159 init_utsname()->version); 160 printk(KERN_INFO "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip); 161 printk_address(regs->ip, 1); 162 printk(KERN_INFO "RSP: %04lx:%016lx EFLAGS: %08lx\n", regs->ss, 163 regs->sp, regs->flags); 164 printk(KERN_INFO "RAX: %016lx RBX: %016lx RCX: %016lx\n", 165 regs->ax, regs->bx, regs->cx); 166 printk(KERN_INFO "RDX: %016lx RSI: %016lx RDI: %016lx\n", 167 regs->dx, regs->si, regs->di); 168 printk(KERN_INFO "RBP: %016lx R08: %016lx R09: %016lx\n", 169 regs->bp, regs->r8, regs->r9); 170 printk(KERN_INFO "R10: %016lx R11: %016lx R12: %016lx\n", 171 regs->r10, regs->r11, regs->r12); 172 printk(KERN_INFO "R13: %016lx R14: %016lx R15: %016lx\n", 173 regs->r13, regs->r14, regs->r15); 174 175 asm("movl %%ds,%0" : "=r" (ds)); 176 asm("movl %%cs,%0" : "=r" (cs)); 177 asm("movl %%es,%0" : "=r" (es)); 178 asm("movl %%fs,%0" : "=r" (fsindex)); 179 asm("movl %%gs,%0" : "=r" (gsindex)); 180 181 rdmsrl(MSR_FS_BASE, fs); 182 rdmsrl(MSR_GS_BASE, gs); 183 rdmsrl(MSR_KERNEL_GS_BASE, shadowgs); 184 185 if (!all) 186 return; 187 188 cr0 = read_cr0(); 189 cr2 = read_cr2(); 190 cr3 = read_cr3(); 191 cr4 = read_cr4(); 192 193 printk(KERN_INFO "FS: %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n", 194 fs, fsindex, gs, gsindex, shadowgs); 195 printk(KERN_INFO "CS: %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, 196 es, cr0); 197 printk(KERN_INFO "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, 198 cr4); 199 200 get_debugreg(d0, 0); 201 get_debugreg(d1, 1); 202 get_debugreg(d2, 2); 203 printk(KERN_INFO "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2); 204 get_debugreg(d3, 3); 205 get_debugreg(d6, 6); 206 get_debugreg(d7, 7); 207 printk(KERN_INFO "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7); 208 } 209 210 void show_regs(struct pt_regs *regs) 211 { 212 printk(KERN_INFO "CPU %d:", smp_processor_id()); 213 __show_regs(regs, 1); 214 show_trace(NULL, regs, (void *)(regs + 1), regs->bp); 215 } 216 217 /* 218 * Free current thread data structures etc.. 219 */ 220 void exit_thread(void) 221 { 222 struct task_struct *me = current; 223 struct thread_struct *t = &me->thread; 224 225 if (me->thread.io_bitmap_ptr) { 226 struct tss_struct *tss = &per_cpu(init_tss, get_cpu()); 227 228 kfree(t->io_bitmap_ptr); 229 t->io_bitmap_ptr = NULL; 230 clear_thread_flag(TIF_IO_BITMAP); 231 /* 232 * Careful, clear this in the TSS too: 233 */ 234 memset(tss->io_bitmap, 0xff, t->io_bitmap_max); 235 t->io_bitmap_max = 0; 236 put_cpu(); 237 } 238 #ifdef CONFIG_X86_DS 239 /* Free any DS contexts that have not been properly released. */ 240 if (unlikely(t->ds_ctx)) { 241 /* we clear debugctl to make sure DS is not used. */ 242 update_debugctlmsr(0); 243 ds_free(t->ds_ctx); 244 } 245 #endif /* CONFIG_X86_DS */ 246 } 247 248 void flush_thread(void) 249 { 250 struct task_struct *tsk = current; 251 252 if (test_tsk_thread_flag(tsk, TIF_ABI_PENDING)) { 253 clear_tsk_thread_flag(tsk, TIF_ABI_PENDING); 254 if (test_tsk_thread_flag(tsk, TIF_IA32)) { 255 clear_tsk_thread_flag(tsk, TIF_IA32); 256 } else { 257 set_tsk_thread_flag(tsk, TIF_IA32); 258 current_thread_info()->status |= TS_COMPAT; 259 } 260 } 261 clear_tsk_thread_flag(tsk, TIF_DEBUG); 262 263 tsk->thread.debugreg0 = 0; 264 tsk->thread.debugreg1 = 0; 265 tsk->thread.debugreg2 = 0; 266 tsk->thread.debugreg3 = 0; 267 tsk->thread.debugreg6 = 0; 268 tsk->thread.debugreg7 = 0; 269 memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array)); 270 /* 271 * Forget coprocessor state.. 272 */ 273 tsk->fpu_counter = 0; 274 clear_fpu(tsk); 275 clear_used_math(); 276 } 277 278 void release_thread(struct task_struct *dead_task) 279 { 280 if (dead_task->mm) { 281 if (dead_task->mm->context.size) { 282 printk("WARNING: dead process %8s still has LDT? <%p/%d>\n", 283 dead_task->comm, 284 dead_task->mm->context.ldt, 285 dead_task->mm->context.size); 286 BUG(); 287 } 288 } 289 } 290 291 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr) 292 { 293 struct user_desc ud = { 294 .base_addr = addr, 295 .limit = 0xfffff, 296 .seg_32bit = 1, 297 .limit_in_pages = 1, 298 .useable = 1, 299 }; 300 struct desc_struct *desc = t->thread.tls_array; 301 desc += tls; 302 fill_ldt(desc, &ud); 303 } 304 305 static inline u32 read_32bit_tls(struct task_struct *t, int tls) 306 { 307 return get_desc_base(&t->thread.tls_array[tls]); 308 } 309 310 /* 311 * This gets called before we allocate a new thread and copy 312 * the current task into it. 313 */ 314 void prepare_to_copy(struct task_struct *tsk) 315 { 316 unlazy_fpu(tsk); 317 } 318 319 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp, 320 unsigned long unused, 321 struct task_struct *p, struct pt_regs *regs) 322 { 323 int err; 324 struct pt_regs *childregs; 325 struct task_struct *me = current; 326 327 childregs = ((struct pt_regs *) 328 (THREAD_SIZE + task_stack_page(p))) - 1; 329 *childregs = *regs; 330 331 childregs->ax = 0; 332 childregs->sp = sp; 333 if (sp == ~0UL) 334 childregs->sp = (unsigned long)childregs; 335 336 p->thread.sp = (unsigned long) childregs; 337 p->thread.sp0 = (unsigned long) (childregs+1); 338 p->thread.usersp = me->thread.usersp; 339 340 set_tsk_thread_flag(p, TIF_FORK); 341 342 p->thread.fs = me->thread.fs; 343 p->thread.gs = me->thread.gs; 344 345 savesegment(gs, p->thread.gsindex); 346 savesegment(fs, p->thread.fsindex); 347 savesegment(es, p->thread.es); 348 savesegment(ds, p->thread.ds); 349 350 if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) { 351 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL); 352 if (!p->thread.io_bitmap_ptr) { 353 p->thread.io_bitmap_max = 0; 354 return -ENOMEM; 355 } 356 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr, 357 IO_BITMAP_BYTES); 358 set_tsk_thread_flag(p, TIF_IO_BITMAP); 359 } 360 361 /* 362 * Set a new TLS for the child thread? 363 */ 364 if (clone_flags & CLONE_SETTLS) { 365 #ifdef CONFIG_IA32_EMULATION 366 if (test_thread_flag(TIF_IA32)) 367 err = do_set_thread_area(p, -1, 368 (struct user_desc __user *)childregs->si, 0); 369 else 370 #endif 371 err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8); 372 if (err) 373 goto out; 374 } 375 err = 0; 376 out: 377 if (err && p->thread.io_bitmap_ptr) { 378 kfree(p->thread.io_bitmap_ptr); 379 p->thread.io_bitmap_max = 0; 380 } 381 return err; 382 } 383 384 void 385 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp) 386 { 387 loadsegment(fs, 0); 388 loadsegment(es, 0); 389 loadsegment(ds, 0); 390 load_gs_index(0); 391 regs->ip = new_ip; 392 regs->sp = new_sp; 393 write_pda(oldrsp, new_sp); 394 regs->cs = __USER_CS; 395 regs->ss = __USER_DS; 396 regs->flags = 0x200; 397 set_fs(USER_DS); 398 /* 399 * Free the old FP and other extended state 400 */ 401 free_thread_xstate(current); 402 } 403 EXPORT_SYMBOL_GPL(start_thread); 404 405 static void hard_disable_TSC(void) 406 { 407 write_cr4(read_cr4() | X86_CR4_TSD); 408 } 409 410 void disable_TSC(void) 411 { 412 preempt_disable(); 413 if (!test_and_set_thread_flag(TIF_NOTSC)) 414 /* 415 * Must flip the CPU state synchronously with 416 * TIF_NOTSC in the current running context. 417 */ 418 hard_disable_TSC(); 419 preempt_enable(); 420 } 421 422 static void hard_enable_TSC(void) 423 { 424 write_cr4(read_cr4() & ~X86_CR4_TSD); 425 } 426 427 static void enable_TSC(void) 428 { 429 preempt_disable(); 430 if (test_and_clear_thread_flag(TIF_NOTSC)) 431 /* 432 * Must flip the CPU state synchronously with 433 * TIF_NOTSC in the current running context. 434 */ 435 hard_enable_TSC(); 436 preempt_enable(); 437 } 438 439 int get_tsc_mode(unsigned long adr) 440 { 441 unsigned int val; 442 443 if (test_thread_flag(TIF_NOTSC)) 444 val = PR_TSC_SIGSEGV; 445 else 446 val = PR_TSC_ENABLE; 447 448 return put_user(val, (unsigned int __user *)adr); 449 } 450 451 int set_tsc_mode(unsigned int val) 452 { 453 if (val == PR_TSC_SIGSEGV) 454 disable_TSC(); 455 else if (val == PR_TSC_ENABLE) 456 enable_TSC(); 457 else 458 return -EINVAL; 459 460 return 0; 461 } 462 463 /* 464 * This special macro can be used to load a debugging register 465 */ 466 #define loaddebug(thread, r) set_debugreg(thread->debugreg ## r, r) 467 468 static inline void __switch_to_xtra(struct task_struct *prev_p, 469 struct task_struct *next_p, 470 struct tss_struct *tss) 471 { 472 struct thread_struct *prev, *next; 473 unsigned long debugctl; 474 475 prev = &prev_p->thread, 476 next = &next_p->thread; 477 478 debugctl = prev->debugctlmsr; 479 480 #ifdef CONFIG_X86_DS 481 { 482 unsigned long ds_prev = 0, ds_next = 0; 483 484 if (prev->ds_ctx) 485 ds_prev = (unsigned long)prev->ds_ctx->ds; 486 if (next->ds_ctx) 487 ds_next = (unsigned long)next->ds_ctx->ds; 488 489 if (ds_next != ds_prev) { 490 /* 491 * We clear debugctl to make sure DS 492 * is not in use when we change it: 493 */ 494 debugctl = 0; 495 update_debugctlmsr(0); 496 wrmsrl(MSR_IA32_DS_AREA, ds_next); 497 } 498 } 499 #endif /* CONFIG_X86_DS */ 500 501 if (next->debugctlmsr != debugctl) 502 update_debugctlmsr(next->debugctlmsr); 503 504 if (test_tsk_thread_flag(next_p, TIF_DEBUG)) { 505 loaddebug(next, 0); 506 loaddebug(next, 1); 507 loaddebug(next, 2); 508 loaddebug(next, 3); 509 /* no 4 and 5 */ 510 loaddebug(next, 6); 511 loaddebug(next, 7); 512 } 513 514 if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^ 515 test_tsk_thread_flag(next_p, TIF_NOTSC)) { 516 /* prev and next are different */ 517 if (test_tsk_thread_flag(next_p, TIF_NOTSC)) 518 hard_disable_TSC(); 519 else 520 hard_enable_TSC(); 521 } 522 523 if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) { 524 /* 525 * Copy the relevant range of the IO bitmap. 526 * Normally this is 128 bytes or less: 527 */ 528 memcpy(tss->io_bitmap, next->io_bitmap_ptr, 529 max(prev->io_bitmap_max, next->io_bitmap_max)); 530 } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) { 531 /* 532 * Clear any possible leftover bits: 533 */ 534 memset(tss->io_bitmap, 0xff, prev->io_bitmap_max); 535 } 536 537 #ifdef CONFIG_X86_PTRACE_BTS 538 if (test_tsk_thread_flag(prev_p, TIF_BTS_TRACE_TS)) 539 ptrace_bts_take_timestamp(prev_p, BTS_TASK_DEPARTS); 540 541 if (test_tsk_thread_flag(next_p, TIF_BTS_TRACE_TS)) 542 ptrace_bts_take_timestamp(next_p, BTS_TASK_ARRIVES); 543 #endif /* CONFIG_X86_PTRACE_BTS */ 544 } 545 546 /* 547 * switch_to(x,y) should switch tasks from x to y. 548 * 549 * This could still be optimized: 550 * - fold all the options into a flag word and test it with a single test. 551 * - could test fs/gs bitsliced 552 * 553 * Kprobes not supported here. Set the probe on schedule instead. 554 */ 555 struct task_struct * 556 __switch_to(struct task_struct *prev_p, struct task_struct *next_p) 557 { 558 struct thread_struct *prev = &prev_p->thread; 559 struct thread_struct *next = &next_p->thread; 560 int cpu = smp_processor_id(); 561 struct tss_struct *tss = &per_cpu(init_tss, cpu); 562 unsigned fsindex, gsindex; 563 564 /* we're going to use this soon, after a few expensive things */ 565 if (next_p->fpu_counter > 5) 566 prefetch(next->xstate); 567 568 /* 569 * Reload esp0, LDT and the page table pointer: 570 */ 571 load_sp0(tss, next); 572 573 /* 574 * Switch DS and ES. 575 * This won't pick up thread selector changes, but I guess that is ok. 576 */ 577 savesegment(es, prev->es); 578 if (unlikely(next->es | prev->es)) 579 loadsegment(es, next->es); 580 581 savesegment(ds, prev->ds); 582 if (unlikely(next->ds | prev->ds)) 583 loadsegment(ds, next->ds); 584 585 586 /* We must save %fs and %gs before load_TLS() because 587 * %fs and %gs may be cleared by load_TLS(). 588 * 589 * (e.g. xen_load_tls()) 590 */ 591 savesegment(fs, fsindex); 592 savesegment(gs, gsindex); 593 594 load_TLS(next, cpu); 595 596 /* 597 * Leave lazy mode, flushing any hypercalls made here. 598 * This must be done before restoring TLS segments so 599 * the GDT and LDT are properly updated, and must be 600 * done before math_state_restore, so the TS bit is up 601 * to date. 602 */ 603 arch_leave_lazy_cpu_mode(); 604 605 /* 606 * Switch FS and GS. 607 * 608 * Segment register != 0 always requires a reload. Also 609 * reload when it has changed. When prev process used 64bit 610 * base always reload to avoid an information leak. 611 */ 612 if (unlikely(fsindex | next->fsindex | prev->fs)) { 613 loadsegment(fs, next->fsindex); 614 /* 615 * Check if the user used a selector != 0; if yes 616 * clear 64bit base, since overloaded base is always 617 * mapped to the Null selector 618 */ 619 if (fsindex) 620 prev->fs = 0; 621 } 622 /* when next process has a 64bit base use it */ 623 if (next->fs) 624 wrmsrl(MSR_FS_BASE, next->fs); 625 prev->fsindex = fsindex; 626 627 if (unlikely(gsindex | next->gsindex | prev->gs)) { 628 load_gs_index(next->gsindex); 629 if (gsindex) 630 prev->gs = 0; 631 } 632 if (next->gs) 633 wrmsrl(MSR_KERNEL_GS_BASE, next->gs); 634 prev->gsindex = gsindex; 635 636 /* Must be after DS reload */ 637 unlazy_fpu(prev_p); 638 639 /* 640 * Switch the PDA and FPU contexts. 641 */ 642 prev->usersp = read_pda(oldrsp); 643 write_pda(oldrsp, next->usersp); 644 write_pda(pcurrent, next_p); 645 646 write_pda(kernelstack, 647 (unsigned long)task_stack_page(next_p) + 648 THREAD_SIZE - PDA_STACKOFFSET); 649 #ifdef CONFIG_CC_STACKPROTECTOR 650 write_pda(stack_canary, next_p->stack_canary); 651 /* 652 * Build time only check to make sure the stack_canary is at 653 * offset 40 in the pda; this is a gcc ABI requirement 654 */ 655 BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40); 656 #endif 657 658 /* 659 * Now maybe reload the debug registers and handle I/O bitmaps 660 */ 661 if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT || 662 task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV)) 663 __switch_to_xtra(prev_p, next_p, tss); 664 665 /* If the task has used fpu the last 5 timeslices, just do a full 666 * restore of the math state immediately to avoid the trap; the 667 * chances of needing FPU soon are obviously high now 668 * 669 * tsk_used_math() checks prevent calling math_state_restore(), 670 * which can sleep in the case of !tsk_used_math() 671 */ 672 if (tsk_used_math(next_p) && next_p->fpu_counter > 5) 673 math_state_restore(); 674 return prev_p; 675 } 676 677 /* 678 * sys_execve() executes a new program. 679 */ 680 asmlinkage 681 long sys_execve(char __user *name, char __user * __user *argv, 682 char __user * __user *envp, struct pt_regs *regs) 683 { 684 long error; 685 char *filename; 686 687 filename = getname(name); 688 error = PTR_ERR(filename); 689 if (IS_ERR(filename)) 690 return error; 691 error = do_execve(filename, argv, envp, regs); 692 putname(filename); 693 return error; 694 } 695 696 void set_personality_64bit(void) 697 { 698 /* inherit personality from parent */ 699 700 /* Make sure to be in 64bit mode */ 701 clear_thread_flag(TIF_IA32); 702 703 /* TBD: overwrites user setup. Should have two bits. 704 But 64bit processes have always behaved this way, 705 so it's not too bad. The main problem is just that 706 32bit childs are affected again. */ 707 current->personality &= ~READ_IMPLIES_EXEC; 708 } 709 710 asmlinkage long sys_fork(struct pt_regs *regs) 711 { 712 return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL); 713 } 714 715 asmlinkage long 716 sys_clone(unsigned long clone_flags, unsigned long newsp, 717 void __user *parent_tid, void __user *child_tid, struct pt_regs *regs) 718 { 719 if (!newsp) 720 newsp = regs->sp; 721 return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid); 722 } 723 724 /* 725 * This is trivial, and on the face of it looks like it 726 * could equally well be done in user mode. 727 * 728 * Not so, for quite unobvious reasons - register pressure. 729 * In user mode vfork() cannot have a stack frame, and if 730 * done by calling the "clone()" system call directly, you 731 * do not have enough call-clobbered registers to hold all 732 * the information you need. 733 */ 734 asmlinkage long sys_vfork(struct pt_regs *regs) 735 { 736 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0, 737 NULL, NULL); 738 } 739 740 unsigned long get_wchan(struct task_struct *p) 741 { 742 unsigned long stack; 743 u64 fp, ip; 744 int count = 0; 745 746 if (!p || p == current || p->state == TASK_RUNNING) 747 return 0; 748 stack = (unsigned long)task_stack_page(p); 749 if (p->thread.sp < stack || p->thread.sp >= stack+THREAD_SIZE) 750 return 0; 751 fp = *(u64 *)(p->thread.sp); 752 do { 753 if (fp < (unsigned long)stack || 754 fp >= (unsigned long)stack+THREAD_SIZE) 755 return 0; 756 ip = *(u64 *)(fp+8); 757 if (!in_sched_functions(ip)) 758 return ip; 759 fp = *(u64 *)fp; 760 } while (count++ < 16); 761 return 0; 762 } 763 764 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr) 765 { 766 int ret = 0; 767 int doit = task == current; 768 int cpu; 769 770 switch (code) { 771 case ARCH_SET_GS: 772 if (addr >= TASK_SIZE_OF(task)) 773 return -EPERM; 774 cpu = get_cpu(); 775 /* handle small bases via the GDT because that's faster to 776 switch. */ 777 if (addr <= 0xffffffff) { 778 set_32bit_tls(task, GS_TLS, addr); 779 if (doit) { 780 load_TLS(&task->thread, cpu); 781 load_gs_index(GS_TLS_SEL); 782 } 783 task->thread.gsindex = GS_TLS_SEL; 784 task->thread.gs = 0; 785 } else { 786 task->thread.gsindex = 0; 787 task->thread.gs = addr; 788 if (doit) { 789 load_gs_index(0); 790 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr); 791 } 792 } 793 put_cpu(); 794 break; 795 case ARCH_SET_FS: 796 /* Not strictly needed for fs, but do it for symmetry 797 with gs */ 798 if (addr >= TASK_SIZE_OF(task)) 799 return -EPERM; 800 cpu = get_cpu(); 801 /* handle small bases via the GDT because that's faster to 802 switch. */ 803 if (addr <= 0xffffffff) { 804 set_32bit_tls(task, FS_TLS, addr); 805 if (doit) { 806 load_TLS(&task->thread, cpu); 807 loadsegment(fs, FS_TLS_SEL); 808 } 809 task->thread.fsindex = FS_TLS_SEL; 810 task->thread.fs = 0; 811 } else { 812 task->thread.fsindex = 0; 813 task->thread.fs = addr; 814 if (doit) { 815 /* set the selector to 0 to not confuse 816 __switch_to */ 817 loadsegment(fs, 0); 818 ret = checking_wrmsrl(MSR_FS_BASE, addr); 819 } 820 } 821 put_cpu(); 822 break; 823 case ARCH_GET_FS: { 824 unsigned long base; 825 if (task->thread.fsindex == FS_TLS_SEL) 826 base = read_32bit_tls(task, FS_TLS); 827 else if (doit) 828 rdmsrl(MSR_FS_BASE, base); 829 else 830 base = task->thread.fs; 831 ret = put_user(base, (unsigned long __user *)addr); 832 break; 833 } 834 case ARCH_GET_GS: { 835 unsigned long base; 836 unsigned gsindex; 837 if (task->thread.gsindex == GS_TLS_SEL) 838 base = read_32bit_tls(task, GS_TLS); 839 else if (doit) { 840 savesegment(gs, gsindex); 841 if (gsindex) 842 rdmsrl(MSR_KERNEL_GS_BASE, base); 843 else 844 base = task->thread.gs; 845 } else 846 base = task->thread.gs; 847 ret = put_user(base, (unsigned long __user *)addr); 848 break; 849 } 850 851 default: 852 ret = -EINVAL; 853 break; 854 } 855 856 return ret; 857 } 858 859 long sys_arch_prctl(int code, unsigned long addr) 860 { 861 return do_arch_prctl(current, code, addr); 862 } 863 864 unsigned long arch_align_stack(unsigned long sp) 865 { 866 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space) 867 sp -= get_random_int() % 8192; 868 return sp & ~0xf; 869 } 870 871 unsigned long arch_randomize_brk(struct mm_struct *mm) 872 { 873 unsigned long range_end = mm->brk + 0x02000000; 874 return randomize_range(mm->brk, range_end, 0) ? : mm->brk; 875 } 876