2 * arch/xtensa/kernel/process.c
4 * Xtensa Processor version.
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
10 * Copyright (C) 2001 - 2005 Tensilica Inc.
12 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
13 * Chris Zankel <chris@zankel.net>
14 * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca>
18 #include <linux/errno.h>
19 #include <linux/sched.h>
20 #include <linux/kernel.h>
22 #include <linux/smp.h>
23 #include <linux/stddef.h>
24 #include <linux/unistd.h>
25 #include <linux/ptrace.h>
26 #include <linux/elf.h>
27 #include <linux/init.h>
28 #include <linux/prctl.h>
29 #include <linux/init_task.h>
30 #include <linux/module.h>
31 #include <linux/mqueue.h>
33 #include <linux/slab.h>
35 #include <asm/pgtable.h>
36 #include <asm/uaccess.h>
37 #include <asm/system.h>
39 #include <asm/processor.h>
40 #include <asm/platform.h>
43 #include <linux/atomic.h>
44 #include <asm/asm-offsets.h>
47 extern void ret_from_fork(void);
49 struct task_struct
*current_set
[NR_CPUS
] = {&init_task
, };
51 void (*pm_power_off
)(void) = NULL
;
52 EXPORT_SYMBOL(pm_power_off
);
55 #if XTENSA_HAVE_COPROCESSORS
57 void coprocessor_release_all(struct thread_info
*ti
)
59 unsigned long cpenable
;
62 /* Make sure we don't switch tasks during this operation. */
66 /* Walk through all cp owners and release it for the requested one. */
68 cpenable
= ti
->cpenable
;
70 for (i
= 0; i
< XCHAL_CP_MAX
; i
++) {
71 if (coprocessor_owner
[i
] == ti
) {
72 coprocessor_owner
[i
] = 0;
73 cpenable
&= ~(1 << i
);
77 ti
->cpenable
= cpenable
;
78 coprocessor_clear_cpenable();
83 void coprocessor_flush_all(struct thread_info
*ti
)
85 unsigned long cpenable
;
90 cpenable
= ti
->cpenable
;
92 for (i
= 0; i
< XCHAL_CP_MAX
; i
++) {
93 if ((cpenable
& 1) != 0 && coprocessor_owner
[i
] == ti
)
94 coprocessor_flush(ti
, i
);
105 * Powermanagement idle function, if any is provided by the platform.
112 /* endless idle loop with no priority at all */
114 while (!need_resched())
116 schedule_preempt_disabled();
121 * This is called when the thread calls exit().
123 void exit_thread(void)
125 #if XTENSA_HAVE_COPROCESSORS
126 coprocessor_release_all(current_thread_info());
131 * Flush thread state. This is called when a thread does an execve()
132 * Note that we flush coprocessor registers for the case execve fails.
134 void flush_thread(void)
136 #if XTENSA_HAVE_COPROCESSORS
137 struct thread_info
*ti
= current_thread_info();
138 coprocessor_flush_all(ti
);
139 coprocessor_release_all(ti
);
144 * This is called before the thread is copied.
146 void prepare_to_copy(struct task_struct
*tsk
)
148 #if XTENSA_HAVE_COPROCESSORS
149 coprocessor_flush_all(task_thread_info(tsk
));
156 * The stack layout for the new thread looks like this:
158 * +------------------------+ <- sp in childregs (= tos)
160 * +------------------------+ <- thread.sp = sp in dummy-frame
161 * | dummy-frame | (saved in dummy-frame spill-area)
162 * +------------------------+
164 * We create a dummy frame to return to ret_from_fork:
165 * a0 points to ret_from_fork (simulating a call4)
166 * sp points to itself (thread.sp)
169 * Note: This is a pristine frame, so we don't need any spill region on top of
173 int copy_thread(unsigned long clone_flags
, unsigned long usp
,
174 unsigned long unused
,
175 struct task_struct
* p
, struct pt_regs
* regs
)
177 struct pt_regs
*childregs
;
178 struct thread_info
*ti
;
180 int user_mode
= user_mode(regs
);
182 /* Set up new TSS. */
183 tos
= (unsigned long)task_stack_page(p
) + THREAD_SIZE
;
185 childregs
= (struct pt_regs
*)(tos
- PT_USER_SIZE
);
187 childregs
= (struct pt_regs
*)tos
- 1;
191 /* Create a call4 dummy-frame: a0 = 0, a1 = childregs. */
192 *((int*)childregs
- 3) = (unsigned long)childregs
;
193 *((int*)childregs
- 4) = 0;
195 childregs
->areg
[1] = tos
;
196 childregs
->areg
[2] = 0;
197 p
->set_child_tid
= p
->clear_child_tid
= NULL
;
198 p
->thread
.ra
= MAKE_RA_FOR_CALL((unsigned long)ret_from_fork
, 0x1);
199 p
->thread
.sp
= (unsigned long)childregs
;
201 if (user_mode(regs
)) {
203 int len
= childregs
->wmask
& ~0xf;
204 childregs
->areg
[1] = usp
;
205 memcpy(&childregs
->areg
[XCHAL_NUM_AREGS
- len
/4],
206 ®s
->areg
[XCHAL_NUM_AREGS
- len
/4], len
);
207 // FIXME: we need to set THREADPTR in thread_info...
208 if (clone_flags
& CLONE_SETTLS
)
209 childregs
->areg
[2] = childregs
->areg
[6];
212 /* In kernel space, we start a new thread with a new stack. */
213 childregs
->wmask
= 1;
216 #if (XTENSA_HAVE_COPROCESSORS || XTENSA_HAVE_IO_PORTS)
217 ti
= task_thread_info(p
);
226 * These bracket the sleeping functions..
229 unsigned long get_wchan(struct task_struct
*p
)
231 unsigned long sp
, pc
;
232 unsigned long stack_page
= (unsigned long) task_stack_page(p
);
235 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
)
239 pc
= MAKE_PC_FROM_RA(p
->thread
.ra
, p
->thread
.sp
);
242 if (sp
< stack_page
+ sizeof(struct task_struct
) ||
243 sp
>= (stack_page
+ THREAD_SIZE
) ||
246 if (!in_sched_functions(pc
))
249 /* Stack layout: sp-4: ra, sp-3: sp' */
251 pc
= MAKE_PC_FROM_RA(*(unsigned long*)sp
- 4, sp
);
252 sp
= *(unsigned long *)sp
- 3;
253 } while (count
++ < 16);
258 * xtensa_gregset_t and 'struct pt_regs' are vastly different formats
259 * of processor registers. Besides different ordering,
260 * xtensa_gregset_t contains non-live register information that
261 * 'struct pt_regs' does not. Exception handling (primarily) uses
262 * 'struct pt_regs'. Core files and ptrace use xtensa_gregset_t.
266 void xtensa_elf_core_copy_regs (xtensa_gregset_t
*elfregs
, struct pt_regs
*regs
)
268 unsigned long wb
, ws
, wm
;
271 wb
= regs
->windowbase
;
272 ws
= regs
->windowstart
;
274 ws
= ((ws
>> wb
) | (ws
<< (WSBITS
- wb
))) & ((1 << WSBITS
) - 1);
276 /* Don't leak any random bits. */
278 memset(elfregs
, 0, sizeof (elfregs
));
280 /* Note: PS.EXCM is not set while user task is running; its
281 * being set in regs->ps is for exception handling convenience.
284 elfregs
->pc
= regs
->pc
;
285 elfregs
->ps
= (regs
->ps
& ~(1 << PS_EXCM_BIT
));
286 elfregs
->lbeg
= regs
->lbeg
;
287 elfregs
->lend
= regs
->lend
;
288 elfregs
->lcount
= regs
->lcount
;
289 elfregs
->sar
= regs
->sar
;
290 elfregs
->windowstart
= ws
;
292 live
= (wm
& 2) ? 4 : (wm
& 4) ? 8 : (wm
& 8) ? 12 : 16;
293 last
= XCHAL_NUM_AREGS
- (wm
>> 4) * 4;
294 memcpy(elfregs
->a
, regs
->areg
, live
* 4);
295 memcpy(elfregs
->a
+ last
, regs
->areg
+ last
, (wm
>> 4) * 16);
304 long xtensa_clone(unsigned long clone_flags
, unsigned long newsp
,
305 void __user
*parent_tid
, void *child_tls
,
306 void __user
*child_tid
, long a5
,
307 struct pt_regs
*regs
)
310 newsp
= regs
->areg
[1];
311 return do_fork(clone_flags
, newsp
, regs
, 0, parent_tid
, child_tid
);
315 * xtensa_execve() executes a new program.
319 long xtensa_execve(const char __user
*name
,
320 const char __user
*const __user
*argv
,
321 const char __user
*const __user
*envp
,
322 long a3
, long a4
, long a5
,
323 struct pt_regs
*regs
)
328 filename
= getname(name
);
329 error
= PTR_ERR(filename
);
330 if (IS_ERR(filename
))
332 error
= do_execve(filename
, argv
, envp
, regs
);
This page took 0.047386 seconds and 5 git commands to generate.