process.c 10.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  linux/arch/arm/kernel/process.c
 *
 *  Copyright (C) 1996-2000 Russell King - Converted to ARM.
 *  Original Copyright (C) 1995  Linus Torvalds
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <stdarg.h>

13
#include <linux/export.h>
L
Linus Torvalds 已提交
14 15 16 17 18 19 20 21 22
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/user.h>
#include <linux/interrupt.h>
#include <linux/kallsyms.h>
#include <linux/init.h>
23
#include <linux/elfcore.h>
24
#include <linux/pm.h>
25
#include <linux/tick.h>
26
#include <linux/utsname.h>
27
#include <linux/uaccess.h>
28
#include <linux/random.h>
29
#include <linux/hw_breakpoint.h>
30
#include <linux/leds.h>
L
Linus Torvalds 已提交
31 32

#include <asm/processor.h>
33
#include <asm/thread_notify.h>
34
#include <asm/stacktrace.h>
35
#include <asm/system_misc.h>
36
#include <asm/mach/time.h>
37
#include <asm/tls.h>
38
#include <asm/vdso.h>
L
Linus Torvalds 已提交
39

40 41 42 43 44 45
#ifdef CONFIG_CC_STACKPROTECTOR
#include <linux/stackprotector.h>
unsigned long __stack_chk_guard __read_mostly;
EXPORT_SYMBOL(__stack_chk_guard);
#endif

46
static const char *processor_modes[] __maybe_unused = {
47 48
  "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
  "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
49 50
  "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "MON_32" , "ABT_32" ,
  "UK8_32" , "UK9_32" , "HYP_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
51 52
};

53
static const char *isa_modes[] __maybe_unused = {
54 55 56
  "ARM" , "Thumb" , "Jazelle", "ThumbEE"
};

L
Linus Torvalds 已提交
57
/*
N
Nicolas Pitre 已提交
58
 * This is our default idle handler.
L
Linus Torvalds 已提交
59
 */
N
Nicolas Pitre 已提交
60 61 62

void (*arm_pm_idle)(void);

63 64 65 66 67
/*
 * Called from the core idle loop.
 */

void arch_cpu_idle(void)
L
Linus Torvalds 已提交
68
{
N
Nicolas Pitre 已提交
69 70 71
	if (arm_pm_idle)
		arm_pm_idle();
	else
N
Nicolas Pitre 已提交
72
		cpu_do_idle();
73
	local_irq_enable();
L
Linus Torvalds 已提交
74 75
}

T
Thomas Gleixner 已提交
76
void arch_cpu_idle_prepare(void)
L
Linus Torvalds 已提交
77 78
{
	local_fiq_enable();
T
Thomas Gleixner 已提交
79
}
L
Linus Torvalds 已提交
80

T
Thomas Gleixner 已提交
81 82 83 84 85
void arch_cpu_idle_enter(void)
{
	ledtrig_cpu(CPU_LED_IDLE_START);
#ifdef CONFIG_PL310_ERRATA_769419
	wmb();
86
#endif
T
Thomas Gleixner 已提交
87
}
88

T
Thomas Gleixner 已提交
89 90 91 92 93
void arch_cpu_idle_exit(void)
{
	ledtrig_cpu(CPU_LED_IDLE_END);
}

R
Russell King 已提交
94
void __show_regs(struct pt_regs *regs)
L
Linus Torvalds 已提交
95
{
96 97
	unsigned long flags;
	char buf[64];
98
#ifndef CONFIG_CPU_V7M
99
	unsigned int domain, fs;
100 101 102 103 104 105
#ifdef CONFIG_CPU_SW_DOMAIN_PAN
	/*
	 * Get the domain register for the parent context. In user
	 * mode, we don't save the DACR, so lets use what it should
	 * be. For other modes, we place it after the pt_regs struct.
	 */
106
	if (user_mode(regs)) {
107
		domain = DACR_UACCESS_ENABLE;
108 109
		fs = get_fs();
	} else {
110
		domain = to_svc_pt_regs(regs)->dacr;
111 112
		fs = to_svc_pt_regs(regs)->addr_limit;
	}
113 114
#else
	domain = get_domain();
115
	fs = get_fs();
116 117
#endif
#endif
L
Linus Torvalds 已提交
118

119 120
	show_regs_print_info(KERN_DEFAULT);

L
Linus Torvalds 已提交
121 122
	print_symbol("PC is at %s\n", instruction_pointer(regs));
	print_symbol("LR is at %s\n", regs->ARM_lr);
123
	printk("pc : [<%08lx>]    lr : [<%08lx>]    psr: %08lx\n"
L
Linus Torvalds 已提交
124
	       "sp : %08lx  ip : %08lx  fp : %08lx\n",
125 126
		regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr,
		regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);
L
Linus Torvalds 已提交
127 128 129 130 131 132 133 134 135
	printk("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
		regs->ARM_r10, regs->ARM_r9,
		regs->ARM_r8);
	printk("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
		regs->ARM_r7, regs->ARM_r6,
		regs->ARM_r5, regs->ARM_r4);
	printk("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
		regs->ARM_r3, regs->ARM_r2,
		regs->ARM_r1, regs->ARM_r0);
136 137 138 139 140 141 142 143

	flags = regs->ARM_cpsr;
	buf[0] = flags & PSR_N_BIT ? 'N' : 'n';
	buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z';
	buf[2] = flags & PSR_C_BIT ? 'C' : 'c';
	buf[3] = flags & PSR_V_BIT ? 'V' : 'v';
	buf[4] = '\0';

144
#ifndef CONFIG_CPU_V7M
145 146 147 148 149 150
	{
		const char *segment;

		if ((domain & domain_mask(DOMAIN_USER)) ==
		    domain_val(DOMAIN_USER, DOMAIN_NOACCESS))
			segment = "none";
151
		else if (fs == get_ds())
152 153 154 155 156 157 158 159 160 161
			segment = "kernel";
		else
			segment = "user";

		printk("Flags: %s  IRQs o%s  FIQs o%s  Mode %s  ISA %s  Segment %s\n",
			buf, interrupts_enabled(regs) ? "n" : "ff",
			fast_interrupts_enabled(regs) ? "n" : "ff",
			processor_modes[processor_mode(regs)],
			isa_modes[isa_mode(regs)], segment);
	}
162 163 164 165
#else
	printk("xPSR: %08lx\n", regs->ARM_cpsr);
#endif

166
#ifdef CONFIG_CPU_CP15
L
Linus Torvalds 已提交
167
	{
168
		unsigned int ctrl;
169 170

		buf[0] = '\0';
171
#ifdef CONFIG_CPU_CP15_MMU
172
		{
173
			unsigned int transbase;
174
			asm("mrc p15, 0, %0, c2, c0\n\t"
175
			    : "=r" (transbase));
176
			snprintf(buf, sizeof(buf), "  Table: %08x  DAC: %08x",
177
				transbase, domain);
178
		}
179
#endif
180 181 182 183
		asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl));

		printk("Control: %08x%s\n", ctrl, buf);
	}
184
#endif
L
Linus Torvalds 已提交
185 186
}

R
Russell King 已提交
187 188 189
void show_regs(struct pt_regs * regs)
{
	__show_regs(regs);
190
	dump_stack();
R
Russell King 已提交
191 192
}

193 194 195 196
ATOMIC_NOTIFIER_HEAD(thread_notify_head);

EXPORT_SYMBOL_GPL(thread_notify_head);

L
Linus Torvalds 已提交
197 198 199
/*
 * Free current thread data structures etc..
 */
200
void exit_thread(struct task_struct *tsk)
L
Linus Torvalds 已提交
201
{
202
	thread_notify(THREAD_NOTIFY_EXIT, task_thread_info(tsk));
L
Linus Torvalds 已提交
203 204 205 206 207 208 209
}

void flush_thread(void)
{
	struct thread_info *thread = current_thread_info();
	struct task_struct *tsk = current;

210 211
	flush_ptrace_hw_breakpoint(tsk);

L
Linus Torvalds 已提交
212 213
	memset(thread->used_cp, 0, sizeof(thread->used_cp));
	memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
214 215
	memset(&thread->fpstate, 0, sizeof(union fp_state));

216 217
	flush_tls();

218
	thread_notify(THREAD_NOTIFY_FLUSH, thread);
L
Linus Torvalds 已提交
219 220 221 222 223 224 225 226 227
}

void release_thread(struct task_struct *dead_task)
{
}

asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");

int
A
Alexey Dobriyan 已提交
228
copy_thread(unsigned long clone_flags, unsigned long stack_start,
229
	    unsigned long stk_sz, struct task_struct *p)
L
Linus Torvalds 已提交
230
{
A
Al Viro 已提交
231 232
	struct thread_info *thread = task_thread_info(p);
	struct pt_regs *childregs = task_pt_regs(p);
L
Linus Torvalds 已提交
233 234

	memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
235

236
#ifdef CONFIG_CPU_USE_DOMAINS
237 238 239 240 241 242 243
	/*
	 * Copy the initial value of the domain access control register
	 * from the current thread: thread->addr_limit will have been
	 * copied from the current thread via setup_thread_stack() in
	 * kernel/fork.c
	 */
	thread->cpu_domain = get_domain();
244
#endif
245

A
Al Viro 已提交
246 247
	if (likely(!(p->flags & PF_KTHREAD))) {
		*childregs = *current_pt_regs();
248
		childregs->ARM_r0 = 0;
A
Al Viro 已提交
249 250
		if (stack_start)
			childregs->ARM_sp = stack_start;
251
	} else {
252
		memset(childregs, 0, sizeof(struct pt_regs));
253 254 255 256
		thread->cpu_context.r4 = stk_sz;
		thread->cpu_context.r5 = stack_start;
		childregs->ARM_cpsr = SVC_MODE;
	}
257
	thread->cpu_context.pc = (unsigned long)ret_from_fork;
L
Linus Torvalds 已提交
258 259
	thread->cpu_context.sp = (unsigned long)childregs;

260 261
	clear_ptrace_hw_breakpoint(p);

L
Linus Torvalds 已提交
262
	if (clone_flags & CLONE_SETTLS)
263 264
		thread->tp_value[0] = childregs->ARM_r3;
	thread->tp_value[1] = get_tpuser();
L
Linus Torvalds 已提交
265

266 267
	thread_notify(THREAD_NOTIFY_COPY, thread);

L
Linus Torvalds 已提交
268 269 270
	return 0;
}

271 272 273 274 275 276 277 278 279
/*
 * Fill in the task's elfregs structure for a core dump.
 */
int dump_task_regs(struct task_struct *t, elf_gregset_t *elfregs)
{
	elf_core_copy_regs(elfregs, task_pt_regs(t));
	return 1;
}

L
Linus Torvalds 已提交
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
/*
 * fill in the fpe structure for a core dump...
 */
int dump_fpu (struct pt_regs *regs, struct user_fp *fp)
{
	struct thread_info *thread = current_thread_info();
	int used_math = thread->used_cp[1] | thread->used_cp[2];

	if (used_math)
		memcpy(fp, &thread->fpstate.soft, sizeof (*fp));

	return used_math != 0;
}
EXPORT_SYMBOL(dump_fpu);

unsigned long get_wchan(struct task_struct *p)
{
297
	struct stackframe frame;
298
	unsigned long stack_page;
L
Linus Torvalds 已提交
299 300 301 302
	int count = 0;
	if (!p || p == current || p->state == TASK_RUNNING)
		return 0;

303 304 305 306
	frame.fp = thread_saved_fp(p);
	frame.sp = thread_saved_sp(p);
	frame.lr = 0;			/* recovered from the stack */
	frame.pc = thread_saved_pc(p);
307
	stack_page = (unsigned long)task_stack_page(p);
L
Linus Torvalds 已提交
308
	do {
309 310 311
		if (frame.sp < stack_page ||
		    frame.sp >= stack_page + THREAD_SIZE ||
		    unwind_frame(&frame) < 0)
L
Linus Torvalds 已提交
312
			return 0;
313 314
		if (!in_sched_functions(frame.pc))
			return frame.pc;
L
Linus Torvalds 已提交
315 316 317
	} while (count ++ < 16);
	return 0;
}
318 319 320 321 322 323

unsigned long arch_randomize_brk(struct mm_struct *mm)
{
	unsigned long range_end = mm->brk + 0x02000000;
	return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
}
324

325
#ifdef CONFIG_MMU
326
#ifdef CONFIG_KUSER_HELPERS
327 328
/*
 * The vectors page is always readable from user space for the
329 330
 * atomic helpers. Insert it into the gate_vma so that it is visible
 * through ptrace and /proc/<pid>/mem.
331
 */
332 333 334 335 336
static struct vm_area_struct gate_vma = {
	.vm_start	= 0xffff0000,
	.vm_end		= 0xffff0000 + PAGE_SIZE,
	.vm_flags	= VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYEXEC,
};
337

338
static int __init gate_vma_init(void)
339
{
340
	gate_vma.vm_page_prot = PAGE_READONLY_EXEC;
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
	return 0;
}
arch_initcall(gate_vma_init);

struct vm_area_struct *get_gate_vma(struct mm_struct *mm)
{
	return &gate_vma;
}

int in_gate_area(struct mm_struct *mm, unsigned long addr)
{
	return (addr >= gate_vma.vm_start) && (addr < gate_vma.vm_end);
}

int in_gate_area_no_mm(unsigned long addr)
{
	return in_gate_area(NULL, addr);
358
}
359
#define is_gate_vma(vma)	((vma) == &gate_vma)
360 361 362
#else
#define is_gate_vma(vma)	0
#endif
363 364 365

const char *arch_vma_name(struct vm_area_struct *vma)
{
366
	return is_gate_vma(vma) ? "[vectors]" : NULL;
367 368
}

369
/* If possible, provide a placement hint at a random offset from the
370
 * stack for the sigpage and vdso pages.
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
 */
static unsigned long sigpage_addr(const struct mm_struct *mm,
				  unsigned int npages)
{
	unsigned long offset;
	unsigned long first;
	unsigned long last;
	unsigned long addr;
	unsigned int slots;

	first = PAGE_ALIGN(mm->start_stack);

	last = TASK_SIZE - (npages << PAGE_SHIFT);

	/* No room after stack? */
	if (first > last)
		return 0;

	/* Just enough room? */
	if (first == last)
		return first;

	slots = ((last - first) >> PAGE_SHIFT) + 1;

	offset = get_random_int() % slots;

	addr = first + (offset << PAGE_SHIFT);

	return addr;
400 401
}

402
static struct page *signal_page;
403 404
extern struct page *get_signal_page(void);

405 406 407 408 409
static const struct vm_special_mapping sigpage_mapping = {
	.name = "[sigpage]",
	.pages = &signal_page,
};

410 411 412
int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
{
	struct mm_struct *mm = current->mm;
413
	struct vm_area_struct *vma;
414
	unsigned long npages;
415
	unsigned long addr;
416
	unsigned long hint;
417
	int ret = 0;
418

419 420 421
	if (!signal_page)
		signal_page = get_signal_page();
	if (!signal_page)
422 423
		return -ENOMEM;

424 425 426
	npages = 1; /* for sigpage */
	npages += vdso_total_pages;

427 428
	if (down_write_killable(&mm->mmap_sem))
		return -EINTR;
429 430
	hint = sigpage_addr(mm, npages);
	addr = get_unmapped_area(NULL, hint, npages << PAGE_SHIFT, 0, 0);
431 432 433 434 435
	if (IS_ERR_VALUE(addr)) {
		ret = addr;
		goto up_fail;
	}

436
	vma = _install_special_mapping(mm, addr, PAGE_SIZE,
437
		VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC,
438 439 440 441 442 443
		&sigpage_mapping);

	if (IS_ERR(vma)) {
		ret = PTR_ERR(vma);
		goto up_fail;
	}
444

445
	mm->context.sigpage = addr;
446

447 448 449 450 451 452
	/* Unlike the sigpage, failure to install the vdso is unlikely
	 * to be fatal to the process, so no error check needed
	 * here.
	 */
	arm_install_vdso(mm, addr + PAGE_SIZE);

453 454 455
 up_fail:
	up_write(&mm->mmap_sem);
	return ret;
456
}
457
#endif