Loading...
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/errno.h>
26#include <linux/module.h>
27#include <linux/sched.h>
28#include <linux/kernel.h>
29#include <linux/mm.h>
30#include <linux/smp.h>
31#include <linux/stddef.h>
32#include <linux/unistd.h>
33#include <linux/ptrace.h>
34#include <linux/user.h>
35#include <linux/interrupt.h>
36#include <linux/reboot.h>
37#include <linux/fs.h>
38#include <linux/slab.h>
39
40#include <asm/uaccess.h>
41#include <asm/traps.h>
42#include <asm/setup.h>
43#include <asm/pgtable.h>
44
45void (*pm_power_off)(void) = NULL;
46EXPORT_SYMBOL(pm_power_off);
47
48asmlinkage 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)
54static void default_idle(void)
55{
56 local_irq_disable();
57 if (!need_resched()) {
58 local_irq_enable();
59 /* XXX: race here! What if need_resched() gets set now? */
60 __asm__("sleep");
61 } else
62 local_irq_enable();
63}
64#else
65static void default_idle(void)
66{
67 cpu_relax();
68}
69#endif
70void (*idle)(void) = default_idle;
71
72/*
73 * The idle thread. There's no useful work to be
74 * done, so just try to conserve power and have a
75 * low exit latency (ie sit in a loop waiting for
76 * somebody to say that they'd like to reschedule)
77 */
78void cpu_idle(void)
79{
80 while (1) {
81 while (!need_resched())
82 idle();
83 schedule_preempt_disabled();
84 }
85}
86
87void machine_restart(char * __unused)
88{
89 local_irq_disable();
90 __asm__("jmp @@0");
91}
92
93void machine_halt(void)
94{
95 local_irq_disable();
96 __asm__("sleep");
97 for (;;);
98}
99
100void machine_power_off(void)
101{
102 local_irq_disable();
103 __asm__("sleep");
104 for (;;);
105}
106
107void show_regs(struct pt_regs * regs)
108{
109 printk("\nPC: %08lx Status: %02x",
110 regs->pc, regs->ccr);
111 printk("\nORIG_ER0: %08lx ER0: %08lx ER1: %08lx",
112 regs->orig_er0, regs->er0, regs->er1);
113 printk("\nER2: %08lx ER3: %08lx ER4: %08lx ER5: %08lx",
114 regs->er2, regs->er3, regs->er4, regs->er5);
115 printk("\nER6' %08lx ",regs->er6);
116 if (user_mode(regs))
117 printk("USP: %08lx\n", rdusp());
118 else
119 printk("\n");
120}
121
122/*
123 * Create a kernel thread
124 */
125int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
126{
127 long retval;
128 long clone_arg;
129 mm_segment_t fs;
130
131 fs = get_fs();
132 set_fs (KERNEL_DS);
133 clone_arg = flags | CLONE_VM;
134 __asm__("mov.l sp,er3\n\t"
135 "sub.l er2,er2\n\t"
136 "mov.l %2,er1\n\t"
137 "mov.l %1,er0\n\t"
138 "trapa #0\n\t"
139 "cmp.l sp,er3\n\t"
140 "beq 1f\n\t"
141 "mov.l %4,er0\n\t"
142 "mov.l %3,er1\n\t"
143 "jsr @er1\n\t"
144 "mov.l %5,er0\n\t"
145 "trapa #0\n"
146 "1:\n\t"
147 "mov.l er0,%0"
148 :"=r"(retval)
149 :"i"(__NR_clone),"g"(clone_arg),"g"(fn),"g"(arg),"i"(__NR_exit)
150 :"er0","er1","er2","er3");
151 set_fs (fs);
152 return retval;
153}
154
155void flush_thread(void)
156{
157}
158
159/*
160 * "h8300_fork()".. By the time we get here, the
161 * non-volatile registers have also been saved on the
162 * stack. We do some ugly pointer stuff here.. (see
163 * also copy_thread)
164 */
165
166asmlinkage int h8300_fork(struct pt_regs *regs)
167{
168 return -EINVAL;
169}
170
171asmlinkage int h8300_vfork(struct pt_regs *regs)
172{
173 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
174}
175
176asmlinkage int h8300_clone(struct pt_regs *regs)
177{
178 unsigned long clone_flags;
179 unsigned long newsp;
180
181 /* syscall2 puts clone_flags in er1 and usp in er2 */
182 clone_flags = regs->er1;
183 newsp = regs->er2;
184 if (!newsp)
185 newsp = rdusp();
186 return do_fork(clone_flags, newsp, regs, 0, NULL, NULL);
187
188}
189
190int copy_thread(unsigned long clone_flags,
191 unsigned long usp, unsigned long topstk,
192 struct task_struct * p, struct pt_regs * regs)
193{
194 struct pt_regs * childregs;
195
196 childregs = (struct pt_regs *) (THREAD_SIZE + task_stack_page(p)) - 1;
197
198 *childregs = *regs;
199 childregs->retpc = (unsigned long) ret_from_fork;
200 childregs->er0 = 0;
201
202 p->thread.usp = usp;
203 p->thread.ksp = (unsigned long)childregs;
204
205 return 0;
206}
207
208/*
209 * sys_execve() executes a new program.
210 */
211asmlinkage int sys_execve(const char *name,
212 const char *const *argv,
213 const char *const *envp,
214 int dummy, ...)
215{
216 int error;
217 char * filename;
218 struct pt_regs *regs = (struct pt_regs *) ((unsigned char *)&dummy-4);
219
220 filename = getname(name);
221 error = PTR_ERR(filename);
222 if (IS_ERR(filename))
223 return error;
224 error = do_execve(filename, argv, envp, regs);
225 putname(filename);
226 return error;
227}
228
229unsigned long thread_saved_pc(struct task_struct *tsk)
230{
231 return ((struct pt_regs *)tsk->thread.esp0)->pc;
232}
233
234unsigned long get_wchan(struct task_struct *p)
235{
236 unsigned long fp, pc;
237 unsigned long stack_page;
238 int count = 0;
239 if (!p || p == current || p->state == TASK_RUNNING)
240 return 0;
241
242 stack_page = (unsigned long)p;
243 fp = ((struct pt_regs *)p->thread.ksp)->er6;
244 do {
245 if (fp < stack_page+sizeof(struct thread_info) ||
246 fp >= 8184+stack_page)
247 return 0;
248 pc = ((unsigned long *)fp)[1];
249 if (!in_sched_functions(pc))
250 return pc;
251 fp = *(unsigned long *) fp;
252 } while (count++ < 16);
253 return 0;
254}
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/errno.h>
26#include <linux/module.h>
27#include <linux/sched.h>
28#include <linux/kernel.h>
29#include <linux/mm.h>
30#include <linux/smp.h>
31#include <linux/stddef.h>
32#include <linux/unistd.h>
33#include <linux/ptrace.h>
34#include <linux/user.h>
35#include <linux/interrupt.h>
36#include <linux/reboot.h>
37#include <linux/fs.h>
38#include <linux/slab.h>
39#include <linux/rcupdate.h>
40
41#include <linux/uaccess.h>
42#include <asm/traps.h>
43#include <asm/setup.h>
44#include <asm/pgtable.h>
45
46void (*pm_power_off)(void) = NULL;
47EXPORT_SYMBOL(pm_power_off);
48
49asmlinkage void ret_from_fork(void);
50asmlinkage void ret_from_kernel_thread(void);
51
52/*
53 * The idle loop on an H8/300..
54 */
55void arch_cpu_idle(void)
56{
57 local_irq_enable();
58 __asm__("sleep");
59}
60
61void machine_restart(char *__unused)
62{
63 local_irq_disable();
64 __asm__("jmp @@0");
65}
66
67void machine_halt(void)
68{
69 local_irq_disable();
70 __asm__("sleep");
71 for (;;)
72 ;
73}
74
75void machine_power_off(void)
76{
77 local_irq_disable();
78 __asm__("sleep");
79 for (;;)
80 ;
81}
82
83void show_regs(struct pt_regs *regs)
84{
85 show_regs_print_info(KERN_DEFAULT);
86
87 pr_notice("\n");
88 pr_notice("PC: %08lx Status: %02x\n",
89 regs->pc, regs->ccr);
90 pr_notice("ORIG_ER0: %08lx ER0: %08lx ER1: %08lx\n",
91 regs->orig_er0, regs->er0, regs->er1);
92 pr_notice("ER2: %08lx ER3: %08lx ER4: %08lx ER5: %08lx\n",
93 regs->er2, regs->er3, regs->er4, regs->er5);
94 pr_notice("ER6' %08lx ", regs->er6);
95 if (user_mode(regs))
96 printk("USP: %08lx\n", rdusp());
97 else
98 printk("\n");
99}
100
101void flush_thread(void)
102{
103}
104
105int copy_thread(unsigned long clone_flags,
106 unsigned long usp, unsigned long topstk,
107 struct task_struct *p)
108{
109 struct pt_regs *childregs;
110
111 childregs = (struct pt_regs *) (THREAD_SIZE + task_stack_page(p)) - 1;
112
113 if (unlikely(p->flags & PF_KTHREAD)) {
114 memset(childregs, 0, sizeof(struct pt_regs));
115 childregs->retpc = (unsigned long) ret_from_kernel_thread;
116 childregs->er4 = topstk; /* arg */
117 childregs->er5 = usp; /* fn */
118 } else {
119 *childregs = *current_pt_regs();
120 childregs->er0 = 0;
121 childregs->retpc = (unsigned long) ret_from_fork;
122 p->thread.usp = usp ?: rdusp();
123 }
124 p->thread.ksp = (unsigned long)childregs;
125
126 return 0;
127}
128
129unsigned long thread_saved_pc(struct task_struct *tsk)
130{
131 return ((struct pt_regs *)tsk->thread.esp0)->pc;
132}
133
134unsigned long get_wchan(struct task_struct *p)
135{
136 unsigned long fp, pc;
137 unsigned long stack_page;
138 int count = 0;
139
140 if (!p || p == current || p->state == TASK_RUNNING)
141 return 0;
142
143 stack_page = (unsigned long)p;
144 fp = ((struct pt_regs *)p->thread.ksp)->er6;
145 do {
146 if (fp < stack_page+sizeof(struct thread_info) ||
147 fp >= 8184+stack_page)
148 return 0;
149 pc = ((unsigned long *)fp)[1];
150 if (!in_sched_functions(pc))
151 return pc;
152 fp = *(unsigned long *) fp;
153 } while (count++ < 16);
154 return 0;
155}
156
157/* generic sys_clone is not enough registers */
158asmlinkage int sys_clone(unsigned long __user *args)
159{
160 unsigned long clone_flags;
161 unsigned long newsp;
162 uintptr_t parent_tidptr;
163 uintptr_t child_tidptr;
164
165 get_user(clone_flags, &args[0]);
166 get_user(newsp, &args[1]);
167 get_user(parent_tidptr, &args[2]);
168 get_user(child_tidptr, &args[3]);
169 return do_fork(clone_flags, newsp, 0,
170 (int __user *)parent_tidptr, (int __user *)child_tidptr);
171}