process.c 9.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 *  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>

#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/user.h>
#include <linux/delay.h>
#include <linux/reboot.h>
#include <linux/interrupt.h>
#include <linux/kallsyms.h>
#include <linux/init.h>
25
#include <linux/cpu.h>
26
#include <linux/elfcore.h>
27
#include <linux/pm.h>
28
#include <linux/tick.h>
29
#include <linux/utsname.h>
30
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
31 32 33

#include <asm/leds.h>
#include <asm/processor.h>
R
Russell King 已提交
34
#include <asm/system.h>
35
#include <asm/thread_notify.h>
36
#include <asm/stacktrace.h>
37
#include <asm/mach/time.h>
L
Linus Torvalds 已提交
38

39 40 41 42 43 44 45
static const char *processor_modes[] = {
  "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",
  "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" ,
  "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
};

46 47 48 49
static const char *isa_modes[] = {
  "ARM" , "Thumb" , "Jazelle", "ThumbEE"
};

L
Linus Torvalds 已提交
50 51 52 53
extern void setup_mm_for_reboot(char mode);

static volatile int hlt_counter;

54
#include <mach/system.h>
L
Linus Torvalds 已提交
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

void disable_hlt(void)
{
	hlt_counter++;
}

EXPORT_SYMBOL(disable_hlt);

void enable_hlt(void)
{
	hlt_counter--;
}

EXPORT_SYMBOL(enable_hlt);

static int __init nohlt_setup(char *__unused)
{
	hlt_counter = 1;
	return 1;
}

static int __init hlt_setup(char *__unused)
{
	hlt_counter = 0;
	return 1;
}

__setup("nohlt", nohlt_setup);
__setup("hlt", hlt_setup);

85
void arm_machine_restart(char mode, const char *cmd)
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
{
	/*
	 * Clean and disable cache, and turn off interrupts
	 */
	cpu_proc_fin();

	/*
	 * Tell the mm system that we are going to reboot -
	 * we may need it to insert some 1:1 mappings so that
	 * soft boot works.
	 */
	setup_mm_for_reboot(mode);

	/*
	 * Now call the architecture specific reboot code.
	 */
102
	arch_reset(mode, cmd);
103 104 105 106 107 108 109 110 111 112

	/*
	 * Whoops - the architecture was unable to reboot.
	 * Tell the user!
	 */
	mdelay(1000);
	printk("Reboot failed -- System halted\n");
	while (1);
}

L
Linus Torvalds 已提交
113
/*
114
 * Function pointers to optional machine specific functions
L
Linus Torvalds 已提交
115 116 117 118
 */
void (*pm_power_off)(void);
EXPORT_SYMBOL(pm_power_off);

119
void (*arm_pm_restart)(char str, const char *cmd) = arm_machine_restart;
120 121 122
EXPORT_SYMBOL_GPL(arm_pm_restart);


L
Linus Torvalds 已提交
123 124 125 126
/*
 * This is our default idle handler.  We need to disable
 * interrupts here to ensure we don't miss a wakeup call.
 */
127
static void default_idle(void)
L
Linus Torvalds 已提交
128
{
129 130 131
	if (!need_resched())
		arch_idle();
	local_irq_enable();
L
Linus Torvalds 已提交
132 133
}

134 135 136
void (*pm_idle)(void) = default_idle;
EXPORT_SYMBOL(pm_idle);

L
Linus Torvalds 已提交
137
/*
138 139 140 141
 * The idle thread, has rather strange semantics for calling pm_idle,
 * but this is what x86 does and we need to do the same, so that
 * things like cpuidle get called in the same way.  The only difference
 * is that we always respect 'hlt_counter' to prevent low power idle.
L
Linus Torvalds 已提交
142 143 144 145 146 147 148
 */
void cpu_idle(void)
{
	local_fiq_enable();

	/* endless idle loop with no priority at all */
	while (1) {
149 150 151
		tick_nohz_stop_sched_tick(1);
		leds_event(led_idle_start);
		while (!need_resched()) {
152
#ifdef CONFIG_HOTPLUG_CPU
153 154
			if (cpu_is_offline(smp_processor_id()))
				cpu_die();
155 156
#endif

157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
			local_irq_disable();
			if (hlt_counter) {
				local_irq_enable();
				cpu_relax();
			} else {
				stop_critical_timings();
				pm_idle();
				start_critical_timings();
				/*
				 * This will eventually be removed - pm_idle
				 * functions should always return with IRQs
				 * enabled.
				 */
				WARN_ON(irqs_disabled());
				local_irq_enable();
			}
		}
L
Linus Torvalds 已提交
174
		leds_event(led_idle_end);
175
		tick_nohz_restart_sched_tick();
176
		preempt_enable_no_resched();
L
Linus Torvalds 已提交
177
		schedule();
178
		preempt_disable();
L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
	}
}

static char reboot_mode = 'h';

int __init reboot_setup(char *str)
{
	reboot_mode = str[0];
	return 1;
}

__setup("reboot=", reboot_setup);

void machine_halt(void)
{
}


void machine_power_off(void)
{
	if (pm_power_off)
		pm_power_off();
}

203
void machine_restart(char *cmd)
L
Linus Torvalds 已提交
204
{
205
	arm_pm_restart(reboot_mode, cmd);
L
Linus Torvalds 已提交
206 207
}

R
Russell King 已提交
208
void __show_regs(struct pt_regs *regs)
L
Linus Torvalds 已提交
209
{
210 211
	unsigned long flags;
	char buf[64];
L
Linus Torvalds 已提交
212

213
	printk("CPU: %d    %s  (%s %.*s)\n",
214 215
		raw_smp_processor_id(), print_tainted(),
		init_utsname()->release,
216 217
		(int)strcspn(init_utsname()->version, " "),
		init_utsname()->version);
L
Linus Torvalds 已提交
218 219
	print_symbol("PC is at %s\n", instruction_pointer(regs));
	print_symbol("LR is at %s\n", regs->ARM_lr);
220
	printk("pc : [<%08lx>]    lr : [<%08lx>]    psr: %08lx\n"
L
Linus Torvalds 已提交
221
	       "sp : %08lx  ip : %08lx  fp : %08lx\n",
222 223
		regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr,
		regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);
L
Linus Torvalds 已提交
224 225 226 227 228 229 230 231 232
	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);
233 234 235 236 237 238 239 240

	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';

241
	printk("Flags: %s  IRQs o%s  FIQs o%s  Mode %s  ISA %s  Segment %s\n",
242
		buf, interrupts_enabled(regs) ? "n" : "ff",
L
Linus Torvalds 已提交
243 244
		fast_interrupts_enabled(regs) ? "n" : "ff",
		processor_modes[processor_mode(regs)],
245
		isa_modes[isa_mode(regs)],
L
Linus Torvalds 已提交
246
		get_fs() == get_ds() ? "kernel" : "user");
247
#ifdef CONFIG_CPU_CP15
L
Linus Torvalds 已提交
248
	{
249
		unsigned int ctrl;
250 251

		buf[0] = '\0';
252
#ifdef CONFIG_CPU_CP15_MMU
253 254 255 256 257 258 259 260
		{
			unsigned int transbase, dac;
			asm("mrc p15, 0, %0, c2, c0\n\t"
			    "mrc p15, 0, %1, c3, c0\n"
			    : "=r" (transbase), "=r" (dac));
			snprintf(buf, sizeof(buf), "  Table: %08x  DAC: %08x",
			  	transbase, dac);
		}
261
#endif
262 263 264 265
		asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl));

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

R
Russell King 已提交
269 270 271
void show_regs(struct pt_regs * regs)
{
	printk("\n");
272
	printk("Pid: %d, comm: %20s\n", task_pid_nr(current), current->comm);
R
Russell King 已提交
273 274 275 276
	__show_regs(regs);
	__backtrace();
}

277 278 279 280
ATOMIC_NOTIFIER_HEAD(thread_notify_head);

EXPORT_SYMBOL_GPL(thread_notify_head);

L
Linus Torvalds 已提交
281 282 283 284 285
/*
 * Free current thread data structures etc..
 */
void exit_thread(void)
{
286
	thread_notify(THREAD_NOTIFY_EXIT, current_thread_info());
L
Linus Torvalds 已提交
287 288 289 290 291 292 293 294 295
}

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

	memset(thread->used_cp, 0, sizeof(thread->used_cp));
	memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
296 297 298
	memset(&thread->fpstate, 0, sizeof(union fp_state));

	thread_notify(THREAD_NOTIFY_FLUSH, thread);
L
Linus Torvalds 已提交
299 300 301 302 303 304 305 306 307
}

void release_thread(struct task_struct *dead_task)
{
}

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

int
A
Alexey Dobriyan 已提交
308
copy_thread(unsigned long clone_flags, unsigned long stack_start,
L
Linus Torvalds 已提交
309 310
	    unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
{
A
Al Viro 已提交
311 312
	struct thread_info *thread = task_thread_info(p);
	struct pt_regs *childregs = task_pt_regs(p);
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

	*childregs = *regs;
	childregs->ARM_r0 = 0;
	childregs->ARM_sp = stack_start;

	memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
	thread->cpu_context.sp = (unsigned long)childregs;
	thread->cpu_context.pc = (unsigned long)ret_from_fork;

	if (clone_flags & CLONE_SETTLS)
		thread->tp_value = regs->ARM_r3;

	return 0;
}

328 329 330 331 332 333 334 335 336
/*
 * 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 已提交
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
/*
 * 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);

/*
 * Shuffle the argument into the correct register before calling the
 * thread function.  r1 is the thread argument, r2 is the pointer to
 * the thread function, and r3 points to the exit function.
 */
extern void kernel_thread_helper(void);
asm(	".section .text\n"
"	.align\n"
"	.type	kernel_thread_helper, #function\n"
"kernel_thread_helper:\n"
"	mov	r0, r1\n"
"	mov	lr, r3\n"
"	mov	pc, r2\n"
"	.size	kernel_thread_helper, . - kernel_thread_helper\n"
"	.previous");

368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
#ifdef CONFIG_ARM_UNWIND
extern void kernel_thread_exit(long code);
asm(	".section .text\n"
"	.align\n"
"	.type	kernel_thread_exit, #function\n"
"kernel_thread_exit:\n"
"	.fnstart\n"
"	.cantunwind\n"
"	bl	do_exit\n"
"	nop\n"
"	.fnend\n"
"	.size	kernel_thread_exit, . - kernel_thread_exit\n"
"	.previous");
#else
#define kernel_thread_exit	do_exit
#endif

L
Linus Torvalds 已提交
385 386 387 388 389 390 391 392 393 394 395
/*
 * Create a kernel thread.
 */
pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
	struct pt_regs regs;

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

	regs.ARM_r1 = (unsigned long)arg;
	regs.ARM_r2 = (unsigned long)fn;
396
	regs.ARM_r3 = (unsigned long)kernel_thread_exit;
L
Linus Torvalds 已提交
397
	regs.ARM_pc = (unsigned long)kernel_thread_helper;
398
	regs.ARM_cpsr = SVC_MODE | PSR_ENDSTATE | PSR_ISETSTATE;
L
Linus Torvalds 已提交
399 400 401 402 403 404 405

	return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
}
EXPORT_SYMBOL(kernel_thread);

unsigned long get_wchan(struct task_struct *p)
{
406
	struct stackframe frame;
L
Linus Torvalds 已提交
407 408 409 410
	int count = 0;
	if (!p || p == current || p->state == TASK_RUNNING)
		return 0;

411 412 413 414
	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);
L
Linus Torvalds 已提交
415
	do {
416 417
		int ret = unwind_frame(&frame);
		if (ret < 0)
L
Linus Torvalds 已提交
418
			return 0;
419 420
		if (!in_sched_functions(frame.pc))
			return frame.pc;
L
Linus Torvalds 已提交
421 422 423
	} while (count ++ < 16);
	return 0;
}