process.c 11.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1994 - 1999, 2000 by Ralf Baechle and others.
7
 * Copyright (C) 2005, 2006 by Ralf Baechle (ralf@linux-mips.org)
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
 * Copyright (C) 2004 Thiemo Seufer
 */
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/mman.h>
#include <linux/personality.h>
#include <linux/sys.h>
#include <linux/user.h>
#include <linux/a.out.h>
#include <linux/init.h>
#include <linux/completion.h>
27
#include <linux/kallsyms.h>
L
Linus Torvalds 已提交
28

29
#include <asm/abi.h>
L
Linus Torvalds 已提交
30 31
#include <asm/bootinfo.h>
#include <asm/cpu.h>
32
#include <asm/dsp.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42
#include <asm/fpu.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/mipsregs.h>
#include <asm/processor.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/elf.h>
#include <asm/isadep.h>
#include <asm/inst.h>
43 44 45 46
#ifdef CONFIG_MIPS_MT_SMTC
#include <asm/mipsmtregs.h>
extern void smtc_idle_loop_hook(void);
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54 55 56

/*
 * The idle thread. There's no useful work to be done, so just try to conserve
 * power and have a low exit latency (ie sit in a loop waiting for somebody to
 * say that they'd like to reschedule)
 */
ATTRIB_NORET void cpu_idle(void)
{
	/* endless idle loop with no priority at all */
	while (1) {
57 58 59 60
		while (!need_resched()) {
#ifdef CONFIG_MIPS_MT_SMTC
			smtc_idle_loop_hook();
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
61 62
			if (cpu_wait)
				(*cpu_wait)();
63
		}
64
		preempt_enable_no_resched();
L
Linus Torvalds 已提交
65
		schedule();
66
		preempt_disable();
L
Linus Torvalds 已提交
67 68 69
	}
}

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
/*
 * Native o32 and N64 ABI without DSP ASE
 */
struct mips_abi mips_abi = {
	.do_signal	= do_signal,
#ifdef CONFIG_TRAD_SIGNALS
	.setup_frame	= setup_frame,
#endif
	.setup_rt_frame	= setup_rt_frame
};

#ifdef CONFIG_MIPS32_O32
/*
 * o32 compatibility on 64-bit kernels, without DSP ASE
 */
struct mips_abi mips_abi_32 = {
	.do_signal	= do_signal32,
	.setup_frame	= setup_frame_32,
	.setup_rt_frame	= setup_rt_frame_32
};
#endif /* CONFIG_MIPS32_O32 */

#ifdef CONFIG_MIPS32_N32
/*
 * N32 on 64-bit kernels, without DSP ASE
 */
struct mips_abi mips_abi_n32 = {
	.do_signal	= do_signal,
	.setup_rt_frame	= setup_rt_frame_n32
};
#endif /* CONFIG_MIPS32_N32 */

L
Linus Torvalds 已提交
102 103 104 105 106 107 108 109
asmlinkage void ret_from_fork(void);

void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
{
	unsigned long status;

	/* New thread loses kernel privileges. */
	status = regs->cp0_status & ~(ST0_CU0|ST0_CU1|KU_MASK);
110
#ifdef CONFIG_64BIT
L
Linus Torvalds 已提交
111 112 113 114 115 116 117
	status &= ~ST0_FR;
	status |= (current->thread.mflags & MF_32BIT_REGS) ? 0 : ST0_FR;
#endif
	status |= KU_USER;
	regs->cp0_status = status;
	clear_used_math();
	lose_fpu();
118 119
	if (cpu_has_dsp)
		__init_dsp();
L
Linus Torvalds 已提交
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	regs->cp0_epc = pc;
	regs->regs[29] = sp;
	current_thread_info()->addr_limit = USER_DS;
}

void exit_thread(void)
{
}

void flush_thread(void)
{
}

int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
	unsigned long unused, struct task_struct *p, struct pt_regs *regs)
{
A
Al Viro 已提交
136
	struct thread_info *ti = task_thread_info(p);
L
Linus Torvalds 已提交
137 138
	struct pt_regs *childregs;
	long childksp;
R
Ralf Baechle 已提交
139
	p->set_child_tid = p->clear_child_tid = NULL;
L
Linus Torvalds 已提交
140

A
Al Viro 已提交
141
	childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;
L
Linus Torvalds 已提交
142 143 144

	preempt_disable();

145
	if (is_fpu_owner())
L
Linus Torvalds 已提交
146
		save_fp(p);
147 148 149

	if (cpu_has_dsp)
		save_dsp(p);
L
Linus Torvalds 已提交
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

	preempt_enable();

	/* set up new TSS. */
	childregs = (struct pt_regs *) childksp - 1;
	*childregs = *regs;
	childregs->regs[7] = 0;	/* Clear error flag */

#if defined(CONFIG_BINFMT_IRIX)
	if (current->personality != PER_LINUX) {
		/* Under IRIX things are a little different. */
		childregs->regs[3] = 1;
		regs->regs[3] = 0;
	}
#endif
	childregs->regs[2] = 0;	/* Child gets zero as return value */
	regs->regs[2] = p->pid;

	if (childregs->cp0_status & ST0_CU0) {
		childregs->regs[28] = (unsigned long) ti;
		childregs->regs[29] = childksp;
		ti->addr_limit = KERNEL_DS;
	} else {
		childregs->regs[29] = usp;
		ti->addr_limit = USER_DS;
	}
	p->thread.reg29 = (unsigned long) childregs;
	p->thread.reg31 = (unsigned long) ret_from_fork;

	/*
	 * New tasks lose permission to use the fpu. This accelerates context
	 * switching for most programs since they don't use the fpu.
	 */
	p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
	childregs->cp0_status &= ~(ST0_CU2|ST0_CU1);
	clear_tsk_thread_flag(p, TIF_USEDFPU);

R
Ralf Baechle 已提交
187 188 189 190 191 192 193 194 195 196 197
#ifdef CONFIG_MIPS_MT_FPAFF
	/*
	 * FPU affinity support is cleaner if we track the
	 * user-visible CPU affinity from the very beginning.
	 * The generic cpus_allowed mask will already have
	 * been copied from the parent before copy_thread
	 * is invoked.
	 */
	p->thread.user_cpus_allowed = p->cpus_allowed;
#endif /* CONFIG_MIPS_MT_FPAFF */

R
Ralf Baechle 已提交
198 199 200
	if (clone_flags & CLONE_SETTLS)
		ti->tp_value = regs->regs[7];

L
Linus Torvalds 已提交
201 202 203 204 205 206 207 208 209 210 211
	return 0;
}

/* Fill in the fpu structure for a core dump.. */
int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
{
	memcpy(r, &current->thread.fpu, sizeof(current->thread.fpu));

	return 1;
}

212
void elf_dump_regs(elf_greg_t *gp, struct pt_regs *regs)
L
Linus Torvalds 已提交
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
{
	int i;

	for (i = 0; i < EF_R0; i++)
		gp[i] = 0;
	gp[EF_R0] = 0;
	for (i = 1; i <= 31; i++)
		gp[EF_R0 + i] = regs->regs[i];
	gp[EF_R26] = 0;
	gp[EF_R27] = 0;
	gp[EF_LO] = regs->lo;
	gp[EF_HI] = regs->hi;
	gp[EF_CP0_EPC] = regs->cp0_epc;
	gp[EF_CP0_BADVADDR] = regs->cp0_badvaddr;
	gp[EF_CP0_STATUS] = regs->cp0_status;
	gp[EF_CP0_CAUSE] = regs->cp0_cause;
#ifdef EF_UNUSED0
	gp[EF_UNUSED0] = 0;
#endif
}

R
Ralf Baechle 已提交
234 235
int dump_task_regs (struct task_struct *tsk, elf_gregset_t *regs)
{
A
Al Viro 已提交
236
	elf_dump_regs(*regs, task_pt_regs(tsk));
R
Ralf Baechle 已提交
237 238 239
	return 1;
}

L
Linus Torvalds 已提交
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
int dump_task_fpu (struct task_struct *t, elf_fpregset_t *fpr)
{
	memcpy(fpr, &t->thread.fpu, sizeof(current->thread.fpu));

	return 1;
}

/*
 * Create a kernel thread
 */
ATTRIB_NORET void kernel_thread_helper(void *arg, int (*fn)(void *))
{
	do_exit(fn(arg));
}

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

	memset(&regs, 0, sizeof(regs));

	regs.regs[4] = (unsigned long) arg;
	regs.regs[5] = (unsigned long) fn;
	regs.cp0_epc = (unsigned long) kernel_thread_helper;
	regs.cp0_status = read_c0_status();
#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
	regs.cp0_status &= ~(ST0_KUP | ST0_IEC);
	regs.cp0_status |= ST0_IEP;
#else
	regs.cp0_status |= ST0_EXL;
#endif

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

276 277
static struct mips_frame_info {
	void *func;
278 279
	unsigned long func_size;
	int frame_size;
L
Linus Torvalds 已提交
280
	int pc_offset;
281 282
} *schedule_frame, mfinfo[64];
static int mfinfo_num;
283

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
static inline int is_ra_save_ins(union mips_instruction *ip)
{
	/* sw / sd $ra, offset($sp) */
	return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) &&
		ip->i_format.rs == 29 &&
		ip->i_format.rt == 31;
}

static inline int is_jal_jalr_jr_ins(union mips_instruction *ip)
{
	if (ip->j_format.opcode == jal_op)
		return 1;
	if (ip->r_format.opcode != spec_op)
		return 0;
	return ip->r_format.func == jalr_op || ip->r_format.func == jr_op;
}

static inline int is_sp_move_ins(union mips_instruction *ip)
{
	/* addiu/daddiu sp,sp,-imm */
	if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
		return 0;
	if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
		return 1;
	return 0;
}

311
static int get_frame_info(struct mips_frame_info *info)
L
Linus Torvalds 已提交
312
{
313 314 315 316
	union mips_instruction *ip = info->func;
	int i, max_insns =
		min(128UL, info->func_size / sizeof(union mips_instruction));

L
Linus Torvalds 已提交
317
	info->pc_offset = -1;
318
	info->frame_size = 0;
L
Linus Torvalds 已提交
319

320 321 322
	for (i = 0; i < max_insns; i++, ip++) {

		if (is_jal_jalr_jr_ins(ip))
323
			break;
324 325 326 327
		if (!info->frame_size) {
			if (is_sp_move_ins(ip))
				info->frame_size = - ip->i_format.simmediate;
			continue;
328
		}
329
		if (info->pc_offset == -1 && is_ra_save_ins(ip)) {
330 331
			info->pc_offset =
				ip->i_format.simmediate / sizeof(long);
332
			break;
L
Linus Torvalds 已提交
333 334
		}
	}
335 336 337 338 339 340
	if (info->frame_size && info->pc_offset >= 0) /* nested */
		return 0;
	if (info->pc_offset < 0) /* leaf */
		return 1;
	/* prologue seems boggus... */
	return -1;
L
Linus Torvalds 已提交
341 342 343 344
}

static int __init frame_info_init(void)
{
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
	int i;
#ifdef CONFIG_KALLSYMS
	char *modname;
	char namebuf[KSYM_NAME_LEN + 1];
	unsigned long start, size, ofs;
	extern char __sched_text_start[], __sched_text_end[];
	extern char __lock_text_start[], __lock_text_end[];

	start = (unsigned long)__sched_text_start;
	for (i = 0; i < ARRAY_SIZE(mfinfo); i++) {
		if (start == (unsigned long)schedule)
			schedule_frame = &mfinfo[i];
		if (!kallsyms_lookup(start, &size, &ofs, &modname, namebuf))
			break;
		mfinfo[i].func = (void *)(start + ofs);
		mfinfo[i].func_size = size;
		start += size - ofs;
		if (start >= (unsigned long)__lock_text_end)
			break;
		if (start == (unsigned long)__sched_text_end)
			start = (unsigned long)__lock_text_start;
	}
#else
	mfinfo[0].func = schedule;
	schedule_frame = &mfinfo[0];
#endif
371 372 373 374 375 376 377 378 379
	for (i = 0; i < ARRAY_SIZE(mfinfo) && mfinfo[i].func; i++)
		get_frame_info(mfinfo + i);

	/*
	 * Without schedule() frame info, result given by
	 * thread_saved_pc() and get_wchan() are not reliable.
	 */
	if (schedule_frame->pc_offset < 0)
		printk("Can't analyze schedule() prologue at %p\n", schedule);
380 381

	mfinfo_num = i;
L
Linus Torvalds 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
	return 0;
}

arch_initcall(frame_info_init);

/*
 * Return saved PC of a blocked thread.
 */
unsigned long thread_saved_pc(struct task_struct *tsk)
{
	struct thread_struct *t = &tsk->thread;

	/* New born processes are a special case */
	if (t->reg31 == (unsigned long) ret_from_fork)
		return t->reg31;

398
	if (!schedule_frame || schedule_frame->pc_offset < 0)
L
Linus Torvalds 已提交
399
		return 0;
400
	return ((unsigned long *)t->reg29)[schedule_frame->pc_offset];
L
Linus Torvalds 已提交
401 402 403 404 405
}

/* get_wchan - a maintenance nightmare^W^Wpain in the ass ...  */
unsigned long get_wchan(struct task_struct *p)
{
406
	unsigned long stack_page;
407 408 409 410
	unsigned long pc;
#ifdef CONFIG_KALLSYMS
	unsigned long frame;
#endif
L
Linus Torvalds 已提交
411 412 413 414

	if (!p || p == current || p->state == TASK_RUNNING)
		return 0;

A
Al Viro 已提交
415
	stack_page = (unsigned long)task_stack_page(p);
416
	if (!stack_page || !mfinfo_num)
L
Linus Torvalds 已提交
417
		return 0;
418

L
Linus Torvalds 已提交
419
	pc = thread_saved_pc(p);
420
#ifdef CONFIG_KALLSYMS
L
Linus Torvalds 已提交
421
	if (!in_sched_functions(pc))
422
		return pc;
L
Linus Torvalds 已提交
423

424
	frame = p->thread.reg29 + schedule_frame->frame_size;
425 426
	do {
		int i;
L
Linus Torvalds 已提交
427

428 429
		if (frame < stack_page || frame > stack_page + THREAD_SIZE - 32)
			return 0;
L
Linus Torvalds 已提交
430

431
		for (i = mfinfo_num - 1; i >= 0; i--) {
432 433 434 435 436
			if (pc >= (unsigned long) mfinfo[i].func)
				break;
		}
		if (i < 0)
			break;
L
Linus Torvalds 已提交
437

438 439
		if (mfinfo[i].pc_offset < 0)
			break;
440
		pc = ((unsigned long *)frame)[mfinfo[i].pc_offset];
441 442 443
		if (!mfinfo[i].frame_size)
			break;
		frame += mfinfo[i].frame_size;
444
	} while (in_sched_functions(pc));
445
#endif
L
Linus Torvalds 已提交
446 447 448 449

	return pc;
}

450
#ifdef CONFIG_KALLSYMS
F
Franck Bui-Huu 已提交
451 452 453
/* used by show_backtrace() */
unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
			   unsigned long pc, unsigned long ra)
454 455 456 457 458 459
{
	unsigned long stack_page;
	struct mips_frame_info info;
	char *modname;
	char namebuf[KSYM_NAME_LEN + 1];
	unsigned long size, ofs;
F
Franck Bui-Huu 已提交
460
	int leaf;
461 462 463 464 465 466 467 468 469 470 471 472

	stack_page = (unsigned long)task_stack_page(task);
	if (!stack_page)
		return 0;

	if (!kallsyms_lookup(pc, &size, &ofs, &modname, namebuf))
		return 0;
	if (ofs == 0)
		return 0;

	info.func = (void *)(pc - ofs);
	info.func_size = ofs;	/* analyze from start to ofs */
F
Franck Bui-Huu 已提交
473 474
	leaf = get_frame_info(&info);
	if (leaf < 0)
475
		return 0;
F
Franck Bui-Huu 已提交
476 477 478

	if (*sp < stack_page ||
	    *sp + info.frame_size > stack_page + THREAD_SIZE - 32)
479 480
		return 0;

F
Franck Bui-Huu 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493
	if (leaf)
		/*
		 * For some extreme cases, get_frame_info() can
		 * consider wrongly a nested function as a leaf
		 * one. In that cases avoid to return always the
		 * same value.
		 */
		pc = pc != ra ? ra : 0;
	else
		pc = ((unsigned long *)(*sp))[info.pc_offset];

	*sp += info.frame_size;
	return __kernel_text_address(pc) ? pc : 0;
494 495
}
#endif