blob: 4a28a1568d856c7b1605743ca33c143921caacd4 [file] [log] [blame]
Jeff Dike995473a2006-09-27 01:50:40 -07001/*
Jeff Dikeba180fd2007-10-16 01:27:00 -07002 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Copyright 2003 PathScale, Inc.
4 * Licensed under the GPL
5 */
6
Jeff Dikec5d4bb12008-02-04 22:31:14 -08007#include <linux/stddef.h>
8#include <linux/err.h>
9#include <linux/hardirq.h>
10#include <linux/gfp.h>
11#include <linux/mm.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/sched.h>
17#include <linux/tick.h>
18#include <linux/threads.h>
19#include <asm/current.h>
20#include <asm/pgtable.h>
21#include <asm/uaccess.h>
Jeff Dike4ff83ce2007-05-06 14:51:08 -070022#include "as-layout.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -070023#include "kern_util.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "os.h"
Jeff Dike77bf4402007-10-16 01:26:58 -070025#include "skas.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -070026#include "tlb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Jeff Dikeba180fd2007-10-16 01:27:00 -070028/*
29 * This is a per-cpu array. A processor only modifies its entry and it only
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 * cares about its entry, so it's OK if another processor is modifying its
31 * entry.
32 */
33struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
34
Karol Swietlicki2dc58022008-02-04 22:31:03 -080035static inline int external_pid(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070036{
Jeff Dike77bf4402007-10-16 01:26:58 -070037 /* FIXME: Need to look up userspace_pid by cpu */
Jeff Dikeba180fd2007-10-16 01:27:00 -070038 return userspace_pid[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -070039}
40
41int pid_to_processor_id(int pid)
42{
43 int i;
44
Jeff Dikec5d4bb12008-02-04 22:31:14 -080045 for (i = 0; i < ncpus; i++) {
Jeff Dikeba180fd2007-10-16 01:27:00 -070046 if (cpu_tasks[i].pid == pid)
Jeff Dike6e21aec2007-05-06 14:51:21 -070047 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 }
Jeff Dike6e21aec2007-05-06 14:51:21 -070049 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050}
51
52void free_stack(unsigned long stack, int order)
53{
54 free_pages(stack, order);
55}
56
57unsigned long alloc_stack(int order, int atomic)
58{
59 unsigned long page;
Al Viro53f9fc92005-10-21 03:22:24 -040060 gfp_t flags = GFP_KERNEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Paolo 'Blaisorblade' Giarrusso46db4a42005-09-22 21:44:20 -070062 if (atomic)
63 flags = GFP_ATOMIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 page = __get_free_pages(flags, order);
Jeff Dike5c8aace2007-10-16 01:26:46 -070065
Jeff Dike6e21aec2007-05-06 14:51:21 -070066 return page;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067}
68
69int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
70{
71 int pid;
72
73 current->thread.request.u.thread.proc = fn;
74 current->thread.request.u.thread.arg = arg;
Jeff Dikee0877f02005-06-25 14:55:21 -070075 pid = do_fork(CLONE_VM | CLONE_UNTRACED | flags, 0,
76 &current->thread.regs, 0, NULL, NULL);
Jeff Dike6e21aec2007-05-06 14:51:21 -070077 return pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
Jeff Dike6e21aec2007-05-06 14:51:21 -070080static inline void set_current(struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
Al Viroca9bc0b2006-01-12 01:05:48 -080082 cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
Karol Swietlicki2dc58022008-02-04 22:31:03 -080083 { external_pid(), task });
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Karol Swietlicki291248f2008-02-04 22:30:49 -080086extern void arch_switch_to(struct task_struct *to);
Jeff Dike77bf4402007-10-16 01:26:58 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088void *_switch_to(void *prev, void *next, void *last)
89{
Jeff Dike995473a2006-09-27 01:50:40 -070090 struct task_struct *from = prev;
Karol Swietlicki291248f2008-02-04 22:30:49 -080091 struct task_struct *to = next;
Jeff Dikef6e34c62005-09-16 19:27:43 -070092
Jeff Dike995473a2006-09-27 01:50:40 -070093 to->thread.prev_sched = from;
94 set_current(to);
Jeff Dikef6e34c62005-09-16 19:27:43 -070095
Jeff Dike3eddddc2005-09-16 19:27:46 -070096 do {
Jeff Dike6aa802c2007-10-16 01:26:56 -070097 current->thread.saved_task = NULL;
Jeff Dike77bf4402007-10-16 01:26:58 -070098
Jeff Dikec5d4bb12008-02-04 22:31:14 -080099 switch_threads(&from->thread.switch_buf,
100 &to->thread.switch_buf);
Jeff Dike77bf4402007-10-16 01:26:58 -0700101
Karol Swietlicki291248f2008-02-04 22:30:49 -0800102 arch_switch_to(current);
Jeff Dike77bf4402007-10-16 01:26:58 -0700103
Jeff Dikeba180fd2007-10-16 01:27:00 -0700104 if (current->thread.saved_task)
Jeff Dike3eddddc2005-09-16 19:27:46 -0700105 show_regs(&(current->thread.regs));
Jeff Dikec5d4bb12008-02-04 22:31:14 -0800106 to = current->thread.saved_task;
107 from = current;
Karol Swietlicki291248f2008-02-04 22:30:49 -0800108 } while (current->thread.saved_task);
Jeff Dikef6e34c62005-09-16 19:27:43 -0700109
Jeff Dike6e21aec2007-05-06 14:51:21 -0700110 return current->thread.prev_sched;
Jeff Dikef6e34c62005-09-16 19:27:43 -0700111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
114void interrupt_end(void)
115{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700116 if (need_resched())
Jeff Dike6e21aec2007-05-06 14:51:21 -0700117 schedule();
Jeff Dikeba180fd2007-10-16 01:27:00 -0700118 if (test_tsk_thread_flag(current, TIF_SIGPENDING))
Jeff Dike6e21aec2007-05-06 14:51:21 -0700119 do_signal();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122void exit_thread(void)
123{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
Jeff Dike995473a2006-09-27 01:50:40 -0700125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126void *get_current(void)
127{
Jeff Dike6e21aec2007-05-06 14:51:21 -0700128 return current;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129}
130
Jeff Dikeba180fd2007-10-16 01:27:00 -0700131/*
132 * This is called magically, by its address being stuffed in a jmp_buf
Jeff Dike77bf4402007-10-16 01:26:58 -0700133 * and being longjmp-d to.
134 */
135void new_thread_handler(void)
136{
137 int (*fn)(void *), n;
138 void *arg;
139
Jeff Dikeba180fd2007-10-16 01:27:00 -0700140 if (current->thread.prev_sched != NULL)
Jeff Dike77bf4402007-10-16 01:26:58 -0700141 schedule_tail(current->thread.prev_sched);
142 current->thread.prev_sched = NULL;
143
144 fn = current->thread.request.u.thread.proc;
145 arg = current->thread.request.u.thread.arg;
146
Jeff Dikeba180fd2007-10-16 01:27:00 -0700147 /*
148 * The return value is 1 if the kernel thread execs a process,
Jeff Dike77bf4402007-10-16 01:26:58 -0700149 * 0 if it just exits
150 */
151 n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700152 if (n == 1) {
Jeff Dike77bf4402007-10-16 01:26:58 -0700153 /* Handle any immediate reschedules or signals */
154 interrupt_end();
155 userspace(&current->thread.regs.regs);
156 }
157 else do_exit(0);
158}
159
160/* Called magically, see new_thread_handler above */
161void fork_handler(void)
162{
163 force_flush_all();
Jeff Dike77bf4402007-10-16 01:26:58 -0700164
165 schedule_tail(current->thread.prev_sched);
166
Jeff Dikeba180fd2007-10-16 01:27:00 -0700167 /*
168 * XXX: if interrupt_end() calls schedule, this call to
Jeff Dike77bf4402007-10-16 01:26:58 -0700169 * arch_switch_to isn't needed. We could want to apply this to
Jeff Dikeba180fd2007-10-16 01:27:00 -0700170 * improve performance. -bb
171 */
Karol Swietlicki291248f2008-02-04 22:30:49 -0800172 arch_switch_to(current);
Jeff Dike77bf4402007-10-16 01:26:58 -0700173
174 current->thread.prev_sched = NULL;
175
176 /* Handle any immediate reschedules or signals */
177 interrupt_end();
178
179 userspace(&current->thread.regs.regs);
180}
181
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -0700182int copy_thread(unsigned long clone_flags, unsigned long sp,
Jeff Dike995473a2006-09-27 01:50:40 -0700183 unsigned long stack_top, struct task_struct * p,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 struct pt_regs *regs)
185{
Jeff Dike77bf4402007-10-16 01:26:58 -0700186 void (*handler)(void);
187 int ret = 0;
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 p->thread = (struct thread_struct) INIT_THREAD;
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800190
Jeff Dikeba180fd2007-10-16 01:27:00 -0700191 if (current->thread.forking) {
Jeff Dike77bf4402007-10-16 01:26:58 -0700192 memcpy(&p->thread.regs.regs, &regs->regs,
193 sizeof(p->thread.regs.regs));
Jeff Dike18baddd2007-10-16 01:27:07 -0700194 REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.gp, 0);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700195 if (sp != 0)
Jeff Dike18baddd2007-10-16 01:27:07 -0700196 REGS_SP(p->thread.regs.regs.gp) = sp;
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800197
Jeff Dike77bf4402007-10-16 01:26:58 -0700198 handler = fork_handler;
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800199
Jeff Dike77bf4402007-10-16 01:26:58 -0700200 arch_copy_thread(&current->thread.arch, &p->thread.arch);
201 }
202 else {
Jeff Diked25f2e12008-02-04 22:30:57 -0800203 get_safe_registers(p->thread.regs.regs.gp);
Jeff Dike77bf4402007-10-16 01:26:58 -0700204 p->thread.request.u.thread = current->thread.request.u.thread;
205 handler = new_thread_handler;
206 }
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800207
Jeff Dike77bf4402007-10-16 01:26:58 -0700208 new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
209
210 if (current->thread.forking) {
211 clear_flushed_tls(p);
212
213 /*
214 * Set a new TLS for the child thread?
215 */
216 if (clone_flags & CLONE_SETTLS)
217 ret = arch_copy_tls(p);
218 }
219
Paolo 'Blaisorblade' Giarrussoaa6758d2006-03-31 02:30:22 -0800220 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
223void initial_thread_cb(void (*proc)(void *), void *arg)
224{
225 int save_kmalloc_ok = kmalloc_ok;
226
227 kmalloc_ok = 0;
Jeff Dike6aa802c2007-10-16 01:26:56 -0700228 initial_thread_cb_skas(proc, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 kmalloc_ok = save_kmalloc_ok;
230}
Jeff Dike995473a2006-09-27 01:50:40 -0700231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232void default_idle(void)
233{
Jeff Dikeb160fb62007-10-16 01:27:26 -0700234 unsigned long long nsecs;
235
Jeff Dikec5d4bb12008-02-04 22:31:14 -0800236 while (1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 /* endless idle loop with no priority at all */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239 /*
240 * although we are an idle CPU, we do not want to
241 * get into the scheduler unnecessarily.
242 */
Jeff Dikeba180fd2007-10-16 01:27:00 -0700243 if (need_resched())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 schedule();
Jeff Dike995473a2006-09-27 01:50:40 -0700245
Thomas Gleixnerb8f8c3c2008-07-18 17:27:28 +0200246 tick_nohz_stop_sched_tick(1);
Jeff Dikeb160fb62007-10-16 01:27:26 -0700247 nsecs = disable_timer();
248 idle_sleep(nsecs);
Jeff Diked2753a6d2007-10-16 01:27:25 -0700249 tick_nohz_restart_sched_tick();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 }
251}
252
253void cpu_idle(void)
254{
Jeff Dikea5a678c2008-02-04 22:30:54 -0800255 cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
Jeff Dike77bf4402007-10-16 01:26:58 -0700256 default_idle();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
Paolo 'Blaisorblade' Giarrussob6316292006-01-18 17:42:58 -0800259int __cant_sleep(void) {
260 return in_atomic() || irqs_disabled() || in_interrupt();
261 /* Is in_interrupt() really needed? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264int user_context(unsigned long sp)
265{
266 unsigned long stack;
267
268 stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
Jeff Dikea5a678c2008-02-04 22:30:54 -0800269 return stack != (unsigned long) current_thread_info();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
273
274void do_uml_exitcalls(void)
275{
276 exitcall_t *call;
277
278 call = &__uml_exitcall_end;
279 while (--call >= &__uml_exitcall_begin)
280 (*call)();
281}
282
WANG Congc0a92902008-02-04 22:30:41 -0800283char *uml_strdup(const char *string)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
Robert Lovedfe52242005-06-23 00:09:04 -0700285 return kstrdup(string, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288int copy_to_user_proc(void __user *to, void *from, int size)
289{
Jeff Dike6e21aec2007-05-06 14:51:21 -0700290 return copy_to_user(to, from, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
293int copy_from_user_proc(void *to, void __user *from, int size)
294{
Jeff Dike6e21aec2007-05-06 14:51:21 -0700295 return copy_from_user(to, from, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
298int clear_user_proc(void __user *buf, int size)
299{
Jeff Dike6e21aec2007-05-06 14:51:21 -0700300 return clear_user(buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302
303int strlen_user_proc(char __user *str)
304{
Jeff Dike6e21aec2007-05-06 14:51:21 -0700305 return strlen_user(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
307
308int smp_sigio_handler(void)
309{
310#ifdef CONFIG_SMP
Jeff Dikea5a678c2008-02-04 22:30:54 -0800311 int cpu = current_thread_info()->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 IPI_handler(cpu);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700313 if (cpu != 0)
Jeff Dike6e21aec2007-05-06 14:51:21 -0700314 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315#endif
Jeff Dike6e21aec2007-05-06 14:51:21 -0700316 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319int cpu(void)
320{
Jeff Dikea5a678c2008-02-04 22:30:54 -0800321 return current_thread_info()->cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
324static atomic_t using_sysemu = ATOMIC_INIT(0);
325int sysemu_supported;
326
327void set_using_sysemu(int value)
328{
329 if (value > sysemu_supported)
330 return;
331 atomic_set(&using_sysemu, value);
332}
333
334int get_using_sysemu(void)
335{
336 return atomic_read(&using_sysemu);
337}
338
339static int proc_read_sysemu(char *buf, char **start, off_t offset, int size,int *eof, void *data)
340{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700341 if (snprintf(buf, size, "%d\n", get_using_sysemu()) < size)
342 /* No overflow */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 *eof = 1;
344
345 return strlen(buf);
346}
347
Al Viro4d338e12006-03-31 02:30:15 -0800348static int proc_write_sysemu(struct file *file,const char __user *buf, unsigned long count,void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
350 char tmp[2];
351
352 if (copy_from_user(tmp, buf, 1))
353 return -EFAULT;
354
355 if (tmp[0] >= '0' && tmp[0] <= '2')
356 set_using_sysemu(tmp[0] - '0');
Jeff Dikeba180fd2007-10-16 01:27:00 -0700357 /* We use the first char, but pretend to write everything */
358 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
361int __init make_proc_sysemu(void)
362{
363 struct proc_dir_entry *ent;
364 if (!sysemu_supported)
365 return 0;
366
Alexey Dobriyanc74c1202008-04-29 01:01:44 -0700367 ent = create_proc_entry("sysemu", 0600, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
369 if (ent == NULL)
370 {
Christophe Lucas30f417c2005-07-28 21:16:12 -0700371 printk(KERN_WARNING "Failed to register /proc/sysemu\n");
Jeff Dike6e21aec2007-05-06 14:51:21 -0700372 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 }
374
375 ent->read_proc = proc_read_sysemu;
376 ent->write_proc = proc_write_sysemu;
377
378 return 0;
379}
380
381late_initcall(make_proc_sysemu);
382
383int singlestepping(void * t)
384{
385 struct task_struct *task = t ? t : current;
386
Jeff Dikec5d4bb12008-02-04 22:31:14 -0800387 if (!(task->ptrace & PT_DTRACE))
Jeff Dikeba180fd2007-10-16 01:27:00 -0700388 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 if (task->thread.singlestep_syscall)
Jeff Dikeba180fd2007-10-16 01:27:00 -0700391 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 return 2;
394}
395
Bodo Stroesserb8bd0222005-05-06 21:30:53 -0700396/*
397 * Only x86 and x86_64 have an arch_align_stack().
398 * All other arches have "#define arch_align_stack(x) (x)"
399 * in their asm/system.h
400 * As this is included in UML from asm-um/system-generic.h,
401 * we can use it to behave as the subarch does.
402 */
403#ifndef arch_align_stack
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404unsigned long arch_align_stack(unsigned long sp)
405{
Jeff Dike8f80e942006-09-25 23:33:01 -0700406 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 sp -= get_random_int() % 8192;
408 return sp & ~0xf;
409}
Bodo Stroesserb8bd0222005-05-06 21:30:53 -0700410#endif
Jeff Dikec1127462008-02-04 22:30:36 -0800411
412unsigned long get_wchan(struct task_struct *p)
413{
414 unsigned long stack_page, sp, ip;
415 bool seen_sched = 0;
416
417 if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
418 return 0;
419
420 stack_page = (unsigned long) task_stack_page(p);
421 /* Bail if the process has no kernel stack for some reason */
422 if (stack_page == 0)
423 return 0;
424
425 sp = p->thread.switch_buf->JB_SP;
426 /*
427 * Bail if the stack pointer is below the bottom of the kernel
428 * stack for some reason
429 */
430 if (sp < stack_page)
431 return 0;
432
433 while (sp < stack_page + THREAD_SIZE) {
434 ip = *((unsigned long *) sp);
435 if (in_sched_functions(ip))
436 /* Ignore everything until we're above the scheduler */
437 seen_sched = 1;
438 else if (kernel_text_address(ip) && seen_sched)
439 return ip;
440
441 sp += sizeof(unsigned long);
442 }
443
444 return 0;
445}
Jeff Dike8192ab42008-02-04 22:30:53 -0800446
447int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
448{
449 int cpu = current_thread_info()->cpu;
450
451 return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);
452}
453