process.c 10.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *  arch/s390/kernel/process.c
 *
 *  S390 version
 *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
 *               Hartmut Penner (hp@de.ibm.com),
 *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
 *
 *  Derived from "arch/i386/kernel/process.c"
 *    Copyright (C) 1995, Linus Torvalds
 */

/*
 * This file handles the architecture-dependent parts of process handling..
 */

#include <linux/compiler.h>
#include <linux/cpu.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
24
#include <linux/fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27 28 29 30 31 32 33 34 35 36 37 38
#include <linux/smp.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/user.h>
#include <linux/a.out.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/notifier.h>
39
#include <linux/utsname.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/processor.h>
#include <asm/irq.h>
#include <asm/timer.h>
47
#include <asm/cpu.h>
Linus Torvalds's avatar
Linus Torvalds committed
48

49
asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
Linus Torvalds's avatar
Linus Torvalds committed
50 51 52 53 54 55 56 57 58 59 60

/*
 * Return saved PC of a blocked thread. used in kernel/sched.
 * resume in entry.S does not create a new stack frame, it
 * just stores the registers %r6-%r15 to the frame given by
 * schedule. We want to return the address of the caller of
 * schedule, so we have to walk the backchain one time to
 * find the frame schedule() store its return address.
 */
unsigned long thread_saved_pc(struct task_struct *tsk)
{
61
	struct stack_frame *sf, *low, *high;
Linus Torvalds's avatar
Linus Torvalds committed
62

63 64 65 66 67 68 69 70 71 72
	if (!tsk || !task_stack_page(tsk))
		return 0;
	low = task_stack_page(tsk);
	high = (struct stack_frame *) task_pt_regs(tsk);
	sf = (struct stack_frame *) (tsk->thread.ksp & PSW_ADDR_INSN);
	if (sf <= low || sf > high)
		return 0;
	sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
	if (sf <= low || sf > high)
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78
	return sf->gprs[8];
}

/*
 * Need to know about CPUs going idle?
 */
79
static ATOMIC_NOTIFIER_HEAD(idle_chain);
Linus Torvalds's avatar
Linus Torvalds committed
80 81 82

int register_idle_notifier(struct notifier_block *nb)
{
83
	return atomic_notifier_chain_register(&idle_chain, nb);
Linus Torvalds's avatar
Linus Torvalds committed
84 85 86 87 88
}
EXPORT_SYMBOL(register_idle_notifier);

int unregister_idle_notifier(struct notifier_block *nb)
{
89
	return atomic_notifier_chain_unregister(&idle_chain, nb);
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92 93 94
}
EXPORT_SYMBOL(unregister_idle_notifier);

void do_monitor_call(struct pt_regs *regs, long interruption_code)
{
95
#ifdef CONFIG_SMP
96 97 98 99 100 101 102
	struct s390_idle_data *idle;

	idle = &__get_cpu_var(s390_idle);
	spin_lock(&idle->lock);
	idle->idle_time += get_clock() - idle->idle_enter;
	idle->in_idle = 0;
	spin_unlock(&idle->lock);
103
#endif
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106
	/* disable monitor call class 0 */
	__ctl_clear_bit(8, 15);

107 108
	atomic_notifier_call_chain(&idle_chain, S390_CPU_NOT_IDLE,
				   (void *)(long) smp_processor_id());
Linus Torvalds's avatar
Linus Torvalds committed
109 110
}

111
extern void s390_handle_mcck(void);
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114
/*
 * The idle loop on a S390...
 */
115
static void default_idle(void)
Linus Torvalds's avatar
Linus Torvalds committed
116 117
{
	int cpu, rc;
118
#ifdef CONFIG_SMP
119
	struct s390_idle_data *idle;
120
#endif
Linus Torvalds's avatar
Linus Torvalds committed
121

122 123 124
	/* CPU is going idle. */
	cpu = smp_processor_id();

Linus Torvalds's avatar
Linus Torvalds committed
125
	local_irq_disable();
126
	if (need_resched()) {
Linus Torvalds's avatar
Linus Torvalds committed
127
		local_irq_enable();
128 129
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
130

131
	rc = atomic_notifier_call_chain(&idle_chain,
132
					S390_CPU_IDLE, (void *)(long) cpu);
Linus Torvalds's avatar
Linus Torvalds committed
133 134 135 136 137 138 139 140 141 142 143
	if (rc != NOTIFY_OK && rc != NOTIFY_DONE)
		BUG();
	if (rc != NOTIFY_OK) {
		local_irq_enable();
		return;
	}

	/* enable monitor call class 0 */
	__ctl_set_bit(8, 15);

#ifdef CONFIG_HOTPLUG_CPU
144 145
	if (cpu_is_offline(cpu)) {
		preempt_enable_no_resched();
Linus Torvalds's avatar
Linus Torvalds committed
146
		cpu_die();
147
	}
Linus Torvalds's avatar
Linus Torvalds committed
148 149
#endif

150 151 152 153 154 155 156
	local_mcck_disable();
	if (test_thread_flag(TIF_MCCK_PENDING)) {
		local_mcck_enable();
		local_irq_enable();
		s390_handle_mcck();
		return;
	}
157
#ifdef CONFIG_SMP
158 159 160 161 162 163
	idle = &__get_cpu_var(s390_idle);
	spin_lock(&idle->lock);
	idle->idle_count++;
	idle->in_idle = 1;
	idle->idle_enter = get_clock();
	spin_unlock(&idle->lock);
164
#endif
165
	trace_hardirqs_on();
166
	/* Wait for external, I/O or machine check interrupt. */
Gerald Schaefer's avatar
Gerald Schaefer committed
167
	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
168
			PSW_MASK_IO | PSW_MASK_EXT);
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172
}

void cpu_idle(void)
{
173 174 175 176 177 178 179 180
	for (;;) {
		while (!need_resched())
			default_idle();

		preempt_enable_no_resched();
		schedule();
		preempt_disable();
	}
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183 184
}

void show_regs(struct pt_regs *regs)
{
185 186 187 188 189 190 191 192 193
	print_modules();
	printk("CPU: %d %s %s %.*s\n",
	       task_thread_info(current)->cpu, print_tainted(),
	       init_utsname()->release,
	       (int)strcspn(init_utsname()->version, " "),
	       init_utsname()->version);
	printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
	       current->comm, current->pid, current,
	       (void *) current->thread.ksp);
Linus Torvalds's avatar
Linus Torvalds committed
194 195 196
	show_registers(regs);
	/* Show stack backtrace if pt_regs is from kernel mode */
	if (!(regs->psw.mask & PSW_MASK_PSTATE))
Heiko Carstens's avatar
Heiko Carstens committed
197
		show_trace(NULL, (unsigned long *) regs->gprs[15]);
Linus Torvalds's avatar
Linus Torvalds committed
198 199 200 201
}

extern void kernel_thread_starter(void);

202 203
asm(
	".align 4\n"
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208 209 210 211 212 213 214
	"kernel_thread_starter:\n"
	"    la    2,0(10)\n"
	"    basr  14,9\n"
	"    la    2,0\n"
	"    br    11\n");

int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
{
	struct pt_regs regs;

	memset(&regs, 0, sizeof(regs));
Gerald Schaefer's avatar
Gerald Schaefer committed
215
	regs.psw.mask = psw_kernel_bits | PSW_MASK_IO | PSW_MASK_EXT;
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
	regs.psw.addr = (unsigned long) kernel_thread_starter | PSW_ADDR_AMODE;
	regs.gprs[9] = (unsigned long) fn;
	regs.gprs[10] = (unsigned long) arg;
	regs.gprs[11] = (unsigned long) do_exit;
	regs.orig_gpr2 = -1;

	/* Ok, create the new process.. */
	return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
		       0, &regs, 0, NULL, NULL);
}

/*
 * Free current thread data structures etc..
 */
void exit_thread(void)
{
}

void flush_thread(void)
{
	clear_used_math();
	clear_tsk_thread_flag(current, TIF_USEDFPU);
}

void release_thread(struct task_struct *dead_task)
{
}

int copy_thread(int nr, unsigned long clone_flags, unsigned long new_stackp,
	unsigned long unused,
        struct task_struct * p, struct pt_regs * regs)
{
        struct fake_frame
          {
	    struct stack_frame sf;
            struct pt_regs childregs;
          } *frame;

Al Viro's avatar
Al Viro committed
254
        frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
Linus Torvalds's avatar
Linus Torvalds committed
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
        p->thread.ksp = (unsigned long) frame;
	/* Store access registers to kernel stack of new process. */
        frame->childregs = *regs;
	frame->childregs.gprs[2] = 0;	/* child returns 0 on fork. */
        frame->childregs.gprs[15] = new_stackp;
        frame->sf.back_chain = 0;

        /* new return point is ret_from_fork */
        frame->sf.gprs[8] = (unsigned long) ret_from_fork;

        /* fake return stack for resume(), don't go back to schedule */
        frame->sf.gprs[9] = (unsigned long) frame;

	/* Save access registers to new thread structure. */
	save_access_regs(&p->thread.acrs[0]);

271
#ifndef CONFIG_64BIT
Linus Torvalds's avatar
Linus Torvalds committed
272 273 274 275 276 277 278 279 280 281
        /*
	 * save fprs to current->thread.fp_regs to merge them with
	 * the emulated registers and then copy the result to the child.
	 */
	save_fp_regs(&current->thread.fp_regs);
	memcpy(&p->thread.fp_regs, &current->thread.fp_regs,
	       sizeof(s390_fp_regs));
	/* Set a new TLS ?  */
	if (clone_flags & CLONE_SETTLS)
		p->thread.acrs[0] = regs->gprs[6];
282
#else /* CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
283 284 285 286 287 288 289 290 291 292 293
	/* Save the fpu registers to new thread structure. */
	save_fp_regs(&p->thread.fp_regs);
	/* Set a new TLS ?  */
	if (clone_flags & CLONE_SETTLS) {
		if (test_thread_flag(TIF_31BIT)) {
			p->thread.acrs[0] = (unsigned int) regs->gprs[6];
		} else {
			p->thread.acrs[0] = (unsigned int)(regs->gprs[6] >> 32);
			p->thread.acrs[1] = (unsigned int) regs->gprs[6];
		}
	}
294
#endif /* CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297 298 299 300 301 302
	/* start new process with ar4 pointing to the correct address space */
	p->thread.mm_segment = get_fs();
        /* Don't copy debug registers */
        memset(&p->thread.per_info,0,sizeof(p->thread.per_info));

        return 0;
}

303
asmlinkage long sys_fork(void)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
305 306
	struct pt_regs *regs = task_pt_regs(current);
	return do_fork(SIGCHLD, regs->gprs[15], regs, 0, NULL, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
307 308
}

309
asmlinkage long sys_clone(void)
Linus Torvalds's avatar
Linus Torvalds committed
310
{
311 312 313
	struct pt_regs *regs = task_pt_regs(current);
	unsigned long clone_flags;
	unsigned long newsp;
Linus Torvalds's avatar
Linus Torvalds committed
314 315
	int __user *parent_tidptr, *child_tidptr;

316 317 318 319 320 321 322
	clone_flags = regs->gprs[3];
	newsp = regs->orig_gpr2;
	parent_tidptr = (int __user *) regs->gprs[4];
	child_tidptr = (int __user *) regs->gprs[5];
	if (!newsp)
		newsp = regs->gprs[15];
	return do_fork(clone_flags, newsp, regs, 0,
Linus Torvalds's avatar
Linus Torvalds committed
323 324 325 326 327 328 329 330 331 332 333 334 335
		       parent_tidptr, child_tidptr);
}

/*
 * This is trivial, and on the face of it looks like it
 * could equally well be done in user mode.
 *
 * Not so, for quite unobvious reasons - register pressure.
 * In user mode vfork() cannot have a stack frame, and if
 * done by calling the "clone()" system call directly, you
 * do not have enough call-clobbered registers to hold all
 * the information you need.
 */
336
asmlinkage long sys_vfork(void)
Linus Torvalds's avatar
Linus Torvalds committed
337
{
338
	struct pt_regs *regs = task_pt_regs(current);
Linus Torvalds's avatar
Linus Torvalds committed
339
	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
340 341 342 343 344 345 346 347 348 349 350
		       regs->gprs[15], regs, 0, NULL, NULL);
}

asmlinkage void execve_tail(void)
{
	task_lock(current);
	current->ptrace &= ~PT_DTRACE;
	task_unlock(current);
	current->thread.fp_regs.fpc = 0;
	if (MACHINE_HAS_IEEE)
		asm volatile("sfpc %0,%0" : : "d" (0));
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355
}

/*
 * sys_execve() executes a new program.
 */
356
asmlinkage long sys_execve(void)
Linus Torvalds's avatar
Linus Torvalds committed
357
{
358 359 360 361 362 363 364 365 366
	struct pt_regs *regs = task_pt_regs(current);
	char *filename;
	unsigned long result;
	int rc;

	filename = getname((char __user *) regs->orig_gpr2);
	if (IS_ERR(filename)) {
		result = PTR_ERR(filename);
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
367
	}
368 369 370 371 372 373 374 375 376 377
	rc = do_execve(filename, (char __user * __user *) regs->gprs[3],
		       (char __user * __user *) regs->gprs[4], regs);
	if (rc) {
		result = rc;
		goto out_putname;
	}
	execve_tail();
	result = regs->gprs[2];
out_putname:
	putname(filename);
Linus Torvalds's avatar
Linus Torvalds committed
378
out:
379
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385 386
}

/*
 * fill in the FPU structure for a core dump.
 */
int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
{
387
#ifndef CONFIG_64BIT
Linus Torvalds's avatar
Linus Torvalds committed
388 389 390 391 392 393
        /*
	 * save fprs to current->thread.fp_regs to merge them with
	 * the emulated registers and then copy the result to the dump.
	 */
	save_fp_regs(&current->thread.fp_regs);
	memcpy(fpregs, &current->thread.fp_regs, sizeof(s390_fp_regs));
394
#else /* CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
395
	save_fp_regs(fpregs);
396
#endif /* CONFIG_64BIT */
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399 400 401 402 403 404 405
	return 1;
}

unsigned long get_wchan(struct task_struct *p)
{
	struct stack_frame *sf, *low, *high;
	unsigned long return_address;
	int count;

Al Viro's avatar
Al Viro committed
406
	if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
Linus Torvalds's avatar
Linus Torvalds committed
407
		return 0;
Al Viro's avatar
Al Viro committed
408 409
	low = task_stack_page(p);
	high = (struct stack_frame *) task_pt_regs(p);
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415 416 417 418 419 420 421 422 423
	sf = (struct stack_frame *) (p->thread.ksp & PSW_ADDR_INSN);
	if (sf <= low || sf > high)
		return 0;
	for (count = 0; count < 16; count++) {
		sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
		if (sf <= low || sf > high)
			return 0;
		return_address = sf->gprs[8] & PSW_ADDR_INSN;
		if (!in_sched_functions(return_address))
			return return_address;
	}
	return 0;
}