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 void *get_current(void)
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_stop_sched_tick(1);
250 nsecs = disable_timer();
252 tick_nohz_restart_sched_tick();
258 cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
262 int __cant_sleep(void) {
263 return in_atomic() || irqs_disabled() || in_interrupt();
264 /* Is in_interrupt() really needed? */
267 int user_context(unsigned long sp)
271 stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
272 return stack != (unsigned long) current_thread_info();
275 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
277 void do_uml_exitcalls(void)
281 call = &__uml_exitcall_end;
282 while (--call >= &__uml_exitcall_begin)
286 char *uml_strdup(const char *string)
288 return kstrdup(string, GFP_KERNEL);
290 EXPORT_SYMBOL(uml_strdup);
292 int copy_to_user_proc(void __user *to, void *from, int size)
294 return copy_to_user(to, from, size);
297 int copy_from_user_proc(void *to, void __user *from, int size)
299 return copy_from_user(to, from, size);
302 int clear_user_proc(void __user *buf, int size)
304 return clear_user(buf, size);
307 int strlen_user_proc(char __user *str)
309 return strlen_user(str);
312 int smp_sigio_handler(void)
315 int cpu = current_thread_info()->cpu;
325 return current_thread_info()->cpu;
328 static atomic_t using_sysemu = ATOMIC_INIT(0);
329 int sysemu_supported;
331 void set_using_sysemu(int value)
333 if (value > sysemu_supported)
335 atomic_set(&using_sysemu, value);
338 int get_using_sysemu(void)
340 return atomic_read(&using_sysemu);
343 static int sysemu_proc_show(struct seq_file *m, void *v)
345 seq_printf(m, "%d\n", get_using_sysemu());
349 static int sysemu_proc_open(struct inode *inode, struct file *file)
351 return single_open(file, sysemu_proc_show, NULL);
354 static ssize_t sysemu_proc_write(struct file *file, const char __user *buf,
355 size_t count, loff_t *pos)
359 if (copy_from_user(tmp, buf, 1))
362 if (tmp[0] >= '0' && tmp[0] <= '2')
363 set_using_sysemu(tmp[0] - '0');
364 /* We use the first char, but pretend to write everything */
368 static const struct file_operations sysemu_proc_fops = {
369 .owner = THIS_MODULE,
370 .open = sysemu_proc_open,
373 .release = single_release,
374 .write = sysemu_proc_write,
377 int __init make_proc_sysemu(void)
379 struct proc_dir_entry *ent;
380 if (!sysemu_supported)
383 ent = proc_create("sysemu", 0600, NULL, &sysemu_proc_fops);
387 printk(KERN_WARNING "Failed to register /proc/sysemu\n");
394 late_initcall(make_proc_sysemu);
396 int singlestepping(void * t)
398 struct task_struct *task = t ? t : current;
400 if (!(task->ptrace & PT_DTRACE))
403 if (task->thread.singlestep_syscall)
410 * Only x86 and x86_64 have an arch_align_stack().
411 * All other arches have "#define arch_align_stack(x) (x)"
412 * in their asm/system.h
413 * As this is included in UML from asm-um/system-generic.h,
414 * we can use it to behave as the subarch does.
416 #ifndef arch_align_stack
417 unsigned long arch_align_stack(unsigned long sp)
419 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
420 sp -= get_random_int() % 8192;
425 unsigned long get_wchan(struct task_struct *p)
427 unsigned long stack_page, sp, ip;
430 if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
433 stack_page = (unsigned long) task_stack_page(p);
434 /* Bail if the process has no kernel stack for some reason */
438 sp = p->thread.switch_buf->JB_SP;
440 * Bail if the stack pointer is below the bottom of the kernel
441 * stack for some reason
446 while (sp < stack_page + THREAD_SIZE) {
447 ip = *((unsigned long *) sp);
448 if (in_sched_functions(ip))
449 /* Ignore everything until we're above the scheduler */
451 else if (kernel_text_address(ip) && seen_sched)
454 sp += sizeof(unsigned long);
460 int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
462 int cpu = current_thread_info()->cpu;
464 return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);