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/elf-randomize.h>
11 #include <linux/compiler.h>
12 #include <linux/cpu.h>
13 #include <linux/sched.h>
14 #include <linux/sched/debug.h>
15 #include <linux/sched/task.h>
16 #include <linux/sched/task_stack.h>
17 #include <linux/kernel.h>
19 #include <linux/elfcore.h>
20 #include <linux/smp.h>
21 #include <linux/slab.h>
22 #include <linux/interrupt.h>
23 #include <linux/tick.h>
24 #include <linux/personality.h>
25 #include <linux/syscalls.h>
26 #include <linux/compat.h>
27 #include <linux/kprobes.h>
28 #include <linux/random.h>
29 #include <linux/export.h>
30 #include <linux/init_task.h>
32 #include <asm/processor.h>
33 #include <asm/vtimer.h>
38 #include <asm/switch_to.h>
39 #include <asm/runtime_instr.h>
42 asmlinkage
void ret_from_fork(void) asm ("ret_from_fork");
45 * Return saved PC of a blocked thread. used in kernel/sched.
46 * resume in entry.S does not create a new stack frame, it
47 * just stores the registers %r6-%r15 to the frame given by
48 * schedule. We want to return the address of the caller of
49 * schedule, so we have to walk the backchain one time to
50 * find the frame schedule() store its return address.
52 unsigned long thread_saved_pc(struct task_struct
*tsk
)
54 struct stack_frame
*sf
, *low
, *high
;
56 if (!tsk
|| !task_stack_page(tsk
))
58 low
= task_stack_page(tsk
);
59 high
= (struct stack_frame
*) task_pt_regs(tsk
);
60 sf
= (struct stack_frame
*) tsk
->thread
.ksp
;
61 if (sf
<= low
|| sf
> high
)
63 sf
= (struct stack_frame
*) sf
->back_chain
;
64 if (sf
<= low
|| sf
> high
)
69 extern void kernel_thread_starter(void);
72 * Free current thread data structures etc..
74 void exit_thread(struct task_struct
*tsk
)
77 exit_thread_runtime_instr();
82 void flush_thread(void)
86 void release_thread(struct task_struct
*dead_task
)
90 void arch_release_task_struct(struct task_struct
*tsk
)
94 int arch_dup_task_struct(struct task_struct
*dst
, struct task_struct
*src
)
97 * Save the floating-point or vector register state of the current
98 * task and set the CIF_FPU flag to lazy restore the FPU register
99 * state when returning to user space.
103 memcpy(dst
, src
, arch_task_struct_size
);
104 dst
->thread
.fpu
.regs
= dst
->thread
.fpu
.fprs
;
108 int copy_thread_tls(unsigned long clone_flags
, unsigned long new_stackp
,
109 unsigned long arg
, struct task_struct
*p
, unsigned long tls
)
113 struct stack_frame sf
;
114 struct pt_regs childregs
;
117 frame
= container_of(task_pt_regs(p
), struct fake_frame
, childregs
);
118 p
->thread
.ksp
= (unsigned long) frame
;
119 /* Save access registers to new thread structure. */
120 save_access_regs(&p
->thread
.acrs
[0]);
121 /* start new process with ar4 pointing to the correct address space */
122 p
->thread
.mm_segment
= get_fs();
123 /* Don't copy debug registers */
124 memset(&p
->thread
.per_user
, 0, sizeof(p
->thread
.per_user
));
125 memset(&p
->thread
.per_event
, 0, sizeof(p
->thread
.per_event
));
126 clear_tsk_thread_flag(p
, TIF_SINGLE_STEP
);
127 /* Initialize per thread user and system timer values */
128 p
->thread
.user_timer
= 0;
129 p
->thread
.guest_timer
= 0;
130 p
->thread
.system_timer
= 0;
131 p
->thread
.hardirq_timer
= 0;
132 p
->thread
.softirq_timer
= 0;
134 frame
->sf
.back_chain
= 0;
135 /* new return point is ret_from_fork */
136 frame
->sf
.gprs
[8] = (unsigned long) ret_from_fork
;
137 /* fake return stack for resume(), don't go back to schedule */
138 frame
->sf
.gprs
[9] = (unsigned long) frame
;
140 /* Store access registers to kernel stack of new process. */
141 if (unlikely(p
->flags
& PF_KTHREAD
)) {
143 memset(&frame
->childregs
, 0, sizeof(struct pt_regs
));
144 frame
->childregs
.psw
.mask
= PSW_KERNEL_BITS
| PSW_MASK_DAT
|
145 PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
;
146 frame
->childregs
.psw
.addr
=
147 (unsigned long) kernel_thread_starter
;
148 frame
->childregs
.gprs
[9] = new_stackp
; /* function */
149 frame
->childregs
.gprs
[10] = arg
;
150 frame
->childregs
.gprs
[11] = (unsigned long) do_exit
;
151 frame
->childregs
.orig_gpr2
= -1;
155 frame
->childregs
= *current_pt_regs();
156 frame
->childregs
.gprs
[2] = 0; /* child returns 0 on fork. */
157 frame
->childregs
.flags
= 0;
159 frame
->childregs
.gprs
[15] = new_stackp
;
161 /* Don't copy runtime instrumentation info */
162 p
->thread
.ri_cb
= NULL
;
163 frame
->childregs
.psw
.mask
&= ~PSW_MASK_RI
;
164 /* Don't copy guarded storage control block */
165 p
->thread
.gs_cb
= NULL
;
166 p
->thread
.gs_bc_cb
= NULL
;
168 /* Set a new TLS ? */
169 if (clone_flags
& CLONE_SETTLS
) {
170 if (is_compat_task()) {
171 p
->thread
.acrs
[0] = (unsigned int)tls
;
173 p
->thread
.acrs
[0] = (unsigned int)(tls
>> 32);
174 p
->thread
.acrs
[1] = (unsigned int)tls
;
180 asmlinkage
void execve_tail(void)
182 current
->thread
.fpu
.fpc
= 0;
183 asm volatile("sfpc %0" : : "d" (0));
187 * fill in the FPU structure for a core dump.
189 int dump_fpu (struct pt_regs
* regs
, s390_fp_regs
*fpregs
)
192 fpregs
->fpc
= current
->thread
.fpu
.fpc
;
195 convert_vx_to_fp((freg_t
*)&fpregs
->fprs
,
196 current
->thread
.fpu
.vxrs
);
198 memcpy(&fpregs
->fprs
, current
->thread
.fpu
.fprs
,
199 sizeof(fpregs
->fprs
));
202 EXPORT_SYMBOL(dump_fpu
);
204 unsigned long get_wchan(struct task_struct
*p
)
206 struct stack_frame
*sf
, *low
, *high
;
207 unsigned long return_address
;
210 if (!p
|| p
== current
|| p
->state
== TASK_RUNNING
|| !task_stack_page(p
))
212 low
= task_stack_page(p
);
213 high
= (struct stack_frame
*) task_pt_regs(p
);
214 sf
= (struct stack_frame
*) p
->thread
.ksp
;
215 if (sf
<= low
|| sf
> high
)
217 for (count
= 0; count
< 16; count
++) {
218 sf
= (struct stack_frame
*) sf
->back_chain
;
219 if (sf
<= low
|| sf
> high
)
221 return_address
= sf
->gprs
[8];
222 if (!in_sched_functions(return_address
))
223 return return_address
;
228 unsigned long arch_align_stack(unsigned long sp
)
230 if (!(current
->personality
& ADDR_NO_RANDOMIZE
) && randomize_va_space
)
231 sp
-= get_random_int() & ~PAGE_MASK
;
235 static inline unsigned long brk_rnd(void)
237 return (get_random_int() & BRK_RND_MASK
) << PAGE_SHIFT
;
240 unsigned long arch_randomize_brk(struct mm_struct
*mm
)
244 ret
= PAGE_ALIGN(mm
->brk
+ brk_rnd());
245 return (ret
> mm
->brk
) ? ret
: mm
->brk
;
248 void set_fs_fixup(void)
250 struct pt_regs
*regs
= current_pt_regs();
256 WARN(1, "Unbalanced set_fs - int code: 0x%x\n", regs
->int_code
);
257 show_registers(regs
);