2 * This file handles the architecture dependent parts of process handling.
4 * Copyright IBM Corp. 1999, 2009
5 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
6 * Hartmut Penner <hp@de.ibm.com>,
10 #include <linux/compiler.h>
11 #include <linux/cpu.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
15 #include <linux/elfcore.h>
16 #include <linux/smp.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/tick.h>
20 #include <linux/personality.h>
21 #include <linux/syscalls.h>
22 #include <linux/compat.h>
23 #include <linux/kprobes.h>
24 #include <linux/random.h>
25 #include <linux/module.h>
27 #include <asm/processor.h>
28 #include <asm/vtimer.h>
33 #include <asm/switch_to.h>
34 #include <asm/runtime_instr.h>
37 asmlinkage
void ret_from_fork(void) asm ("ret_from_fork");
40 * Return saved PC of a blocked thread. used in kernel/sched.
41 * resume in entry.S does not create a new stack frame, it
42 * just stores the registers %r6-%r15 to the frame given by
43 * schedule. We want to return the address of the caller of
44 * schedule, so we have to walk the backchain one time to
45 * find the frame schedule() store its return address.
47 unsigned long thread_saved_pc(struct task_struct
*tsk
)
49 struct stack_frame
*sf
, *low
, *high
;
51 if (!tsk
|| !task_stack_page(tsk
))
53 low
= task_stack_page(tsk
);
54 high
= (struct stack_frame
*) task_pt_regs(tsk
);
55 sf
= (struct stack_frame
*) (tsk
->thread
.ksp
& PSW_ADDR_INSN
);
56 if (sf
<= low
|| sf
> high
)
58 sf
= (struct stack_frame
*) (sf
->back_chain
& PSW_ADDR_INSN
);
59 if (sf
<= low
|| sf
> high
)
64 extern void kernel_thread_starter(void);
67 * Free current thread data structures etc..
69 void exit_thread(void)
71 exit_thread_runtime_instr();
74 void flush_thread(void)
78 void release_thread(struct task_struct
*dead_task
)
82 void arch_release_task_struct(struct task_struct
*tsk
)
84 /* Free either the floating-point or the vector register save area */
85 kfree(tsk
->thread
.fpu
.regs
);
88 int arch_dup_task_struct(struct task_struct
*dst
, struct task_struct
*src
)
92 /* Set up a new floating-point register save area */
93 dst
->thread
.fpu
.fpc
= 0;
94 dst
->thread
.fpu
.flags
= 0; /* Always start with VX disabled */
95 dst
->thread
.fpu
.fprs
= kzalloc(sizeof(freg_t
) * __NUM_FPRS
,
96 GFP_KERNEL
|__GFP_REPEAT
);
97 if (!dst
->thread
.fpu
.fprs
)
101 * Save the floating-point or vector register state of the current
102 * task. The state is not saved for early kernel threads, for example,
103 * the init_task, which do not have an allocated save area.
104 * The CIF_FPU flag is set in any case to lazy clear or restore a saved
105 * state when switching to a different task or returning to user space.
108 dst
->thread
.fpu
.fpc
= current
->thread
.fpu
.fpc
;
109 if (is_vx_task(current
))
110 convert_vx_to_fp(dst
->thread
.fpu
.fprs
,
111 current
->thread
.fpu
.vxrs
);
113 memcpy(dst
->thread
.fpu
.fprs
, current
->thread
.fpu
.fprs
,
114 sizeof(freg_t
) * __NUM_FPRS
);
118 int copy_thread(unsigned long clone_flags
, unsigned long new_stackp
,
119 unsigned long arg
, struct task_struct
*p
)
121 struct thread_info
*ti
;
124 struct stack_frame sf
;
125 struct pt_regs childregs
;
128 frame
= container_of(task_pt_regs(p
), struct fake_frame
, childregs
);
129 p
->thread
.ksp
= (unsigned long) frame
;
130 /* Save access registers to new thread structure. */
131 save_access_regs(&p
->thread
.acrs
[0]);
132 /* start new process with ar4 pointing to the correct address space */
133 p
->thread
.mm_segment
= get_fs();
134 /* Don't copy debug registers */
135 memset(&p
->thread
.per_user
, 0, sizeof(p
->thread
.per_user
));
136 memset(&p
->thread
.per_event
, 0, sizeof(p
->thread
.per_event
));
137 clear_tsk_thread_flag(p
, TIF_SINGLE_STEP
);
138 /* Initialize per thread user and system timer values */
139 ti
= task_thread_info(p
);
141 ti
->system_timer
= 0;
143 frame
->sf
.back_chain
= 0;
144 /* new return point is ret_from_fork */
145 frame
->sf
.gprs
[8] = (unsigned long) ret_from_fork
;
146 /* fake return stack for resume(), don't go back to schedule */
147 frame
->sf
.gprs
[9] = (unsigned long) frame
;
149 /* Store access registers to kernel stack of new process. */
150 if (unlikely(p
->flags
& PF_KTHREAD
)) {
152 memset(&frame
->childregs
, 0, sizeof(struct pt_regs
));
153 frame
->childregs
.psw
.mask
= PSW_KERNEL_BITS
| PSW_MASK_DAT
|
154 PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
;
155 frame
->childregs
.psw
.addr
= PSW_ADDR_AMODE
|
156 (unsigned long) kernel_thread_starter
;
157 frame
->childregs
.gprs
[9] = new_stackp
; /* function */
158 frame
->childregs
.gprs
[10] = arg
;
159 frame
->childregs
.gprs
[11] = (unsigned long) do_exit
;
160 frame
->childregs
.orig_gpr2
= -1;
164 frame
->childregs
= *current_pt_regs();
165 frame
->childregs
.gprs
[2] = 0; /* child returns 0 on fork. */
166 frame
->childregs
.flags
= 0;
168 frame
->childregs
.gprs
[15] = new_stackp
;
170 /* Don't copy runtime instrumentation info */
171 p
->thread
.ri_cb
= NULL
;
172 p
->thread
.ri_signum
= 0;
173 frame
->childregs
.psw
.mask
&= ~PSW_MASK_RI
;
175 /* Set a new TLS ? */
176 if (clone_flags
& CLONE_SETTLS
) {
177 unsigned long tls
= frame
->childregs
.gprs
[6];
178 if (is_compat_task()) {
179 p
->thread
.acrs
[0] = (unsigned int)tls
;
181 p
->thread
.acrs
[0] = (unsigned int)(tls
>> 32);
182 p
->thread
.acrs
[1] = (unsigned int)tls
;
188 asmlinkage
void execve_tail(void)
190 current
->thread
.fpu
.fpc
= 0;
191 asm volatile("sfpc %0" : : "d" (0));
195 * fill in the FPU structure for a core dump.
197 int dump_fpu (struct pt_regs
* regs
, s390_fp_regs
*fpregs
)
200 fpregs
->fpc
= current
->thread
.fpu
.fpc
;
202 if (is_vx_task(current
))
203 convert_vx_to_fp((freg_t
*)&fpregs
->fprs
,
204 current
->thread
.fpu
.vxrs
);
206 memcpy(&fpregs
->fprs
, current
->thread
.fpu
.fprs
,
207 sizeof(fpregs
->fprs
));
210 EXPORT_SYMBOL(dump_fpu
);
212 unsigned long get_wchan(struct task_struct
*p
)
214 struct stack_frame
*sf
, *low
, *high
;
215 unsigned long return_address
;
218 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
|| !task_stack_page(p
))
220 low
= task_stack_page(p
);
221 high
= (struct stack_frame
*) task_pt_regs(p
);
222 sf
= (struct stack_frame
*) (p
->thread
.ksp
& PSW_ADDR_INSN
);
223 if (sf
<= low
|| sf
> high
)
225 for (count
= 0; count
< 16; count
++) {
226 sf
= (struct stack_frame
*) (sf
->back_chain
& PSW_ADDR_INSN
);
227 if (sf
<= low
|| sf
> high
)
229 return_address
= sf
->gprs
[8] & PSW_ADDR_INSN
;
230 if (!in_sched_functions(return_address
))
231 return return_address
;
236 unsigned long arch_align_stack(unsigned long sp
)
238 if (!(current
->personality
& ADDR_NO_RANDOMIZE
) && randomize_va_space
)
239 sp
-= get_random_int() & ~PAGE_MASK
;
243 static inline unsigned long brk_rnd(void)
245 /* 8MB for 32bit, 1GB for 64bit */
247 return (get_random_int() & 0x7ffUL
) << PAGE_SHIFT
;
249 return (get_random_int() & 0x3ffffUL
) << PAGE_SHIFT
;
252 unsigned long arch_randomize_brk(struct mm_struct
*mm
)
256 ret
= PAGE_ALIGN(mm
->brk
+ brk_rnd());
257 return (ret
> mm
->brk
) ? ret
: mm
->brk
;