File: /usr/src/linux/arch/parisc/kernel/process.c
1 /*
2 * linux/arch/parisc/kernel/process.c
3 * based on the work for i386
4 */
5
6 /*
7 * This file handles the architecture-dependent parts of process handling..
8 */
9
10 #define __KERNEL_SYSCALLS__
11 #include <stdarg.h>
12
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/mm.h>
17 #include <linux/smp.h>
18 #include <linux/smp_lock.h>
19 #include <linux/stddef.h>
20 #include <linux/unistd.h>
21 #include <linux/ptrace.h>
22 #include <linux/slab.h>
23 #include <linux/vmalloc.h>
24 #include <linux/interrupt.h>
25 #include <linux/reboot.h>
26 #include <linux/init.h>
27 #include <linux/version.h>
28 #include <linux/elf.h>
29
30 #include <asm/machdep.h>
31 #include <asm/offset.h>
32 #include <asm/uaccess.h>
33 #include <asm/pgtable.h>
34 #include <asm/system.h>
35 #include <asm/io.h>
36 #include <asm/gsc.h>
37 #include <asm/processor.h>
38
39 spinlock_t semaphore_wake_lock = SPIN_LOCK_UNLOCKED;
40
41 #ifdef __LP64__
42 /* The 64-bit code should work equally well in 32-bit land but I didn't
43 * want to take the time to confirm that. -PB
44 */
45 extern unsigned int ret_from_kernel_thread;
46 #else
47 asmlinkage void ret_from_kernel_thread(void) __asm__("ret_from_kernel_thread");
48 #endif
49
50
51 int hlt_counter=0;
52
53 void disable_hlt(void)
54 {
55 hlt_counter++;
56 }
57
58 void enable_hlt(void)
59 {
60 hlt_counter--;
61 }
62
63 /*
64 * The idle thread. There's no useful work to be
65 * done, so just try to conserve power and have a
66 * low exit latency (ie sit in a loop waiting for
67 * somebody to say that they'd like to reschedule)
68 */
69 void cpu_idle(void)
70 {
71 /* endless idle loop with no priority at all */
72 init_idle();
73 current->nice = 20;
74 current->counter = -100;
75
76 while (1) {
77 while (!current->need_resched) {
78 }
79 schedule();
80 check_pgt_cache();
81 }
82 }
83
84 void __init reboot_setup(char *str, int *ints)
85 {
86 }
87
88 struct notifier_block *mach_notifier;
89
90 void machine_restart(char *ptr)
91 {
92 notifier_call_chain(&mach_notifier, MACH_RESTART, ptr);
93 }
94
95 void machine_halt(void)
96 {
97 notifier_call_chain(&mach_notifier, MACH_HALT, NULL);
98 }
99
100 void machine_power_on(void)
101 {
102 notifier_call_chain(&mach_notifier, MACH_POWER_ON, NULL);
103 }
104
105 void machine_power_off(void)
106 {
107 notifier_call_chain(&mach_notifier, MACH_POWER_OFF, NULL);
108 }
109
110
111 void machine_heartbeat(void)
112 {
113 }
114
115
116 /*
117 * Create a kernel thread
118 */
119
120 extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
121 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
122 {
123
124 /*
125 * FIXME: Once we are sure we don't need any debug here,
126 * kernel_thread can become a #define.
127 */
128
129 return __kernel_thread(fn, arg, flags);
130 }
131
132 /*
133 * Free current thread data structures etc..
134 */
135 void exit_thread(void)
136 {
137 }
138
139 void flush_thread(void)
140 {
141 set_fs(USER_DS);
142 }
143
144 void release_thread(struct task_struct *dead_task)
145 {
146 }
147
148 /*
149 * Fill in the FPU structure for a core dump.
150 */
151 int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
152 {
153 memcpy(r, regs->fr, sizeof *r);
154 return 1;
155 }
156
157 /* Note that "fork()" is implemented in terms of clone, with
158 parameters (SIGCHLD, regs->gr[30], regs). */
159 int
160 sys_clone(unsigned long clone_flags, unsigned long usp,
161 struct pt_regs *regs)
162 {
163 return do_fork(clone_flags, usp, regs, 0);
164 }
165
166 int
167 sys_vfork(struct pt_regs *regs)
168 {
169 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
170 regs->gr[30], regs, 0);
171 }
172
173 int
174 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
175 unsigned long unused, /* in ia64 this is "user_stack_size" */
176 struct task_struct * p, struct pt_regs * pregs)
177 {
178 struct pt_regs * cregs = &(p->thread.regs);
179 long ksp;
180
181 *cregs = *pregs;
182
183 /* Set the return value for the child. Note that this is not
184 actually restored by the syscall exit path, but we put it
185 here for consistency in case of signals. */
186 cregs->gr[28] = 0; /* child */
187
188 /*
189 * We need to differentiate between a user fork and a
190 * kernel fork. We can't use user_mode, because the
191 * the syscall path doesn't save iaoq. Right now
192 * We rely on the fact that kernel_thread passes
193 * in zero for usp.
194 */
195 if (usp == 0) {
196 /* Kernel Thread */
197 ksp = (((unsigned long)(p)) + TASK_SZ_ALGN);
198 cregs->ksp = ksp; /* always return to kernel */
199 #ifdef __LP64__
200 cregs->kpc = (unsigned long) &ret_from_kernel_thread;
201 #else
202 cregs->kpc = (unsigned long) ret_from_kernel_thread;
203 #endif
204
205 /*
206 * Copy function and argument to be called from
207 * ret_from_kernel_thread.
208 */
209 cregs->gr[26] = pregs->gr[26];
210 cregs->gr[25] = pregs->gr[25];
211
212 } else {
213 /* User Thread:
214 *
215 * Use same stack depth as parent when in wrapper
216 *
217 * Note that the fork wrappers are responsible
218 * for setting gr[20] and gr[21].
219 */
220
221 cregs->ksp = ((unsigned long)(p))
222 + (pregs->gr[20] & (INIT_TASK_SIZE - 1));
223 cregs->kpc = pregs->gr[21];
224 }
225
226 return 0;
227 }
228
229 /*
230 * sys_execve() executes a new program.
231 */
232
233 asmlinkage int sys_execve(struct pt_regs *regs)
234 {
235 int error;
236 char *filename;
237
238 filename = getname((char *) regs->gr[26]);
239 error = PTR_ERR(filename);
240 if (IS_ERR(filename))
241 goto out;
242 error = do_execve(filename, (char **) regs->gr[25],
243 (char **) regs->gr[24], regs);
244 if (error == 0)
245 current->ptrace &= ~PT_DTRACE;
246 putname(filename);
247 out:
248
249 return error;
250 }
251