compat: fix compile breakage on s390
[linux-2.6.git] / arch / s390 / kernel / process.c
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/system.h>
27 #include <asm/io.h>
28 #include <asm/processor.h>
29 #include <asm/irq.h>
30 #include <asm/timer.h>
31 #include <asm/nmi.h>
32 #include <asm/smp.h>
33 #include "entry.h"
34
35 asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
36
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  */
45 unsigned long thread_saved_pc(struct task_struct *tsk)
46 {
47         struct stack_frame *sf, *low, *high;
48
49         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;
59         return sf->gprs[8];
60 }
61
62 /*
63  * The idle loop on a S390...
64  */
65 static void default_idle(void)
66 {
67         if (cpu_is_offline(smp_processor_id()))
68                 cpu_die();
69         local_irq_disable();
70         if (need_resched()) {
71                 local_irq_enable();
72                 return;
73         }
74         local_mcck_disable();
75         if (test_thread_flag(TIF_MCCK_PENDING)) {
76                 local_mcck_enable();
77                 local_irq_enable();
78                 return;
79         }
80         trace_hardirqs_on();
81         /* Don't trace preempt off for idle. */
82         stop_critical_timings();
83         /* Stop virtual timer and halt the cpu. */
84         vtime_stop_cpu();
85         /* Reenable preemption tracer. */
86         start_critical_timings();
87 }
88
89 void cpu_idle(void)
90 {
91         for (;;) {
92                 tick_nohz_idle_enter();
93                 rcu_idle_enter();
94                 while (!need_resched() && !test_thread_flag(TIF_MCCK_PENDING))
95                         default_idle();
96                 rcu_idle_exit();
97                 tick_nohz_idle_exit();
98                 if (test_thread_flag(TIF_MCCK_PENDING))
99                         s390_handle_mcck();
100                 preempt_enable_no_resched();
101                 schedule();
102                 preempt_disable();
103         }
104 }
105
106 extern void __kprobes kernel_thread_starter(void);
107
108 asm(
109         ".section .kprobes.text, \"ax\"\n"
110         ".global kernel_thread_starter\n"
111         "kernel_thread_starter:\n"
112         "    la    2,0(10)\n"
113         "    basr  14,9\n"
114         "    la    2,0\n"
115         "    br    11\n"
116         ".previous\n");
117
118 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
119 {
120         struct pt_regs regs;
121
122         memset(&regs, 0, sizeof(regs));
123         regs.psw.mask = psw_kernel_bits |
124                 PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
125         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 }
135 EXPORT_SYMBOL(kernel_thread);
136
137 /*
138  * Free current thread data structures etc..
139  */
140 void exit_thread(void)
141 {
142 }
143
144 void flush_thread(void)
145 {
146 }
147
148 void release_thread(struct task_struct *dead_task)
149 {
150 }
151
152 int copy_thread(unsigned long clone_flags, unsigned long new_stackp,
153                 unsigned long unused,
154                 struct task_struct *p, struct pt_regs *regs)
155 {
156         struct thread_info *ti;
157         struct fake_frame
158         {
159                 struct stack_frame sf;
160                 struct pt_regs childregs;
161         } *frame;
162
163         frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
164         p->thread.ksp = (unsigned long) frame;
165         /* Store access registers to kernel stack of new process. */
166         frame->childregs = *regs;
167         frame->childregs.gprs[2] = 0;   /* child returns 0 on fork. */
168         frame->childregs.gprs[15] = new_stackp;
169         frame->sf.back_chain = 0;
170
171         /* new return point is ret_from_fork */
172         frame->sf.gprs[8] = (unsigned long) ret_from_fork;
173
174         /* fake return stack for resume(), don't go back to schedule */
175         frame->sf.gprs[9] = (unsigned long) frame;
176
177         /* Save access registers to new thread structure. */
178         save_access_regs(&p->thread.acrs[0]);
179
180 #ifndef CONFIG_64BIT
181         /*
182          * 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));
188         /* Set a new TLS ?  */
189         if (clone_flags & CLONE_SETTLS)
190                 p->thread.acrs[0] = regs->gprs[6];
191 #else /* CONFIG_64BIT */
192         /* Save the fpu registers to new thread structure. */
193         save_fp_regs(&p->thread.fp_regs);
194         /* Set a new TLS ?  */
195         if (clone_flags & CLONE_SETTLS) {
196                 if (is_compat_task()) {
197                         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         }
203 #endif /* CONFIG_64BIT */
204         /* start new process with ar4 pointing to the correct address space */
205         p->thread.mm_segment = get_fs();
206         /* Don't copy debug registers */
207         memset(&p->thread.per_user, 0, sizeof(p->thread.per_user));
208         memset(&p->thread.per_event, 0, sizeof(p->thread.per_event));
209         clear_tsk_thread_flag(p, TIF_SINGLE_STEP);
210         clear_tsk_thread_flag(p, TIF_PER_TRAP);
211         /* Initialize per thread user and system timer values */
212         ti = task_thread_info(p);
213         ti->user_timer = 0;
214         ti->system_timer = 0;
215         return 0;
216 }
217
218 SYSCALL_DEFINE0(fork)
219 {
220         struct pt_regs *regs = task_pt_regs(current);
221         return do_fork(SIGCHLD, regs->gprs[15], regs, 0, NULL, NULL);
222 }
223
224 SYSCALL_DEFINE4(clone, unsigned long, newsp, unsigned long, clone_flags,
225                 int __user *, parent_tidptr, int __user *, child_tidptr)
226 {
227         struct pt_regs *regs = task_pt_regs(current);
228
229         if (!newsp)
230                 newsp = regs->gprs[15];
231         return do_fork(clone_flags, newsp, regs, 0,
232                        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  */
245 SYSCALL_DEFINE0(vfork)
246 {
247         struct pt_regs *regs = task_pt_regs(current);
248         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
249                        regs->gprs[15], regs, 0, NULL, NULL);
250 }
251
252 asmlinkage void execve_tail(void)
253 {
254         current->thread.fp_regs.fpc = 0;
255         if (MACHINE_HAS_IEEE)
256                 asm volatile("sfpc %0,%0" : : "d" (0));
257 }
258
259 /*
260  * sys_execve() executes a new program.
261  */
262 SYSCALL_DEFINE3(execve, const char __user *, name,
263                 const char __user *const __user *, argv,
264                 const char __user *const __user *, envp)
265 {
266         struct pt_regs *regs = task_pt_regs(current);
267         char *filename;
268         long rc;
269
270         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)
276                 goto out;
277         execve_tail();
278         rc = regs->gprs[2];
279 out:
280         putname(filename);
281         return rc;
282 }
283
284 /*
285  * fill in the FPU structure for a core dump.
286  */
287 int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
288 {
289 #ifndef CONFIG_64BIT
290         /*
291          * 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));
296 #else /* CONFIG_64BIT */
297         save_fp_regs(fpregs);
298 #endif /* CONFIG_64BIT */
299         return 1;
300 }
301 EXPORT_SYMBOL(dump_fpu);
302
303 unsigned long get_wchan(struct task_struct *p)
304 {
305         struct stack_frame *sf, *low, *high;
306         unsigned long return_address;
307         int count;
308
309         if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
310                 return 0;
311         low = task_stack_page(p);
312         high = (struct stack_frame *) task_pt_regs(p);
313         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 }
326
327 unsigned 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 }
333
334 static 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
343 unsigned 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 }
351
352 unsigned 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 }