diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/h8300/kernel/process.c |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'arch/h8300/kernel/process.c')
-rw-r--r-- | arch/h8300/kernel/process.c | 288 |
1 files changed, 288 insertions, 0 deletions
diff --git a/arch/h8300/kernel/process.c b/arch/h8300/kernel/process.c new file mode 100644 index 00000000000..134aec1c6d1 --- /dev/null +++ b/arch/h8300/kernel/process.c | |||
@@ -0,0 +1,288 @@ | |||
1 | /* | ||
2 | * linux/arch/h8300/kernel/process.c | ||
3 | * | ||
4 | * Yoshinori Sato <ysato@users.sourceforge.jp> | ||
5 | * | ||
6 | * Based on: | ||
7 | * | ||
8 | * linux/arch/m68knommu/kernel/process.c | ||
9 | * | ||
10 | * Copyright (C) 1998 D. Jeff Dionne <jeff@ryeham.ee.ryerson.ca>, | ||
11 | * Kenneth Albanowski <kjahds@kjahds.com>, | ||
12 | * The Silver Hammer Group, Ltd. | ||
13 | * | ||
14 | * linux/arch/m68k/kernel/process.c | ||
15 | * | ||
16 | * Copyright (C) 1995 Hamish Macdonald | ||
17 | * | ||
18 | * 68060 fixes by Jesper Skov | ||
19 | */ | ||
20 | |||
21 | /* | ||
22 | * This file handles the architecture-dependent parts of process handling.. | ||
23 | */ | ||
24 | |||
25 | #include <linux/config.h> | ||
26 | #include <linux/errno.h> | ||
27 | #include <linux/module.h> | ||
28 | #include <linux/sched.h> | ||
29 | #include <linux/kernel.h> | ||
30 | #include <linux/mm.h> | ||
31 | #include <linux/smp.h> | ||
32 | #include <linux/smp_lock.h> | ||
33 | #include <linux/stddef.h> | ||
34 | #include <linux/unistd.h> | ||
35 | #include <linux/ptrace.h> | ||
36 | #include <linux/slab.h> | ||
37 | #include <linux/user.h> | ||
38 | #include <linux/a.out.h> | ||
39 | #include <linux/interrupt.h> | ||
40 | #include <linux/reboot.h> | ||
41 | |||
42 | #include <asm/uaccess.h> | ||
43 | #include <asm/system.h> | ||
44 | #include <asm/traps.h> | ||
45 | #include <asm/setup.h> | ||
46 | #include <asm/pgtable.h> | ||
47 | |||
48 | asmlinkage void ret_from_fork(void); | ||
49 | |||
50 | /* | ||
51 | * The idle loop on an H8/300.. | ||
52 | */ | ||
53 | #if !defined(CONFIG_H8300H_SIM) && !defined(CONFIG_H8S_SIM) | ||
54 | void default_idle(void) | ||
55 | { | ||
56 | while(1) { | ||
57 | if (need_resched()) { | ||
58 | local_irq_enable(); | ||
59 | __asm__("sleep"); | ||
60 | local_irq_disable(); | ||
61 | } | ||
62 | schedule(); | ||
63 | } | ||
64 | } | ||
65 | #else | ||
66 | void default_idle(void) | ||
67 | { | ||
68 | while(1) { | ||
69 | if (need_resched()) | ||
70 | schedule(); | ||
71 | } | ||
72 | } | ||
73 | #endif | ||
74 | void (*idle)(void) = default_idle; | ||
75 | |||
76 | /* | ||
77 | * The idle thread. There's no useful work to be | ||
78 | * done, so just try to conserve power and have a | ||
79 | * low exit latency (ie sit in a loop waiting for | ||
80 | * somebody to say that they'd like to reschedule) | ||
81 | */ | ||
82 | void cpu_idle(void) | ||
83 | { | ||
84 | idle(); | ||
85 | } | ||
86 | |||
87 | void machine_restart(char * __unused) | ||
88 | { | ||
89 | local_irq_disable(); | ||
90 | __asm__("jmp @@0"); | ||
91 | } | ||
92 | |||
93 | EXPORT_SYMBOL(machine_restart); | ||
94 | |||
95 | void machine_halt(void) | ||
96 | { | ||
97 | local_irq_disable(); | ||
98 | __asm__("sleep"); | ||
99 | for (;;); | ||
100 | } | ||
101 | |||
102 | EXPORT_SYMBOL(machine_halt); | ||
103 | |||
104 | void machine_power_off(void) | ||
105 | { | ||
106 | local_irq_disable(); | ||
107 | __asm__("sleep"); | ||
108 | for (;;); | ||
109 | } | ||
110 | |||
111 | EXPORT_SYMBOL(machine_power_off); | ||
112 | |||
113 | void show_regs(struct pt_regs * regs) | ||
114 | { | ||
115 | printk("\nPC: %08lx Status: %02x", | ||
116 | regs->pc, regs->ccr); | ||
117 | printk("\nORIG_ER0: %08lx ER0: %08lx ER1: %08lx", | ||
118 | regs->orig_er0, regs->er0, regs->er1); | ||
119 | printk("\nER2: %08lx ER3: %08lx ER4: %08lx ER5: %08lx", | ||
120 | regs->er2, regs->er3, regs->er4, regs->er5); | ||
121 | printk("\nER6' %08lx ",regs->er6); | ||
122 | if (user_mode(regs)) | ||
123 | printk("USP: %08lx\n", rdusp()); | ||
124 | else | ||
125 | printk("\n"); | ||
126 | } | ||
127 | |||
128 | /* | ||
129 | * Create a kernel thread | ||
130 | */ | ||
131 | int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) | ||
132 | { | ||
133 | long retval; | ||
134 | long clone_arg; | ||
135 | mm_segment_t fs; | ||
136 | |||
137 | fs = get_fs(); | ||
138 | set_fs (KERNEL_DS); | ||
139 | clone_arg = flags | CLONE_VM; | ||
140 | __asm__("mov.l sp,er3\n\t" | ||
141 | "sub.l er2,er2\n\t" | ||
142 | "mov.l %2,er1\n\t" | ||
143 | "mov.l %1,er0\n\t" | ||
144 | "trapa #0\n\t" | ||
145 | "cmp.l sp,er3\n\t" | ||
146 | "beq 1f\n\t" | ||
147 | "mov.l %4,er0\n\t" | ||
148 | "mov.l %3,er1\n\t" | ||
149 | "jsr @er1\n\t" | ||
150 | "mov.l %5,er0\n\t" | ||
151 | "trapa #0\n" | ||
152 | "1:\n\t" | ||
153 | "mov.l er0,%0" | ||
154 | :"=r"(retval) | ||
155 | :"i"(__NR_clone),"g"(clone_arg),"g"(fn),"g"(arg),"i"(__NR_exit) | ||
156 | :"er0","er1","er2","er3"); | ||
157 | set_fs (fs); | ||
158 | return retval; | ||
159 | } | ||
160 | |||
161 | void flush_thread(void) | ||
162 | { | ||
163 | } | ||
164 | |||
165 | /* | ||
166 | * "h8300_fork()".. By the time we get here, the | ||
167 | * non-volatile registers have also been saved on the | ||
168 | * stack. We do some ugly pointer stuff here.. (see | ||
169 | * also copy_thread) | ||
170 | */ | ||
171 | |||
172 | asmlinkage int h8300_fork(struct pt_regs *regs) | ||
173 | { | ||
174 | return -EINVAL; | ||
175 | } | ||
176 | |||
177 | asmlinkage int h8300_vfork(struct pt_regs *regs) | ||
178 | { | ||
179 | return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL); | ||
180 | } | ||
181 | |||
182 | asmlinkage int h8300_clone(struct pt_regs *regs) | ||
183 | { | ||
184 | unsigned long clone_flags; | ||
185 | unsigned long newsp; | ||
186 | |||
187 | /* syscall2 puts clone_flags in er1 and usp in er2 */ | ||
188 | clone_flags = regs->er1; | ||
189 | newsp = regs->er2; | ||
190 | if (!newsp) | ||
191 | newsp = rdusp(); | ||
192 | return do_fork(clone_flags, newsp, regs, 0, NULL, NULL); | ||
193 | |||
194 | } | ||
195 | |||
196 | int copy_thread(int nr, unsigned long clone_flags, | ||
197 | unsigned long usp, unsigned long topstk, | ||
198 | struct task_struct * p, struct pt_regs * regs) | ||
199 | { | ||
200 | struct pt_regs * childregs; | ||
201 | |||
202 | childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p->thread_info)) - 1; | ||
203 | |||
204 | *childregs = *regs; | ||
205 | childregs->retpc = (unsigned long) ret_from_fork; | ||
206 | childregs->er0 = 0; | ||
207 | |||
208 | p->thread.usp = usp; | ||
209 | p->thread.ksp = (unsigned long)childregs; | ||
210 | |||
211 | return 0; | ||
212 | } | ||
213 | |||
214 | /* | ||
215 | * fill in the user structure for a core dump.. | ||
216 | */ | ||
217 | void dump_thread(struct pt_regs * regs, struct user * dump) | ||
218 | { | ||
219 | /* changed the size calculations - should hopefully work better. lbt */ | ||
220 | dump->magic = CMAGIC; | ||
221 | dump->start_code = 0; | ||
222 | dump->start_stack = rdusp() & ~(PAGE_SIZE - 1); | ||
223 | dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT; | ||
224 | dump->u_dsize = ((unsigned long) (current->mm->brk + | ||
225 | (PAGE_SIZE-1))) >> PAGE_SHIFT; | ||
226 | dump->u_dsize -= dump->u_tsize; | ||
227 | dump->u_ssize = 0; | ||
228 | |||
229 | dump->u_ar0 = (struct user_regs_struct *)(((int)(&dump->regs)) -((int)(dump))); | ||
230 | dump->regs.er0 = regs->er0; | ||
231 | dump->regs.er1 = regs->er1; | ||
232 | dump->regs.er2 = regs->er2; | ||
233 | dump->regs.er3 = regs->er3; | ||
234 | dump->regs.er4 = regs->er4; | ||
235 | dump->regs.er5 = regs->er5; | ||
236 | dump->regs.er6 = regs->er6; | ||
237 | dump->regs.orig_er0 = regs->orig_er0; | ||
238 | dump->regs.ccr = regs->ccr; | ||
239 | dump->regs.pc = regs->pc; | ||
240 | } | ||
241 | |||
242 | /* | ||
243 | * sys_execve() executes a new program. | ||
244 | */ | ||
245 | asmlinkage int sys_execve(char *name, char **argv, char **envp,int dummy,...) | ||
246 | { | ||
247 | int error; | ||
248 | char * filename; | ||
249 | struct pt_regs *regs = (struct pt_regs *) ((unsigned char *)&dummy-4); | ||
250 | |||
251 | lock_kernel(); | ||
252 | filename = getname(name); | ||
253 | error = PTR_ERR(filename); | ||
254 | if (IS_ERR(filename)) | ||
255 | goto out; | ||
256 | error = do_execve(filename, argv, envp, regs); | ||
257 | putname(filename); | ||
258 | out: | ||
259 | unlock_kernel(); | ||
260 | return error; | ||
261 | } | ||
262 | |||
263 | unsigned long thread_saved_pc(struct task_struct *tsk) | ||
264 | { | ||
265 | return ((struct pt_regs *)tsk->thread.esp0)->pc; | ||
266 | } | ||
267 | |||
268 | unsigned long get_wchan(struct task_struct *p) | ||
269 | { | ||
270 | unsigned long fp, pc; | ||
271 | unsigned long stack_page; | ||
272 | int count = 0; | ||
273 | if (!p || p == current || p->state == TASK_RUNNING) | ||
274 | return 0; | ||
275 | |||
276 | stack_page = (unsigned long)p; | ||
277 | fp = ((struct pt_regs *)p->thread.ksp)->er6; | ||
278 | do { | ||
279 | if (fp < stack_page+sizeof(struct thread_info) || | ||
280 | fp >= 8184+stack_page) | ||
281 | return 0; | ||
282 | pc = ((unsigned long *)fp)[1]; | ||
283 | if (!in_sched_functions(pc)) | ||
284 | return pc; | ||
285 | fp = *(unsigned long *) fp; | ||
286 | } while (count++ < 16); | ||
287 | return 0; | ||
288 | } | ||