xref: /openbmc/linux/arch/s390/kernel/process.c (revision d2999e1b)
1 /*
2  * This file handles the architecture dependent parts of process handling.
3  *
4  *    Copyright IBM Corp. 1999, 2009
5  *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
6  *		 Hartmut Penner <hp@de.ibm.com>,
7  *		 Denis Joseph Barrow,
8  */
9 
10 #include <linux/compiler.h>
11 #include <linux/cpu.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/mm.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>
26 #include <asm/io.h>
27 #include <asm/processor.h>
28 #include <asm/vtimer.h>
29 #include <asm/exec.h>
30 #include <asm/irq.h>
31 #include <asm/nmi.h>
32 #include <asm/smp.h>
33 #include <asm/switch_to.h>
34 #include <asm/runtime_instr.h>
35 #include "entry.h"
36 
37 asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
38 
39 /*
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.
46  */
47 unsigned long thread_saved_pc(struct task_struct *tsk)
48 {
49 	struct stack_frame *sf, *low, *high;
50 
51 	if (!tsk || !task_stack_page(tsk))
52 		return 0;
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)
57 		return 0;
58 	sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
59 	if (sf <= low || sf > high)
60 		return 0;
61 	return sf->gprs[8];
62 }
63 
64 void arch_cpu_idle(void)
65 {
66 	local_mcck_disable();
67 	if (test_cpu_flag(CIF_MCCK_PENDING)) {
68 		local_mcck_enable();
69 		local_irq_enable();
70 		return;
71 	}
72 	/* Halt the cpu and keep track of cpu time accounting. */
73 	vtime_stop_cpu();
74 	local_irq_enable();
75 }
76 
77 void arch_cpu_idle_exit(void)
78 {
79 	if (test_cpu_flag(CIF_MCCK_PENDING))
80 		s390_handle_mcck();
81 }
82 
83 void arch_cpu_idle_dead(void)
84 {
85 	cpu_die();
86 }
87 
88 extern void __kprobes kernel_thread_starter(void);
89 
90 /*
91  * Free current thread data structures etc..
92  */
93 void exit_thread(void)
94 {
95 	exit_thread_runtime_instr();
96 }
97 
98 void flush_thread(void)
99 {
100 }
101 
102 void release_thread(struct task_struct *dead_task)
103 {
104 }
105 
106 int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
107 		unsigned long arg, struct task_struct *p)
108 {
109 	struct thread_info *ti;
110 	struct fake_frame
111 	{
112 		struct stack_frame sf;
113 		struct pt_regs childregs;
114 	} *frame;
115 
116 	frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
117 	p->thread.ksp = (unsigned long) frame;
118 	/* Save access registers to new thread structure. */
119 	save_access_regs(&p->thread.acrs[0]);
120 	/* start new process with ar4 pointing to the correct address space */
121 	p->thread.mm_segment = get_fs();
122 	/* Don't copy debug registers */
123 	memset(&p->thread.per_user, 0, sizeof(p->thread.per_user));
124 	memset(&p->thread.per_event, 0, sizeof(p->thread.per_event));
125 	clear_tsk_thread_flag(p, TIF_SINGLE_STEP);
126 	/* Initialize per thread user and system timer values */
127 	ti = task_thread_info(p);
128 	ti->user_timer = 0;
129 	ti->system_timer = 0;
130 
131 	frame->sf.back_chain = 0;
132 	/* new return point is ret_from_fork */
133 	frame->sf.gprs[8] = (unsigned long) ret_from_fork;
134 	/* fake return stack for resume(), don't go back to schedule */
135 	frame->sf.gprs[9] = (unsigned long) frame;
136 
137 	/* Store access registers to kernel stack of new process. */
138 	if (unlikely(p->flags & PF_KTHREAD)) {
139 		/* kernel thread */
140 		memset(&frame->childregs, 0, sizeof(struct pt_regs));
141 		frame->childregs.psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT |
142 				PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
143 		frame->childregs.psw.addr = PSW_ADDR_AMODE |
144 				(unsigned long) kernel_thread_starter;
145 		frame->childregs.gprs[9] = new_stackp; /* function */
146 		frame->childregs.gprs[10] = arg;
147 		frame->childregs.gprs[11] = (unsigned long) do_exit;
148 		frame->childregs.orig_gpr2 = -1;
149 
150 		return 0;
151 	}
152 	frame->childregs = *current_pt_regs();
153 	frame->childregs.gprs[2] = 0;	/* child returns 0 on fork. */
154 	frame->childregs.flags = 0;
155 	if (new_stackp)
156 		frame->childregs.gprs[15] = new_stackp;
157 
158 	/* Don't copy runtime instrumentation info */
159 	p->thread.ri_cb = NULL;
160 	p->thread.ri_signum = 0;
161 	frame->childregs.psw.mask &= ~PSW_MASK_RI;
162 
163 #ifndef CONFIG_64BIT
164 	/*
165 	 * save fprs to current->thread.fp_regs to merge them with
166 	 * the emulated registers and then copy the result to the child.
167 	 */
168 	save_fp_ctl(&current->thread.fp_regs.fpc);
169 	save_fp_regs(current->thread.fp_regs.fprs);
170 	memcpy(&p->thread.fp_regs, &current->thread.fp_regs,
171 	       sizeof(s390_fp_regs));
172 	/* Set a new TLS ?  */
173 	if (clone_flags & CLONE_SETTLS)
174 		p->thread.acrs[0] = frame->childregs.gprs[6];
175 #else /* CONFIG_64BIT */
176 	/* Save the fpu registers to new thread structure. */
177 	save_fp_ctl(&p->thread.fp_regs.fpc);
178 	save_fp_regs(p->thread.fp_regs.fprs);
179 	p->thread.fp_regs.pad = 0;
180 	/* Set a new TLS ?  */
181 	if (clone_flags & CLONE_SETTLS) {
182 		unsigned long tls = frame->childregs.gprs[6];
183 		if (is_compat_task()) {
184 			p->thread.acrs[0] = (unsigned int)tls;
185 		} else {
186 			p->thread.acrs[0] = (unsigned int)(tls >> 32);
187 			p->thread.acrs[1] = (unsigned int)tls;
188 		}
189 	}
190 #endif /* CONFIG_64BIT */
191 	return 0;
192 }
193 
194 asmlinkage void execve_tail(void)
195 {
196 	current->thread.fp_regs.fpc = 0;
197 	if (MACHINE_HAS_IEEE)
198 		asm volatile("sfpc %0,%0" : : "d" (0));
199 }
200 
201 /*
202  * fill in the FPU structure for a core dump.
203  */
204 int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
205 {
206 #ifndef CONFIG_64BIT
207 	/*
208 	 * save fprs to current->thread.fp_regs to merge them with
209 	 * the emulated registers and then copy the result to the dump.
210 	 */
211 	save_fp_ctl(&current->thread.fp_regs.fpc);
212 	save_fp_regs(current->thread.fp_regs.fprs);
213 	memcpy(fpregs, &current->thread.fp_regs, sizeof(s390_fp_regs));
214 #else /* CONFIG_64BIT */
215 	save_fp_ctl(&fpregs->fpc);
216 	save_fp_regs(fpregs->fprs);
217 #endif /* CONFIG_64BIT */
218 	return 1;
219 }
220 EXPORT_SYMBOL(dump_fpu);
221 
222 unsigned long get_wchan(struct task_struct *p)
223 {
224 	struct stack_frame *sf, *low, *high;
225 	unsigned long return_address;
226 	int count;
227 
228 	if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
229 		return 0;
230 	low = task_stack_page(p);
231 	high = (struct stack_frame *) task_pt_regs(p);
232 	sf = (struct stack_frame *) (p->thread.ksp & PSW_ADDR_INSN);
233 	if (sf <= low || sf > high)
234 		return 0;
235 	for (count = 0; count < 16; count++) {
236 		sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
237 		if (sf <= low || sf > high)
238 			return 0;
239 		return_address = sf->gprs[8] & PSW_ADDR_INSN;
240 		if (!in_sched_functions(return_address))
241 			return return_address;
242 	}
243 	return 0;
244 }
245 
246 unsigned long arch_align_stack(unsigned long sp)
247 {
248 	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
249 		sp -= get_random_int() & ~PAGE_MASK;
250 	return sp & ~0xf;
251 }
252 
253 static inline unsigned long brk_rnd(void)
254 {
255 	/* 8MB for 32bit, 1GB for 64bit */
256 	if (is_32bit_task())
257 		return (get_random_int() & 0x7ffUL) << PAGE_SHIFT;
258 	else
259 		return (get_random_int() & 0x3ffffUL) << PAGE_SHIFT;
260 }
261 
262 unsigned long arch_randomize_brk(struct mm_struct *mm)
263 {
264 	unsigned long ret;
265 
266 	ret = PAGE_ALIGN(mm->brk + brk_rnd());
267 	return (ret > mm->brk) ? ret : mm->brk;
268 }
269 
270 unsigned long randomize_et_dyn(unsigned long base)
271 {
272 	unsigned long ret;
273 
274 	if (!(current->flags & PF_RANDOMIZE))
275 		return base;
276 	ret = PAGE_ALIGN(base + brk_rnd());
277 	return (ret > base) ? ret : base;
278 }
279