]>
git.ipfire.org Git - thirdparty/linux.git/blob - arch/s390/kernel/process.c
1 // SPDX-License-Identifier: GPL-2.0
3 * This file handles the architecture dependent parts of process handling.
5 * Copyright IBM Corp. 1999, 2009
6 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
7 * Hartmut Penner <hp@de.ibm.com>,
11 #include <linux/elf-randomize.h>
12 #include <linux/compiler.h>
13 #include <linux/cpu.h>
14 #include <linux/sched.h>
15 #include <linux/sched/debug.h>
16 #include <linux/sched/task.h>
17 #include <linux/sched/task_stack.h>
18 #include <linux/kernel.h>
20 #include <linux/elfcore.h>
21 #include <linux/smp.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/tick.h>
25 #include <linux/personality.h>
26 #include <linux/syscalls.h>
27 #include <linux/compat.h>
28 #include <linux/kprobes.h>
29 #include <linux/random.h>
30 #include <linux/export.h>
31 #include <linux/init_task.h>
32 #include <linux/entry-common.h>
33 #include <asm/cpu_mf.h>
35 #include <asm/processor.h>
36 #include <asm/vtimer.h>
41 #include <asm/stacktrace.h>
42 #include <asm/switch_to.h>
43 #include <asm/runtime_instr.h>
44 #include <asm/unwind.h>
47 void ret_from_fork(void) asm("ret_from_fork");
49 void __ret_from_fork(struct task_struct
*prev
, struct pt_regs
*regs
)
51 void (*func
)(void *arg
);
55 if (!user_mode(regs
)) {
57 func
= (void *)regs
->gprs
[9];
58 func((void *)regs
->gprs
[10]);
60 clear_pt_regs_flag(regs
, PIF_SYSCALL
);
61 syscall_exit_to_user_mode(regs
);
64 void flush_thread(void)
68 void arch_setup_new_exec(void)
70 if (S390_lowcore
.current_pid
!= current
->pid
) {
71 S390_lowcore
.current_pid
= current
->pid
;
72 if (test_facility(40))
73 lpp(&S390_lowcore
.lpp
);
77 void arch_release_task_struct(struct task_struct
*tsk
)
79 runtime_instr_release(tsk
);
80 guarded_storage_release(tsk
);
83 int arch_dup_task_struct(struct task_struct
*dst
, struct task_struct
*src
)
86 * Save the floating-point or vector register state of the current
87 * task and set the CIF_FPU flag to lazy restore the FPU register
88 * state when returning to user space.
92 memcpy(dst
, src
, arch_task_struct_size
);
93 dst
->thread
.fpu
.regs
= dst
->thread
.fpu
.fprs
;
97 int copy_thread(unsigned long clone_flags
, unsigned long new_stackp
,
98 unsigned long arg
, struct task_struct
*p
, unsigned long tls
)
102 struct stack_frame sf
;
103 struct pt_regs childregs
;
106 frame
= container_of(task_pt_regs(p
), struct fake_frame
, childregs
);
107 p
->thread
.ksp
= (unsigned long) frame
;
108 /* Save access registers to new thread structure. */
109 save_access_regs(&p
->thread
.acrs
[0]);
110 /* start new process with ar4 pointing to the correct address space */
111 /* Don't copy debug registers */
112 memset(&p
->thread
.per_user
, 0, sizeof(p
->thread
.per_user
));
113 memset(&p
->thread
.per_event
, 0, sizeof(p
->thread
.per_event
));
114 clear_tsk_thread_flag(p
, TIF_SINGLE_STEP
);
115 p
->thread
.per_flags
= 0;
116 /* Initialize per thread user and system timer values */
117 p
->thread
.user_timer
= 0;
118 p
->thread
.guest_timer
= 0;
119 p
->thread
.system_timer
= 0;
120 p
->thread
.hardirq_timer
= 0;
121 p
->thread
.softirq_timer
= 0;
122 p
->thread
.last_break
= 1;
124 frame
->sf
.back_chain
= 0;
125 frame
->sf
.gprs
[5] = (unsigned long)frame
+ sizeof(struct stack_frame
);
126 frame
->sf
.gprs
[6] = (unsigned long)p
;
127 /* new return point is ret_from_fork */
128 frame
->sf
.gprs
[8] = (unsigned long)ret_from_fork
;
129 /* fake return stack for resume(), don't go back to schedule */
130 frame
->sf
.gprs
[9] = (unsigned long)frame
;
132 /* Store access registers to kernel stack of new process. */
133 if (unlikely(p
->flags
& (PF_KTHREAD
| PF_IO_WORKER
))) {
135 memset(&frame
->childregs
, 0, sizeof(struct pt_regs
));
136 frame
->childregs
.psw
.mask
= PSW_KERNEL_BITS
| PSW_MASK_DAT
|
137 PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
;
138 frame
->childregs
.psw
.addr
=
139 (unsigned long)__ret_from_fork
;
140 frame
->childregs
.gprs
[9] = new_stackp
; /* function */
141 frame
->childregs
.gprs
[10] = arg
;
142 frame
->childregs
.orig_gpr2
= -1;
143 frame
->childregs
.last_break
= 1;
146 frame
->childregs
= *current_pt_regs();
147 frame
->childregs
.gprs
[2] = 0; /* child returns 0 on fork. */
148 frame
->childregs
.flags
= 0;
150 frame
->childregs
.gprs
[15] = new_stackp
;
152 /* Don't copy runtime instrumentation info */
153 p
->thread
.ri_cb
= NULL
;
154 frame
->childregs
.psw
.mask
&= ~PSW_MASK_RI
;
155 /* Don't copy guarded storage control block */
156 p
->thread
.gs_cb
= NULL
;
157 p
->thread
.gs_bc_cb
= NULL
;
159 /* Set a new TLS ? */
160 if (clone_flags
& CLONE_SETTLS
) {
161 if (is_compat_task()) {
162 p
->thread
.acrs
[0] = (unsigned int)tls
;
164 p
->thread
.acrs
[0] = (unsigned int)(tls
>> 32);
165 p
->thread
.acrs
[1] = (unsigned int)tls
;
169 * s390 stores the svc return address in arch_data when calling
170 * sigreturn()/restart_syscall() via vdso. 1 means no valid address
173 p
->restart_block
.arch_data
= 1;
177 void execve_tail(void)
179 current
->thread
.fpu
.fpc
= 0;
180 asm volatile("sfpc %0" : : "d" (0));
183 unsigned long __get_wchan(struct task_struct
*p
)
185 struct unwind_state state
;
186 unsigned long ip
= 0;
188 if (!task_stack_page(p
))
191 if (!try_get_task_stack(p
))
194 unwind_for_each_frame(&state
, p
, NULL
, 0) {
195 if (state
.stack_info
.type
!= STACK_TYPE_TASK
) {
200 ip
= unwind_get_return_address(&state
);
204 if (!in_sched_functions(ip
))
212 unsigned long arch_align_stack(unsigned long sp
)
214 if (!(current
->personality
& ADDR_NO_RANDOMIZE
) && randomize_va_space
)
215 sp
-= get_random_int() & ~PAGE_MASK
;
219 static inline unsigned long brk_rnd(void)
221 return (get_random_int() & BRK_RND_MASK
) << PAGE_SHIFT
;
224 unsigned long arch_randomize_brk(struct mm_struct
*mm
)
228 ret
= PAGE_ALIGN(mm
->brk
+ brk_rnd());
229 return (ret
> mm
->brk
) ? ret
: mm
->brk
;