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(void *prev, void *next, void *last)
93 struct task_struct *from = prev;
94 struct task_struct *to = next;
96 to->thread.prev_sched = from;
100 current->thread.saved_task = NULL;
102 switch_threads(&from->thread.switch_buf,
103 &to->thread.switch_buf);
105 arch_switch_to(current);
107 if (current->thread.saved_task)
108 show_regs(&(current->thread.regs));
109 to = current->thread.saved_task;
111 } while (current->thread.saved_task);
113 return current->thread.prev_sched;
117 void interrupt_end(void)
121 if (test_tsk_thread_flag(current, TIF_SIGPENDING))
125 void exit_thread(void)
129 int get_current_pid(void)
131 return task_pid_nr(current);
135 * This is called magically, by its address being stuffed in a jmp_buf
136 * and being longjmp-d to.
138 void new_thread_handler(void)
140 int (*fn)(void *), n;
143 if (current->thread.prev_sched != NULL)
144 schedule_tail(current->thread.prev_sched);
145 current->thread.prev_sched = NULL;
147 fn = current->thread.request.u.thread.proc;
148 arg = current->thread.request.u.thread.arg;
151 * The return value is 1 if the kernel thread execs a process,
154 n = run_kernel_thread(fn, arg, ¤t->thread.exec_buf);
156 /* Handle any immediate reschedules or signals */
158 userspace(¤t->thread.regs.regs);
163 /* Called magically, see new_thread_handler above */
164 void fork_handler(void)
168 schedule_tail(current->thread.prev_sched);
171 * XXX: if interrupt_end() calls schedule, this call to
172 * arch_switch_to isn't needed. We could want to apply this to
173 * improve performance. -bb
175 arch_switch_to(current);
177 current->thread.prev_sched = NULL;
179 /* Handle any immediate reschedules or signals */
182 userspace(¤t->thread.regs.regs);
185 int copy_thread(unsigned long clone_flags, unsigned long sp,
186 unsigned long stack_top, struct task_struct * p,
187 struct pt_regs *regs)
189 void (*handler)(void);
192 p->thread = (struct thread_struct) INIT_THREAD;
194 if (current->thread.forking) {
195 memcpy(&p->thread.regs.regs, ®s->regs,
196 sizeof(p->thread.regs.regs));
197 REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.gp, 0);
199 REGS_SP(p->thread.regs.regs.gp) = sp;
201 handler = fork_handler;
203 arch_copy_thread(¤t->thread.arch, &p->thread.arch);
206 get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
207 p->thread.request.u.thread = current->thread.request.u.thread;
208 handler = new_thread_handler;
211 new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
213 if (current->thread.forking) {
214 clear_flushed_tls(p);
217 * Set a new TLS for the child thread?
219 if (clone_flags & CLONE_SETTLS)
220 ret = arch_copy_tls(p);
226 void initial_thread_cb(void (*proc)(void *), void *arg)
228 int save_kmalloc_ok = kmalloc_ok;
231 initial_thread_cb_skas(proc, arg);
232 kmalloc_ok = save_kmalloc_ok;
235 void default_idle(void)
237 unsigned long long nsecs;
240 /* endless idle loop with no priority at all */
243 * although we are an idle CPU, we do not want to
244 * get into the scheduler unnecessarily.
249 tick_nohz_idle_enter();
251 nsecs = disable_timer();
254 tick_nohz_idle_exit();
260 cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
264 int __cant_sleep(void) {
265 return in_atomic() || irqs_disabled() || in_interrupt();
266 /* Is in_interrupt() really needed? */
269 int user_context(unsigned long sp)
273 stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
274 return stack != (unsigned long) current_thread_info();
277 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
279 void do_uml_exitcalls(void)
283 call = &__uml_exitcall_end;
284 while (--call >= &__uml_exitcall_begin)
288 char *uml_strdup(const char *string)
290 return kstrdup(string, GFP_KERNEL);
292 EXPORT_SYMBOL(uml_strdup);
294 int copy_to_user_proc(void __user *to, void *from, int size)
296 return copy_to_user(to, from, size);
299 int copy_from_user_proc(void *to, void __user *from, int size)
301 return copy_from_user(to, from, size);
304 int clear_user_proc(void __user *buf, int size)
306 return clear_user(buf, size);
309 int strlen_user_proc(char __user *str)
311 return strlen_user(str);
314 int smp_sigio_handler(void)
317 int cpu = current_thread_info()->cpu;
327 return current_thread_info()->cpu;
330 static atomic_t using_sysemu = ATOMIC_INIT(0);
331 int sysemu_supported;
333 void set_using_sysemu(int value)
335 if (value > sysemu_supported)
337 atomic_set(&using_sysemu, value);
340 int get_using_sysemu(void)
342 return atomic_read(&using_sysemu);
345 static int sysemu_proc_show(struct seq_file *m, void *v)
347 seq_printf(m, "%d\n", get_using_sysemu());
351 static int sysemu_proc_open(struct inode *inode, struct file *file)
353 return single_open(file, sysemu_proc_show, NULL);
356 static ssize_t sysemu_proc_write(struct file *file, const char __user *buf,
357 size_t count, loff_t *pos)
361 if (copy_from_user(tmp, buf, 1))
364 if (tmp[0] >= '0' && tmp[0] <= '2')
365 set_using_sysemu(tmp[0] - '0');
366 /* We use the first char, but pretend to write everything */
370 static const struct file_operations sysemu_proc_fops = {
371 .owner = THIS_MODULE,
372 .open = sysemu_proc_open,
375 .release = single_release,
376 .write = sysemu_proc_write,
379 int __init make_proc_sysemu(void)
381 struct proc_dir_entry *ent;
382 if (!sysemu_supported)
385 ent = proc_create("sysemu", 0600, NULL, &sysemu_proc_fops);
389 printk(KERN_WARNING "Failed to register /proc/sysemu\n");
396 late_initcall(make_proc_sysemu);
398 int singlestepping(void * t)
400 struct task_struct *task = t ? t : current;
402 if (!(task->ptrace & PT_DTRACE))
405 if (task->thread.singlestep_syscall)
412 * Only x86 and x86_64 have an arch_align_stack().
413 * All other arches have "#define arch_align_stack(x) (x)"
414 * in their asm/system.h
415 * As this is included in UML from asm-um/system-generic.h,
416 * we can use it to behave as the subarch does.
418 #ifndef arch_align_stack
419 unsigned long arch_align_stack(unsigned long sp)
421 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
422 sp -= get_random_int() % 8192;
427 unsigned long get_wchan(struct task_struct *p)
429 unsigned long stack_page, sp, ip;
432 if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
435 stack_page = (unsigned long) task_stack_page(p);
436 /* Bail if the process has no kernel stack for some reason */
440 sp = p->thread.switch_buf->JB_SP;
442 * Bail if the stack pointer is below the bottom of the kernel
443 * stack for some reason
448 while (sp < stack_page + THREAD_SIZE) {
449 ip = *((unsigned long *) sp);
450 if (in_sched_functions(ip))
451 /* Ignore everything until we're above the scheduler */
453 else if (kernel_text_address(ip) && seen_sched)
456 sp += sizeof(unsigned long);
462 int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
464 int cpu = current_thread_info()->cpu;
466 return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);