2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Copyright 2003 PathScale, Inc.
4 * Licensed under the GPL
7 #include <linux/stddef.h>
9 #include <linux/hardirq.h>
11 #include <linux/module.h>
12 #include <linux/personality.h>
13 #include <linux/proc_fs.h>
14 #include <linux/ptrace.h>
15 #include <linux/random.h>
16 #include <linux/slab.h>
17 #include <linux/sched.h>
18 #include <linux/seq_file.h>
19 #include <linux/tick.h>
20 #include <linux/threads.h>
21 #include <asm/current.h>
22 #include <asm/pgtable.h>
23 #include <asm/mmu_context.h>
24 #include <asm/uaccess.h>
25 #include "as-layout.h"
26 #include "kern_util.h"
31 * This is a per-cpu array. A processor only modifies its entry and it only
32 * cares about its entry, so it's OK if another processor is modifying its
35 struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
37 static inline int external_pid(void)
39 /* FIXME: Need to look up userspace_pid by cpu */
40 return userspace_pid[0];
43 int pid_to_processor_id(int pid)
47 for (i = 0; i < ncpus; i++) {
48 if (cpu_tasks[i].pid == pid)
54 void free_stack(unsigned long stack, int order)
56 free_pages(stack, order);
59 unsigned long alloc_stack(int order, int atomic)
62 gfp_t flags = GFP_KERNEL;
66 page = __get_free_pages(flags, order);
71 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
75 current->thread.request.u.thread.proc = fn;
76 current->thread.request.u.thread.arg = arg;
77 pid = do_fork(CLONE_VM | CLONE_UNTRACED | flags, 0,
78 ¤t->thread.regs, 0, NULL, NULL);
81 EXPORT_SYMBOL(kernel_thread);
83 static inline void set_current(struct task_struct *task)
85 cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
86 { external_pid(), task });
89 extern void arch_switch_to(struct task_struct *to);
91 void *__switch_to(struct task_struct *from, struct task_struct *to)
93 to->thread.prev_sched = from;
97 current->thread.saved_task = NULL;
99 switch_threads(&from->thread.switch_buf,
100 &to->thread.switch_buf);
102 arch_switch_to(current);
104 if (current->thread.saved_task)
105 show_regs(&(current->thread.regs));
106 to = current->thread.saved_task;
108 } while (current->thread.saved_task);
110 return current->thread.prev_sched;
113 void interrupt_end(void)
117 if (test_tsk_thread_flag(current, TIF_SIGPENDING))
121 void exit_thread(void)
125 int get_current_pid(void)
127 return task_pid_nr(current);
131 * This is called magically, by its address being stuffed in a jmp_buf
132 * and being longjmp-d to.
134 void new_thread_handler(void)
136 int (*fn)(void *), n;
139 if (current->thread.prev_sched != NULL)
140 schedule_tail(current->thread.prev_sched);
141 current->thread.prev_sched = NULL;
143 fn = current->thread.request.u.thread.proc;
144 arg = current->thread.request.u.thread.arg;
147 * The return value is 1 if the kernel thread execs a process,
150 n = run_kernel_thread(fn, arg, ¤t->thread.exec_buf);
152 /* Handle any immediate reschedules or signals */
154 userspace(¤t->thread.regs.regs);
159 /* Called magically, see new_thread_handler above */
160 void fork_handler(void)
164 schedule_tail(current->thread.prev_sched);
167 * XXX: if interrupt_end() calls schedule, this call to
168 * arch_switch_to isn't needed. We could want to apply this to
169 * improve performance. -bb
171 arch_switch_to(current);
173 current->thread.prev_sched = NULL;
175 /* Handle any immediate reschedules or signals */
178 userspace(¤t->thread.regs.regs);
181 int copy_thread(unsigned long clone_flags, unsigned long sp,
182 unsigned long stack_top, struct task_struct * p,
183 struct pt_regs *regs)
185 void (*handler)(void);
188 p->thread = (struct thread_struct) INIT_THREAD;
190 if (current->thread.forking) {
191 memcpy(&p->thread.regs.regs, ®s->regs,
192 sizeof(p->thread.regs.regs));
193 REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.gp, 0);
195 REGS_SP(p->thread.regs.regs.gp) = sp;
197 handler = fork_handler;
199 arch_copy_thread(¤t->thread.arch, &p->thread.arch);
202 get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
203 p->thread.request.u.thread = current->thread.request.u.thread;
204 handler = new_thread_handler;
207 new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
209 if (current->thread.forking) {
210 clear_flushed_tls(p);
213 * Set a new TLS for the child thread?
215 if (clone_flags & CLONE_SETTLS)
216 ret = arch_copy_tls(p);
222 void initial_thread_cb(void (*proc)(void *), void *arg)
224 int save_kmalloc_ok = kmalloc_ok;
227 initial_thread_cb_skas(proc, arg);
228 kmalloc_ok = save_kmalloc_ok;
231 void default_idle(void)
233 unsigned long long nsecs;
236 /* endless idle loop with no priority at all */
239 * although we are an idle CPU, we do not want to
240 * get into the scheduler unnecessarily.
245 tick_nohz_idle_enter();
247 nsecs = disable_timer();
250 tick_nohz_idle_exit();
256 cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
260 int __cant_sleep(void) {
261 return in_atomic() || irqs_disabled() || in_interrupt();
262 /* Is in_interrupt() really needed? */
265 int user_context(unsigned long sp)
269 stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
270 return stack != (unsigned long) current_thread_info();
273 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
275 void do_uml_exitcalls(void)
279 call = &__uml_exitcall_end;
280 while (--call >= &__uml_exitcall_begin)
284 char *uml_strdup(const char *string)
286 return kstrdup(string, GFP_KERNEL);
288 EXPORT_SYMBOL(uml_strdup);
290 int copy_to_user_proc(void __user *to, void *from, int size)
292 return copy_to_user(to, from, size);
295 int copy_from_user_proc(void *to, void __user *from, int size)
297 return copy_from_user(to, from, size);
300 int clear_user_proc(void __user *buf, int size)
302 return clear_user(buf, size);
305 int strlen_user_proc(char __user *str)
307 return strlen_user(str);
310 int smp_sigio_handler(void)
313 int cpu = current_thread_info()->cpu;
323 return current_thread_info()->cpu;
326 static atomic_t using_sysemu = ATOMIC_INIT(0);
327 int sysemu_supported;
329 void set_using_sysemu(int value)
331 if (value > sysemu_supported)
333 atomic_set(&using_sysemu, value);
336 int get_using_sysemu(void)
338 return atomic_read(&using_sysemu);
341 static int sysemu_proc_show(struct seq_file *m, void *v)
343 seq_printf(m, "%d\n", get_using_sysemu());
347 static int sysemu_proc_open(struct inode *inode, struct file *file)
349 return single_open(file, sysemu_proc_show, NULL);
352 static ssize_t sysemu_proc_write(struct file *file, const char __user *buf,
353 size_t count, loff_t *pos)
357 if (copy_from_user(tmp, buf, 1))
360 if (tmp[0] >= '0' && tmp[0] <= '2')
361 set_using_sysemu(tmp[0] - '0');
362 /* We use the first char, but pretend to write everything */
366 static const struct file_operations sysemu_proc_fops = {
367 .owner = THIS_MODULE,
368 .open = sysemu_proc_open,
371 .release = single_release,
372 .write = sysemu_proc_write,
375 int __init make_proc_sysemu(void)
377 struct proc_dir_entry *ent;
378 if (!sysemu_supported)
381 ent = proc_create("sysemu", 0600, NULL, &sysemu_proc_fops);
385 printk(KERN_WARNING "Failed to register /proc/sysemu\n");
392 late_initcall(make_proc_sysemu);
394 int singlestepping(void * t)
396 struct task_struct *task = t ? t : current;
398 if (!(task->ptrace & PT_DTRACE))
401 if (task->thread.singlestep_syscall)
408 * Only x86 and x86_64 have an arch_align_stack().
409 * All other arches have "#define arch_align_stack(x) (x)"
410 * in their asm/system.h
411 * As this is included in UML from asm-um/system-generic.h,
412 * we can use it to behave as the subarch does.
414 #ifndef arch_align_stack
415 unsigned long arch_align_stack(unsigned long sp)
417 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
418 sp -= get_random_int() % 8192;
423 unsigned long get_wchan(struct task_struct *p)
425 unsigned long stack_page, sp, ip;
428 if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
431 stack_page = (unsigned long) task_stack_page(p);
432 /* Bail if the process has no kernel stack for some reason */
436 sp = p->thread.switch_buf->JB_SP;
438 * Bail if the stack pointer is below the bottom of the kernel
439 * stack for some reason
444 while (sp < stack_page + THREAD_SIZE) {
445 ip = *((unsigned long *) sp);
446 if (in_sched_functions(ip))
447 /* Ignore everything until we're above the scheduler */
449 else if (kernel_text_address(ip) && seen_sched)
452 sp += sizeof(unsigned long);
458 int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
460 int cpu = current_thread_info()->cpu;
462 return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);