blob: e795933eb2cbaaf446d5ea62c0b43976d38479f0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Heiko Carstenscbdc2292009-03-26 15:23:52 +01002 * This file handles the architecture dependent parts of process handling.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Heiko Carstenscbdc2292009-03-26 15:23:52 +01004 * 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/compiler.h>
11#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/sched.h>
13#include <linux/kernel.h>
14#include <linux/mm.h>
Martin Schwidefsky638ad342011-10-30 15:17:13 +010015#include <linux/elfcore.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/smp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/interrupt.h>
Heiko Carstens5a62b192008-04-17 07:46:25 +020019#include <linux/tick.h>
Heiko Carstens9887a1f2011-01-12 09:55:28 +010020#include <linux/personality.h>
Heiko Carstens26689452009-01-14 14:14:36 +010021#include <linux/syscalls.h>
Heiko Carstens3e86a8c2009-09-22 22:58:42 +020022#include <linux/compat.h>
Martin Schwidefsky860dba42011-01-05 12:47:25 +010023#include <linux/kprobes.h>
Heiko Carstens9887a1f2011-01-12 09:55:28 +010024#include <linux/random.h>
Jan Glauber3af6fb62011-05-23 10:24:44 +020025#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/system.h>
27#include <asm/io.h>
28#include <asm/processor.h>
29#include <asm/irq.h>
30#include <asm/timer.h>
Heiko Carstensf5daba12009-03-26 15:24:01 +010031#include <asm/nmi.h>
Heiko Carstensda7f51c2011-01-05 12:48:09 +010032#include <asm/smp.h>
Heiko Carstensa8061702008-04-17 07:46:26 +020033#include "entry.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +020035asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37/*
38 * Return saved PC of a blocked thread. used in kernel/sched.
39 * resume in entry.S does not create a new stack frame, it
40 * just stores the registers %r6-%r15 to the frame given by
41 * schedule. We want to return the address of the caller of
42 * schedule, so we have to walk the backchain one time to
43 * find the frame schedule() store its return address.
44 */
45unsigned long thread_saved_pc(struct task_struct *tsk)
46{
Heiko Carstenseb33c192006-01-14 13:20:57 -080047 struct stack_frame *sf, *low, *high;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Heiko Carstenseb33c192006-01-14 13:20:57 -080049 if (!tsk || !task_stack_page(tsk))
50 return 0;
51 low = task_stack_page(tsk);
52 high = (struct stack_frame *) task_pt_regs(tsk);
53 sf = (struct stack_frame *) (tsk->thread.ksp & PSW_ADDR_INSN);
54 if (sf <= low || sf > high)
55 return 0;
56 sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
57 if (sf <= low || sf > high)
58 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 return sf->gprs[8];
60}
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062/*
63 * The idle loop on a S390...
64 */
Adrian Bunkcdb04522006-03-24 03:15:57 -080065static void default_idle(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
Heiko Carstensda7f51c2011-01-05 12:48:09 +010067 if (cpu_is_offline(smp_processor_id()))
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 cpu_die();
Heiko Carstens6931be02010-10-25 16:10:12 +020069 local_irq_disable();
70 if (need_resched()) {
71 local_irq_enable();
72 return;
73 }
Heiko Carstens77fa2242005-06-25 14:55:30 -070074 local_mcck_disable();
75 if (test_thread_flag(TIF_MCCK_PENDING)) {
76 local_mcck_enable();
77 local_irq_enable();
Heiko Carstens77fa2242005-06-25 14:55:30 -070078 return;
79 }
Heiko Carstens1f194a42006-07-03 00:24:46 -070080 trace_hardirqs_on();
Heiko Carstens632448f2008-11-14 18:18:04 +010081 /* Don't trace preempt off for idle. */
82 stop_critical_timings();
Martin Schwidefsky9cfb9b32008-12-31 15:11:41 +010083 /* Stop virtual timer and halt the cpu. */
84 vtime_stop_cpu();
85 /* Reenable preemption tracer. */
Heiko Carstens632448f2008-11-14 18:18:04 +010086 start_critical_timings();
Linus Torvalds1da177e2005-04-16 15:20:36 -070087}
88
89void cpu_idle(void)
90{
Nick Piggin5bfb5d62005-11-08 21:39:01 -080091 for (;;) {
Frederic Weisbecker1268fbc2011-11-17 18:48:14 +010092 tick_nohz_idle_enter();
93 rcu_idle_enter();
Heiko Carstensf36123042012-02-17 10:29:20 +010094 while (!need_resched() && !test_thread_flag(TIF_MCCK_PENDING))
Nick Piggin5bfb5d62005-11-08 21:39:01 -080095 default_idle();
Frederic Weisbecker1268fbc2011-11-17 18:48:14 +010096 rcu_idle_exit();
97 tick_nohz_idle_exit();
Heiko Carstensf36123042012-02-17 10:29:20 +010098 if (test_thread_flag(TIF_MCCK_PENDING))
99 s390_handle_mcck();
Nick Piggin5bfb5d62005-11-08 21:39:01 -0800100 preempt_enable_no_resched();
101 schedule();
102 preempt_disable();
103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
Martin Schwidefsky860dba42011-01-05 12:47:25 +0100106extern void __kprobes kernel_thread_starter(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200108asm(
Martin Schwidefsky860dba42011-01-05 12:47:25 +0100109 ".section .kprobes.text, \"ax\"\n"
110 ".global kernel_thread_starter\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 "kernel_thread_starter:\n"
112 " la 2,0(10)\n"
113 " basr 14,9\n"
114 " la 2,0\n"
Martin Schwidefsky860dba42011-01-05 12:47:25 +0100115 " br 11\n"
116 ".previous\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
119{
120 struct pt_regs regs;
121
122 memset(&regs, 0, sizeof(regs));
Martin Schwidefskyb50511e2011-10-30 15:16:50 +0100123 regs.psw.mask = psw_kernel_bits |
124 PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 regs.psw.addr = (unsigned long) kernel_thread_starter | PSW_ADDR_AMODE;
126 regs.gprs[9] = (unsigned long) fn;
127 regs.gprs[10] = (unsigned long) arg;
128 regs.gprs[11] = (unsigned long) do_exit;
129 regs.orig_gpr2 = -1;
130
131 /* Ok, create the new process.. */
132 return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
133 0, &regs, 0, NULL, NULL);
134}
Heiko Carstens1485c5c2009-03-26 15:24:04 +0100135EXPORT_SYMBOL(kernel_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137/*
138 * Free current thread data structures etc..
139 */
140void exit_thread(void)
141{
142}
143
144void flush_thread(void)
145{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146}
147
148void release_thread(struct task_struct *dead_task)
149{
150}
151
Alexey Dobriyan6f2c55b2009-04-02 16:56:59 -0700152int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100153 unsigned long unused,
154 struct task_struct *p, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Heiko Carstens5168ce22009-03-26 15:23:53 +0100156 struct thread_info *ti;
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100157 struct fake_frame
158 {
159 struct stack_frame sf;
160 struct pt_regs childregs;
161 } *frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100163 frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
164 p->thread.ksp = (unsigned long) frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /* Store access registers to kernel stack of new process. */
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100166 frame->childregs = *regs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 frame->childregs.gprs[2] = 0; /* child returns 0 on fork. */
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100168 frame->childregs.gprs[15] = new_stackp;
169 frame->sf.back_chain = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100171 /* new return point is ret_from_fork */
172 frame->sf.gprs[8] = (unsigned long) ret_from_fork;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100174 /* fake return stack for resume(), don't go back to schedule */
175 frame->sf.gprs[9] = (unsigned long) frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 /* Save access registers to new thread structure. */
178 save_access_regs(&p->thread.acrs[0]);
179
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800180#ifndef CONFIG_64BIT
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100181 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * save fprs to current->thread.fp_regs to merge them with
183 * the emulated registers and then copy the result to the child.
184 */
185 save_fp_regs(&current->thread.fp_regs);
186 memcpy(&p->thread.fp_regs, &current->thread.fp_regs,
187 sizeof(s390_fp_regs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 /* Set a new TLS ? */
189 if (clone_flags & CLONE_SETTLS)
190 p->thread.acrs[0] = regs->gprs[6];
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800191#else /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 /* Save the fpu registers to new thread structure. */
193 save_fp_regs(&p->thread.fp_regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 /* Set a new TLS ? */
195 if (clone_flags & CLONE_SETTLS) {
Heiko Carstens77575912009-06-12 10:26:25 +0200196 if (is_compat_task()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 p->thread.acrs[0] = (unsigned int) regs->gprs[6];
198 } else {
199 p->thread.acrs[0] = (unsigned int)(regs->gprs[6] >> 32);
200 p->thread.acrs[1] = (unsigned int) regs->gprs[6];
201 }
202 }
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800203#endif /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 /* start new process with ar4 pointing to the correct address space */
205 p->thread.mm_segment = get_fs();
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100206 /* Don't copy debug registers */
Martin Schwidefsky5e9a2692011-01-05 12:48:10 +0100207 memset(&p->thread.per_user, 0, sizeof(p->thread.per_user));
208 memset(&p->thread.per_event, 0, sizeof(p->thread.per_event));
Martin Schwidefskyf8d5faf2010-01-13 20:44:26 +0100209 clear_tsk_thread_flag(p, TIF_SINGLE_STEP);
Martin Schwidefsky5e9a2692011-01-05 12:48:10 +0100210 clear_tsk_thread_flag(p, TIF_PER_TRAP);
Heiko Carstens5168ce22009-03-26 15:23:53 +0100211 /* Initialize per thread user and system timer values */
212 ti = task_thread_info(p);
213 ti->user_timer = 0;
214 ti->system_timer = 0;
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100215 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Heiko Carstens26689452009-01-14 14:14:36 +0100218SYSCALL_DEFINE0(fork)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200220 struct pt_regs *regs = task_pt_regs(current);
221 return do_fork(SIGCHLD, regs->gprs[15], regs, 0, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
223
Heiko Carstens2d70ca22009-09-22 22:58:41 +0200224SYSCALL_DEFINE4(clone, unsigned long, newsp, unsigned long, clone_flags,
225 int __user *, parent_tidptr, int __user *, child_tidptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200227 struct pt_regs *regs = task_pt_regs(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200229 if (!newsp)
230 newsp = regs->gprs[15];
231 return do_fork(clone_flags, newsp, regs, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 parent_tidptr, child_tidptr);
233}
234
235/*
236 * This is trivial, and on the face of it looks like it
237 * could equally well be done in user mode.
238 *
239 * Not so, for quite unobvious reasons - register pressure.
240 * In user mode vfork() cannot have a stack frame, and if
241 * done by calling the "clone()" system call directly, you
242 * do not have enough call-clobbered registers to hold all
243 * the information you need.
244 */
Heiko Carstens26689452009-01-14 14:14:36 +0100245SYSCALL_DEFINE0(vfork)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200247 struct pt_regs *regs = task_pt_regs(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200249 regs->gprs[15], regs, 0, NULL, NULL);
250}
251
252asmlinkage void execve_tail(void)
253{
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200254 current->thread.fp_regs.fpc = 0;
255 if (MACHINE_HAS_IEEE)
256 asm volatile("sfpc %0,%0" : : "d" (0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257}
258
259/*
260 * sys_execve() executes a new program.
261 */
David Howellsd7627462010-08-17 23:52:56 +0100262SYSCALL_DEFINE3(execve, const char __user *, name,
263 const char __user *const __user *, argv,
264 const char __user *const __user *, envp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200266 struct pt_regs *regs = task_pt_regs(current);
267 char *filename;
Heiko Carstens3e86a8c2009-09-22 22:58:42 +0200268 long rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Heiko Carstens3e86a8c2009-09-22 22:58:42 +0200270 filename = getname(name);
271 rc = PTR_ERR(filename);
272 if (IS_ERR(filename))
273 return rc;
274 rc = do_execve(filename, argv, envp, regs);
275 if (rc)
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200276 goto out;
Martin Schwidefsky03ff9a22007-04-27 16:01:40 +0200277 execve_tail();
Heiko Carstens3e86a8c2009-09-22 22:58:42 +0200278 rc = regs->gprs[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279out:
Heiko Carstens3e86a8c2009-09-22 22:58:42 +0200280 putname(filename);
281 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284/*
285 * fill in the FPU structure for a core dump.
286 */
287int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
288{
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800289#ifndef CONFIG_64BIT
Heiko Carstenscbdc2292009-03-26 15:23:52 +0100290 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 * save fprs to current->thread.fp_regs to merge them with
292 * the emulated registers and then copy the result to the dump.
293 */
294 save_fp_regs(&current->thread.fp_regs);
295 memcpy(fpregs, &current->thread.fp_regs, sizeof(s390_fp_regs));
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800296#else /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 save_fp_regs(fpregs);
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800298#endif /* CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return 1;
300}
Heiko Carstens1485c5c2009-03-26 15:24:04 +0100301EXPORT_SYMBOL(dump_fpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303unsigned long get_wchan(struct task_struct *p)
304{
305 struct stack_frame *sf, *low, *high;
306 unsigned long return_address;
307 int count;
308
Al Viro30af7122006-01-12 01:05:50 -0800309 if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return 0;
Al Viro30af7122006-01-12 01:05:50 -0800311 low = task_stack_page(p);
312 high = (struct stack_frame *) task_pt_regs(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 sf = (struct stack_frame *) (p->thread.ksp & PSW_ADDR_INSN);
314 if (sf <= low || sf > high)
315 return 0;
316 for (count = 0; count < 16; count++) {
317 sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
318 if (sf <= low || sf > high)
319 return 0;
320 return_address = sf->gprs[8] & PSW_ADDR_INSN;
321 if (!in_sched_functions(return_address))
322 return return_address;
323 }
324 return 0;
325}
Heiko Carstens9887a1f2011-01-12 09:55:28 +0100326
327unsigned long arch_align_stack(unsigned long sp)
328{
329 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
330 sp -= get_random_int() & ~PAGE_MASK;
331 return sp & ~0xf;
332}
Heiko Carstens33519182011-01-12 09:55:30 +0100333
334static inline unsigned long brk_rnd(void)
335{
336 /* 8MB for 32bit, 1GB for 64bit */
337 if (is_32bit_task())
338 return (get_random_int() & 0x7ffUL) << PAGE_SHIFT;
339 else
340 return (get_random_int() & 0x3ffffUL) << PAGE_SHIFT;
341}
342
343unsigned long arch_randomize_brk(struct mm_struct *mm)
344{
345 unsigned long ret = PAGE_ALIGN(mm->brk + brk_rnd());
346
347 if (ret < mm->brk)
348 return mm->brk;
349 return ret;
350}
Heiko Carstensd2c9dfc2011-01-12 09:55:31 +0100351
352unsigned long randomize_et_dyn(unsigned long base)
353{
354 unsigned long ret = PAGE_ALIGN(base + brk_rnd());
355
356 if (!(current->flags & PF_RANDOMIZE))
357 return base;
358 if (ret < base)
359 return base;
360 return ret;
361}