Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 59586e5a262a29361c45c929ea3253d4aec830b0

Authored by Eric W. Biederman 2005-07-27 01:36:01 +0800

Committed by Linus Torvalds 2005-07-27 05:35:42 +0800

Exists in master and in 7 other branches

[PATCH] Don't export machine_restart, machine_halt, or machine_power_off.

machine_restart, machine_halt and machine_power_off are machine
specific hooks deep into the reboot logic, that modules
have no business messing with.  Usually code should be calling
kernel_restart, kernel_halt, kernel_power_off, or
emergency_restart. So don't export machine_restart,
machine_halt, and machine_power_off so we can catch buggy users.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 29 changed files with 0 additions and 152 deletions Inline Diff

arch/alpha/kernel/process.c
arch/arm/kernel/process.c
arch/arm26/kernel/process.c
arch/cris/kernel/process.c
arch/h8300/kernel/process.c
arch/i386/kernel/reboot.c
arch/i386/mach-visws/reboot.c
arch/i386/mach-voyager/voyager_basic.c
arch/ia64/kernel/process.c
arch/m32r/kernel/process.c
arch/m68k/kernel/process.c
arch/m68knommu/kernel/process.c
arch/mips/kernel/reset.c
arch/parisc/kernel/process.c
arch/ppc/kernel/setup.c
arch/ppc64/kernel/setup.c
arch/s390/kernel/setup.c
arch/sh/kernel/process.c
arch/sparc/kernel/process.c
arch/sparc64/kernel/power.c
arch/sparc64/kernel/process.c
arch/um/kernel/reboot.c
arch/v850/kernel/anna.c
arch/v850/kernel/as85ep1.c
arch/v850/kernel/fpga85e2c.c
arch/v850/kernel/rte_cb.c
arch/v850/kernel/sim.c
arch/v850/kernel/sim85e2.c
arch/x86_64/kernel/reboot.c

arch/alpha/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/alpha/kernel/process.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  */
 /*
  * This file handles the architecture-dependent parts of process handling.
  */
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/utsname.h>
 #include <linux/time.h>
 #include <linux/major.h>
 #include <linux/stat.h>
 #include <linux/mman.h>
 #include <linux/elfcore.h>
 #include <linux/reboot.h>
 #include <linux/tty.h>
 #include <linux/console.h>
 #include <asm/reg.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/pgtable.h>
 #include <asm/hwrpb.h>
 #include <asm/fpu.h>
 #include "proto.h"
 #include "pci_impl.h"
 void default_idle(void)
 {
 	barrier();
 }
 void
 cpu_idle(void)
 {
 	while (1) {
 		void (*idle)(void) = default_idle;
 		/* FIXME -- EV6 and LCA45 know how to power down
 		   the CPU.  */
 		while (!need_resched())
 			idle();
 		schedule();
 	}
 }
 struct halt_info {
 	int mode;
 	char *restart_cmd;
 };
 static void
 common_shutdown_1(void *generic_ptr)
 {
 	struct halt_info *how = (struct halt_info *)generic_ptr;
 	struct percpu_struct *cpup;
 	unsigned long *pflags, flags;
 	int cpuid = smp_processor_id();
 	/* No point in taking interrupts anymore. */
 	local_irq_disable();
 	cpup = (struct percpu_struct *)
 			((unsigned long)hwrpb + hwrpb->processor_offset
 			 + hwrpb->processor_size * cpuid);
 	pflags = &cpup->flags;
 	flags = *pflags;
 	/* Clear reason to "default"; clear "bootstrap in progress". */
 	flags &= ~0x00ff0001UL;
 #ifdef CONFIG_SMP
 	/* Secondaries halt here. */
 	if (cpuid != boot_cpuid) {
 		flags |= 0x00040000UL; /* "remain halted" */
 		*pflags = flags;
 		clear_bit(cpuid, &cpu_present_mask);
 		halt();
 	}
 #endif
 	if (how->mode == LINUX_REBOOT_CMD_RESTART) {
 		if (!how->restart_cmd) {
 			flags |= 0x00020000UL; /* "cold bootstrap" */
 		} else {
 			/* For SRM, we could probably set environment
 			   variables to get this to work.  We'd have to
 			   delay this until after srm_paging_stop unless
 			   we ever got srm_fixup working.
 			   At the moment, SRM will use the last boot device,
 			   but the file and flags will be the defaults, when
 			   doing a "warm" bootstrap.  */
 			flags |= 0x00030000UL; /* "warm bootstrap" */
 		}
 	} else {
 		flags |= 0x00040000UL; /* "remain halted" */
 	}
 	*pflags = flags;
 #ifdef CONFIG_SMP
 	/* Wait for the secondaries to halt. */
 	cpu_clear(boot_cpuid, cpu_possible_map);
 	while (cpus_weight(cpu_possible_map))
 		barrier();
 #endif
 	/* If booted from SRM, reset some of the original environment. */
 	if (alpha_using_srm) {
 #ifdef CONFIG_DUMMY_CONSOLE
 		/* This has the effect of resetting the VGA video origin.  */
 		take_over_console(&dummy_con, 0, MAX_NR_CONSOLES-1, 1);
 #endif
 		pci_restore_srm_config();
 		set_hae(srm_hae);
 	}
 	if (alpha_mv.kill_arch)
 		alpha_mv.kill_arch(how->mode);
 	if (! alpha_using_srm && how->mode != LINUX_REBOOT_CMD_RESTART) {
 		/* Unfortunately, since MILO doesn't currently understand
 		   the hwrpb bits above, we can't reliably halt the
 		   processor and keep it halted.  So just loop.  */
 		return;
 	}
 	if (alpha_using_srm)
 		srm_paging_stop();
 	halt();
 }
 static void
 common_shutdown(int mode, char *restart_cmd)
 {
 	struct halt_info args;
 	args.mode = mode;
 	args.restart_cmd = restart_cmd;
 	on_each_cpu(common_shutdown_1, &args, 1, 0);
 }
 void
 machine_restart(char *restart_cmd)
 {
 	common_shutdown(LINUX_REBOOT_CMD_RESTART, restart_cmd);
 }
-EXPORT_SYMBOL(machine_restart);
 void
 machine_halt(void)
 {
 	common_shutdown(LINUX_REBOOT_CMD_HALT, NULL);
 }
-EXPORT_SYMBOL(machine_halt);
 void
 machine_power_off(void)
 {
 	common_shutdown(LINUX_REBOOT_CMD_POWER_OFF, NULL);
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Used by sysrq-p, among others.  I don't believe r9-r15 are ever
    saved in the context it's used.  */
 void
 show_regs(struct pt_regs *regs)
 {
 	dik_show_regs(regs, NULL);
 }
 /*
  * Re-start a thread when doing execve()
  */
 void
 start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
 {
 	set_fs(USER_DS);
 	regs->pc = pc;
 	regs->ps = 8;
 	wrusp(sp);
 }
 /*
  * Free current thread data structures etc..
  */
 void
 exit_thread(void)
 {
 }
 void
 flush_thread(void)
 {
 	/* Arrange for each exec'ed process to start off with a clean slate
 	   with respect to the FPU.  This is all exceptions disabled.  */
 	current_thread_info()->ieee_state = 0;
 	wrfpcr(FPCR_DYN_NORMAL | ieee_swcr_to_fpcr(0));
 	/* Clean slate for TLS.  */
 	current_thread_info()->pcb.unique = 0;
 }
 void
 release_thread(struct task_struct *dead_task)
 {
 }
 /*
  * "alpha_clone()".. By the time we get here, the
  * non-volatile registers have also been saved on the
  * stack. We do some ugly pointer stuff here.. (see
  * also copy_thread)
  *
  * Notice that "fork()" is implemented in terms of clone,
  * with parameters (SIGCHLD, 0).
  */
 int
 alpha_clone(unsigned long clone_flags, unsigned long usp,
 	    int __user *parent_tid, int __user *child_tid,
 	    unsigned long tls_value, struct pt_regs *regs)
 {
 	if (!usp)
 		usp = rdusp();
 	return do_fork(clone_flags, usp, regs, 0, parent_tid, child_tid);
 }
 int
 alpha_vfork(struct pt_regs *regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(),
 		       regs, 0, NULL, NULL);
 }
 /*
  * Copy an alpha thread..
  *
  * Note the "stack_offset" stuff: when returning to kernel mode, we need
  * to have some extra stack-space for the kernel stack that still exists
  * after the "ret_from_fork".  When returning to user mode, we only want
  * the space needed by the syscall stack frame (ie "struct pt_regs").
  * Use the passed "regs" pointer to determine how much space we need
  * for a kernel fork().
  */
 int
 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 	    unsigned long unused,
 	    struct task_struct * p, struct pt_regs * regs)
 {
 	extern void ret_from_fork(void);
 	struct thread_info *childti = p->thread_info;
 	struct pt_regs * childregs;
 	struct switch_stack * childstack, *stack;
 	unsigned long stack_offset, settls;
 	stack_offset = PAGE_SIZE - sizeof(struct pt_regs);
 	if (!(regs->ps & 8))
 		stack_offset = (PAGE_SIZE-1) & (unsigned long) regs;
 	childregs = (struct pt_regs *)
 	  (stack_offset + PAGE_SIZE + (long) childti);
 	*childregs = *regs;
 	settls = regs->r20;
 	childregs->r0 = 0;
 	childregs->r19 = 0;
 	childregs->r20 = 1;	/* OSF/1 has some strange fork() semantics.  */
 	regs->r20 = 0;
 	stack = ((struct switch_stack *) regs) - 1;
 	childstack = ((struct switch_stack *) childregs) - 1;
 	*childstack = *stack;
 	childstack->r26 = (unsigned long) ret_from_fork;
 	childti->pcb.usp = usp;
 	childti->pcb.ksp = (unsigned long) childstack;
 	childti->pcb.flags = 1;	/* set FEN, clear everything else */
 	/* Set a new TLS for the child thread?  Peek back into the
 	   syscall arguments that we saved on syscall entry.  Oops,
 	   except we'd have clobbered it with the parent/child set
 	   of r20.  Read the saved copy.  */
 	/* Note: if CLONE_SETTLS is not set, then we must inherit the
 	   value from the parent, which will have been set by the block
 	   copy in dup_task_struct.  This is non-intuitive, but is
 	   required for proper operation in the case of a threaded
 	   application calling fork.  */
 	if (clone_flags & CLONE_SETTLS)
 		childti->pcb.unique = settls;
 	return 0;
 }
 /*
  * Fill in the user structure for an ECOFF core dump.
  */
 void
 dump_thread(struct pt_regs * pt, struct user * dump)
 {
 	/* switch stack follows right below pt_regs: */
 	struct switch_stack * sw = ((struct switch_stack *) pt) - 1;
 	dump->magic = CMAGIC;
 	dump->start_code  = current->mm->start_code;
 	dump->start_data  = current->mm->start_data;
 	dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
 	dump->u_tsize = ((current->mm->end_code - dump->start_code)
 			 >> PAGE_SHIFT);
 	dump->u_dsize = ((current->mm->brk + PAGE_SIZE-1 - dump->start_data)
 			 >> PAGE_SHIFT);
 	dump->u_ssize = (current->mm->start_stack - dump->start_stack
 			 + PAGE_SIZE-1) >> PAGE_SHIFT;
 	/*
 	 * We store the registers in an order/format that is
 	 * compatible with DEC Unix/OSF/1 as this makes life easier
 	 * for gdb.
 	 */
 	dump->regs[EF_V0]  = pt->r0;
 	dump->regs[EF_T0]  = pt->r1;
 	dump->regs[EF_T1]  = pt->r2;
 	dump->regs[EF_T2]  = pt->r3;
 	dump->regs[EF_T3]  = pt->r4;
 	dump->regs[EF_T4]  = pt->r5;
 	dump->regs[EF_T5]  = pt->r6;
 	dump->regs[EF_T6]  = pt->r7;
 	dump->regs[EF_T7]  = pt->r8;
 	dump->regs[EF_S0]  = sw->r9;
 	dump->regs[EF_S1]  = sw->r10;
 	dump->regs[EF_S2]  = sw->r11;
 	dump->regs[EF_S3]  = sw->r12;
 	dump->regs[EF_S4]  = sw->r13;
 	dump->regs[EF_S5]  = sw->r14;
 	dump->regs[EF_S6]  = sw->r15;
 	dump->regs[EF_A3]  = pt->r19;
 	dump->regs[EF_A4]  = pt->r20;
 	dump->regs[EF_A5]  = pt->r21;
 	dump->regs[EF_T8]  = pt->r22;
 	dump->regs[EF_T9]  = pt->r23;
 	dump->regs[EF_T10] = pt->r24;
 	dump->regs[EF_T11] = pt->r25;
 	dump->regs[EF_RA]  = pt->r26;
 	dump->regs[EF_T12] = pt->r27;
 	dump->regs[EF_AT]  = pt->r28;
 	dump->regs[EF_SP]  = rdusp();
 	dump->regs[EF_PS]  = pt->ps;
 	dump->regs[EF_PC]  = pt->pc;
 	dump->regs[EF_GP]  = pt->gp;
 	dump->regs[EF_A0]  = pt->r16;
 	dump->regs[EF_A1]  = pt->r17;
 	dump->regs[EF_A2]  = pt->r18;
 	memcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8);
 }
 /*
  * Fill in the user structure for a ELF core dump.
  */
 void
 dump_elf_thread(elf_greg_t *dest, struct pt_regs *pt, struct thread_info *ti)
 {
 	/* switch stack follows right below pt_regs: */
 	struct switch_stack * sw = ((struct switch_stack *) pt) - 1;
 	dest[ 0] = pt->r0;
 	dest[ 1] = pt->r1;
 	dest[ 2] = pt->r2;
 	dest[ 3] = pt->r3;
 	dest[ 4] = pt->r4;
 	dest[ 5] = pt->r5;
 	dest[ 6] = pt->r6;
 	dest[ 7] = pt->r7;
 	dest[ 8] = pt->r8;
 	dest[ 9] = sw->r9;
 	dest[10] = sw->r10;
 	dest[11] = sw->r11;
 	dest[12] = sw->r12;
 	dest[13] = sw->r13;
 	dest[14] = sw->r14;
 	dest[15] = sw->r15;
 	dest[16] = pt->r16;
 	dest[17] = pt->r17;
 	dest[18] = pt->r18;
 	dest[19] = pt->r19;
 	dest[20] = pt->r20;
 	dest[21] = pt->r21;
 	dest[22] = pt->r22;
 	dest[23] = pt->r23;
 	dest[24] = pt->r24;
 	dest[25] = pt->r25;
 	dest[26] = pt->r26;
 	dest[27] = pt->r27;
 	dest[28] = pt->r28;
 	dest[29] = pt->gp;
 	dest[30] = rdusp();
 	dest[31] = pt->pc;
 	/* Once upon a time this was the PS value.  Which is stupid
 	   since that is always 8 for usermode.  Usurped for the more
 	   useful value of the thread's UNIQUE field.  */
 	dest[32] = ti->pcb.unique;
 }
 int
 dump_elf_task(elf_greg_t *dest, struct task_struct *task)
 {
 	struct thread_info *ti;
 	struct pt_regs *pt;
 	ti = task->thread_info;
 	pt = (struct pt_regs *)((unsigned long)ti + 2*PAGE_SIZE) - 1;
 	dump_elf_thread(dest, pt, ti);
 	return 1;
 }
 int
 dump_elf_task_fp(elf_fpreg_t *dest, struct task_struct *task)
 {
 	struct thread_info *ti;
 	struct pt_regs *pt;
 	struct switch_stack *sw;
 	ti = task->thread_info;
 	pt = (struct pt_regs *)((unsigned long)ti + 2*PAGE_SIZE) - 1;
 	sw = (struct switch_stack *)pt - 1;
 	memcpy(dest, sw->fp, 32 * 8);
 	return 1;
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int
 do_sys_execve(char __user *ufilename, char __user * __user *argv,
 	      char __user * __user *envp, struct pt_regs *regs)
 {
 	int error;
 	char *filename;
 	filename = getname(ufilename);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, argv, envp, regs);
 	putname(filename);
 out:
 	return error;
 }
 /*
  * Return saved PC of a blocked thread.  This assumes the frame
  * pointer is the 6th saved long on the kernel stack and that the
  * saved return address is the first long in the frame.  This all
  * holds provided the thread blocked through a call to schedule() ($15
  * is the frame pointer in schedule() and $15 is saved at offset 48 by
  * entry.S:do_switch_stack).
  *
  * Under heavy swap load I've seen this lose in an ugly way.  So do
  * some extra sanity checking on the ranges we expect these pointers
  * to be in so that we can fail gracefully.  This is just for ps after
  * all.  -- r~
  */
 unsigned long
 thread_saved_pc(task_t *t)
 {
 	unsigned long base = (unsigned long)t->thread_info;
 	unsigned long fp, sp = t->thread_info->pcb.ksp;
 	if (sp > base && sp+6*8 < base + 16*1024) {
 		fp = ((unsigned long*)sp)[6];
 		if (fp > sp && fp < base + 16*1024)
 			return *(unsigned long *)fp;
 	}
 	return 0;
 }
 unsigned long
 get_wchan(struct task_struct *p)
 {
 	unsigned long schedule_frame;
 	unsigned long pc;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	/*
 	 * This one depends on the frame size of schedule().  Do a
 	 * "disass schedule" in gdb to find the frame size.  Also, the
 	 * code assumes that sleep_on() follows immediately after
 	 * interruptible_sleep_on() and that add_timer() follows
 	 * immediately after interruptible_sleep().  Ugly, isn't it?
 	 * Maybe adding a wchan field to task_struct would be better,
 	 * after all...
 	 */
 	pc = thread_saved_pc(p);
 	if (in_sched_functions(pc)) {
 		schedule_frame = ((unsigned long *)p->thread_info->pcb.ksp)[6];
 		return ((unsigned long *)schedule_frame)[12];
 	}
 	return pc;
 }

arch/arm/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  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/config.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/user.h>
 #include <linux/a.out.h>
 #include <linux/delay.h>
 #include <linux/reboot.h>
 #include <linux/interrupt.h>
 #include <linux/kallsyms.h>
 #include <linux/init.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/leds.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
 #include <asm/mach/time.h>
 extern const char *processor_modes[];
 extern void setup_mm_for_reboot(char mode);
 static volatile int hlt_counter;
 #include <asm/arch/system.h>
 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);
 /*
  * The following aren't currently used.
  */
 void (*pm_idle)(void);
 EXPORT_SYMBOL(pm_idle);
 void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
 /*
  * This is our default idle handler.  We need to disable
  * interrupts here to ensure we don't miss a wakeup call.
  */
 void default_idle(void)
 {
 	local_irq_disable();
 	if (!need_resched() && !hlt_counter) {
 		timer_dyn_reprogram();
 		arch_idle();
 	}
 	local_irq_enable();
 }
 /*
  * The idle thread.  We try to conserve power, while trying to keep
  * overall latency low.  The architecture specific idle is passed
  * a value to indicate the level of "idleness" of the system.
  */
 void cpu_idle(void)
 {
 	local_fiq_enable();
 	/* endless idle loop with no priority at all */
 	while (1) {
 		void (*idle)(void) = pm_idle;
 		if (!idle)
 			idle = default_idle;
 		preempt_disable();
 		leds_event(led_idle_start);
 		while (!need_resched())
 			idle();
 		leds_event(led_idle_end);
 		preempt_enable();
 		schedule();
 	}
 }
 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)
 {
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	if (pm_power_off)
 		pm_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);
 void machine_restart(char * __unused)
 {
 	/*
 	 * 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(reboot_mode);
 	/*
 	 * Now call the architecture specific reboot code.
 	 */
 	arch_reset(reboot_mode);
 	/*
 	 * Whoops - the architecture was unable to reboot.
 	 * Tell the user!
 	 */
 	mdelay(1000);
 	printk("Reboot failed -- System halted\n");
 	while (1);
 }
-EXPORT_SYMBOL(machine_restart);
 void __show_regs(struct pt_regs *regs)
 {
 	unsigned long flags = condition_codes(regs);
 	printk("CPU: %d\n", smp_processor_id());
 	print_symbol("PC is at %s\n", instruction_pointer(regs));
 	print_symbol("LR is at %s\n", regs->ARM_lr);
 	printk("pc : [<%08lx>]    lr : [<%08lx>]    %s\n"
 	       "sp : %08lx  ip : %08lx  fp : %08lx\n",
 		instruction_pointer(regs),
 		regs->ARM_lr, print_tainted(), regs->ARM_sp,
 		regs->ARM_ip, regs->ARM_fp);
 	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);
 	printk("Flags: %c%c%c%c",
 		flags & PSR_N_BIT ? 'N' : 'n',
 		flags & PSR_Z_BIT ? 'Z' : 'z',
 		flags & PSR_C_BIT ? 'C' : 'c',
 		flags & PSR_V_BIT ? 'V' : 'v');
 	printk("  IRQs o%s  FIQs o%s  Mode %s%s  Segment %s\n",
 		interrupts_enabled(regs) ? "n" : "ff",
 		fast_interrupts_enabled(regs) ? "n" : "ff",
 		processor_modes[processor_mode(regs)],
 		thumb_mode(regs) ? " (T)" : "",
 		get_fs() == get_ds() ? "kernel" : "user");
 	{
 		unsigned int ctrl, transbase, dac;
 		  __asm__ (
 		"	mrc p15, 0, %0, c1, c0\n"
 		"	mrc p15, 0, %1, c2, c0\n"
 		"	mrc p15, 0, %2, c3, c0\n"
 		: "=r" (ctrl), "=r" (transbase), "=r" (dac));
 		printk("Control: %04X  Table: %08X  DAC: %08X\n",
 		  	ctrl, transbase, dac);
 	}
 }
 void show_regs(struct pt_regs * regs)
 {
 	printk("\n");
 	printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
 	__show_regs(regs);
 	__backtrace();
 }
 void show_fpregs(struct user_fp *regs)
 {
 	int i;
 	for (i = 0; i < 8; i++) {
 		unsigned long *p;
 		char type;
 		p = (unsigned long *)(regs->fpregs + i);
 		switch (regs->ftype[i]) {
 			case 1: type = 'f'; break;
 			case 2: type = 'd'; break;
 			case 3: type = 'e'; break;
 			default: type = '?'; break;
 		}
 		if (regs->init_flag)
 			type = '?';
 		printk("  f%d(%c): %08lx %08lx %08lx%c",
 			i, type, p[0], p[1], p[2], i & 1 ? '\n' : ' ');
 	}
 	printk("FPSR: %08lx FPCR: %08lx\n",
 		(unsigned long)regs->fpsr,
 		(unsigned long)regs->fpcr);
 }
 /*
  * Task structure and kernel stack allocation.
  */
 static unsigned long *thread_info_head;
 static unsigned int nr_thread_info;
 #define EXTRA_TASK_STRUCT	4
 struct thread_info *alloc_thread_info(struct task_struct *task)
 {
 	struct thread_info *thread = NULL;
 	if (EXTRA_TASK_STRUCT) {
 		unsigned long *p = thread_info_head;
 		if (p) {
 			thread_info_head = (unsigned long *)p[0];
 			nr_thread_info -= 1;
 		}
 		thread = (struct thread_info *)p;
 	}
 	if (!thread)
 		thread = (struct thread_info *)
 			   __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER);
 #ifdef CONFIG_DEBUG_STACK_USAGE
 	/*
 	 * The stack must be cleared if you want SYSRQ-T to
 	 * give sensible stack usage information
 	 */
 	if (thread)
 		memzero(thread, THREAD_SIZE);
 #endif
 	return thread;
 }
 void free_thread_info(struct thread_info *thread)
 {
 	if (EXTRA_TASK_STRUCT && nr_thread_info < EXTRA_TASK_STRUCT) {
 		unsigned long *p = (unsigned long *)thread;
 		p[0] = (unsigned long)thread_info_head;
 		thread_info_head = p;
 		nr_thread_info += 1;
 	} else
 		free_pages((unsigned long)thread, THREAD_SIZE_ORDER);
 }
 /*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
 {
 }
 static void default_fp_init(union fp_state *fp)
 {
 	memset(fp, 0, sizeof(union fp_state));
 }
 void (*fp_init)(union fp_state *) = default_fp_init;
 EXPORT_SYMBOL(fp_init);
 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));
 #if defined(CONFIG_IWMMXT)
 	iwmmxt_task_release(thread);
 #endif
 	fp_init(&thread->fpstate);
 #if defined(CONFIG_VFP)
 	vfp_flush_thread(&thread->vfpstate);
 #endif
 }
 void release_thread(struct task_struct *dead_task)
 {
 #if defined(CONFIG_VFP)
 	vfp_release_thread(&dead_task->thread_info->vfpstate);
 #endif
 #if defined(CONFIG_IWMMXT)
 	iwmmxt_task_release(dead_task->thread_info);
 #endif
 }
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
 int
 copy_thread(int nr, unsigned long clone_flags, unsigned long stack_start,
 	    unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
 {
 	struct thread_info *thread = p->thread_info;
 	struct pt_regs *childregs;
 	childregs = ((struct pt_regs *)((unsigned long)thread + THREAD_START_SP)) - 1;
 	*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;
 }
 /*
  * 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);
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	struct task_struct *tsk = current;
 	dump->magic = CMAGIC;
 	dump->start_code = tsk->mm->start_code;
 	dump->start_stack = regs->ARM_sp & ~(PAGE_SIZE - 1);
 	dump->u_tsize = (tsk->mm->end_code - tsk->mm->start_code) >> PAGE_SHIFT;
 	dump->u_dsize = (tsk->mm->brk - tsk->mm->start_data + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	dump->u_ssize = 0;
 	dump->u_debugreg[0] = tsk->thread.debug.bp[0].address;
 	dump->u_debugreg[1] = tsk->thread.debug.bp[1].address;
 	dump->u_debugreg[2] = tsk->thread.debug.bp[0].insn.arm;
 	dump->u_debugreg[3] = tsk->thread.debug.bp[1].insn.arm;
 	dump->u_debugreg[4] = tsk->thread.debug.nsaved;
 	if (dump->start_stack < 0x04000000)
 		dump->u_ssize = (0x04000000 - dump->start_stack) >> PAGE_SHIFT;
 	dump->regs = *regs;
 	dump->u_fpvalid = dump_fpu (regs, &dump->u_fp);
 }
 EXPORT_SYMBOL(dump_thread);
 /*
  * 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");
 /*
  * 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;
 	regs.ARM_r3 = (unsigned long)do_exit;
 	regs.ARM_pc = (unsigned long)kernel_thread_helper;
 	regs.ARM_cpsr = SVC_MODE;
 	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)
 {
 	unsigned long fp, lr;
 	unsigned long stack_start, stack_end;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	stack_start = (unsigned long)(p->thread_info + 1);
 	stack_end = ((unsigned long)p->thread_info) + THREAD_SIZE;
 	fp = thread_saved_fp(p);
 	do {
 		if (fp < stack_start || fp > stack_end)
 			return 0;
 		lr = pc_pointer (((unsigned long *)fp)[-1]);
 		if (!in_sched_functions(lr))
 			return lr;
 		fp = *(unsigned long *) (fp - 12);
 	} while (count ++ < 16);
 	return 0;
 }
 EXPORT_SYMBOL(get_wchan);

arch/arm26/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/arm26/kernel/process.c
  *
  *  Copyright (C) 2003 Ian Molton - adapted for ARM26
  *  Copyright (C) 1996-2000 Russell King - Converted to ARM.
  *  Origional 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/config.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/user.h>
 #include <linux/a.out.h>
 #include <linux/delay.h>
 #include <linux/reboot.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/leds.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
 extern const char *processor_modes[];
 extern void setup_mm_for_reboot(char mode);
 static volatile int hlt_counter;
 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);
 /*
  * This is our default idle handler.  We need to disable
  * interrupts here to ensure we don't miss a wakeup call.
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	preempt_disable();
 	while (1) {
 		while (!need_resched()) {
 			local_irq_disable();
 			if (!need_resched() && !hlt_counter)
 				local_irq_enable();
 		}
 	}
 	schedule();
 }
 static char reboot_mode = 'h';
 int __init reboot_setup(char *str)
 {
 	reboot_mode = str[0];
 	return 1;
 }
 __setup("reboot=", reboot_setup);
 /* ARM26 cant do these but we still need to define them. */
 void machine_halt(void)
 {
 }
 void machine_power_off(void)
 {
 }
-EXPORT_SYMBOL(machine_halt);
-EXPORT_SYMBOL(machine_power_off);
 void machine_restart(char * __unused)
 {
 	/*
 	 * 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(reboot_mode);
 	/*
          * copy branch instruction to reset location and call it
          */
         *(unsigned long *)0 = *(unsigned long *)0x03800000;
         ((void(*)(void))0)();
 	/*
 	 * Whoops - the architecture was unable to reboot.
 	 * Tell the user! Should never happen...
 	 */
 	mdelay(1000);
 	printk("Reboot failed -- System halted\n");
 	while (1);
 }
-EXPORT_SYMBOL(machine_restart);
 void show_regs(struct pt_regs * regs)
 {
 	unsigned long flags;
 	flags = condition_codes(regs);
 	printk("pc : [<%08lx>]    lr : [<%08lx>]    %s\n"
 	       "sp : %08lx  ip : %08lx  fp : %08lx\n",
 		instruction_pointer(regs),
 		regs->ARM_lr, print_tainted(), regs->ARM_sp,
 		regs->ARM_ip, regs->ARM_fp);
 	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);
 	printk("Flags: %c%c%c%c",
 		flags & PSR_N_BIT ? 'N' : 'n',
 		flags & PSR_Z_BIT ? 'Z' : 'z',
 		flags & PSR_C_BIT ? 'C' : 'c',
 		flags & PSR_V_BIT ? 'V' : 'v');
 	printk("  IRQs o%s  FIQs o%s  Mode %s  Segment %s\n",
 		interrupts_enabled(regs) ? "n" : "ff",
 		fast_interrupts_enabled(regs) ? "n" : "ff",
 		processor_modes[processor_mode(regs)],
 		get_fs() == get_ds() ? "kernel" : "user");
 }
 void show_fpregs(struct user_fp *regs)
 {
 	int i;
 	for (i = 0; i < 8; i++) {
 		unsigned long *p;
 		char type;
 		p = (unsigned long *)(regs->fpregs + i);
 		switch (regs->ftype[i]) {
 			case 1: type = 'f'; break;
 			case 2: type = 'd'; break;
 			case 3: type = 'e'; break;
 			default: type = '?'; break;
 		}
 		if (regs->init_flag)
 			type = '?';
 		printk("  f%d(%c): %08lx %08lx %08lx%c",
 			i, type, p[0], p[1], p[2], i & 1 ? '\n' : ' ');
 	}
 	printk("FPSR: %08lx FPCR: %08lx\n",
 		(unsigned long)regs->fpsr,
 		(unsigned long)regs->fpcr);
 }
 /*
  * Task structure and kernel stack allocation.
  */
 static unsigned long *thread_info_head;
 static unsigned int nr_thread_info;
 extern unsigned long get_page_8k(int priority);
 extern void free_page_8k(unsigned long page);
 // FIXME - is this valid?
 #define EXTRA_TASK_STRUCT	0
 #define ll_alloc_task_struct()	((struct thread_info *)get_page_8k(GFP_KERNEL))
 #define ll_free_task_struct(p)  free_page_8k((unsigned long)(p))
 //FIXME - do we use *task param below looks like we dont, which is ok?
 //FIXME - if EXTRA_TASK_STRUCT is zero we can optimise the below away permanently. *IF* its supposed to be zero.
 struct thread_info *alloc_thread_info(struct task_struct *task)
 {
 	struct thread_info *thread = NULL;
 	if (EXTRA_TASK_STRUCT) {
 		unsigned long *p = thread_info_head;
 		if (p) {
 			thread_info_head = (unsigned long *)p[0];
 			nr_thread_info -= 1;
 		}
 		thread = (struct thread_info *)p;
 	}
 	if (!thread)
 		thread = ll_alloc_task_struct();
 #ifdef CONFIG_MAGIC_SYSRQ
 	/*
 	 * The stack must be cleared if you want SYSRQ-T to
 	 * give sensible stack usage information
 	 */
 	if (thread) {
 		char *p = (char *)thread;
 		memzero(p+KERNEL_STACK_SIZE, KERNEL_STACK_SIZE);
 	}
 #endif
 	return thread;
 }
 void free_thread_info(struct thread_info *thread)
 {
 	if (EXTRA_TASK_STRUCT && nr_thread_info < EXTRA_TASK_STRUCT) {
 		unsigned long *p = (unsigned long *)thread;
 		p[0] = (unsigned long)thread_info_head;
 		thread_info_head = p;
 		nr_thread_info += 1;
 	} else
 		ll_free_task_struct(thread);
 }
 /*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
 {
 }
 void flush_thread(void)
 {
 	struct thread_info *thread = current_thread_info();
 	struct task_struct *tsk = current;
 	memset(&tsk->thread.debug, 0, sizeof(struct debug_info));
 	memset(&thread->fpstate, 0, sizeof(union fp_state));
 	clear_used_math();
 }
 void release_thread(struct task_struct *dead_task)
 {
 }
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
 int
 copy_thread(int nr, unsigned long clone_flags, unsigned long stack_start,
 	    unsigned long unused, struct task_struct *p, struct pt_regs *regs)
 {
 	struct thread_info *thread = p->thread_info;
 	struct pt_regs *childregs;
 	childregs = __get_user_regs(thread);
 	*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 | MODE_SVC26 | PSR_I_BIT;
 	return 0;
 }
 /*
  * 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 = !!used_math();
 	if (used_math)
 		memcpy(fp, &thread->fpstate.soft, sizeof (*fp));
 	return used_math;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	struct task_struct *tsk = current;
 	dump->magic = CMAGIC;
 	dump->start_code = tsk->mm->start_code;
 	dump->start_stack = regs->ARM_sp & ~(PAGE_SIZE - 1);
 	dump->u_tsize = (tsk->mm->end_code - tsk->mm->start_code) >> PAGE_SHIFT;
 	dump->u_dsize = (tsk->mm->brk - tsk->mm->start_data + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	dump->u_ssize = 0;
 	dump->u_debugreg[0] = tsk->thread.debug.bp[0].address;
 	dump->u_debugreg[1] = tsk->thread.debug.bp[1].address;
 	dump->u_debugreg[2] = tsk->thread.debug.bp[0].insn;
 	dump->u_debugreg[3] = tsk->thread.debug.bp[1].insn;
 	dump->u_debugreg[4] = tsk->thread.debug.nsaved;
 	if (dump->start_stack < 0x04000000)
 		dump->u_ssize = (0x04000000 - dump->start_stack) >> PAGE_SHIFT;
 	dump->regs = *regs;
 	dump->u_fpvalid = dump_fpu (regs, &dump->u_fp);
 }
 /*
  * 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.
  * FIXME - make sure this is right - the older code used to zero fp
  * and cause the parent to call sys_exit (do_exit in this version)
  */
 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");
 /*
  * 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;
         regs.ARM_r3 = (unsigned long)do_exit;
         regs.ARM_pc = (unsigned long)kernel_thread_helper | MODE_SVC26;
         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)
 {
 	unsigned long fp, lr;
 	unsigned long stack_page;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	stack_page = 4096 + (unsigned long)p;
 	fp = thread_saved_fp(p);
 	do {
 		if (fp < stack_page || fp > 4092+stack_page)
 			return 0;
 		lr = pc_pointer (((unsigned long *)fp)[-1]);
 		if (!in_sched_functions(lr))
 			return lr;
 		fp = *(unsigned long *) (fp - 12);
 	} while (count ++ < 16);
 	return 0;
 }

arch/cris/kernel/process.c

Diff comments View file @ 59586e5

 /* $Id: process.c,v 1.17 2004/04/05 13:53:48 starvik Exp $
  *
  *  linux/arch/cris/kernel/process.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  *  Copyright (C) 2000-2002  Axis Communications AB
  *
  *  Authors:   Bjorn Wesen (bjornw@axis.com)
  *
  *  $Log: process.c,v $
  *  Revision 1.17  2004/04/05 13:53:48  starvik
  *  Merge of Linux 2.6.5
  *
  *  Revision 1.16  2003/10/27 08:04:33  starvik
  *  Merge of Linux 2.6.0-test9
  *
  *  Revision 1.15  2003/09/11 07:29:52  starvik
  *  Merge of Linux 2.6.0-test5
  *
  *  Revision 1.14  2003/06/10 10:21:12  johana
  *  Moved thread_saved_pc() from arch/cris/kernel/process.c to
  *  subarch specific process.c. arch-v32 has an erp, no irp.
  *
  *  Revision 1.13  2003/04/09 05:20:47  starvik
  *  Merge of Linux 2.5.67
  *
  *  Revision 1.12  2002/12/11 15:41:11  starvik
  *  Extracted v10 (ETRAX 100LX) specific stuff to arch/cris/arch-v10/kernel
  *
  *  Revision 1.11  2002/12/10 09:00:10  starvik
  *  Merge of Linux 2.5.51
  *
  *  Revision 1.10  2002/11/27 08:42:34  starvik
  *  Argument to user_regs() is thread_info*
  *
  *  Revision 1.9  2002/11/26 09:44:21  starvik
  *  New threads exits through ret_from_fork (necessary for preemptive scheduling)
  *
  *  Revision 1.8  2002/11/19 14:35:24  starvik
  *  Changes from linux 2.4
  *  Changed struct initializer syntax to the currently prefered notation
  *
  *  Revision 1.7  2002/11/18 07:39:42  starvik
  *  thread_saved_pc moved here from processor.h
  *
  *  Revision 1.6  2002/11/14 06:51:27  starvik
  *  Made cpu_idle more similar with other archs
  *  init_task_union -> init_thread_union
  *  Updated for new interrupt macros
  *  sys_clone and do_fork have a new argument, user_tid
  *
  *  Revision 1.5  2002/11/05 06:45:11  starvik
  *  Merge of Linux 2.5.45
  *
  *  Revision 1.4  2002/02/05 15:37:44  bjornw
  *  Need init_task.h
  *
  *  Revision 1.3  2002/01/21 15:22:49  bjornw
  *  current->counter is gone
  *
  *  Revision 1.22  2001/11/13 09:40:43  orjanf
  *  Added dump_fpu (needed for core dumps).
  *
  *  Revision 1.21  2001/11/12 18:26:21  pkj
  *  Fixed compiler warnings.
  *
  *  Revision 1.20  2001/10/03 08:21:39  jonashg
  *  cause_of_death does not exist if CONFIG_SVINTO_SIM is defined.
  *
  *  Revision 1.19  2001/09/26 11:52:54  bjornw
  *  INIT_MMAP is gone in 2.4.10
  *
  *  Revision 1.18  2001/08/21 21:43:51  hp
  *  Move last watchdog fix inside #ifdef CONFIG_ETRAX_WATCHDOG
  *
  *  Revision 1.17  2001/08/21 13:48:01  jonashg
  *  Added fix by HP to avoid oops when doing a hard_reset_now.
  *
  *  Revision 1.16  2001/06/21 02:00:40  hp
  *  	* entry.S: Include asm/unistd.h.
  *  	(_sys_call_table): Use section .rodata, not .data.
  *  	(_kernel_thread): Move from...
  *  	* process.c: ... here.
  *  	* entryoffsets.c (VAL): Break out from...
  *  	(OF): Use VAL.
  *  	(LCLONE_VM): New asmified value from CLONE_VM.
  *
  *  Revision 1.15  2001/06/20 16:31:57  hp
  *  Add comments to describe empty functions according to review.
  *
  *  Revision 1.14  2001/05/29 11:27:59  markusl
  *  Fixed so that hard_reset_now will do reset even if watchdog wasn't enabled
  *
  *  Revision 1.13  2001/03/20 19:44:06  bjornw
  *  Use the 7th syscall argument for regs instead of current_regs
  *
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <asm/atomic.h>
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/fs_struct.h>
 #include <linux/init_task.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
 #include <linux/user.h>
 #include <linux/elfcore.h>
 #include <linux/mqueue.h>
 #include <linux/reboot.h>
 //#define DEBUG
 /*
  * Initial task structure. Make this a per-architecture thing,
  * because different architectures tend to have different
  * alignment requirements and potentially different initial
  * setup.
  */
 static struct fs_struct init_fs = INIT_FS;
 static struct files_struct init_files = INIT_FILES;
 static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
 static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
 struct mm_struct init_mm = INIT_MM(init_mm);
 EXPORT_SYMBOL(init_mm);
 /*
  * Initial thread structure.
  *
  * We need to make sure that this is 8192-byte aligned due to the
  * way process stacks are handled. This is done by having a special
  * "init_task" linker map entry..
  */
 union thread_union init_thread_union
 	__attribute__((__section__(".data.init_task"))) =
 		{ INIT_THREAD_INFO(init_task) };
 /*
  * Initial task structure.
  *
  * All other task structs will be allocated on slabs in fork.c
  */
 struct task_struct init_task = INIT_TASK(init_task);
 EXPORT_SYMBOL(init_task);
 /*
  * The hlt_counter, disable_hlt and enable_hlt is just here as a hook if
  * there would ever be a halt sequence (for power save when idle) with
  * some largish delay when halting or resuming *and* a driver that can't
  * afford that delay.  The hlt_counter would then be checked before
  * executing the halt sequence, and the driver marks the unhaltable
  * region by enable_hlt/disable_hlt.
  */
 static int hlt_counter=0;
 void disable_hlt(void)
 {
 	hlt_counter++;
 }
 EXPORT_SYMBOL(disable_hlt);
 void enable_hlt(void)
 {
 	hlt_counter--;
 }
 EXPORT_SYMBOL(enable_hlt);
 /*
  * The following aren't currently used.
  */
 void (*pm_idle)(void);
 extern void default_idle(void);
 /*
  * 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)
  */
 void cpu_idle (void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		while (!need_resched()) {
 			void (*idle)(void) = pm_idle;
 			if (!idle)
 				idle = default_idle;
 			idle();
 		}
 		schedule();
 	}
 }
 void hard_reset_now (void);
 void machine_restart(char *cmd)
 {
 	hard_reset_now();
 }
-EXPORT_SYMBOL(machine_restart);
 /*
  * Similar to machine_power_off, but don't shut off power.  Add code
  * here to freeze the system for e.g. post-mortem debug purpose when
  * possible.  This halt has nothing to do with the idle halt.
  */
 void machine_halt(void)
 {
 }
-EXPORT_SYMBOL(machine_halt);
 /* If or when software power-off is implemented, add code here.  */
 void machine_power_off(void)
 {
 }
-EXPORT_SYMBOL(machine_power_off);
 /*
  * When a process does an "exec", machine state like FPU and debug
  * registers need to be reset.  This is a hook function for that.
  * Currently we don't have any such state to reset, so this is empty.
  */
 void flush_thread(void)
 {
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 #if 0
 	int i;
 	/* changed the size calculations - should hopefully work better. lbt */
 	dump->magic = CMAGIC;
 	dump->start_code = 0;
 	dump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
 	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
 	dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_ssize = 0;
 	for (i = 0; i < 8; i++)
 		dump->u_debugreg[i] = current->debugreg[i];
 	if (dump->start_stack < TASK_SIZE)
 		dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
 	dump->regs = *regs;
 	dump->u_fpvalid = dump_fpu (regs, &dump->i387);
 #endif
 }
 /* Fill in the fpu structure for a core dump. */
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 {
         return 0;
 }

arch/h8300/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/h8300/kernel/process.c
  *
  * Yoshinori Sato <ysato@users.sourceforge.jp>
  *
  *  Based on:
  *
  *  linux/arch/m68knommu/kernel/process.c
  *
  *  Copyright (C) 1998  D. Jeff Dionne <jeff@ryeham.ee.ryerson.ca>,
  *                      Kenneth Albanowski <kjahds@kjahds.com>,
  *                      The Silver Hammer Group, Ltd.
  *
  *  linux/arch/m68k/kernel/process.c
  *
  *  Copyright (C) 1995  Hamish Macdonald
  *
  *  68060 fixes by Jesper Skov
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/interrupt.h>
 #include <linux/reboot.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/traps.h>
 #include <asm/setup.h>
 #include <asm/pgtable.h>
 asmlinkage void ret_from_fork(void);
 /*
  * The idle loop on an H8/300..
  */
 #if !defined(CONFIG_H8300H_SIM) && !defined(CONFIG_H8S_SIM)
 void default_idle(void)
 {
 	while(1) {
 		if (!need_resched()) {
 			local_irq_enable();
 			__asm__("sleep");
 			local_irq_disable();
 		}
 		schedule();
 	}
 }
 #else
 void default_idle(void)
 {
 	while(1) {
 		if (need_resched())
 			schedule();
 	}
 }
 #endif
 void (*idle)(void) = default_idle;
 /*
  * 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)
  */
 void cpu_idle(void)
 {
 	idle();
 }
 void machine_restart(char * __unused)
 {
 	local_irq_disable();
 	__asm__("jmp @@0");
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	local_irq_disable();
 	__asm__("sleep");
 	for (;;);
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	local_irq_disable();
 	__asm__("sleep");
 	for (;;);
 }
-EXPORT_SYMBOL(machine_power_off);
 void show_regs(struct pt_regs * regs)
 {
 	printk("\nPC: %08lx  Status: %02x",
 	       regs->pc, regs->ccr);
 	printk("\nORIG_ER0: %08lx ER0: %08lx ER1: %08lx",
 	       regs->orig_er0, regs->er0, regs->er1);
 	printk("\nER2: %08lx ER3: %08lx ER4: %08lx ER5: %08lx",
 	       regs->er2, regs->er3, regs->er4, regs->er5);
 	printk("\nER6' %08lx ",regs->er6);
 	if (user_mode(regs))
 		printk("USP: %08lx\n", rdusp());
 	else
 		printk("\n");
 }
 /*
  * Create a kernel thread
  */
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	long retval;
 	long clone_arg;
 	mm_segment_t fs;
 	fs = get_fs();
 	set_fs (KERNEL_DS);
 	clone_arg = flags | CLONE_VM;
 	__asm__("mov.l sp,er3\n\t"
 		"sub.l er2,er2\n\t"
 		"mov.l %2,er1\n\t"
 		"mov.l %1,er0\n\t"
 		"trapa #0\n\t"
 		"cmp.l sp,er3\n\t"
 		"beq 1f\n\t"
 		"mov.l %4,er0\n\t"
 		"mov.l %3,er1\n\t"
 		"jsr @er1\n\t"
 		"mov.l %5,er0\n\t"
 		"trapa #0\n"
 		"1:\n\t"
 		"mov.l er0,%0"
 		:"=r"(retval)
 		:"i"(__NR_clone),"g"(clone_arg),"g"(fn),"g"(arg),"i"(__NR_exit)
 		:"er0","er1","er2","er3");
 	set_fs (fs);
 	return retval;
 }
 void flush_thread(void)
 {
 }
 /*
  * "h8300_fork()".. By the time we get here, the
  * non-volatile registers have also been saved on the
  * stack. We do some ugly pointer stuff here.. (see
  * also copy_thread)
  */
 asmlinkage int h8300_fork(struct pt_regs *regs)
 {
 	return -EINVAL;
 }
 asmlinkage int h8300_vfork(struct pt_regs *regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
 }
 asmlinkage int h8300_clone(struct pt_regs *regs)
 {
 	unsigned long clone_flags;
 	unsigned long newsp;
 	/* syscall2 puts clone_flags in er1 and usp in er2 */
 	clone_flags = regs->er1;
 	newsp = regs->er2;
 	if (!newsp)
 		newsp  = rdusp();
 	return do_fork(clone_flags, newsp, regs, 0, NULL, NULL);
 }
 int copy_thread(int nr, unsigned long clone_flags,
                 unsigned long usp, unsigned long topstk,
 		 struct task_struct * p, struct pt_regs * regs)
 {
 	struct pt_regs * childregs;
 	childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p->thread_info)) - 1;
 	*childregs = *regs;
 	childregs->retpc = (unsigned long) ret_from_fork;
 	childregs->er0 = 0;
 	p->thread.usp = usp;
 	p->thread.ksp = (unsigned long)childregs;
 	return 0;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 /* changed the size calculations - should hopefully work better. lbt */
 	dump->magic = CMAGIC;
 	dump->start_code = 0;
 	dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
 	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
 	dump->u_dsize = ((unsigned long) (current->mm->brk +
 					  (PAGE_SIZE-1))) >> PAGE_SHIFT;
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_ssize = 0;
 	dump->u_ar0 = (struct user_regs_struct *)(((int)(&dump->regs)) -((int)(dump)));
 	dump->regs.er0 = regs->er0;
 	dump->regs.er1 = regs->er1;
 	dump->regs.er2 = regs->er2;
 	dump->regs.er3 = regs->er3;
 	dump->regs.er4 = regs->er4;
 	dump->regs.er5 = regs->er5;
 	dump->regs.er6 = regs->er6;
 	dump->regs.orig_er0 = regs->orig_er0;
 	dump->regs.ccr = regs->ccr;
 	dump->regs.pc  = regs->pc;
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(char *name, char **argv, char **envp,int dummy,...)
 {
 	int error;
 	char * filename;
 	struct pt_regs *regs = (struct pt_regs *) ((unsigned char *)&dummy-4);
 	lock_kernel();
 	filename = getname(name);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, argv, envp, regs);
 	putname(filename);
 out:
 	unlock_kernel();
 	return error;
 }
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	return ((struct pt_regs *)tsk->thread.esp0)->pc;
 }
 unsigned long get_wchan(struct task_struct *p)
 {
 	unsigned long fp, pc;
 	unsigned long stack_page;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	stack_page = (unsigned long)p;
 	fp = ((struct pt_regs *)p->thread.ksp)->er6;
 	do {
 		if (fp < stack_page+sizeof(struct thread_info) ||
 		    fp >= 8184+stack_page)
 			return 0;
 		pc = ((unsigned long *)fp)[1];
 		if (!in_sched_functions(pc))
 			return pc;
 		fp = *(unsigned long *) fp;
 	} while (count++ < 16);
 	return 0;
 }

arch/i386/kernel/reboot.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/i386/kernel/reboot.c
  */
 #include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/mc146818rtc.h>
 #include <linux/efi.h>
 #include <linux/dmi.h>
 #include <asm/uaccess.h>
 #include <asm/apic.h>
 #include "mach_reboot.h"
 #include <linux/reboot_fixups.h>
 /*
  * Power off function, if any
  */
 void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
 static int reboot_mode;
 static int reboot_thru_bios;
 #ifdef CONFIG_SMP
 static int reboot_cpu = -1;
 /* shamelessly grabbed from lib/vsprintf.c for readability */
 #define is_digit(c)	((c) >= '0' && (c) <= '9')
 #endif
 static int __init reboot_setup(char *str)
 {
 	while(1) {
 		switch (*str) {
 		case 'w': /* "warm" reboot (no memory testing etc) */
 			reboot_mode = 0x1234;
 			break;
 		case 'c': /* "cold" reboot (with memory testing etc) */
 			reboot_mode = 0x0;
 			break;
 		case 'b': /* "bios" reboot by jumping through the BIOS */
 			reboot_thru_bios = 1;
 			break;
 		case 'h': /* "hard" reboot by toggling RESET and/or crashing the CPU */
 			reboot_thru_bios = 0;
 			break;
 #ifdef CONFIG_SMP
 		case 's': /* "smp" reboot by executing reset on BSP or other CPU*/
 			if (is_digit(*(str+1))) {
 				reboot_cpu = (int) (*(str+1) - '0');
 				if (is_digit(*(str+2)))
 					reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0');
 			}
 				/* we will leave sorting out the final value
 				when we are ready to reboot, since we might not
  				have set up boot_cpu_id or smp_num_cpu */
 			break;
 #endif
 		}
 		if((str = strchr(str,',')) != NULL)
 			str++;
 		else
 			break;
 	}
 	return 1;
 }
 __setup("reboot=", reboot_setup);
 /*
  * Reboot options and system auto-detection code provided by
  * Dell Inc. so their systems "just work". :-)
  */
 /*
  * Some machines require the "reboot=b"  commandline option, this quirk makes that automatic.
  */
 static int __init set_bios_reboot(struct dmi_system_id *d)
 {
 	if (!reboot_thru_bios) {
 		reboot_thru_bios = 1;
 		printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident);
 	}
 	return 0;
 }
 static struct dmi_system_id __initdata reboot_dmi_table[] = {
 	{	/* Handle problems with rebooting on Dell 1300's */
 		.callback = set_bios_reboot,
 		.ident = "Dell PowerEdge 1300",
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"),
 		},
 	},
 	{	/* Handle problems with rebooting on Dell 300's */
 		.callback = set_bios_reboot,
 		.ident = "Dell PowerEdge 300",
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
 		},
 	},
 	{	/* Handle problems with rebooting on Dell 2400's */
 		.callback = set_bios_reboot,
 		.ident = "Dell PowerEdge 2400",
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"),
 		},
 	},
 	{ }
 };
 static int __init reboot_init(void)
 {
 	dmi_check_system(reboot_dmi_table);
 	return 0;
 }
 core_initcall(reboot_init);
 /* The following code and data reboots the machine by switching to real
    mode and jumping to the BIOS reset entry point, as if the CPU has
    really been reset.  The previous version asked the keyboard
    controller to pulse the CPU reset line, which is more thorough, but
    doesn't work with at least one type of 486 motherboard.  It is easy
    to stop this code working; hence the copious comments. */
 static unsigned long long
 real_mode_gdt_entries [3] =
 {
 	0x0000000000000000ULL,	/* Null descriptor */
 	0x00009a000000ffffULL,	/* 16-bit real-mode 64k code at 0x00000000 */
 	0x000092000100ffffULL	/* 16-bit real-mode 64k data at 0x00000100 */
 };
 static struct
 {
 	unsigned short       size __attribute__ ((packed));
 	unsigned long long * base __attribute__ ((packed));
 }
 real_mode_gdt = { sizeof (real_mode_gdt_entries) - 1, real_mode_gdt_entries },
 real_mode_idt = { 0x3ff, NULL },
 no_idt = { 0, NULL };
 /* This is 16-bit protected mode code to disable paging and the cache,
    switch to real mode and jump to the BIOS reset code.
    The instruction that switches to real mode by writing to CR0 must be
    followed immediately by a far jump instruction, which set CS to a
    valid value for real mode, and flushes the prefetch queue to avoid
    running instructions that have already been decoded in protected
    mode.
    Clears all the flags except ET, especially PG (paging), PE
    (protected-mode enable) and TS (task switch for coprocessor state
    save).  Flushes the TLB after paging has been disabled.  Sets CD and
    NW, to disable the cache on a 486, and invalidates the cache.  This
    is more like the state of a 486 after reset.  I don't know if
    something else should be done for other chips.
    More could be done here to set up the registers as if a CPU reset had
    occurred; hopefully real BIOSs don't assume much. */
 static unsigned char real_mode_switch [] =
 {
 	0x66, 0x0f, 0x20, 0xc0,			/*    movl  %cr0,%eax        */
 	0x66, 0x83, 0xe0, 0x11,			/*    andl  $0x00000011,%eax */
 	0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,	/*    orl   $0x60000000,%eax */
 	0x66, 0x0f, 0x22, 0xc0,			/*    movl  %eax,%cr0        */
 	0x66, 0x0f, 0x22, 0xd8,			/*    movl  %eax,%cr3        */
 	0x66, 0x0f, 0x20, 0xc3,			/*    movl  %cr0,%ebx        */
 	0x66, 0x81, 0xe3, 0x00, 0x00, 0x00, 0x60,	/*    andl  $0x60000000,%ebx */
 	0x74, 0x02,				/*    jz    f                */
 	0x0f, 0x09,				/*    wbinvd                 */
 	0x24, 0x10,				/* f: andb  $0x10,al         */
 	0x66, 0x0f, 0x22, 0xc0			/*    movl  %eax,%cr0        */
 };
 static unsigned char jump_to_bios [] =
 {
 	0xea, 0x00, 0x00, 0xff, 0xff		/*    ljmp  $0xffff,$0x0000  */
 };
 /*
  * Switch to real mode and then execute the code
  * specified by the code and length parameters.
  * We assume that length will aways be less that 100!
  */
 void machine_real_restart(unsigned char *code, int length)
 {
 	unsigned long flags;
 	local_irq_disable();
 	/* Write zero to CMOS register number 0x0f, which the BIOS POST
 	   routine will recognize as telling it to do a proper reboot.  (Well
 	   that's what this book in front of me says -- it may only apply to
 	   the Phoenix BIOS though, it's not clear).  At the same time,
 	   disable NMIs by setting the top bit in the CMOS address register,
 	   as we're about to do peculiar things to the CPU.  I'm not sure if
 	   `outb_p' is needed instead of just `outb'.  Use it to be on the
 	   safe side.  (Yes, CMOS_WRITE does outb_p's. -  Paul G.)
 	 */
 	spin_lock_irqsave(&rtc_lock, flags);
 	CMOS_WRITE(0x00, 0x8f);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	/* Remap the kernel at virtual address zero, as well as offset zero
 	   from the kernel segment.  This assumes the kernel segment starts at
 	   virtual address PAGE_OFFSET. */
 	memcpy (swapper_pg_dir, swapper_pg_dir + USER_PGD_PTRS,
 		sizeof (swapper_pg_dir [0]) * KERNEL_PGD_PTRS);
 	/*
 	 * Use `swapper_pg_dir' as our page directory.
 	 */
 	load_cr3(swapper_pg_dir);
 	/* Write 0x1234 to absolute memory location 0x472.  The BIOS reads
 	   this on booting to tell it to "Bypass memory test (also warm
 	   boot)".  This seems like a fairly standard thing that gets set by
 	   REBOOT.COM programs, and the previous reset routine did this
 	   too. */
 	*((unsigned short *)0x472) = reboot_mode;
 	/* For the switch to real mode, copy some code to low memory.  It has
 	   to be in the first 64k because it is running in 16-bit mode, and it
 	   has to have the same physical and virtual address, because it turns
 	   off paging.  Copy it near the end of the first page, out of the way
 	   of BIOS variables. */
 	memcpy ((void *) (0x1000 - sizeof (real_mode_switch) - 100),
 		real_mode_switch, sizeof (real_mode_switch));
 	memcpy ((void *) (0x1000 - 100), code, length);
 	/* Set up the IDT for real mode. */
 	__asm__ __volatile__ ("lidt %0" : : "m" (real_mode_idt));
 	/* Set up a GDT from which we can load segment descriptors for real
 	   mode.  The GDT is not used in real mode; it is just needed here to
 	   prepare the descriptors. */
 	__asm__ __volatile__ ("lgdt %0" : : "m" (real_mode_gdt));
 	/* Load the data segment registers, and thus the descriptors ready for
 	   real mode.  The base address of each segment is 0x100, 16 times the
 	   selector value being loaded here.  This is so that the segment
 	   registers don't have to be reloaded after switching to real mode:
 	   the values are consistent for real mode operation already. */
 	__asm__ __volatile__ ("movl $0x0010,%%eax\n"
 				"\tmovl %%eax,%%ds\n"
 				"\tmovl %%eax,%%es\n"
 				"\tmovl %%eax,%%fs\n"
 				"\tmovl %%eax,%%gs\n"
 				"\tmovl %%eax,%%ss" : : : "eax");
 	/* Jump to the 16-bit code that we copied earlier.  It disables paging
 	   and the cache, switches to real mode, and jumps to the BIOS reset
 	   entry point. */
 	__asm__ __volatile__ ("ljmp $0x0008,%0"
 				:
 				: "i" ((void *) (0x1000 - sizeof (real_mode_switch) - 100)));
 }
 #ifdef CONFIG_APM_MODULE
 EXPORT_SYMBOL(machine_real_restart);
 #endif
 void machine_shutdown(void)
 {
 #ifdef CONFIG_SMP
 	int reboot_cpu_id;
 	/* The boot cpu is always logical cpu 0 */
 	reboot_cpu_id = 0;
 	/* See if there has been given a command line override */
 	if ((reboot_cpu_id != -1) && (reboot_cpu < NR_CPUS) &&
 		cpu_isset(reboot_cpu, cpu_online_map)) {
 		reboot_cpu_id = reboot_cpu;
 	}
 	/* Make certain the cpu I'm rebooting on is online */
 	if (!cpu_isset(reboot_cpu_id, cpu_online_map)) {
 		reboot_cpu_id = smp_processor_id();
 	}
 	/* Make certain I only run on the appropriate processor */
 	set_cpus_allowed(current, cpumask_of_cpu(reboot_cpu_id));
 	/* O.K. Now that I'm on the appropriate processor, stop
 	 * all of the others, and disable their local APICs.
 	 */
 	smp_send_stop();
 #endif /* CONFIG_SMP */
 	lapic_shutdown();
 #ifdef CONFIG_X86_IO_APIC
 	disable_IO_APIC();
 #endif
 }
 void machine_restart(char * __unused)
 {
 	machine_shutdown();
 	if (!reboot_thru_bios) {
 		if (efi_enabled) {
 			efi.reset_system(EFI_RESET_COLD, EFI_SUCCESS, 0, NULL);
 			__asm__ __volatile__("lidt %0": :"m" (no_idt));
 			__asm__ __volatile__("int3");
 		}
 		/* rebooting needs to touch the page at absolute addr 0 */
 		*((unsigned short *)__va(0x472)) = reboot_mode;
 		for (;;) {
 			mach_reboot_fixups(); /* for board specific fixups */
 			mach_reboot();
 			/* That didn't work - force a triple fault.. */
 			__asm__ __volatile__("lidt %0": :"m" (no_idt));
 			__asm__ __volatile__("int3");
 		}
 	}
 	if (efi_enabled)
 		efi.reset_system(EFI_RESET_WARM, EFI_SUCCESS, 0, NULL);
 	machine_real_restart(jump_to_bios, sizeof(jump_to_bios));
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	lapic_shutdown();
 	if (efi_enabled)
 		efi.reset_system(EFI_RESET_SHUTDOWN, EFI_SUCCESS, 0, NULL);
 	if (pm_power_off)
 		pm_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);

arch/i386/mach-visws/reboot.c

Diff comments View file @ 59586e5

 #include <linux/module.h>
 #include <linux/smp.h>
 #include <linux/delay.h>
 #include <linux/platform.h>
 #include <asm/io.h>
 #include "piix4.h"
 void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
 void machine_restart(char * __unused)
 {
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	/*
 	 * Visual Workstations restart after this
 	 * register is poked on the PIIX4
 	 */
 	outb(PIIX4_RESET_VAL, PIIX4_RESET_PORT);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off(void)
 {
 	unsigned short pm_status;
 	extern unsigned int pci_bus0;
 	while ((pm_status = inw(PMSTS_PORT)) & 0x100)
 		outw(pm_status, PMSTS_PORT);
 	outw(PM_SUSPEND_ENABLE, PMCNTRL_PORT);
 	mdelay(10);
 #define PCI_CONF1_ADDRESS(bus, devfn, reg) \
 	(0x80000000 | (bus << 16) | (devfn << 8) | (reg & ~3))
 	outl(PCI_CONF1_ADDRESS(pci_bus0, SPECIAL_DEV, SPECIAL_REG), 0xCF8);
 	outl(PIIX_SPECIAL_STOP, 0xCFC);
 }
-EXPORT_SYMBOL(machine_power_off);
 void machine_halt(void)
 {
 }
-EXPORT_SYMBOL(machine_halt);

arch/i386/mach-voyager/voyager_basic.c

Diff comments View file @ 59586e5

 /* Copyright (C) 1999,2001
  *
  * Author: J.E.J.Bottomley@HansenPartnership.com
  *
  * linux/arch/i386/kernel/voyager.c
  *
  * This file contains all the voyager specific routines for getting
  * initialisation of the architecture to function.  For additional
  * features see:
  *
  *	voyager_cat.c - Voyager CAT bus interface
  *	voyager_smp.c - Voyager SMP hal (emulates linux smp.c)
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/ptrace.h>
 #include <linux/ioport.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/reboot.h>
 #include <linux/sysrq.h>
 #include <asm/io.h>
 #include <asm/voyager.h>
 #include <asm/vic.h>
 #include <linux/pm.h>
 #include <linux/irq.h>
 #include <asm/tlbflush.h>
 #include <asm/arch_hooks.h>
 #include <asm/i8253.h>
 /*
  * Power off function, if any
  */
 void (*pm_power_off)(void);
 EXPORT_SYMBOL(pm_power_off);
 int voyager_level = 0;
 struct voyager_SUS *voyager_SUS = NULL;
 #ifdef CONFIG_SMP
 static void
 voyager_dump(int dummy1, struct pt_regs *dummy2, struct tty_struct *dummy3)
 {
 	/* get here via a sysrq */
 	voyager_smp_dump();
 }
 static struct sysrq_key_op sysrq_voyager_dump_op = {
 	.handler	= voyager_dump,
 	.help_msg	= "Voyager",
 	.action_msg	= "Dump Voyager Status",
 };
 #endif
 void
 voyager_detect(struct voyager_bios_info *bios)
 {
 	if(bios->len != 0xff) {
 		int class = (bios->class_1 << 8)
 			| (bios->class_2 & 0xff);
 		printk("Voyager System detected.\n"
 		       "        Class %x, Revision %d.%d\n",
 		       class, bios->major, bios->minor);
 		if(class == VOYAGER_LEVEL4)
 			voyager_level = 4;
 		else if(class < VOYAGER_LEVEL5_AND_ABOVE)
 			voyager_level = 3;
 		else
 			voyager_level = 5;
 		printk("        Architecture Level %d\n", voyager_level);
 		if(voyager_level < 4)
 			printk("\n**WARNING**: Voyager HAL only supports Levels 4 and 5 Architectures at the moment\n\n");
 		/* install the power off handler */
 		pm_power_off = voyager_power_off;
 #ifdef CONFIG_SMP
 		register_sysrq_key('v', &sysrq_voyager_dump_op);
 #endif
 	} else {
 		printk("\n\n**WARNING**: No Voyager Subsystem Found\n");
 	}
 }
 void
 voyager_system_interrupt(int cpl, void *dev_id, struct pt_regs *regs)
 {
 	printk("Voyager: detected system interrupt\n");
 }
 /* Routine to read information from the extended CMOS area */
 __u8
 voyager_extended_cmos_read(__u16 addr)
 {
 	outb(addr & 0xff, 0x74);
 	outb((addr >> 8) & 0xff, 0x75);
 	return inb(0x76);
 }
 /* internal definitions for the SUS Click Map of memory */
 #define CLICK_ENTRIES	16
 #define CLICK_SIZE	4096	/* click to byte conversion for Length */
 typedef struct ClickMap {
 	struct Entry {
 		__u32	Address;
 		__u32	Length;
 	} Entry[CLICK_ENTRIES];
 } ClickMap_t;
 /* This routine is pretty much an awful hack to read the bios clickmap by
  * mapping it into page 0.  There are usually three regions in the map:
  * 	Base Memory
  * 	Extended Memory
  *	zero length marker for end of map
  *
  * Returns are 0 for failure and 1 for success on extracting region.
  */
 int __init
 voyager_memory_detect(int region, __u32 *start, __u32 *length)
 {
 	int i;
 	int retval = 0;
 	__u8 cmos[4];
 	ClickMap_t *map;
 	unsigned long map_addr;
 	unsigned long old;
 	if(region >= CLICK_ENTRIES) {
 		printk("Voyager: Illegal ClickMap region %d\n", region);
 		return 0;
 	}
 	for(i = 0; i < sizeof(cmos); i++)
 		cmos[i] = voyager_extended_cmos_read(VOYAGER_MEMORY_CLICKMAP + i);
 	map_addr = *(unsigned long *)cmos;
 	/* steal page 0 for this */
 	old = pg0[0];
 	pg0[0] = ((map_addr & PAGE_MASK) | _PAGE_RW | _PAGE_PRESENT);
 	local_flush_tlb();
 	/* now clear everything out but page 0 */
 	map = (ClickMap_t *)(map_addr & (~PAGE_MASK));
 	/* zero length is the end of the clickmap */
 	if(map->Entry[region].Length != 0) {
 		*length = map->Entry[region].Length * CLICK_SIZE;
 		*start = map->Entry[region].Address;
 		retval = 1;
 	}
 	/* replace the mapping */
 	pg0[0] = old;
 	local_flush_tlb();
 	return retval;
 }
 /* voyager specific handling code for timer interrupts.  Used to hand
  * off the timer tick to the SMP code, since the VIC doesn't have an
  * internal timer (The QIC does, but that's another story). */
 void
 voyager_timer_interrupt(struct pt_regs *regs)
 {
 	if((jiffies & 0x3ff) == 0) {
 		/* There seems to be something flaky in either
 		 * hardware or software that is resetting the timer 0
 		 * count to something much higher than it should be
 		 * This seems to occur in the boot sequence, just
 		 * before root is mounted.  Therefore, every 10
 		 * seconds or so, we sanity check the timer zero count
 		 * and kick it back to where it should be.
 		 *
 		 * FIXME: This is the most awful hack yet seen.  I
 		 * should work out exactly what is interfering with
 		 * the timer count settings early in the boot sequence
 		 * and swiftly introduce it to something sharp and
 		 * pointy.  */
 		__u16 val;
 		spin_lock(&i8253_lock);
 		outb_p(0x00, 0x43);
 		val = inb_p(0x40);
 		val |= inb(0x40) << 8;
 		spin_unlock(&i8253_lock);
 		if(val > LATCH) {
 			printk("\nVOYAGER: countdown timer value too high (%d), resetting\n\n", val);
 			spin_lock(&i8253_lock);
 			outb(0x34,0x43);
 			outb_p(LATCH & 0xff , 0x40);	/* LSB */
 			outb(LATCH >> 8 , 0x40);	/* MSB */
 			spin_unlock(&i8253_lock);
 		}
 	}
 #ifdef CONFIG_SMP
 	smp_vic_timer_interrupt(regs);
 #endif
 }
 void
 voyager_power_off(void)
 {
 	printk("VOYAGER Power Off\n");
 	if(voyager_level == 5) {
 		voyager_cat_power_off();
 	} else if(voyager_level == 4) {
 		/* This doesn't apparently work on most L4 machines,
 		 * but the specs say to do this to get automatic power
 		 * off.  Unfortunately, if it doesn't power off the
 		 * machine, it ends up doing a cold restart, which
 		 * isn't really intended, so comment out the code */
 #if 0
 		int port;
 		/* enable the voyager Configuration Space */
 		outb((inb(VOYAGER_MC_SETUP) & 0xf0) | 0x8,
 		     VOYAGER_MC_SETUP);
 		/* the port for the power off flag is an offset from the
 		   floating base */
 		port = (inb(VOYAGER_SSPB_RELOCATION_PORT) << 8) + 0x21;
 		/* set the power off flag */
 		outb(inb(port) | 0x1, port);
 #endif
 	}
 	/* and wait for it to happen */
 	for(;;) {
 		__asm("cli");
 		__asm("hlt");
 	}
 }
 /* copied from process.c */
 static inline void
 kb_wait(void)
 {
 	int i;
 	for (i=0; i<0x10000; i++)
 		if ((inb_p(0x64) & 0x02) == 0)
 			break;
 }
 void
 machine_restart(char *cmd)
 {
 	printk("Voyager Warm Restart\n");
 	kb_wait();
 	if(voyager_level == 5) {
 		/* write magic values to the RTC to inform system that
 		 * shutdown is beginning */
 		outb(0x8f, 0x70);
 		outb(0x5 , 0x71);
 		udelay(50);
 		outb(0xfe,0x64);         /* pull reset low */
 	} else if(voyager_level == 4) {
 		__u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT)<<8;
 		__u8 basebd = inb(VOYAGER_MC_SETUP);
 		outb(basebd | 0x08, VOYAGER_MC_SETUP);
 		outb(0x02, catbase + 0x21);
 	}
 	for(;;) {
 		asm("cli");
 		asm("hlt");
 	}
 }
-EXPORT_SYMBOL(machine_restart);
 void
 mca_nmi_hook(void)
 {
 	__u8 dumpval __attribute__((unused)) = inb(0xf823);
 	__u8 swnmi __attribute__((unused)) = inb(0xf813);
 	/* FIXME: assume dump switch pressed */
 	/* check to see if the dump switch was pressed */
 	VDEBUG(("VOYAGER: dumpval = 0x%x, swnmi = 0x%x\n", dumpval, swnmi));
 	/* clear swnmi */
 	outb(0xff, 0xf813);
 	/* tell SUS to ignore dump */
 	if(voyager_level == 5 && voyager_SUS != NULL) {
 		if(voyager_SUS->SUS_mbox == VOYAGER_DUMP_BUTTON_NMI) {
 			voyager_SUS->kernel_mbox = VOYAGER_NO_COMMAND;
 			voyager_SUS->kernel_flags |= VOYAGER_OS_IN_PROGRESS;
 			udelay(1000);
 			voyager_SUS->kernel_mbox = VOYAGER_IGNORE_DUMP;
 			voyager_SUS->kernel_flags &= ~VOYAGER_OS_IN_PROGRESS;
 		}
 	}
 	printk(KERN_ERR "VOYAGER: Dump switch pressed, printing CPU%d tracebacks\n", smp_processor_id());
 	show_stack(NULL, NULL);
 	show_state();
 }
 void
 machine_halt(void)
 {
 	/* treat a halt like a power off */
 	machine_power_off();
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	if (pm_power_off)
 		pm_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);

arch/ia64/kernel/process.c

Diff comments View file @ 59586e5

 /*
  * Architecture-specific setup.
  *
  * Copyright (C) 1998-2003 Hewlett-Packard Co
  *	David Mosberger-Tang <davidm@hpl.hp.com>
  * 04/11/17 Ashok Raj	<ashok.raj@intel.com> Added CPU Hotplug Support
  */
 #define __KERNEL_SYSCALLS__	/* see <asm/unistd.h> */
 #include <linux/config.h>
 #include <linux/cpu.h>
 #include <linux/pm.h>
 #include <linux/elf.h>
 #include <linux/errno.h>
 #include <linux/kallsyms.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/personality.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/thread_info.h>
 #include <linux/unistd.h>
 #include <linux/efi.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/kprobes.h>
 #include <asm/cpu.h>
 #include <asm/delay.h>
 #include <asm/elf.h>
 #include <asm/ia32.h>
 #include <asm/irq.h>
 #include <asm/pgalloc.h>
 #include <asm/processor.h>
 #include <asm/sal.h>
 #include <asm/tlbflush.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 #include <asm/user.h>
 #include "entry.h"
 #ifdef CONFIG_PERFMON
 # include <asm/perfmon.h>
 #endif
 #include "sigframe.h"
 void (*ia64_mark_idle)(int);
 static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
 unsigned long boot_option_idle_override = 0;
 EXPORT_SYMBOL(boot_option_idle_override);
 void
 ia64_do_show_stack (struct unw_frame_info *info, void *arg)
 {
 	unsigned long ip, sp, bsp;
 	char buf[128];			/* don't make it so big that it overflows the stack! */
 	printk("\nCall Trace:\n");
 	do {
 		unw_get_ip(info, &ip);
 		if (ip == 0)
 			break;
 		unw_get_sp(info, &sp);
 		unw_get_bsp(info, &bsp);
 		snprintf(buf, sizeof(buf),
 			 " [<%016lx>] %%s\n"
 			 "                                sp=%016lx bsp=%016lx\n",
 			 ip, sp, bsp);
 		print_symbol(buf, ip);
 	} while (unw_unwind(info) >= 0);
 }
 void
 show_stack (struct task_struct *task, unsigned long *sp)
 {
 	if (!task)
 		unw_init_running(ia64_do_show_stack, NULL);
 	else {
 		struct unw_frame_info info;
 		unw_init_from_blocked_task(&info, task);
 		ia64_do_show_stack(&info, NULL);
 	}
 }
 void
 dump_stack (void)
 {
 	show_stack(NULL, NULL);
 }
 EXPORT_SYMBOL(dump_stack);
 void
 show_regs (struct pt_regs *regs)
 {
 	unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
 	print_modules();
 	printk("\nPid: %d, CPU %d, comm: %20s\n", current->pid, smp_processor_id(), current->comm);
 	printk("psr : %016lx ifs : %016lx ip  : [<%016lx>]    %s\n",
 	       regs->cr_ipsr, regs->cr_ifs, ip, print_tainted());
 	print_symbol("ip is at %s\n", ip);
 	printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
 	       regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
 	printk("rnat: %016lx bsps: %016lx pr  : %016lx\n",
 	       regs->ar_rnat, regs->ar_bspstore, regs->pr);
 	printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
 	       regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
 	printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
 	printk("b0  : %016lx b6  : %016lx b7  : %016lx\n", regs->b0, regs->b6, regs->b7);
 	printk("f6  : %05lx%016lx f7  : %05lx%016lx\n",
 	       regs->f6.u.bits[1], regs->f6.u.bits[0],
 	       regs->f7.u.bits[1], regs->f7.u.bits[0]);
 	printk("f8  : %05lx%016lx f9  : %05lx%016lx\n",
 	       regs->f8.u.bits[1], regs->f8.u.bits[0],
 	       regs->f9.u.bits[1], regs->f9.u.bits[0]);
 	printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
 	       regs->f10.u.bits[1], regs->f10.u.bits[0],
 	       regs->f11.u.bits[1], regs->f11.u.bits[0]);
 	printk("r1  : %016lx r2  : %016lx r3  : %016lx\n", regs->r1, regs->r2, regs->r3);
 	printk("r8  : %016lx r9  : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
 	printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
 	printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
 	printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
 	printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
 	printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
 	printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
 	printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
 	if (user_mode(regs)) {
 		/* print the stacked registers */
 		unsigned long val, *bsp, ndirty;
 		int i, sof, is_nat = 0;
 		sof = regs->cr_ifs & 0x7f;	/* size of frame */
 		ndirty = (regs->loadrs >> 19);
 		bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
 		for (i = 0; i < sof; ++i) {
 			get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
 			printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
 			       ((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
 		}
 	} else
 		show_stack(NULL, NULL);
 }
 void
 do_notify_resume_user (sigset_t *oldset, struct sigscratch *scr, long in_syscall)
 {
 	if (fsys_mode(current, &scr->pt)) {
 		/* defer signal-handling etc. until we return to privilege-level 0.  */
 		if (!ia64_psr(&scr->pt)->lp)
 			ia64_psr(&scr->pt)->lp = 1;
 		return;
 	}
 #ifdef CONFIG_PERFMON
 	if (current->thread.pfm_needs_checking)
 		pfm_handle_work();
 #endif
 	/* deal with pending signal delivery */
 	if (test_thread_flag(TIF_SIGPENDING))
 		ia64_do_signal(oldset, scr, in_syscall);
 }
 static int pal_halt        = 1;
 static int can_do_pal_halt = 1;
 static int __init nohalt_setup(char * str)
 {
 	pal_halt = 0;
 	return 1;
 }
 __setup("nohalt", nohalt_setup);
 void
 update_pal_halt_status(int status)
 {
 	can_do_pal_halt = pal_halt && status;
 }
 /*
  * We use this if we don't have any better idle routine..
  */
 void
 default_idle (void)
 {
 	local_irq_enable();
 	while (!need_resched())
 		if (can_do_pal_halt)
 			safe_halt();
 		else
 			cpu_relax();
 }
 #ifdef CONFIG_HOTPLUG_CPU
 /* We don't actually take CPU down, just spin without interrupts. */
 static inline void play_dead(void)
 {
 	extern void ia64_cpu_local_tick (void);
 	unsigned int this_cpu = smp_processor_id();
 	/* Ack it */
 	__get_cpu_var(cpu_state) = CPU_DEAD;
 	max_xtp();
 	local_irq_disable();
 	idle_task_exit();
 	ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
 	/*
 	 * The above is a point of no-return, the processor is
 	 * expected to be in SAL loop now.
 	 */
 	BUG();
 }
 #else
 static inline void play_dead(void)
 {
 	BUG();
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 void cpu_idle_wait(void)
 {
 	unsigned int cpu, this_cpu = get_cpu();
 	cpumask_t map;
 	set_cpus_allowed(current, cpumask_of_cpu(this_cpu));
 	put_cpu();
 	cpus_clear(map);
 	for_each_online_cpu(cpu) {
 		per_cpu(cpu_idle_state, cpu) = 1;
 		cpu_set(cpu, map);
 	}
 	__get_cpu_var(cpu_idle_state) = 0;
 	wmb();
 	do {
 		ssleep(1);
 		for_each_online_cpu(cpu) {
 			if (cpu_isset(cpu, map) && !per_cpu(cpu_idle_state, cpu))
 				cpu_clear(cpu, map);
 		}
 		cpus_and(map, map, cpu_online_map);
 	} while (!cpus_empty(map));
 }
 EXPORT_SYMBOL_GPL(cpu_idle_wait);
 void __attribute__((noreturn))
 cpu_idle (void)
 {
 	void (*mark_idle)(int) = ia64_mark_idle;
 	/* endless idle loop with no priority at all */
 	while (1) {
 #ifdef CONFIG_SMP
 		if (!need_resched())
 			min_xtp();
 #endif
 		while (!need_resched()) {
 			void (*idle)(void);
 			if (__get_cpu_var(cpu_idle_state))
 				__get_cpu_var(cpu_idle_state) = 0;
 			rmb();
 			if (mark_idle)
 				(*mark_idle)(1);
 			idle = pm_idle;
 			if (!idle)
 				idle = default_idle;
 			(*idle)();
 		}
 		if (mark_idle)
 			(*mark_idle)(0);
 #ifdef CONFIG_SMP
 		normal_xtp();
 #endif
 		schedule();
 		check_pgt_cache();
 		if (cpu_is_offline(smp_processor_id()))
 			play_dead();
 	}
 }
 void
 ia64_save_extra (struct task_struct *task)
 {
 #ifdef CONFIG_PERFMON
 	unsigned long info;
 #endif
 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
 		ia64_save_debug_regs(&task->thread.dbr[0]);
 #ifdef CONFIG_PERFMON
 	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
 		pfm_save_regs(task);
 	info = __get_cpu_var(pfm_syst_info);
 	if (info & PFM_CPUINFO_SYST_WIDE)
 		pfm_syst_wide_update_task(task, info, 0);
 #endif
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(ia64_task_regs(task)))
 		ia32_save_state(task);
 #endif
 }
 void
 ia64_load_extra (struct task_struct *task)
 {
 #ifdef CONFIG_PERFMON
 	unsigned long info;
 #endif
 	if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
 		ia64_load_debug_regs(&task->thread.dbr[0]);
 #ifdef CONFIG_PERFMON
 	if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
 		pfm_load_regs(task);
 	info = __get_cpu_var(pfm_syst_info);
 	if (info & PFM_CPUINFO_SYST_WIDE)
 		pfm_syst_wide_update_task(task, info, 1);
 #endif
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(ia64_task_regs(task)))
 		ia32_load_state(task);
 #endif
 }
 /*
  * Copy the state of an ia-64 thread.
  *
  * We get here through the following  call chain:
  *
  *	from user-level:	from kernel:
  *
  *	<clone syscall>	        <some kernel call frames>
  *	sys_clone		   :
  *	do_fork			do_fork
  *	copy_thread		copy_thread
  *
  * This means that the stack layout is as follows:
  *
  *	+---------------------+ (highest addr)
  *	|   struct pt_regs    |
  *	+---------------------+
  *	| struct switch_stack |
  *	+---------------------+
  *	|                     |
  *	|    memory stack     |
  *	|                     | <-- sp (lowest addr)
  *	+---------------------+
  *
  * Observe that we copy the unat values that are in pt_regs and switch_stack.  Spilling an
  * integer to address X causes bit N in ar.unat to be set to the NaT bit of the register,
  * with N=(X & 0x1ff)/8.  Thus, copying the unat value preserves the NaT bits ONLY if the
  * pt_regs structure in the parent is congruent to that of the child, modulo 512.  Since
  * the stack is page aligned and the page size is at least 4KB, this is always the case,
  * so there is nothing to worry about.
  */
 int
 copy_thread (int nr, unsigned long clone_flags,
 	     unsigned long user_stack_base, unsigned long user_stack_size,
 	     struct task_struct *p, struct pt_regs *regs)
 {
 	extern char ia64_ret_from_clone, ia32_ret_from_clone;
 	struct switch_stack *child_stack, *stack;
 	unsigned long rbs, child_rbs, rbs_size;
 	struct pt_regs *child_ptregs;
 	int retval = 0;
 #ifdef CONFIG_SMP
 	/*
 	 * For SMP idle threads, fork_by_hand() calls do_fork with
 	 * NULL regs.
 	 */
 	if (!regs)
 		return 0;
 #endif
 	stack = ((struct switch_stack *) regs) - 1;
 	child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
 	child_stack = (struct switch_stack *) child_ptregs - 1;
 	/* copy parent's switch_stack & pt_regs to child: */
 	memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
 	rbs = (unsigned long) current + IA64_RBS_OFFSET;
 	child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
 	rbs_size = stack->ar_bspstore - rbs;
 	/* copy the parent's register backing store to the child: */
 	memcpy((void *) child_rbs, (void *) rbs, rbs_size);
 	if (likely(user_mode(child_ptregs))) {
 		if ((clone_flags & CLONE_SETTLS) && !IS_IA32_PROCESS(regs))
 			child_ptregs->r13 = regs->r16;	/* see sys_clone2() in entry.S */
 		if (user_stack_base) {
 			child_ptregs->r12 = user_stack_base + user_stack_size - 16;
 			child_ptregs->ar_bspstore = user_stack_base;
 			child_ptregs->ar_rnat = 0;
 			child_ptregs->loadrs = 0;
 		}
 	} else {
 		/*
 		 * Note: we simply preserve the relative position of
 		 * the stack pointer here.  There is no need to
 		 * allocate a scratch area here, since that will have
 		 * been taken care of by the caller of sys_clone()
 		 * already.
 		 */
 		child_ptregs->r12 = (unsigned long) child_ptregs - 16; /* kernel sp */
 		child_ptregs->r13 = (unsigned long) p;		/* set `current' pointer */
 	}
 	child_stack->ar_bspstore = child_rbs + rbs_size;
 	if (IS_IA32_PROCESS(regs))
 		child_stack->b0 = (unsigned long) &ia32_ret_from_clone;
 	else
 		child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
 	/* copy parts of thread_struct: */
 	p->thread.ksp = (unsigned long) child_stack - 16;
 	/* stop some PSR bits from being inherited.
 	 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
 	 * therefore we must specify them explicitly here and not include them in
 	 * IA64_PSR_BITS_TO_CLEAR.
 	 */
 	child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
 				 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
 	/*
 	 * NOTE: The calling convention considers all floating point
 	 * registers in the high partition (fph) to be scratch.  Since
 	 * the only way to get to this point is through a system call,
 	 * we know that the values in fph are all dead.  Hence, there
 	 * is no need to inherit the fph state from the parent to the
 	 * child and all we have to do is to make sure that
 	 * IA64_THREAD_FPH_VALID is cleared in the child.
 	 *
 	 * XXX We could push this optimization a bit further by
 	 * clearing IA64_THREAD_FPH_VALID on ANY system call.
 	 * However, it's not clear this is worth doing.  Also, it
 	 * would be a slight deviation from the normal Linux system
 	 * call behavior where scratch registers are preserved across
 	 * system calls (unless used by the system call itself).
 	 */
 #	define THREAD_FLAGS_TO_CLEAR	(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
 					 | IA64_THREAD_PM_VALID)
 #	define THREAD_FLAGS_TO_SET	0
 	p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
 			   | THREAD_FLAGS_TO_SET);
 	ia64_drop_fpu(p);	/* don't pick up stale state from a CPU's fph */
 #ifdef CONFIG_IA32_SUPPORT
 	/*
 	 * If we're cloning an IA32 task then save the IA32 extra
 	 * state from the current task to the new task
 	 */
 	if (IS_IA32_PROCESS(ia64_task_regs(current))) {
 		ia32_save_state(p);
 		if (clone_flags & CLONE_SETTLS)
 			retval = ia32_clone_tls(p, child_ptregs);
 		/* Copy partially mapped page list */
 		if (!retval)
 			retval = ia32_copy_partial_page_list(p, clone_flags);
 	}
 #endif
 #ifdef CONFIG_PERFMON
 	if (current->thread.pfm_context)
 		pfm_inherit(p, child_ptregs);
 #endif
 	return retval;
 }
 static void
 do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
 {
 	unsigned long mask, sp, nat_bits = 0, ip, ar_rnat, urbs_end, cfm;
 	elf_greg_t *dst = arg;
 	struct pt_regs *pt;
 	char nat;
 	int i;
 	memset(dst, 0, sizeof(elf_gregset_t));	/* don't leak any kernel bits to user-level */
 	if (unw_unwind_to_user(info) < 0)
 		return;
 	unw_get_sp(info, &sp);
 	pt = (struct pt_regs *) (sp + 16);
 	urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
 	if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
 		return;
 	ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
 		  &ar_rnat);
 	/*
 	 * coredump format:
 	 *	r0-r31
 	 *	NaT bits (for r0-r31; bit N == 1 iff rN is a NaT)
 	 *	predicate registers (p0-p63)
 	 *	b0-b7
 	 *	ip cfm user-mask
 	 *	ar.rsc ar.bsp ar.bspstore ar.rnat
 	 *	ar.ccv ar.unat ar.fpsr ar.pfs ar.lc ar.ec
 	 */
 	/* r0 is zero */
 	for (i = 1, mask = (1UL << i); i < 32; ++i) {
 		unw_get_gr(info, i, &dst[i], &nat);
 		if (nat)
 			nat_bits |= mask;
 		mask <<= 1;
 	}
 	dst[32] = nat_bits;
 	unw_get_pr(info, &dst[33]);
 	for (i = 0; i < 8; ++i)
 		unw_get_br(info, i, &dst[34 + i]);
 	unw_get_rp(info, &ip);
 	dst[42] = ip + ia64_psr(pt)->ri;
 	dst[43] = cfm;
 	dst[44] = pt->cr_ipsr & IA64_PSR_UM;
 	unw_get_ar(info, UNW_AR_RSC, &dst[45]);
 	/*
 	 * For bsp and bspstore, unw_get_ar() would return the kernel
 	 * addresses, but we need the user-level addresses instead:
 	 */
 	dst[46] = urbs_end;	/* note: by convention PT_AR_BSP points to the end of the urbs! */
 	dst[47] = pt->ar_bspstore;
 	dst[48] = ar_rnat;
 	unw_get_ar(info, UNW_AR_CCV, &dst[49]);
 	unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
 	unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
 	dst[52] = pt->ar_pfs;	/* UNW_AR_PFS is == to pt->cr_ifs for interrupt frames */
 	unw_get_ar(info, UNW_AR_LC, &dst[53]);
 	unw_get_ar(info, UNW_AR_EC, &dst[54]);
 	unw_get_ar(info, UNW_AR_CSD, &dst[55]);
 	unw_get_ar(info, UNW_AR_SSD, &dst[56]);
 }
 void
 do_dump_task_fpu (struct task_struct *task, struct unw_frame_info *info, void *arg)
 {
 	elf_fpreg_t *dst = arg;
 	int i;
 	memset(dst, 0, sizeof(elf_fpregset_t));	/* don't leak any "random" bits */
 	if (unw_unwind_to_user(info) < 0)
 		return;
 	/* f0 is 0.0, f1 is 1.0 */
 	for (i = 2; i < 32; ++i)
 		unw_get_fr(info, i, dst + i);
 	ia64_flush_fph(task);
 	if ((task->thread.flags & IA64_THREAD_FPH_VALID) != 0)
 		memcpy(dst + 32, task->thread.fph, 96*16);
 }
 void
 do_copy_regs (struct unw_frame_info *info, void *arg)
 {
 	do_copy_task_regs(current, info, arg);
 }
 void
 do_dump_fpu (struct unw_frame_info *info, void *arg)
 {
 	do_dump_task_fpu(current, info, arg);
 }
 int
 dump_task_regs(struct task_struct *task, elf_gregset_t *regs)
 {
 	struct unw_frame_info tcore_info;
 	if (current == task) {
 		unw_init_running(do_copy_regs, regs);
 	} else {
 		memset(&tcore_info, 0, sizeof(tcore_info));
 		unw_init_from_blocked_task(&tcore_info, task);
 		do_copy_task_regs(task, &tcore_info, regs);
 	}
 	return 1;
 }
 void
 ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
 {
 	unw_init_running(do_copy_regs, dst);
 }
 int
 dump_task_fpu (struct task_struct *task, elf_fpregset_t *dst)
 {
 	struct unw_frame_info tcore_info;
 	if (current == task) {
 		unw_init_running(do_dump_fpu, dst);
 	} else {
 		memset(&tcore_info, 0, sizeof(tcore_info));
 		unw_init_from_blocked_task(&tcore_info, task);
 		do_dump_task_fpu(task, &tcore_info, dst);
 	}
 	return 1;
 }
 int
 dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
 {
 	unw_init_running(do_dump_fpu, dst);
 	return 1;	/* f0-f31 are always valid so we always return 1 */
 }
 long
 sys_execve (char __user *filename, char __user * __user *argv, char __user * __user *envp,
 	    struct pt_regs *regs)
 {
 	char *fname;
 	int error;
 	fname = getname(filename);
 	error = PTR_ERR(fname);
 	if (IS_ERR(fname))
 		goto out;
 	error = do_execve(fname, argv, envp, regs);
 	putname(fname);
 out:
 	return error;
 }
 pid_t
 kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
 {
 	extern void start_kernel_thread (void);
 	unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
 	struct {
 		struct switch_stack sw;
 		struct pt_regs pt;
 	} regs;
 	memset(&regs, 0, sizeof(regs));
 	regs.pt.cr_iip = helper_fptr[0];	/* set entry point (IP) */
 	regs.pt.r1 = helper_fptr[1];		/* set GP */
 	regs.pt.r9 = (unsigned long) fn;	/* 1st argument */
 	regs.pt.r11 = (unsigned long) arg;	/* 2nd argument */
 	/* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read.  */
 	regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
 	regs.pt.cr_ifs = 1UL << 63;		/* mark as valid, empty frame */
 	regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
 	regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
 	regs.sw.pr = (1 << PRED_KERNEL_STACK);
 	return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs.pt, 0, NULL, NULL);
 }
 EXPORT_SYMBOL(kernel_thread);
 /* This gets called from kernel_thread() via ia64_invoke_thread_helper().  */
 int
 kernel_thread_helper (int (*fn)(void *), void *arg)
 {
 #ifdef CONFIG_IA32_SUPPORT
 	if (IS_IA32_PROCESS(ia64_task_regs(current))) {
 		/* A kernel thread is always a 64-bit process. */
 		current->thread.map_base  = DEFAULT_MAP_BASE;
 		current->thread.task_size = DEFAULT_TASK_SIZE;
 		ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
 		ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
 	}
 #endif
 	return (*fn)(arg);
 }
 /*
  * Flush thread state.  This is called when a thread does an execve().
  */
 void
 flush_thread (void)
 {
 	/*
 	 * Remove function-return probe instances associated with this task
 	 * and put them back on the free list. Do not insert an exit probe for
 	 * this function, it will be disabled by kprobe_flush_task if you do.
 	 */
 	kprobe_flush_task(current);
 	/* drop floating-point and debug-register state if it exists: */
 	current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
 	ia64_drop_fpu(current);
 	if (IS_IA32_PROCESS(ia64_task_regs(current)))
 		ia32_drop_partial_page_list(current);
 }
 /*
  * Clean up state associated with current thread.  This is called when
  * the thread calls exit().
  */
 void
 exit_thread (void)
 {
 	/*
 	 * Remove function-return probe instances associated with this task
 	 * and put them back on the free list. Do not insert an exit probe for
 	 * this function, it will be disabled by kprobe_flush_task if you do.
 	 */
 	kprobe_flush_task(current);
 	ia64_drop_fpu(current);
 #ifdef CONFIG_PERFMON
        /* if needed, stop monitoring and flush state to perfmon context */
 	if (current->thread.pfm_context)
 		pfm_exit_thread(current);
 	/* free debug register resources */
 	if (current->thread.flags & IA64_THREAD_DBG_VALID)
 		pfm_release_debug_registers(current);
 #endif
 	if (IS_IA32_PROCESS(ia64_task_regs(current)))
 		ia32_drop_partial_page_list(current);
 }
 unsigned long
 get_wchan (struct task_struct *p)
 {
 	struct unw_frame_info info;
 	unsigned long ip;
 	int count = 0;
 	/*
 	 * Note: p may not be a blocked task (it could be current or
 	 * another process running on some other CPU.  Rather than
 	 * trying to determine if p is really blocked, we just assume
 	 * it's blocked and rely on the unwind routines to fail
 	 * gracefully if the process wasn't really blocked after all.
 	 * --davidm 99/12/15
 	 */
 	unw_init_from_blocked_task(&info, p);
 	do {
 		if (unw_unwind(&info) < 0)
 			return 0;
 		unw_get_ip(&info, &ip);
 		if (!in_sched_functions(ip))
 			return ip;
 	} while (count++ < 16);
 	return 0;
 }
 void
 cpu_halt (void)
 {
 	pal_power_mgmt_info_u_t power_info[8];
 	unsigned long min_power;
 	int i, min_power_state;
 	if (ia64_pal_halt_info(power_info) != 0)
 		return;
 	min_power_state = 0;
 	min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
 	for (i = 1; i < 8; ++i)
 		if (power_info[i].pal_power_mgmt_info_s.im
 		    && power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
 			min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
 			min_power_state = i;
 		}
 	while (1)
 		ia64_pal_halt(min_power_state);
 }
 void
 machine_restart (char *restart_cmd)
 {
 	(*efi.reset_system)(EFI_RESET_WARM, 0, 0, NULL);
 }
-EXPORT_SYMBOL(machine_restart);
 void
 machine_halt (void)
 {
 	cpu_halt();
 }
-EXPORT_SYMBOL(machine_halt);
 void
 machine_power_off (void)
 {
 	if (pm_power_off)
 		pm_power_off();
 	machine_halt();
 }
-EXPORT_SYMBOL(machine_power_off);

arch/m32r/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/m32r/kernel/process.c
  *
  *  Copyright (c) 2001, 2002  Hiroyuki Kondo, Hirokazu Takata,
  *                            Hitoshi Yamamoto
  *  Taken from sh version.
  *    Copyright (C) 1995  Linus Torvalds
  *    SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
  */
 #undef DEBUG_PROCESS
 #ifdef DEBUG_PROCESS
 #define DPRINTK(fmt, args...)  printk("%s:%d:%s: " fmt, __FILE__, __LINE__, \
   __FUNCTION__, ##args)
 #else
 #define DPRINTK(fmt, args...)
 #endif
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <linux/fs.h>
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/ptrace.h>
 #include <linux/unistd.h>
 #include <linux/slab.h>
 #include <linux/hardirq.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/elf.h>
 #include <asm/m32r.h>
 #include <linux/err.h>
 static int hlt_counter=0;
 /*
  * Return saved PC of a blocked thread.
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	return tsk->thread.lr;
 }
 /*
  * Powermanagement idle function, if any..
  */
 void (*pm_idle)(void) = NULL;
 void disable_hlt(void)
 {
 	hlt_counter++;
 }
 EXPORT_SYMBOL(disable_hlt);
 void enable_hlt(void)
 {
 	hlt_counter--;
 }
 EXPORT_SYMBOL(enable_hlt);
 /*
  * We use this is we don't have any better
  * idle routine..
  */
 void default_idle(void)
 {
 	/* M32R_FIXME: Please use "cpu_sleep" mode.  */
 	cpu_relax();
 }
 /*
  * On SMP it's slightly faster (but much more power-consuming!)
  * to poll the ->work.need_resched flag instead of waiting for the
  * cross-CPU IPI to arrive. Use this option with caution.
  */
 static void poll_idle (void)
 {
 	/* M32R_FIXME */
 	cpu_relax();
 }
 /*
  * 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)
  */
 void cpu_idle (void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		while (!need_resched()) {
 			void (*idle)(void) = pm_idle;
 			if (!idle)
 				idle = default_idle;
 			idle();
 		}
 		schedule();
 	}
 }
 void machine_restart(char *__unused)
 {
 	printk("Please push reset button!\n");
 	while (1)
 		cpu_relax();
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	printk("Please push reset button!\n");
 	while (1)
 		cpu_relax();
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	/* M32R_FIXME */
 }
-EXPORT_SYMBOL(machine_power_off);
 static int __init idle_setup (char *str)
 {
 	if (!strncmp(str, "poll", 4)) {
 		printk("using poll in idle threads.\n");
 		pm_idle = poll_idle;
 	} else if (!strncmp(str, "sleep", 4)) {
 		printk("using sleep in idle threads.\n");
 		pm_idle = default_idle;
 	}
 	return 1;
 }
 __setup("idle=", idle_setup);
 void show_regs(struct pt_regs * regs)
 {
 	printk("\n");
 	printk("BPC[%08lx]:PSW[%08lx]:LR [%08lx]:FP [%08lx]\n", \
 	  regs->bpc, regs->psw, regs->lr, regs->fp);
 	printk("BBPC[%08lx]:BBPSW[%08lx]:SPU[%08lx]:SPI[%08lx]\n", \
 	  regs->bbpc, regs->bbpsw, regs->spu, regs->spi);
 	printk("R0 [%08lx]:R1 [%08lx]:R2 [%08lx]:R3 [%08lx]\n", \
 	  regs->r0, regs->r1, regs->r2, regs->r3);
 	printk("R4 [%08lx]:R5 [%08lx]:R6 [%08lx]:R7 [%08lx]\n", \
 	  regs->r4, regs->r5, regs->r6, regs->r7);
 	printk("R8 [%08lx]:R9 [%08lx]:R10[%08lx]:R11[%08lx]\n", \
 	  regs->r8, regs->r9, regs->r10, regs->r11);
 	printk("R12[%08lx]\n", \
 	  regs->r12);
 #if defined(CONFIG_ISA_M32R2) && defined(CONFIG_ISA_DSP_LEVEL2)
 	printk("ACC0H[%08lx]:ACC0L[%08lx]\n", \
 	  regs->acc0h, regs->acc0l);
 	printk("ACC1H[%08lx]:ACC1L[%08lx]\n", \
 	  regs->acc1h, regs->acc1l);
 #elif defined(CONFIG_ISA_M32R2) || defined(CONFIG_ISA_M32R)
 	printk("ACCH[%08lx]:ACCL[%08lx]\n", \
 	  regs->acch, regs->accl);
 #else
 #error unknown isa configuration
 #endif
 }
 /*
  * Create a kernel thread
  */
 /*
  * This is the mechanism for creating a new kernel thread.
  *
  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
  * who haven't done an "execve()") should use this: it will work within
  * a system call from a "real" process, but the process memory space will
  * not be free'd until both the parent and the child have exited.
  */
 static void kernel_thread_helper(void *nouse, int (*fn)(void *), void *arg)
 {
 	fn(arg);
 	do_exit(-1);
 }
 int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
 	struct pt_regs regs;
 	memset(&regs, 0, sizeof (regs));
 	regs.r1 = (unsigned long)fn;
 	regs.r2 = (unsigned long)arg;
 	regs.bpc = (unsigned long)kernel_thread_helper;
 	regs.psw = M32R_PSW_BIE;
 	/* 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)
 {
 	/* Nothing to do. */
 	DPRINTK("pid = %d\n", current->pid);
 }
 void flush_thread(void)
 {
 	DPRINTK("pid = %d\n", current->pid);
 	memset(&current->thread.debug_trap, 0, sizeof(struct debug_trap));
 }
 void release_thread(struct task_struct *dead_task)
 {
 	/* do nothing */
 	DPRINTK("pid = %d\n", dead_task->pid);
 }
 /* Fill in the fpu structure for a core dump.. */
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 {
 	return 0; /* Task didn't use the fpu at all. */
 }
 int copy_thread(int nr, unsigned long clone_flags, unsigned long spu,
 	unsigned long unused, struct task_struct *tsk, struct pt_regs *regs)
 {
 	struct pt_regs *childregs;
 	unsigned long sp = (unsigned long)tsk->thread_info + THREAD_SIZE;
 	extern void ret_from_fork(void);
 	/* Copy registers */
 	sp -= sizeof (struct pt_regs);
 	childregs = (struct pt_regs *)sp;
 	*childregs = *regs;
 	childregs->spu = spu;
 	childregs->r0 = 0;	/* Child gets zero as return value */
 	regs->r0 = tsk->pid;
 	tsk->thread.sp = (unsigned long)childregs;
 	tsk->thread.lr = (unsigned long)ret_from_fork;
 	return 0;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	/* M32R_FIXME */
 }
 /*
  * Capture the user space registers if the task is not running (in user space)
  */
 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
 {
 	/* M32R_FIXME */
 	return 1;
 }
 asmlinkage int sys_fork(unsigned long r0, unsigned long r1, unsigned long r2,
 	unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
 	struct pt_regs regs)
 {
 #ifdef CONFIG_MMU
 	return do_fork(SIGCHLD, regs.spu, &regs, 0, NULL, NULL);
 #else
 	return -EINVAL;
 #endif /* CONFIG_MMU */
 }
 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
 			 unsigned long parent_tidptr,
 			 unsigned long child_tidptr,
 			 unsigned long r4, unsigned long r5, unsigned long r6,
 			 struct pt_regs regs)
 {
 	if (!newsp)
 		newsp = regs.spu;
 	return do_fork(clone_flags, newsp, &regs, 0,
 		       (int __user *)parent_tidptr, (int __user *)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.
  */
 asmlinkage int sys_vfork(unsigned long r0, unsigned long r1, unsigned long r2,
 	unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6,
 	struct pt_regs regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.spu, &regs, 0,
 			NULL, NULL);
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(char __user *ufilename, char __user * __user *uargv,
 			  char __user * __user *uenvp,
 			  unsigned long r3, unsigned long r4, unsigned long r5,
 			  unsigned long r6, struct pt_regs regs)
 {
 	int error;
 	char *filename;
 	filename = getname(ufilename);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, uargv, uenvp, &regs);
 	if (error == 0) {
 		task_lock(current);
 		current->ptrace &= ~PT_DTRACE;
 		task_unlock(current);
 	}
 	putname(filename);
 out:
 	return error;
 }
 /*
  * These bracket the sleeping functions..
  */
 #define first_sched	((unsigned long) scheduling_functions_start_here)
 #define last_sched	((unsigned long) scheduling_functions_end_here)
 unsigned long get_wchan(struct task_struct *p)
 {
 	/* M32R_FIXME */
 	return (0);
 }

arch/m68k/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/m68k/kernel/process.c
  *
  *  Copyright (C) 1995  Hamish Macdonald
  *
  *  68060 fixes by Jesper Skov
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/reboot.h>
 #include <linux/init_task.h>
 #include <linux/mqueue.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/traps.h>
 #include <asm/machdep.h>
 #include <asm/setup.h>
 #include <asm/pgtable.h>
 /*
  * Initial task/thread structure. Make this a per-architecture thing,
  * because different architectures tend to have different
  * alignment requirements and potentially different initial
  * setup.
  */
 static struct fs_struct init_fs = INIT_FS;
 static struct files_struct init_files = INIT_FILES;
 static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
 static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
 struct mm_struct init_mm = INIT_MM(init_mm);
 EXPORT_SYMBOL(init_mm);
 union thread_union init_thread_union
 __attribute__((section(".data.init_task"), aligned(THREAD_SIZE)))
        = { INIT_THREAD_INFO(init_task) };
 /* initial task structure */
 struct task_struct init_task = INIT_TASK(init_task);
 EXPORT_SYMBOL(init_task);
 asmlinkage void ret_from_fork(void);
 /*
  * Return saved PC from a blocked thread
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	struct switch_stack *sw = (struct switch_stack *)tsk->thread.ksp;
 	/* Check whether the thread is blocked in resume() */
 	if (in_sched_functions(sw->retpc))
 		return ((unsigned long *)sw->a6)[1];
 	else
 		return sw->retpc;
 }
 /*
  * The idle loop on an m68k..
  */
 void default_idle(void)
 {
 	if (!need_resched())
 #if defined(MACH_ATARI_ONLY) && !defined(CONFIG_HADES)
 		/* block out HSYNC on the atari (falcon) */
 		__asm__("stop #0x2200" : : : "cc");
 #else
 		__asm__("stop #0x2000" : : : "cc");
 #endif
 }
 void (*idle)(void) = default_idle;
 /*
  * 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)
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		while (!need_resched())
 			idle();
 		schedule();
 	}
 }
 void machine_restart(char * __unused)
 {
 	if (mach_reset)
 		mach_reset();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	if (mach_halt)
 		mach_halt();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	if (mach_power_off)
 		mach_power_off();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_power_off);
 void show_regs(struct pt_regs * regs)
 {
 	printk("\n");
 	printk("Format %02x  Vector: %04x  PC: %08lx  Status: %04x    %s\n",
 	       regs->format, regs->vector, regs->pc, regs->sr, print_tainted());
 	printk("ORIG_D0: %08lx  D0: %08lx  A2: %08lx  A1: %08lx\n",
 	       regs->orig_d0, regs->d0, regs->a2, regs->a1);
 	printk("A0: %08lx  D5: %08lx  D4: %08lx\n",
 	       regs->a0, regs->d5, regs->d4);
 	printk("D3: %08lx  D2: %08lx  D1: %08lx\n",
 	       regs->d3, regs->d2, regs->d1);
 	if (!(regs->sr & PS_S))
 		printk("USP: %08lx\n", rdusp());
 }
 /*
  * Create a kernel thread
  */
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	int pid;
 	mm_segment_t fs;
 	fs = get_fs();
 	set_fs (KERNEL_DS);
 	{
 	register long retval __asm__ ("d0");
 	register long clone_arg __asm__ ("d1") = flags | CLONE_VM | CLONE_UNTRACED;
 	retval = __NR_clone;
 	__asm__ __volatile__
 	  ("clrl %%d2\n\t"
 	   "trap #0\n\t"		/* Linux/m68k system call */
 	   "tstl %0\n\t"		/* child or parent */
 	   "jne 1f\n\t"			/* parent - jump */
 	   "lea %%sp@(%c7),%6\n\t"	/* reload current */
 	   "movel %6@,%6\n\t"
 	   "movel %3,%%sp@-\n\t"	/* push argument */
 	   "jsr %4@\n\t"		/* call fn */
 	   "movel %0,%%d1\n\t"		/* pass exit value */
 	   "movel %2,%%d0\n\t"		/* exit */
 	   "trap #0\n"
 	   "1:"
 	   : "+d" (retval)
 	   : "i" (__NR_clone), "i" (__NR_exit),
 	     "r" (arg), "a" (fn), "d" (clone_arg), "r" (current),
 	     "i" (-THREAD_SIZE)
 	   : "d2");
 	pid = retval;
 	}
 	set_fs (fs);
 	return pid;
 }
 void flush_thread(void)
 {
 	unsigned long zero = 0;
 	set_fs(USER_DS);
 	current->thread.fs = __USER_DS;
 	if (!FPU_IS_EMU)
 		asm volatile (".chip 68k/68881\n\t"
 			      "frestore %0@\n\t"
 			      ".chip 68k" : : "a" (&zero));
 }
 /*
  * "m68k_fork()".. By the time we get here, the
  * non-volatile registers have also been saved on the
  * stack. We do some ugly pointer stuff here.. (see
  * also copy_thread)
  */
 asmlinkage int m68k_fork(struct pt_regs *regs)
 {
 	return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
 }
 asmlinkage int m68k_vfork(struct pt_regs *regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0,
 		       NULL, NULL);
 }
 asmlinkage int m68k_clone(struct pt_regs *regs)
 {
 	unsigned long clone_flags;
 	unsigned long newsp;
 	int *parent_tidptr, *child_tidptr;
 	/* syscall2 puts clone_flags in d1 and usp in d2 */
 	clone_flags = regs->d1;
 	newsp = regs->d2;
 	parent_tidptr = (int *)regs->d3;
 	child_tidptr = (int *)regs->d4;
 	if (!newsp)
 		newsp = rdusp();
 	return do_fork(clone_flags, newsp, regs, 0,
 		       parent_tidptr, child_tidptr);
 }
 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 		 unsigned long unused,
 		 struct task_struct * p, struct pt_regs * regs)
 {
 	struct pt_regs * childregs;
 	struct switch_stack * childstack, *stack;
 	unsigned long stack_offset, *retp;
 	stack_offset = THREAD_SIZE - sizeof(struct pt_regs);
 	childregs = (struct pt_regs *) ((unsigned long) (p->thread_info) + stack_offset);
 	*childregs = *regs;
 	childregs->d0 = 0;
 	retp = ((unsigned long *) regs);
 	stack = ((struct switch_stack *) retp) - 1;
 	childstack = ((struct switch_stack *) childregs) - 1;
 	*childstack = *stack;
 	childstack->retpc = (unsigned long)ret_from_fork;
 	p->thread.usp = usp;
 	p->thread.ksp = (unsigned long)childstack;
 	/*
 	 * Must save the current SFC/DFC value, NOT the value when
 	 * the parent was last descheduled - RGH  10-08-96
 	 */
 	p->thread.fs = get_fs().seg;
 	if (!FPU_IS_EMU) {
 		/* Copy the current fpu state */
 		asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory");
 		if (!CPU_IS_060 ? p->thread.fpstate[0] : p->thread.fpstate[2])
 		  asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t"
 				"fmoveml %/fpiar/%/fpcr/%/fpsr,%1"
 				: : "m" (p->thread.fp[0]), "m" (p->thread.fpcntl[0])
 				: "memory");
 		/* Restore the state in case the fpu was busy */
 		asm volatile ("frestore %0" : : "m" (p->thread.fpstate[0]));
 	}
 	return 0;
 }
 /* Fill in the fpu structure for a core dump.  */
 int dump_fpu (struct pt_regs *regs, struct user_m68kfp_struct *fpu)
 {
 	char fpustate[216];
 	if (FPU_IS_EMU) {
 		int i;
 		memcpy(fpu->fpcntl, current->thread.fpcntl, 12);
 		memcpy(fpu->fpregs, current->thread.fp, 96);
 		/* Convert internal fpu reg representation
 		 * into long double format
 		 */
 		for (i = 0; i < 24; i += 3)
 			fpu->fpregs[i] = ((fpu->fpregs[i] & 0xffff0000) << 15) |
 			                 ((fpu->fpregs[i] & 0x0000ffff) << 16);
 		return 1;
 	}
 	/* First dump the fpu context to avoid protocol violation.  */
 	asm volatile ("fsave %0" :: "m" (fpustate[0]) : "memory");
 	if (!CPU_IS_060 ? !fpustate[0] : !fpustate[2])
 		return 0;
 	asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0"
 		:: "m" (fpu->fpcntl[0])
 		: "memory");
 	asm volatile ("fmovemx %/fp0-%/fp7,%0"
 		:: "m" (fpu->fpregs[0])
 		: "memory");
 	return 1;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	struct switch_stack *sw;
 /* changed the size calculations - should hopefully work better. lbt */
 	dump->magic = CMAGIC;
 	dump->start_code = 0;
 	dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
 	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
 	dump->u_dsize = ((unsigned long) (current->mm->brk +
 					  (PAGE_SIZE-1))) >> PAGE_SHIFT;
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_ssize = 0;
 	if (dump->start_stack < TASK_SIZE)
 		dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
 	dump->u_ar0 = (struct user_regs_struct *)((int)&dump->regs - (int)dump);
 	sw = ((struct switch_stack *)regs) - 1;
 	dump->regs.d1 = regs->d1;
 	dump->regs.d2 = regs->d2;
 	dump->regs.d3 = regs->d3;
 	dump->regs.d4 = regs->d4;
 	dump->regs.d5 = regs->d5;
 	dump->regs.d6 = sw->d6;
 	dump->regs.d7 = sw->d7;
 	dump->regs.a0 = regs->a0;
 	dump->regs.a1 = regs->a1;
 	dump->regs.a2 = regs->a2;
 	dump->regs.a3 = sw->a3;
 	dump->regs.a4 = sw->a4;
 	dump->regs.a5 = sw->a5;
 	dump->regs.a6 = sw->a6;
 	dump->regs.d0 = regs->d0;
 	dump->regs.orig_d0 = regs->orig_d0;
 	dump->regs.stkadj = regs->stkadj;
 	dump->regs.sr = regs->sr;
 	dump->regs.pc = regs->pc;
 	dump->regs.fmtvec = (regs->format << 12) | regs->vector;
 	/* dump floating point stuff */
 	dump->u_fpvalid = dump_fpu (regs, &dump->m68kfp);
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(char *name, char **argv, char **envp)
 {
 	int error;
 	char * filename;
 	struct pt_regs *regs = (struct pt_regs *) &name;
 	lock_kernel();
 	filename = getname(name);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, argv, envp, regs);
 	putname(filename);
 out:
 	unlock_kernel();
 	return error;
 }
 unsigned long get_wchan(struct task_struct *p)
 {
 	unsigned long fp, pc;
 	unsigned long stack_page;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	stack_page = (unsigned long)(p->thread_info);
 	fp = ((struct switch_stack *)p->thread.ksp)->a6;
 	do {
 		if (fp < stack_page+sizeof(struct thread_info) ||
 		    fp >= 8184+stack_page)
 			return 0;
 		pc = ((unsigned long *)fp)[1];
 		if (!in_sched_functions(pc))
 			return pc;
 		fp = *(unsigned long *) fp;
 	} while (count++ < 16);
 	return 0;
 }

arch/m68knommu/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *  linux/arch/m68knommu/kernel/process.c
  *
  *  Copyright (C) 1995  Hamish Macdonald
  *
  *  68060 fixes by Jesper Skov
  *
  *  uClinux changes
  *  Copyright (C) 2000-2002, David McCullough <davidm@snapgear.com>
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/interrupt.h>
 #include <linux/reboot.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/traps.h>
 #include <asm/machdep.h>
 #include <asm/setup.h>
 #include <asm/pgtable.h>
 asmlinkage void ret_from_fork(void);
 /*
  * The idle loop on an m68knommu..
  */
 void default_idle(void)
 {
 	local_irq_disable();
  	while (!need_resched()) {
 		/* This stop will re-enable interrupts */
  		__asm__("stop #0x2000" : : : "cc");
 		local_irq_disable();
 	}
 	local_irq_enable();
 }
 void (*idle)(void) = default_idle;
 /*
  * 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)
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		idle();
 		preempt_enable_no_resched();
 		schedule();
 		preempt_disable();
 	}
 }
 void machine_restart(char * __unused)
 {
 	if (mach_reset)
 		mach_reset();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	if (mach_halt)
 		mach_halt();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	if (mach_power_off)
 		mach_power_off();
 	for (;;);
 }
-EXPORT_SYMBOL(machine_power_off);
 void show_regs(struct pt_regs * regs)
 {
 	printk(KERN_NOTICE "\n");
 	printk(KERN_NOTICE "Format %02x  Vector: %04x  PC: %08lx  Status: %04x    %s\n",
 	       regs->format, regs->vector, regs->pc, regs->sr, print_tainted());
 	printk(KERN_NOTICE "ORIG_D0: %08lx  D0: %08lx  A2: %08lx  A1: %08lx\n",
 	       regs->orig_d0, regs->d0, regs->a2, regs->a1);
 	printk(KERN_NOTICE "A0: %08lx  D5: %08lx  D4: %08lx\n",
 	       regs->a0, regs->d5, regs->d4);
 	printk(KERN_NOTICE "D3: %08lx  D2: %08lx  D1: %08lx\n",
 	       regs->d3, regs->d2, regs->d1);
 	if (!(regs->sr & PS_S))
 		printk(KERN_NOTICE "USP: %08lx\n", rdusp());
 }
 /*
  * Create a kernel thread
  */
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	int retval;
 	long clone_arg = flags | CLONE_VM;
 	mm_segment_t fs;
 	fs = get_fs();
 	set_fs(KERNEL_DS);
 	__asm__ __volatile__ (
 			"movel	%%sp, %%d2\n\t"
 			"movel	%5, %%d1\n\t"
 			"movel	%1, %%d0\n\t"
 			"trap	#0\n\t"
 			"cmpl	%%sp, %%d2\n\t"
 			"jeq	1f\n\t"
 			"movel	%3, %%sp@-\n\t"
 			"jsr	%4@\n\t"
 			"movel	%2, %%d0\n\t"
 			"trap	#0\n"
 			"1:\n\t"
 			"movel	%%d0, %0\n"
 		: "=d" (retval)
 		: "i" (__NR_clone),
 		  "i" (__NR_exit),
 		  "a" (arg),
 		  "a" (fn),
 		  "a" (clone_arg)
 		: "cc", "%d0", "%d1", "%d2");
 	set_fs(fs);
 	return retval;
 }
 void flush_thread(void)
 {
 #ifdef CONFIG_FPU
 	unsigned long zero = 0;
 #endif
 	set_fs(USER_DS);
 	current->thread.fs = __USER_DS;
 #ifdef CONFIG_FPU
 	if (!FPU_IS_EMU)
 		asm volatile (".chip 68k/68881\n\t"
 			      "frestore %0@\n\t"
 			      ".chip 68k" : : "a" (&zero));
 #endif
 }
 /*
  * "m68k_fork()".. By the time we get here, the
  * non-volatile registers have also been saved on the
  * stack. We do some ugly pointer stuff here.. (see
  * also copy_thread)
  */
 asmlinkage int m68k_fork(struct pt_regs *regs)
 {
 	/* fork almost works, enough to trick you into looking elsewhere :-( */
 	return(-EINVAL);
 }
 asmlinkage int m68k_vfork(struct pt_regs *regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
 }
 asmlinkage int m68k_clone(struct pt_regs *regs)
 {
 	unsigned long clone_flags;
 	unsigned long newsp;
 	/* syscall2 puts clone_flags in d1 and usp in d2 */
 	clone_flags = regs->d1;
 	newsp = regs->d2;
 	if (!newsp)
 		newsp = rdusp();
         return do_fork(clone_flags, newsp, regs, 0, NULL, NULL);
 }
 int copy_thread(int nr, unsigned long clone_flags,
 		unsigned long usp, unsigned long topstk,
 		struct task_struct * p, struct pt_regs * regs)
 {
 	struct pt_regs * childregs;
 	struct switch_stack * childstack, *stack;
 	unsigned long stack_offset, *retp;
 	stack_offset = THREAD_SIZE - sizeof(struct pt_regs);
 	childregs = (struct pt_regs *) ((unsigned long) p->thread_info + stack_offset);
 	*childregs = *regs;
 	childregs->d0 = 0;
 	retp = ((unsigned long *) regs);
 	stack = ((struct switch_stack *) retp) - 1;
 	childstack = ((struct switch_stack *) childregs) - 1;
 	*childstack = *stack;
 	childstack->retpc = (unsigned long)ret_from_fork;
 	p->thread.usp = usp;
 	p->thread.ksp = (unsigned long)childstack;
 	/*
 	 * Must save the current SFC/DFC value, NOT the value when
 	 * the parent was last descheduled - RGH  10-08-96
 	 */
 	p->thread.fs = get_fs().seg;
 #ifdef CONFIG_FPU
 	if (!FPU_IS_EMU) {
 		/* Copy the current fpu state */
 		asm volatile ("fsave %0" : : "m" (p->thread.fpstate[0]) : "memory");
 		if (p->thread.fpstate[0])
 		  asm volatile ("fmovemx %/fp0-%/fp7,%0\n\t"
 				"fmoveml %/fpiar/%/fpcr/%/fpsr,%1"
 				: : "m" (p->thread.fp[0]), "m" (p->thread.fpcntl[0])
 				: "memory");
 		/* Restore the state in case the fpu was busy */
 		asm volatile ("frestore %0" : : "m" (p->thread.fpstate[0]));
 	}
 #endif
 	return 0;
 }
 /* Fill in the fpu structure for a core dump.  */
 int dump_fpu(struct pt_regs *regs, struct user_m68kfp_struct *fpu)
 {
 #ifdef CONFIG_FPU
 	char fpustate[216];
 	if (FPU_IS_EMU) {
 		int i;
 		memcpy(fpu->fpcntl, current->thread.fpcntl, 12);
 		memcpy(fpu->fpregs, current->thread.fp, 96);
 		/* Convert internal fpu reg representation
 		 * into long double format
 		 */
 		for (i = 0; i < 24; i += 3)
 			fpu->fpregs[i] = ((fpu->fpregs[i] & 0xffff0000) << 15) |
 			                 ((fpu->fpregs[i] & 0x0000ffff) << 16);
 		return 1;
 	}
 	/* First dump the fpu context to avoid protocol violation.  */
 	asm volatile ("fsave %0" :: "m" (fpustate[0]) : "memory");
 	if (!fpustate[0])
 		return 0;
 	asm volatile ("fmovem %/fpiar/%/fpcr/%/fpsr,%0"
 		:: "m" (fpu->fpcntl[0])
 		: "memory");
 	asm volatile ("fmovemx %/fp0-%/fp7,%0"
 		:: "m" (fpu->fpregs[0])
 		: "memory");
 #endif
 	return 1;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	struct switch_stack *sw;
 	/* changed the size calculations - should hopefully work better. lbt */
 	dump->magic = CMAGIC;
 	dump->start_code = 0;
 	dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
 	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
 	dump->u_dsize = ((unsigned long) (current->mm->brk +
 					  (PAGE_SIZE-1))) >> PAGE_SHIFT;
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_ssize = 0;
 	if (dump->start_stack < TASK_SIZE)
 		dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
 	dump->u_ar0 = (struct user_regs_struct *)((int)&dump->regs - (int)dump);
 	sw = ((struct switch_stack *)regs) - 1;
 	dump->regs.d1 = regs->d1;
 	dump->regs.d2 = regs->d2;
 	dump->regs.d3 = regs->d3;
 	dump->regs.d4 = regs->d4;
 	dump->regs.d5 = regs->d5;
 	dump->regs.d6 = sw->d6;
 	dump->regs.d7 = sw->d7;
 	dump->regs.a0 = regs->a0;
 	dump->regs.a1 = regs->a1;
 	dump->regs.a2 = regs->a2;
 	dump->regs.a3 = sw->a3;
 	dump->regs.a4 = sw->a4;
 	dump->regs.a5 = sw->a5;
 	dump->regs.a6 = sw->a6;
 	dump->regs.d0 = regs->d0;
 	dump->regs.orig_d0 = regs->orig_d0;
 	dump->regs.stkadj = regs->stkadj;
 	dump->regs.sr = regs->sr;
 	dump->regs.pc = regs->pc;
 	dump->regs.fmtvec = (regs->format << 12) | regs->vector;
 	/* dump floating point stuff */
 	dump->u_fpvalid = dump_fpu (regs, &dump->m68kfp);
 }
 /*
  *	Generic dumping code. Used for panic and debug.
  */
 void dump(struct pt_regs *fp)
 {
 	unsigned long	*sp;
 	unsigned char	*tp;
 	int		i;
 	printk(KERN_EMERG "\nCURRENT PROCESS:\n\n");
 	printk(KERN_EMERG "COMM=%s PID=%d\n", current->comm, current->pid);
 	if (current->mm) {
 		printk(KERN_EMERG "TEXT=%08x-%08x DATA=%08x-%08x BSS=%08x-%08x\n",
 			(int) current->mm->start_code,
 			(int) current->mm->end_code,
 			(int) current->mm->start_data,
 			(int) current->mm->end_data,
 			(int) current->mm->end_data,
 			(int) current->mm->brk);
 		printk(KERN_EMERG "USER-STACK=%08x  KERNEL-STACK=%08x\n\n",
 			(int) current->mm->start_stack,
 			(int)(((unsigned long) current) + THREAD_SIZE));
 	}
 	printk(KERN_EMERG "PC: %08lx\n", fp->pc);
 	printk(KERN_EMERG "SR: %08lx    SP: %08lx\n", (long) fp->sr, (long) fp);
 	printk(KERN_EMERG "d0: %08lx    d1: %08lx    d2: %08lx    d3: %08lx\n",
 		fp->d0, fp->d1, fp->d2, fp->d3);
 	printk(KERN_EMERG "d4: %08lx    d5: %08lx    a0: %08lx    a1: %08lx\n",
 		fp->d4, fp->d5, fp->a0, fp->a1);
 	printk(KERN_EMERG "\nUSP: %08x   TRAPFRAME: %08x\n", (unsigned int) rdusp(),
 		(unsigned int) fp);
 	printk(KERN_EMERG "\nCODE:");
 	tp = ((unsigned char *) fp->pc) - 0x20;
 	for (sp = (unsigned long *) tp, i = 0; (i < 0x40);  i += 4) {
 		if ((i % 0x10) == 0)
 			printk(KERN_EMERG "\n%08x: ", (int) (tp + i));
 		printk(KERN_EMERG "%08x ", (int) *sp++);
 	}
 	printk(KERN_EMERG "\n");
 	printk(KERN_EMERG "\nKERNEL STACK:");
 	tp = ((unsigned char *) fp) - 0x40;
 	for (sp = (unsigned long *) tp, i = 0; (i < 0xc0); i += 4) {
 		if ((i % 0x10) == 0)
 			printk(KERN_EMERG "\n%08x: ", (int) (tp + i));
 		printk(KERN_EMERG "%08x ", (int) *sp++);
 	}
 	printk(KERN_EMERG "\n");
 	printk(KERN_EMERG "\n");
 	printk(KERN_EMERG "\nUSER STACK:");
 	tp = (unsigned char *) (rdusp() - 0x10);
 	for (sp = (unsigned long *) tp, i = 0; (i < 0x80); i += 4) {
 		if ((i % 0x10) == 0)
 			printk(KERN_EMERG "\n%08x: ", (int) (tp + i));
 		printk(KERN_EMERG "%08x ", (int) *sp++);
 	}
 	printk(KERN_EMERG "\n\n");
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(char *name, char **argv, char **envp)
 {
 	int error;
 	char * filename;
 	struct pt_regs *regs = (struct pt_regs *) &name;
 	lock_kernel();
 	filename = getname(name);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, argv, envp, regs);
 	putname(filename);
 out:
 	unlock_kernel();
 	return error;
 }
 unsigned long get_wchan(struct task_struct *p)
 {
 	unsigned long fp, pc;
 	unsigned long stack_page;
 	int count = 0;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	stack_page = (unsigned long)p;
 	fp = ((struct switch_stack *)p->thread.ksp)->a6;
 	do {
 		if (fp < stack_page+sizeof(struct thread_info) ||
 		    fp >= 8184+stack_page)
 			return 0;
 		pc = ((unsigned long *)fp)[1];
 		if (!in_sched_functions(pc))
 			return pc;
 		fp = *(unsigned long *) fp;
 	} while (count++ < 16);
 	return 0;
 }
 /*
  * Return saved PC of a blocked thread.
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	struct switch_stack *sw = (struct switch_stack *)tsk->thread.ksp;
 	/* Check whether the thread is blocked in resume() */
 	if (in_sched_functions(sw->retpc))
 		return ((unsigned long *)sw->a6)[1];
 	else
 		return sw->retpc;
 }

arch/mips/kernel/reset.c

Diff comments View file @ 59586e5

 /*
  * 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) 2001 by Ralf Baechle
  * Copyright (C) 2001 MIPS Technologies, Inc.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/reboot.h>
 #include <asm/reboot.h>
 /*
  * Urgs ...  Too many MIPS machines to handle this in a generic way.
  * So handle all using function pointers to machine specific
  * functions.
  */
 void (*_machine_restart)(char *command);
 void (*_machine_halt)(void);
 void (*_machine_power_off)(void);
 void machine_restart(char *command)
 {
 	_machine_restart(command);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	_machine_halt();
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	_machine_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);

arch/parisc/kernel/process.c

Diff comments View file @ 59586e5

 /*
  *    PARISC Architecture-dependent parts of process handling
  *    based on the work for i386
  *
  *    Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
  *    Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
  *    Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
  *    Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
  *    Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
  *    Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
  *    Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
  *    Copyright (C) 2000 Richard Hirst <rhirst with parisc-lixux.org>
  *    Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
  *    Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
  *    Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
  *    Copyright (C) 2001-2002 Helge Deller <deller at parisc-linux.org>
  *    Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
  *
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
  *    the Free Software Foundation; either version 2 of the License, or
  *    (at your option) any later version.
  *
  *    This program is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *    GNU General Public License for more details.
  *
  *    You should have received a copy of the GNU General Public License
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <stdarg.h>
 #include <linux/elf.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/personality.h>
 #include <linux/ptrace.h>
 #include <linux/sched.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/kallsyms.h>
 #include <asm/io.h>
 #include <asm/offsets.h>
 #include <asm/pdc.h>
 #include <asm/pdc_chassis.h>
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 static int hlt_counter;
 /*
  * Power off function, if any
  */
 void (*pm_power_off)(void);
 void disable_hlt(void)
 {
 	hlt_counter++;
 }
 EXPORT_SYMBOL(disable_hlt);
 void enable_hlt(void)
 {
 	hlt_counter--;
 }
 EXPORT_SYMBOL(enable_hlt);
 void default_idle(void)
 {
 	barrier();
 }
 /*
  * 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)
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		while (!need_resched())
 			barrier();
 		schedule();
 		check_pgt_cache();
 	}
 }
 #ifdef __LP64__
 #define COMMAND_GLOBAL  0xfffffffffffe0030UL
 #else
 #define COMMAND_GLOBAL  0xfffe0030
 #endif
 #define CMD_RESET       5       /* reset any module */
 /*
 ** The Wright Brothers and Gecko systems have a H/W problem
 ** (Lasi...'nuf said) may cause a broadcast reset to lockup
 ** the system. An HVERSION dependent PDC call was developed
 ** to perform a "safe", platform specific broadcast reset instead
 ** of kludging up all the code.
 **
 ** Older machines which do not implement PDC_BROADCAST_RESET will
 ** return (with an error) and the regular broadcast reset can be
 ** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
 ** the PDC call will not return (the system will be reset).
 */
 void machine_restart(char *cmd)
 {
 #ifdef FASTBOOT_SELFTEST_SUPPORT
 	/*
 	 ** If user has modified the Firmware Selftest Bitmap,
 	 ** run the tests specified in the bitmap after the
 	 ** system is rebooted w/PDC_DO_RESET.
 	 **
 	 ** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
 	 **
 	 ** Using "directed resets" at each processor with the MEM_TOC
 	 ** vector cleared will also avoid running destructive
 	 ** memory self tests. (Not implemented yet)
 	 */
 	if (ftc_bitmap) {
 		pdc_do_firm_test_reset(ftc_bitmap);
 	}
 #endif
 	/* set up a new led state on systems shipped with a LED State panel */
 	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
 	/* "Normal" system reset */
 	pdc_do_reset();
 	/* Nope...box should reset with just CMD_RESET now */
 	gsc_writel(CMD_RESET, COMMAND_GLOBAL);
 	/* Wait for RESET to lay us to rest. */
 	while (1) ;
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	/*
 	** The LED/ChassisCodes are updated by the led_halt()
 	** function, called by the reboot notifier chain.
 	*/
 }
-EXPORT_SYMBOL(machine_halt);
 /*
  * This routine is called from sys_reboot to actually turn off the
  * machine
  */
 void machine_power_off(void)
 {
 	/* If there is a registered power off handler, call it. */
 	if(pm_power_off)
 		pm_power_off();
 	/* Put the soft power button back under hardware control.
 	 * If the user had already pressed the power button, the
 	 * following call will immediately power off. */
 	pdc_soft_power_button(0);
 	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
 	/* It seems we have no way to power the system off via
 	 * software. The user has to press the button himself. */
 	printk(KERN_EMERG "System shut down completed.\n"
 	       KERN_EMERG "Please power this system off now.");
 }
-EXPORT_SYMBOL(machine_power_off);
 /*
  * Create a kernel thread
  */
 extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
 	/*
 	 * FIXME: Once we are sure we don't need any debug here,
 	 *	  kernel_thread can become a #define.
 	 */
 	return __kernel_thread(fn, arg, flags);
 }
 EXPORT_SYMBOL(kernel_thread);
 /*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
 {
 }
 void flush_thread(void)
 {
 	/* Only needs to handle fpu stuff or perf monitors.
 	** REVISIT: several arches implement a "lazy fpu state".
 	*/
 	set_fs(USER_DS);
 }
 void release_thread(struct task_struct *dead_task)
 {
 }
 /*
  * Fill in the FPU structure for a core dump.
  */
 int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
 {
 	if (regs == NULL)
 		return 0;
 	memcpy(r, regs->fr, sizeof *r);
 	return 1;
 }
 int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
 {
 	memcpy(r, tsk->thread.regs.fr, sizeof(*r));
 	return 1;
 }
 /* Note that "fork()" is implemented in terms of clone, with
    parameters (SIGCHLD, regs->gr[30], regs). */
 int
 sys_clone(unsigned long clone_flags, unsigned long usp,
 	  struct pt_regs *regs)
 {
 	int __user *user_tid = (int __user *)regs->gr[26];
 	/* usp must be word aligned.  This also prevents users from
 	 * passing in the value 1 (which is the signal for a special
 	 * return for a kernel thread) */
 	usp = ALIGN(usp, 4);
 	/* A zero value for usp means use the current stack */
 	if(usp == 0)
 		usp = regs->gr[30];
 	return do_fork(clone_flags, usp, regs, 0, user_tid, NULL);
 }
 int
 sys_vfork(struct pt_regs *regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
 }
 int
 copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 	    unsigned long unused,	/* in ia64 this is "user_stack_size" */
 	    struct task_struct * p, struct pt_regs * pregs)
 {
 	struct pt_regs * cregs = &(p->thread.regs);
 	struct thread_info *ti = p->thread_info;
 	/* We have to use void * instead of a function pointer, because
 	 * function pointers aren't a pointer to the function on 64-bit.
 	 * Make them const so the compiler knows they live in .text */
 	extern void * const ret_from_kernel_thread;
 	extern void * const child_return;
 #ifdef CONFIG_HPUX
 	extern void * const hpux_child_return;
 #endif
 	*cregs = *pregs;
 	/* Set the return value for the child.  Note that this is not
            actually restored by the syscall exit path, but we put it
            here for consistency in case of signals. */
 	cregs->gr[28] = 0; /* child */
 	/*
 	 * We need to differentiate between a user fork and a
 	 * kernel fork. We can't use user_mode, because the
 	 * the syscall path doesn't save iaoq. Right now
 	 * We rely on the fact that kernel_thread passes
 	 * in zero for usp.
 	 */
 	if (usp == 1) {
 		/* kernel thread */
 		cregs->ksp = (((unsigned long)(ti)) + THREAD_SZ_ALGN);
 		/* Must exit via ret_from_kernel_thread in order
 		 * to call schedule_tail()
 		 */
 		cregs->kpc = (unsigned long) &ret_from_kernel_thread;
 		/*
 		 * Copy function and argument to be called from
 		 * ret_from_kernel_thread.
 		 */
 #ifdef __LP64__
 		cregs->gr[27] = pregs->gr[27];
 #endif
 		cregs->gr[26] = pregs->gr[26];
 		cregs->gr[25] = pregs->gr[25];
 	} else {
 		/* user thread */
 		/*
 		 * Note that the fork wrappers are responsible
 		 * for setting gr[21].
 		 */
 		/* Use same stack depth as parent */
 		cregs->ksp = ((unsigned long)(ti))
 			+ (pregs->gr[21] & (THREAD_SIZE - 1));
 		cregs->gr[30] = usp;
 		if (p->personality == PER_HPUX) {
 #ifdef CONFIG_HPUX
 			cregs->kpc = (unsigned long) &hpux_child_return;
 #else
 			BUG();
 #endif
 		} else {
 			cregs->kpc = (unsigned long) &child_return;
 		}
 	}
 	return 0;
 }
 unsigned long thread_saved_pc(struct task_struct *t)
 {
 	return t->thread.regs.kpc;
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(struct pt_regs *regs)
 {
 	int error;
 	char *filename;
 	filename = getname((const char __user *) regs->gr[26]);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename, (char __user **) regs->gr[25],
 		(char __user **) regs->gr[24], regs);
 	if (error == 0) {
 		task_lock(current);
 		current->ptrace &= ~PT_DTRACE;
 		task_unlock(current);
 	}
 	putname(filename);
 out:
 	return error;
 }
 unsigned long
 get_wchan(struct task_struct *p)
 {
 	struct unwind_frame_info info;
 	unsigned long ip;
 	int count = 0;
 	/*
 	 * These bracket the sleeping functions..
 	 */
 	unwind_frame_init_from_blocked_task(&info, p);
 	do {
 		if (unwind_once(&info) < 0)
 			return 0;
 		ip = info.ip;
 		if (!in_sched_functions(ip))
 			return ip;
 	} while (count++ < 16);
 	return 0;
 }

arch/ppc/kernel/setup.c

Diff comments View file @ 59586e5

 /*
  * Common prep/pmac/chrp boot and setup code.
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/tty.h>
 #include <linux/bootmem.h>
 #include <linux/seq_file.h>
 #include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/console.h>
 #include <asm/residual.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/bootinfo.h>
 #include <asm/setup.h>
 #include <asm/amigappc.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/cputable.h>
 #include <asm/bootx.h>
 #include <asm/btext.h>
 #include <asm/machdep.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/pmac_feature.h>
 #include <asm/sections.h>
 #include <asm/nvram.h>
 #include <asm/xmon.h>
 #include <asm/ocp.h>
 #if defined(CONFIG_85xx) || defined(CONFIG_83xx) || defined(CONFIG_MPC10X_BRIDGE)
 #include <asm/ppc_sys.h>
 #endif
 #if defined CONFIG_KGDB
 #include <asm/kgdb.h>
 #endif
 extern void platform_init(unsigned long r3, unsigned long r4,
 		unsigned long r5, unsigned long r6, unsigned long r7);
 extern void bootx_init(unsigned long r4, unsigned long phys);
 extern void identify_cpu(unsigned long offset, unsigned long cpu);
 extern void do_cpu_ftr_fixups(unsigned long offset);
 extern void reloc_got2(unsigned long offset);
 extern void ppc6xx_idle(void);
 extern void power4_idle(void);
 extern boot_infos_t *boot_infos;
 struct ide_machdep_calls ppc_ide_md;
 /* Used with the BI_MEMSIZE bootinfo parameter to store the memory
    size value reported by the boot loader. */
 unsigned long boot_mem_size;
 unsigned long ISA_DMA_THRESHOLD;
 unsigned long DMA_MODE_READ, DMA_MODE_WRITE;
 #ifdef CONFIG_PPC_MULTIPLATFORM
 int _machine = 0;
 extern void prep_init(unsigned long r3, unsigned long r4,
 		unsigned long r5, unsigned long r6, unsigned long r7);
 extern void pmac_init(unsigned long r3, unsigned long r4,
 		unsigned long r5, unsigned long r6, unsigned long r7);
 extern void chrp_init(unsigned long r3, unsigned long r4,
 		unsigned long r5, unsigned long r6, unsigned long r7);
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY = 0x54;
 #endif /* CONFIG_MAGIC_SYSRQ */
 #ifdef CONFIG_VGA_CONSOLE
 unsigned long vgacon_remap_base;
 #endif
 struct machdep_calls ppc_md;
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_FB_VGA16) || \
     defined(CONFIG_FB_VGA16_MODULE) || defined(CONFIG_FB_VESA)
 struct screen_info screen_info = {
 	0, 25,			/* orig-x, orig-y */
 	0,			/* unused */
 	0,			/* orig-video-page */
 	0,			/* orig-video-mode */
 	80,			/* orig-video-cols */
 	0,0,0,			/* ega_ax, ega_bx, ega_cx */
 	25,			/* orig-video-lines */
 	1,			/* orig-video-isVGA */
 	16			/* orig-video-points */
 };
 #endif /* CONFIG_VGA_CONSOLE || CONFIG_FB_VGA16 || CONFIG_FB_VESA */
 void machine_restart(char *cmd)
 {
 #ifdef CONFIG_NVRAM
 	nvram_sync();
 #endif
 	ppc_md.restart(cmd);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off(void)
 {
 #ifdef CONFIG_NVRAM
 	nvram_sync();
 #endif
 	ppc_md.power_off();
 }
-EXPORT_SYMBOL(machine_power_off);
 void machine_halt(void)
 {
 #ifdef CONFIG_NVRAM
 	nvram_sync();
 #endif
 	ppc_md.halt();
 }
-EXPORT_SYMBOL(machine_halt);
 void (*pm_power_off)(void) = machine_power_off;
 #ifdef CONFIG_TAU
 extern u32 cpu_temp(unsigned long cpu);
 extern u32 cpu_temp_both(unsigned long cpu);
 #endif /* CONFIG_TAU */
 int show_cpuinfo(struct seq_file *m, void *v)
 {
 	int i = (int) v - 1;
 	int err = 0;
 	unsigned int pvr;
 	unsigned short maj, min;
 	unsigned long lpj;
 	if (i >= NR_CPUS) {
 		/* Show summary information */
 #ifdef CONFIG_SMP
 		unsigned long bogosum = 0;
 		for (i = 0; i < NR_CPUS; ++i)
 			if (cpu_online(i))
 				bogosum += cpu_data[i].loops_per_jiffy;
 		seq_printf(m, "total bogomips\t: %lu.%02lu\n",
 			   bogosum/(500000/HZ), bogosum/(5000/HZ) % 100);
 #endif /* CONFIG_SMP */
 		if (ppc_md.show_cpuinfo != NULL)
 			err = ppc_md.show_cpuinfo(m);
 		return err;
 	}
 #ifdef CONFIG_SMP
 	if (!cpu_online(i))
 		return 0;
 	pvr = cpu_data[i].pvr;
 	lpj = cpu_data[i].loops_per_jiffy;
 #else
 	pvr = mfspr(SPRN_PVR);
 	lpj = loops_per_jiffy;
 #endif
 	seq_printf(m, "processor\t: %d\n", i);
 	seq_printf(m, "cpu\t\t: ");
 	if (cur_cpu_spec[i]->pvr_mask)
 		seq_printf(m, "%s", cur_cpu_spec[i]->cpu_name);
 	else
 		seq_printf(m, "unknown (%08x)", pvr);
 #ifdef CONFIG_ALTIVEC
 	if (cur_cpu_spec[i]->cpu_features & CPU_FTR_ALTIVEC)
 		seq_printf(m, ", altivec supported");
 #endif
 	seq_printf(m, "\n");
 #ifdef CONFIG_TAU
 	if (cur_cpu_spec[i]->cpu_features & CPU_FTR_TAU) {
 #ifdef CONFIG_TAU_AVERAGE
 		/* more straightforward, but potentially misleading */
 		seq_printf(m,  "temperature \t: %u C (uncalibrated)\n",
 			   cpu_temp(i));
 #else
 		/* show the actual temp sensor range */
 		u32 temp;
 		temp = cpu_temp_both(i);
 		seq_printf(m, "temperature \t: %u-%u C (uncalibrated)\n",
 			   temp & 0xff, temp >> 16);
 #endif
 	}
 #endif /* CONFIG_TAU */
 	if (ppc_md.show_percpuinfo != NULL) {
 		err = ppc_md.show_percpuinfo(m, i);
 		if (err)
 			return err;
 	}
 	/* If we are a Freescale core do a simple check so
 	 * we dont have to keep adding cases in the future */
 	if ((PVR_VER(pvr) & 0x8000) == 0x8000) {
 		maj = PVR_MAJ(pvr);
 		min = PVR_MIN(pvr);
 	} else {
 		switch (PVR_VER(pvr)) {
 			case 0x0020:	/* 403 family */
 				maj = PVR_MAJ(pvr) + 1;
 				min = PVR_MIN(pvr);
 				break;
 			case 0x1008:	/* 740P/750P ?? */
 				maj = ((pvr >> 8) & 0xFF) - 1;
 				min = pvr & 0xFF;
 				break;
 			default:
 				maj = (pvr >> 8) & 0xFF;
 				min = pvr & 0xFF;
 				break;
 		}
 	}
 	seq_printf(m, "revision\t: %hd.%hd (pvr %04x %04x)\n",
 		   maj, min, PVR_VER(pvr), PVR_REV(pvr));
 	seq_printf(m, "bogomips\t: %lu.%02lu\n",
 		   lpj / (500000/HZ), (lpj / (5000/HZ)) % 100);
 #if defined(CONFIG_85xx) || defined(CONFIG_83xx) || defined(CONFIG_MPC10X_BRIDGE)
 	if (cur_ppc_sys_spec->ppc_sys_name)
 		seq_printf(m, "chipset\t\t: %s\n",
 			cur_ppc_sys_spec->ppc_sys_name);
 #endif
 #ifdef CONFIG_SMP
 	seq_printf(m, "\n");
 #endif
 	return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	int i = *pos;
 	return i <= NR_CPUS? (void *) (i + 1): NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 struct seq_operations cpuinfo_op = {
 	.start =c_start,
 	.next =	c_next,
 	.stop =	c_stop,
 	.show =	show_cpuinfo,
 };
 /*
  * We're called here very early in the boot.  We determine the machine
  * type and call the appropriate low-level setup functions.
  *  -- Cort <cort@fsmlabs.com>
  *
  * Note that the kernel may be running at an address which is different
  * from the address that it was linked at, so we must use RELOC/PTRRELOC
  * to access static data (including strings).  -- paulus
  */
 __init
 unsigned long
 early_init(int r3, int r4, int r5)
 {
  	unsigned long phys;
 	unsigned long offset = reloc_offset();
  	/* Default */
  	phys = offset + KERNELBASE;
 	/* First zero the BSS -- use memset, some arches don't have
 	 * caches on yet */
 	memset_io(PTRRELOC(&__bss_start), 0, _end - __bss_start);
 	/*
 	 * Identify the CPU type and fix up code sections
 	 * that depend on which cpu we have.
 	 */
 	identify_cpu(offset, 0);
 	do_cpu_ftr_fixups(offset);
 #if defined(CONFIG_PPC_MULTIPLATFORM)
 	reloc_got2(offset);
 	/* If we came here from BootX, clear the screen,
 	 * set up some pointers and return. */
 	if ((r3 == 0x426f6f58) && (r5 == 0))
 		bootx_init(r4, phys);
 	/*
 	 * don't do anything on prep
 	 * for now, don't use bootinfo because it breaks yaboot 0.5
 	 * and assume that if we didn't find a magic number, we have OF
 	 */
 	else if (*(unsigned long *)(0) != 0xdeadc0de)
 		phys = prom_init(r3, r4, (prom_entry)r5);
 	reloc_got2(-offset);
 #endif
 	return phys;
 }
 #ifdef CONFIG_PPC_OF
 /*
  * Assume here that all clock rates are the same in a
  * smp system.  -- Cort
  */
 int __openfirmware
 of_show_percpuinfo(struct seq_file *m, int i)
 {
 	struct device_node *cpu_node;
 	u32 *fp;
 	int s;
 	cpu_node = find_type_devices("cpu");
 	if (!cpu_node)
 		return 0;
 	for (s = 0; s < i && cpu_node->next; s++)
 		cpu_node = cpu_node->next;
 	fp = (u32 *)get_property(cpu_node, "clock-frequency", NULL);
 	if (fp)
 		seq_printf(m, "clock\t\t: %dMHz\n", *fp / 1000000);
 	return 0;
 }
 void __init
 intuit_machine_type(void)
 {
 	char *model;
 	struct device_node *root;
 	/* ask the OF info if we're a chrp or pmac */
 	root = find_path_device("/");
 	if (root != 0) {
 		/* assume pmac unless proven to be chrp -- Cort */
 		_machine = _MACH_Pmac;
 		model = get_property(root, "device_type", NULL);
 		if (model && !strncmp("chrp", model, 4))
 			_machine = _MACH_chrp;
 		else {
 			model = get_property(root, "model", NULL);
 			if (model && !strncmp(model, "IBM", 3))
 				_machine = _MACH_chrp;
 		}
 	}
 }
 #endif
 #ifdef CONFIG_PPC_MULTIPLATFORM
 /*
  * The PPC_MULTIPLATFORM version of platform_init...
  */
 void __init
 platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
 	      unsigned long r6, unsigned long r7)
 {
 #ifdef CONFIG_BOOTX_TEXT
 	if (boot_text_mapped) {
 		btext_clearscreen();
 		btext_welcome();
 	}
 #endif
 	parse_bootinfo(find_bootinfo());
 	/* if we didn't get any bootinfo telling us what we are... */
 	if (_machine == 0) {
 		/* prep boot loader tells us if we're prep or not */
 		if ( *(unsigned long *)(KERNELBASE) == (0xdeadc0de) )
 			_machine = _MACH_prep;
 	}
 	/* not much more to do here, if prep */
 	if (_machine == _MACH_prep) {
 		prep_init(r3, r4, r5, r6, r7);
 		return;
 	}
 	/* prom_init has already been called from __start */
 	if (boot_infos)
 		relocate_nodes();
 	/* If we aren't PReP, we can find out if we're Pmac
 	 * or CHRP with this. */
 	if (_machine == 0)
 		intuit_machine_type();
 	/* finish_device_tree may need _machine defined. */
 	finish_device_tree();
 	/*
 	 * If we were booted via quik, r3 points to the physical
 	 * address of the command-line parameters.
 	 * If we were booted from an xcoff image (i.e. netbooted or
 	 * booted from floppy), we get the command line from the
 	 * bootargs property of the /chosen node.
 	 * If an initial ramdisk is present, r3 and r4
 	 * are used for initrd_start and initrd_size,
 	 * otherwise they contain 0xdeadbeef.
 	 */
 	if (r3 >= 0x4000 && r3 < 0x800000 && r4 == 0) {
 		strlcpy(cmd_line, (char *)r3 + KERNELBASE,
 			sizeof(cmd_line));
 	} else if (boot_infos != 0) {
 		/* booted by BootX - check for ramdisk */
 		if (boot_infos->kernelParamsOffset != 0)
 			strlcpy(cmd_line, (char *) boot_infos
 				+ boot_infos->kernelParamsOffset,
 				sizeof(cmd_line));
 #ifdef CONFIG_BLK_DEV_INITRD
 		if (boot_infos->ramDisk) {
 			initrd_start = (unsigned long) boot_infos
 				+ boot_infos->ramDisk;
 			initrd_end = initrd_start + boot_infos->ramDiskSize;
 			initrd_below_start_ok = 1;
 		}
 #endif
 	} else {
 		struct device_node *chosen;
 		char *p;
 #ifdef CONFIG_BLK_DEV_INITRD
 		if (r3 && r4 && r4 != 0xdeadbeef) {
 			if (r3 < KERNELBASE)
 				r3 += KERNELBASE;
 			initrd_start = r3;
 			initrd_end = r3 + r4;
 			ROOT_DEV = Root_RAM0;
 			initrd_below_start_ok = 1;
 		}
 #endif
 		chosen = find_devices("chosen");
 		if (chosen != NULL) {
 			p = get_property(chosen, "bootargs", NULL);
 			if (p && *p) {
 				strlcpy(cmd_line, p, sizeof(cmd_line));
 			}
 		}
 	}
 #ifdef CONFIG_ADB
 	if (strstr(cmd_line, "adb_sync")) {
 		extern int __adb_probe_sync;
 		__adb_probe_sync = 1;
 	}
 #endif /* CONFIG_ADB */
 	switch (_machine) {
 	case _MACH_Pmac:
 		pmac_init(r3, r4, r5, r6, r7);
 		break;
 	case _MACH_chrp:
 		chrp_init(r3, r4, r5, r6, r7);
 		break;
 	}
 }
 #ifdef CONFIG_SERIAL_CORE_CONSOLE
 extern char *of_stdout_device;
 static int __init set_preferred_console(void)
 {
 	struct device_node *prom_stdout;
 	char *name;
 	int offset = 0;
 	if (of_stdout_device == NULL)
 		return -ENODEV;
 	/* The user has requested a console so this is already set up. */
 	if (strstr(saved_command_line, "console="))
 		return -EBUSY;
 	prom_stdout = find_path_device(of_stdout_device);
 	if (!prom_stdout)
 		return -ENODEV;
 	name = (char *)get_property(prom_stdout, "name", NULL);
 	if (!name)
 		return -ENODEV;
 	if (strcmp(name, "serial") == 0) {
 		int i;
 		u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);
 		if (i > 8) {
 			switch (reg[1]) {
 				case 0x3f8:
 					offset = 0;
 					break;
 				case 0x2f8:
 					offset = 1;
 					break;
 				case 0x898:
 					offset = 2;
 					break;
 				case 0x890:
 					offset = 3;
 					break;
 				default:
 					/* We dont recognise the serial port */
 					return -ENODEV;
 			}
 		}
 	} else if (strcmp(name, "ch-a") == 0)
 		offset = 0;
 	else if (strcmp(name, "ch-b") == 0)
 		offset = 1;
 	else
 		return -ENODEV;
 	return add_preferred_console("ttyS", offset, NULL);
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_SERIAL_CORE_CONSOLE */
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 struct bi_record *find_bootinfo(void)
 {
 	struct bi_record *rec;
 	rec = (struct bi_record *)_ALIGN((ulong)__bss_start+(1<<20)-1,(1<<20));
 	if ( rec->tag != BI_FIRST ) {
 		/*
 		 * This 0x10000 offset is a terrible hack but it will go away when
 		 * we have the bootloader handle all the relocation and
 		 * prom calls -- Cort
 		 */
 		rec = (struct bi_record *)_ALIGN((ulong)__bss_start+0x10000+(1<<20)-1,(1<<20));
 		if ( rec->tag != BI_FIRST )
 			return NULL;
 	}
 	return rec;
 }
 void parse_bootinfo(struct bi_record *rec)
 {
 	if (rec == NULL || rec->tag != BI_FIRST)
 		return;
 	while (rec->tag != BI_LAST) {
 		ulong *data = rec->data;
 		switch (rec->tag) {
 		case BI_CMD_LINE:
 			strlcpy(cmd_line, (void *)data, sizeof(cmd_line));
 			break;
 #ifdef CONFIG_BLK_DEV_INITRD
 		case BI_INITRD:
 			initrd_start = data[0] + KERNELBASE;
 			initrd_end = data[0] + data[1] + KERNELBASE;
 			break;
 #endif /* CONFIG_BLK_DEV_INITRD */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 		case BI_MACHTYPE:
 			_machine = data[0];
 			break;
 #endif
 		case BI_MEMSIZE:
 			boot_mem_size = data[0];
 			break;
 		}
 		rec = (struct bi_record *)((ulong)rec + rec->size);
 	}
 }
 /*
  * Find out what kind of machine we're on and save any data we need
  * from the early boot process (devtree is copied on pmac by prom_init()).
  * This is called very early on the boot process, after a minimal
  * MMU environment has been set up but before MMU_init is called.
  */
 void __init
 machine_init(unsigned long r3, unsigned long r4, unsigned long r5,
 	     unsigned long r6, unsigned long r7)
 {
 #ifdef CONFIG_CMDLINE
 	strlcpy(cmd_line, CONFIG_CMDLINE, sizeof(cmd_line));
 #endif /* CONFIG_CMDLINE */
 #ifdef CONFIG_6xx
 	ppc_md.power_save = ppc6xx_idle;
 #endif
 #ifdef CONFIG_POWER4
 	ppc_md.power_save = power4_idle;
 #endif
 	platform_init(r3, r4, r5, r6, r7);
 	if (ppc_md.progress)
 		ppc_md.progress("id mach(): done", 0x200);
 }
 /* Checks "l2cr=xxxx" command-line option */
 int __init ppc_setup_l2cr(char *str)
 {
 	if (cpu_has_feature(CPU_FTR_L2CR)) {
 		unsigned long val = simple_strtoul(str, NULL, 0);
 		printk(KERN_INFO "l2cr set to %lx\n", val);
 		_set_L2CR(0);		/* force invalidate by disable cache */
 		_set_L2CR(val);		/* and enable it */
 	}
 	return 1;
 }
 __setup("l2cr=", ppc_setup_l2cr);
 #ifdef CONFIG_GENERIC_NVRAM
 /* Generic nvram hooks used by drivers/char/gen_nvram.c */
 unsigned char nvram_read_byte(int addr)
 {
 	if (ppc_md.nvram_read_val)
 		return ppc_md.nvram_read_val(addr);
 	return 0xff;
 }
 EXPORT_SYMBOL(nvram_read_byte);
 void nvram_write_byte(unsigned char val, int addr)
 {
 	if (ppc_md.nvram_write_val)
 		ppc_md.nvram_write_val(addr, val);
 }
 EXPORT_SYMBOL(nvram_write_byte);
 void nvram_sync(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 EXPORT_SYMBOL(nvram_sync);
 #endif /* CONFIG_NVRAM */
 static struct cpu cpu_devices[NR_CPUS];
 int __init ppc_init(void)
 {
 	int i;
 	/* clear the progress line */
 	if ( ppc_md.progress ) ppc_md.progress("             ", 0xffff);
 	/* register CPU devices */
 	for (i = 0; i < NR_CPUS; i++)
 		if (cpu_possible(i))
 			register_cpu(&cpu_devices[i], i, NULL);
 	/* call platform init */
 	if (ppc_md.init != NULL) {
 		ppc_md.init();
 	}
 	return 0;
 }
 arch_initcall(ppc_init);
 /* Warning, IO base is not yet inited */
 void __init setup_arch(char **cmdline_p)
 {
 	extern char *klimit;
 	extern void do_init_bootmem(void);
 	/* so udelay does something sensible, assume <= 1000 bogomips */
 	loops_per_jiffy = 500000000 / HZ;
 #ifdef CONFIG_PPC_MULTIPLATFORM
 	/* This could be called "early setup arch", it must be done
 	 * now because xmon need it
 	 */
 	if (_machine == _MACH_Pmac)
 		pmac_feature_init();	/* New cool way */
 #endif
 #ifdef CONFIG_XMON
 	xmon_map_scc();
 	if (strstr(cmd_line, "xmon"))
 		xmon(NULL);
 #endif /* CONFIG_XMON */
 	if ( ppc_md.progress ) ppc_md.progress("setup_arch: enter", 0x3eab);
 #if defined(CONFIG_KGDB)
 	if (ppc_md.kgdb_map_scc)
 		ppc_md.kgdb_map_scc();
 	set_debug_traps();
 	if (strstr(cmd_line, "gdb")) {
 		if (ppc_md.progress)
 			ppc_md.progress("setup_arch: kgdb breakpoint", 0x4000);
 		printk("kgdb breakpoint activated\n");
 		breakpoint();
 	}
 #endif
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	if (cpu_has_feature(CPU_FTR_SPLIT_ID_CACHE)) {
 		dcache_bsize = cur_cpu_spec[0]->dcache_bsize;
 		icache_bsize = cur_cpu_spec[0]->icache_bsize;
 		ucache_bsize = 0;
 	} else
 		ucache_bsize = dcache_bsize = icache_bsize
 			= cur_cpu_spec[0]->dcache_bsize;
 	/* reboot on panic */
 	panic_timeout = 180;
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = (unsigned long) klimit;
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	*cmdline_p = cmd_line;
 	parse_early_param();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	if ( ppc_md.progress ) ppc_md.progress("setup_arch: bootmem", 0x3eab);
 #ifdef CONFIG_PPC_OCP
 	/* Initialize OCP device list */
 	ocp_early_init();
 	if ( ppc_md.progress ) ppc_md.progress("ocp: exit", 0x3eab);
 #endif
 #ifdef CONFIG_DUMMY_CONSOLE
 	conswitchp = &dummy_con;
 #endif
 	ppc_md.setup_arch();
 	if ( ppc_md.progress ) ppc_md.progress("arch: exit", 0x3eab);
 	paging_init();
 	/* this is for modules since _machine can be a define -- Cort */
 	ppc_md.ppc_machine = _machine;
 }

arch/ppc64/kernel/setup.c

Diff comments View file @ 59586e5

 /*
  *
  * Common boot and setup code.
  *
  * Copyright (C) 2001 PPC64 Team, IBM Corp
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #undef DEBUG
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
 #include <linux/version.h>
 #include <linux/tty.h>
 #include <linux/root_dev.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/unistd.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/bootinfo.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
 #include <asm/paca.h>
 #include <asm/ppcdebug.h>
 #include <asm/time.h>
 #include <asm/cputable.h>
 #include <asm/sections.h>
 #include <asm/btext.h>
 #include <asm/nvram.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/rtas.h>
 #include <asm/iommu.h>
 #include <asm/serial.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
 #include <asm/iSeries/ItLpNaca.h>
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
 #else
 #define DBG(fmt...)
 #endif
 /*
  * Here are some early debugging facilities. You can enable one
  * but your kernel will not boot on anything else if you do so
  */
 /* This one is for use on LPAR machines that support an HVC console
  * on vterm 0
  */
 extern void udbg_init_debug_lpar(void);
 /* This one is for use on Apple G5 machines
  */
 extern void udbg_init_pmac_realmode(void);
 /* That's RTAS panel debug */
 extern void call_rtas_display_status_delay(unsigned char c);
 /* Here's maple real mode debug */
 extern void udbg_init_maple_realmode(void);
 #define EARLY_DEBUG_INIT() do {} while(0)
 #if 0
 #define EARLY_DEBUG_INIT() udbg_init_debug_lpar()
 #define EARLY_DEBUG_INIT() udbg_init_maple_realmode()
 #define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()
 #define EARLY_DEBUG_INIT()						\
 	do { ppc_md.udbg_putc = call_rtas_display_status_delay; } while(0)
 #endif
 /* extern void *stab; */
 extern unsigned long klimit;
 extern void mm_init_ppc64(void);
 extern void stab_initialize(unsigned long stab);
 extern void htab_initialize(void);
 extern void early_init_devtree(void *flat_dt);
 extern void unflatten_device_tree(void);
 extern void smp_release_cpus(void);
 int have_of = 1;
 int boot_cpuid = 0;
 int boot_cpuid_phys = 0;
 dev_t boot_dev;
 u64 ppc64_pft_size;
 u64 ppc64_debug_switch;
 struct ppc64_caches ppc64_caches;
 EXPORT_SYMBOL_GPL(ppc64_caches);
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 /* The main machine-dep calls structure
  */
 struct machdep_calls ppc_md;
 EXPORT_SYMBOL(ppc_md);
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block ppc64_panic_block = {
 	.notifier_call = ppc64_panic_event,
 	.priority = INT_MIN /* may not return; must be done last */
 };
 /*
  * Perhaps we can put the pmac screen_info[] here
  * on pmac as well so we don't need the ifdef's.
  * Until we get multiple-console support in here
  * that is.  -- Cort
  * Maybe tie it to serial consoles, since this is really what
  * these processors use on existing boards.  -- Dan
  */
 struct screen_info screen_info = {
 	.orig_x = 0,
 	.orig_y = 25,
 	.orig_video_cols = 80,
 	.orig_video_lines = 25,
 	.orig_video_isVGA = 1,
 	.orig_video_points = 16
 };
 /*
  * Initialize the PPCDBG state.  Called before relocation has been enabled.
  */
 void __init ppcdbg_initialize(void)
 {
 	ppc64_debug_switch = PPC_DEBUG_DEFAULT; /* | PPCDBG_BUSWALK | */
 	/* PPCDBG_PHBINIT | PPCDBG_MM | PPCDBG_MMINIT | PPCDBG_TCEINIT | PPCDBG_TCE */;
 }
 /*
  * Early boot console based on udbg
  */
 static struct console udbg_console = {
 	.name	= "udbg",
 	.write	= udbg_console_write,
 	.flags	= CON_PRINTBUFFER,
 	.index	= -1,
 };
 static int early_console_initialized;
 void __init disable_early_printk(void)
 {
 	if (!early_console_initialized)
 		return;
 	unregister_console(&udbg_console);
 	early_console_initialized = 0;
 }
 #if defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP)
 static int smt_enabled_cmdline;
 /* Look for ibm,smt-enabled OF option */
 static void check_smt_enabled(void)
 {
 	struct device_node *dn;
 	char *smt_option;
 	/* Allow the command line to overrule the OF option */
 	if (smt_enabled_cmdline)
 		return;
 	dn = of_find_node_by_path("/options");
 	if (dn) {
 		smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);
                 if (smt_option) {
 			if (!strcmp(smt_option, "on"))
 				smt_enabled_at_boot = 1;
 			else if (!strcmp(smt_option, "off"))
 				smt_enabled_at_boot = 0;
                 }
         }
 }
 /* Look for smt-enabled= cmdline option */
 static int __init early_smt_enabled(char *p)
 {
 	smt_enabled_cmdline = 1;
 	if (!p)
 		return 0;
 	if (!strcmp(p, "on") || !strcmp(p, "1"))
 		smt_enabled_at_boot = 1;
 	else if (!strcmp(p, "off") || !strcmp(p, "0"))
 		smt_enabled_at_boot = 0;
 	return 0;
 }
 early_param("smt-enabled", early_smt_enabled);
 /**
  * setup_cpu_maps - initialize the following cpu maps:
  *                  cpu_possible_map
  *                  cpu_present_map
  *                  cpu_sibling_map
  *
  * Having the possible map set up early allows us to restrict allocations
  * of things like irqstacks to num_possible_cpus() rather than NR_CPUS.
  *
  * We do not initialize the online map here; cpus set their own bits in
  * cpu_online_map as they come up.
  *
  * This function is valid only for Open Firmware systems.  finish_device_tree
  * must be called before using this.
  *
  * While we're here, we may as well set the "physical" cpu ids in the paca.
  */
 static void __init setup_cpu_maps(void)
 {
 	struct device_node *dn = NULL;
 	int cpu = 0;
 	int swap_cpuid = 0;
 	check_smt_enabled();
 	while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {
 		u32 *intserv;
 		int j, len = sizeof(u32), nthreads;
 		intserv = (u32 *)get_property(dn, "ibm,ppc-interrupt-server#s",
 					      &len);
 		if (!intserv)
 			intserv = (u32 *)get_property(dn, "reg", NULL);
 		nthreads = len / sizeof(u32);
 		for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {
 			cpu_set(cpu, cpu_present_map);
 			set_hard_smp_processor_id(cpu, intserv[j]);
 			if (intserv[j] == boot_cpuid_phys)
 				swap_cpuid = cpu;
 			cpu_set(cpu, cpu_possible_map);
 			cpu++;
 		}
 	}
 	/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that
 	 * boot cpu is logical 0.
 	 */
 	if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {
 		u32 tmp;
 		tmp = get_hard_smp_processor_id(0);
 		set_hard_smp_processor_id(0, boot_cpuid_phys);
 		set_hard_smp_processor_id(swap_cpuid, tmp);
 	}
 	/*
 	 * On pSeries LPAR, we need to know how many cpus
 	 * could possibly be added to this partition.
 	 */
 	if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&
 				(dn = of_find_node_by_path("/rtas"))) {
 		int num_addr_cell, num_size_cell, maxcpus;
 		unsigned int *ireg;
 		num_addr_cell = prom_n_addr_cells(dn);
 		num_size_cell = prom_n_size_cells(dn);
 		ireg = (unsigned int *)
 			get_property(dn, "ibm,lrdr-capacity", NULL);
 		if (!ireg)
 			goto out;
 		maxcpus = ireg[num_addr_cell + num_size_cell];
 		/* Double maxcpus for processors which have SMT capability */
 		if (cpu_has_feature(CPU_FTR_SMT))
 			maxcpus *= 2;
 		if (maxcpus > NR_CPUS) {
 			printk(KERN_WARNING
 			       "Partition configured for %d cpus, "
 			       "operating system maximum is %d.\n",
 			       maxcpus, NR_CPUS);
 			maxcpus = NR_CPUS;
 		} else
 			printk(KERN_INFO "Partition configured for %d cpus.\n",
 			       maxcpus);
 		for (cpu = 0; cpu < maxcpus; cpu++)
 			cpu_set(cpu, cpu_possible_map);
 	out:
 		of_node_put(dn);
 	}
 	/*
 	 * Do the sibling map; assume only two threads per processor.
 	 */
 	for_each_cpu(cpu) {
 		cpu_set(cpu, cpu_sibling_map[cpu]);
 		if (cpu_has_feature(CPU_FTR_SMT))
 			cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);
 	}
 	systemcfg->processorCount = num_present_cpus();
 }
 #endif /* defined(CONFIG_PPC_MULTIPLATFORM) && defined(CONFIG_SMP) */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 extern struct machdep_calls pSeries_md;
 extern struct machdep_calls pmac_md;
 extern struct machdep_calls maple_md;
 extern struct machdep_calls bpa_md;
 /* Ultimately, stuff them in an elf section like initcalls... */
 static struct machdep_calls __initdata *machines[] = {
 #ifdef CONFIG_PPC_PSERIES
 	&pSeries_md,
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_PPC_PMAC
 	&pmac_md,
 #endif /* CONFIG_PPC_PMAC */
 #ifdef CONFIG_PPC_MAPLE
 	&maple_md,
 #endif /* CONFIG_PPC_MAPLE */
 #ifdef CONFIG_PPC_BPA
 	&bpa_md,
 #endif
 	NULL
 };
 /*
  * Early initialization entry point. This is called by head.S
  * with MMU translation disabled. We rely on the "feature" of
  * the CPU that ignores the top 2 bits of the address in real
  * mode so we can access kernel globals normally provided we
  * only toy with things in the RMO region. From here, we do
  * some early parsing of the device-tree to setup out LMB
  * data structures, and allocate & initialize the hash table
  * and segment tables so we can start running with translation
  * enabled.
  *
  * It is this function which will call the probe() callback of
  * the various platform types and copy the matching one to the
  * global ppc_md structure. Your platform can eventually do
  * some very early initializations from the probe() routine, but
  * this is not recommended, be very careful as, for example, the
  * device-tree is not accessible via normal means at this point.
  */
 void __init early_setup(unsigned long dt_ptr)
 {
 	struct paca_struct *lpaca = get_paca();
 	static struct machdep_calls **mach;
 	/*
 	 * Enable early debugging if any specified (see top of
 	 * this file)
 	 */
 	EARLY_DEBUG_INIT();
 	DBG(" -> early_setup()\n");
 	/*
 	 * Fill the default DBG level (do we want to keep
 	 * that old mecanism around forever ?)
 	 */
 	ppcdbg_initialize();
 	/*
 	 * Do early initializations using the flattened device
 	 * tree, like retreiving the physical memory map or
 	 * calculating/retreiving the hash table size
 	 */
 	early_init_devtree(__va(dt_ptr));
 	/*
 	 * Iterate all ppc_md structures until we find the proper
 	 * one for the current machine type
 	 */
 	DBG("Probing machine type for platform %x...\n",
 	    systemcfg->platform);
 	for (mach = machines; *mach; mach++) {
 		if ((*mach)->probe(systemcfg->platform))
 			break;
 	}
 	/* What can we do if we didn't find ? */
 	if (*mach == NULL) {
 		DBG("No suitable machine found !\n");
 		for (;;);
 	}
 	ppc_md = **mach;
 	/* our udbg callbacks got overriden by the above, let's put them
 	 * back in. Ultimately, I want those things to be split from the
 	 * main ppc_md
 	 */
 	EARLY_DEBUG_INIT();
 	DBG("Found, Initializing memory management...\n");
 	/*
 	 * Initialize stab / SLB management
 	 */
 	stab_initialize(lpaca->stab_real);
 	/*
 	 * Initialize the MMU Hash table and create the linear mapping
 	 * of memory
 	 */
 	htab_initialize();
 	DBG(" <- early_setup()\n");
 }
 /*
  * Initialize some remaining members of the ppc64_caches and systemcfg structures
  * (at least until we get rid of them completely). This is mostly some
  * cache informations about the CPU that will be used by cache flush
  * routines and/or provided to userland
  */
 static void __init initialize_cache_info(void)
 {
 	struct device_node *np;
 	unsigned long num_cpus = 0;
 	DBG(" -> initialize_cache_info()\n");
 	for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {
 		num_cpus += 1;
 		/* We're assuming *all* of the CPUs have the same
 		 * d-cache and i-cache sizes... -Peter
 		 */
 		if ( num_cpus == 1 ) {
 			u32 *sizep, *lsizep;
 			u32 size, lsize;
 			const char *dc, *ic;
 			/* Then read cache informations */
 			if (systemcfg->platform == PLATFORM_POWERMAC) {
 				dc = "d-cache-block-size";
 				ic = "i-cache-block-size";
 			} else {
 				dc = "d-cache-line-size";
 				ic = "i-cache-line-size";
 			}
 			size = 0;
 			lsize = cur_cpu_spec->dcache_bsize;
 			sizep = (u32 *)get_property(np, "d-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *) get_property(np, dc, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find dcache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->dcache_size = ppc64_caches.dsize = size;
 			systemcfg->dcache_line_size =
 				ppc64_caches.dline_size = lsize;
 			ppc64_caches.log_dline_size = __ilog2(lsize);
 			ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;
 			size = 0;
 			lsize = cur_cpu_spec->icache_bsize;
 			sizep = (u32 *)get_property(np, "i-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *)get_property(np, ic, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find icache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->icache_size = ppc64_caches.isize = size;
 			systemcfg->icache_line_size =
 				ppc64_caches.iline_size = lsize;
 			ppc64_caches.log_iline_size = __ilog2(lsize);
 			ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;
 		}
 	}
 	/* Add an eye catcher and the systemcfg layout version number */
 	strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");
 	systemcfg->version.major = SYSTEMCFG_MAJOR;
 	systemcfg->version.minor = SYSTEMCFG_MINOR;
 	systemcfg->processor = mfspr(SPRN_PVR);
 	DBG(" <- initialize_cache_info()\n");
 }
 static void __init check_for_initrd(void)
 {
 #ifdef CONFIG_BLK_DEV_INITRD
 	u64 *prop;
 	DBG(" -> check_for_initrd()\n");
 	prop = (u64 *)get_property(of_chosen, "linux,initrd-start", NULL);
 	if (prop != NULL) {
 		initrd_start = (unsigned long)__va(*prop);
 		prop = (u64 *)get_property(of_chosen, "linux,initrd-end", NULL);
 		if (prop != NULL) {
 			initrd_end = (unsigned long)__va(*prop);
 			initrd_below_start_ok = 1;
 		} else
 			initrd_start = 0;
 	}
 	/* If we were passed an initrd, set the ROOT_DEV properly if the values
 	 * look sensible. If not, clear initrd reference.
 	 */
 	if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
 	    initrd_end > initrd_start)
 		ROOT_DEV = Root_RAM0;
 	else
 		initrd_start = initrd_end = 0;
 	if (initrd_start)
 		printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);
 	DBG(" <- check_for_initrd()\n");
 #endif /* CONFIG_BLK_DEV_INITRD */
 }
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 /*
  * Do some initial setup of the system.  The parameters are those which
  * were passed in from the bootloader.
  */
 void __init setup_system(void)
 {
 	DBG(" -> setup_system()\n");
 #ifdef CONFIG_PPC_ISERIES
 	/* pSeries systems are identified in prom.c via OF. */
 	if (itLpNaca.xLparInstalled == 1)
 		systemcfg->platform = PLATFORM_ISERIES_LPAR;
 	ppc_md.init_early();
 #else /* CONFIG_PPC_ISERIES */
 	/*
 	 * Unflatten the device-tree passed by prom_init or kexec
 	 */
 	unflatten_device_tree();
 	/*
 	 * Fill the ppc64_caches & systemcfg structures with informations
 	 * retreived from the device-tree. Need to be called before
 	 * finish_device_tree() since the later requires some of the
 	 * informations filled up here to properly parse the interrupt
 	 * tree.
 	 * It also sets up the cache line sizes which allows to call
 	 * routines like flush_icache_range (used by the hash init
 	 * later on).
 	 */
 	initialize_cache_info();
 #ifdef CONFIG_PPC_RTAS
 	/*
 	 * Initialize RTAS if available
 	 */
 	rtas_initialize();
 #endif /* CONFIG_PPC_RTAS */
 	/*
 	 * Check if we have an initrd provided via the device-tree
 	 */
 	check_for_initrd();
 	/*
 	 * Do some platform specific early initializations, that includes
 	 * setting up the hash table pointers. It also sets up some interrupt-mapping
 	 * related options that will be used by finish_device_tree()
 	 */
 	ppc_md.init_early();
 	/*
 	 * "Finish" the device-tree, that is do the actual parsing of
 	 * some of the properties like the interrupt map
 	 */
 	finish_device_tree();
 	/*
 	 * Initialize xmon
 	 */
 #ifdef CONFIG_XMON_DEFAULT
 	xmon_init();
 #endif
 	/*
 	 * Register early console
 	 */
 	early_console_initialized = 1;
 	register_console(&udbg_console);
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	parse_early_param();
 #endif /* !CONFIG_PPC_ISERIES */
 #if defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES)
 	/*
 	 * iSeries has already initialized the cpu maps at this point.
 	 */
 	setup_cpu_maps();
 	/* Release secondary cpus out of their spinloops at 0x60 now that
 	 * we can map physical -> logical CPU ids
 	 */
 	smp_release_cpus();
 #endif /* defined(CONFIG_SMP) && !defined(CONFIG_PPC_ISERIES) */
 	printk("Starting Linux PPC64 %s\n", UTS_RELEASE);
 	printk("-----------------------------------------------------\n");
 	printk("ppc64_pft_size                = 0x%lx\n", ppc64_pft_size);
 	printk("ppc64_debug_switch            = 0x%lx\n", ppc64_debug_switch);
 	printk("ppc64_interrupt_controller    = 0x%ld\n", ppc64_interrupt_controller);
 	printk("systemcfg                     = 0x%p\n", systemcfg);
 	printk("systemcfg->platform           = 0x%x\n", systemcfg->platform);
 	printk("systemcfg->processorCount     = 0x%lx\n", systemcfg->processorCount);
 	printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);
 	printk("ppc64_caches.dcache_line_size = 0x%x\n",
 			ppc64_caches.dline_size);
 	printk("ppc64_caches.icache_line_size = 0x%x\n",
 			ppc64_caches.iline_size);
 	printk("htab_address                  = 0x%p\n", htab_address);
 	printk("htab_hash_mask                = 0x%lx\n", htab_hash_mask);
 	printk("-----------------------------------------------------\n");
 	mm_init_ppc64();
 	DBG(" <- setup_system()\n");
 }
 /* also used by kexec */
 void machine_shutdown(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 void machine_restart(char *cmd)
 {
 	machine_shutdown();
 	ppc_md.restart(cmd);
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off(void)
 {
 	machine_shutdown();
 	ppc_md.power_off();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
-EXPORT_SYMBOL(machine_power_off);
 void machine_halt(void)
 {
 	machine_shutdown();
 	ppc_md.halt();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
-EXPORT_SYMBOL(machine_halt);
 static int ppc64_panic_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
 	ppc_md.panic((char *)ptr);  /* May not return */
 	return NOTIFY_DONE;
 }
 #ifdef CONFIG_SMP
 DEFINE_PER_CPU(unsigned int, pvr);
 #endif
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
 	unsigned long cpu_id = (unsigned long)v - 1;
 	unsigned int pvr;
 	unsigned short maj;
 	unsigned short min;
 	if (cpu_id == NR_CPUS) {
 		seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);
 		if (ppc_md.get_cpuinfo != NULL)
 			ppc_md.get_cpuinfo(m);
 		return 0;
 	}
 	/* We only show online cpus: disable preempt (overzealous, I
 	 * knew) to prevent cpu going down. */
 	preempt_disable();
 	if (!cpu_online(cpu_id)) {
 		preempt_enable();
 		return 0;
 	}
 #ifdef CONFIG_SMP
 	pvr = per_cpu(pvr, cpu_id);
 #else
 	pvr = mfspr(SPRN_PVR);
 #endif
 	maj = (pvr >> 8) & 0xFF;
 	min = pvr & 0xFF;
 	seq_printf(m, "processor\t: %lu\n", cpu_id);
 	seq_printf(m, "cpu\t\t: ");
 	if (cur_cpu_spec->pvr_mask)
 		seq_printf(m, "%s", cur_cpu_spec->cpu_name);
 	else
 		seq_printf(m, "unknown (%08x)", pvr);
 #ifdef CONFIG_ALTIVEC
 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
 		seq_printf(m, ", altivec supported");
 #endif /* CONFIG_ALTIVEC */
 	seq_printf(m, "\n");
 	/*
 	 * Assume here that all clock rates are the same in a
 	 * smp system.  -- Cort
 	 */
 	seq_printf(m, "clock\t\t: %lu.%06luMHz\n", ppc_proc_freq / 1000000,
 		   ppc_proc_freq % 1000000);
 	seq_printf(m, "revision\t: %hd.%hd\n\n", maj, min);
 	preempt_enable();
 	return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	return *pos <= NR_CPUS ? (void *)((*pos)+1) : NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 struct seq_operations cpuinfo_op = {
 	.start =c_start,
 	.next =	c_next,
 	.stop =	c_stop,
 	.show =	show_cpuinfo,
 };
 /*
  * These three variables are used to save values passed to us by prom_init()
  * via the device tree. The TCE variables are needed because with a memory_limit
  * in force we may need to explicitly map the TCE are at the top of RAM.
  */
 unsigned long memory_limit;
 unsigned long tce_alloc_start;
 unsigned long tce_alloc_end;
 #ifdef CONFIG_PPC_ISERIES
 /*
  * On iSeries we just parse the mem=X option from the command line.
  * On pSeries it's a bit more complicated, see prom_init_mem()
  */
 static int __init early_parsemem(char *p)
 {
 	if (!p)
 		return 0;
 	memory_limit = ALIGN(memparse(p, &p), PAGE_SIZE);
 	return 0;
 }
 early_param("mem", early_parsemem);
 #endif /* CONFIG_PPC_ISERIES */
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static int __init set_preferred_console(void)
 {
 	struct device_node *prom_stdout = NULL;
 	char *name;
 	u32 *spd;
 	int offset = 0;
 	DBG(" -> set_preferred_console()\n");
 	/* The user has requested a console so this is already set up. */
 	if (strstr(saved_command_line, "console=")) {
 		DBG(" console was specified !\n");
 		return -EBUSY;
 	}
 	if (!of_chosen) {
 		DBG(" of_chosen is NULL !\n");
 		return -ENODEV;
 	}
 	/* We are getting a weird phandle from OF ... */
 	/* ... So use the full path instead */
 	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
 	if (name == NULL) {
 		DBG(" no linux,stdout-path !\n");
 		return -ENODEV;
 	}
 	prom_stdout = of_find_node_by_path(name);
 	if (!prom_stdout) {
 		DBG(" can't find stdout package %s !\n", name);
 		return -ENODEV;
 	}
 	DBG("stdout is %s\n", prom_stdout->full_name);
 	name = (char *)get_property(prom_stdout, "name", NULL);
 	if (!name) {
 		DBG(" stdout package has no name !\n");
 		goto not_found;
 	}
 	spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);
 	if (0)
 		;
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 	else if (strcmp(name, "serial") == 0) {
 		int i;
 		u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);
 		if (i > 8) {
 			switch (reg[1]) {
 				case 0x3f8:
 					offset = 0;
 					break;
 				case 0x2f8:
 					offset = 1;
 					break;
 				case 0x898:
 					offset = 2;
 					break;
 				case 0x890:
 					offset = 3;
 					break;
 				default:
 					/* We dont recognise the serial port */
 					goto not_found;
 			}
 		}
 	}
 #endif /* CONFIG_SERIAL_8250_CONSOLE */
 #ifdef CONFIG_PPC_PSERIES
 	else if (strcmp(name, "vty") == 0) {
  		u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);
  		char *compat = (char *)get_property(prom_stdout, "compatible", NULL);
  		if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {
  			/* Host Virtual Serial Interface */
  			int offset;
  			switch (reg[0]) {
  				case 0x30000000:
  					offset = 0;
  					break;
  				case 0x30000001:
  					offset = 1;
  					break;
  				default:
 					goto not_found;
  			}
 			of_node_put(prom_stdout);
 			DBG("Found hvsi console at offset %d\n", offset);
  			return add_preferred_console("hvsi", offset, NULL);
  		} else {
  			/* pSeries LPAR virtual console */
 			of_node_put(prom_stdout);
 			DBG("Found hvc console\n");
  			return add_preferred_console("hvc", 0, NULL);
  		}
 	}
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
 	else if (strcmp(name, "ch-a") == 0)
 		offset = 0;
 	else if (strcmp(name, "ch-b") == 0)
 		offset = 1;
 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
 	else
 		goto not_found;
 	of_node_put(prom_stdout);
 	DBG("Found serial console at ttyS%d\n", offset);
 	if (spd) {
 		static char __initdata opt[16];
 		sprintf(opt, "%d", *spd);
 		return add_preferred_console("ttyS", offset, opt);
 	} else
 		return add_preferred_console("ttyS", offset, NULL);
  not_found:
 	DBG("No preferred console found !\n");
 	of_node_put(prom_stdout);
 	return -ENODEV;
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
 	unsigned int i;
 	/*
 	 * interrupt stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them.
 	 */
 	for_each_cpu(i) {
 		softirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 		hardirq_ctx[i] = (struct thread_info *)__va(lmb_alloc_base(THREAD_SIZE,
 					THREAD_SIZE, 0x10000000));
 	}
 }
 #else
 #define irqstack_early_init()
 #endif
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled.
  */
 static void __init emergency_stack_init(void)
 {
 	unsigned long limit;
 	unsigned int i;
 	/*
 	 * Emergency stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them. The ABI also requires them to be 128-byte
 	 * aligned.
 	 *
 	 * Since we use these as temporary stacks during secondary CPU
 	 * bringup, we need to get at them in real mode. This means they
 	 * must also be within the RMO region.
 	 */
 	limit = min(0x10000000UL, lmb.rmo_size);
 	for_each_cpu(i)
 		paca[i].emergency_sp = __va(lmb_alloc_base(PAGE_SIZE, 128,
 						limit)) + PAGE_SIZE;
 }
 /*
  * Called from setup_arch to initialize the bitmap of available
  * syscalls in the systemcfg page
  */
 void __init setup_syscall_map(void)
 {
 	unsigned int i, count64 = 0, count32 = 0;
 	extern unsigned long *sys_call_table;
 	extern unsigned long *sys_call_table32;
 	extern unsigned long sys_ni_syscall;
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table[i] == sys_ni_syscall)
 			continue;
 		count64++;
 		systemcfg->syscall_map_64[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table32[i] == sys_ni_syscall)
 			continue;
 		count32++;
 		systemcfg->syscall_map_32[i >> 5] |= 0x80000000UL >> (i & 0x1f);
 	}
 	printk(KERN_INFO "Syscall map setup, %d 32 bits and %d 64 bits syscalls\n",
 	       count32, count64);
 }
 /*
  * Called into from start_kernel, after lock_kernel has been called.
  * Initializes bootmem, which is unsed to manage page allocation until
  * mem_init is called.
  */
 void __init setup_arch(char **cmdline_p)
 {
 	extern void do_init_bootmem(void);
 	ppc64_boot_msg(0x12, "Setup Arch");
 	*cmdline_p = cmd_line;
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	dcache_bsize = ppc64_caches.dline_size;
 	icache_bsize = ppc64_caches.iline_size;
 	/* reboot on panic */
 	panic_timeout = 180;
 	if (ppc_md.panic)
 		notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = klimit;
 	irqstack_early_init();
 	emergency_stack_init();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	sparse_init();
 	/* initialize the syscall map in systemcfg */
 	setup_syscall_map();
 	ppc_md.setup_arch();
 	/* Use the default idle loop if the platform hasn't provided one. */
 	if (NULL == ppc_md.idle_loop) {
 		ppc_md.idle_loop = default_idle;
 		printk(KERN_INFO "Using default idle loop\n");
 	}
 	paging_init();
 	ppc64_boot_msg(0x15, "Setup Done");
 }
 /* ToDo: do something useful if ppc_md is not yet setup. */
 #define PPC64_LINUX_FUNCTION 0x0f000000
 #define PPC64_IPL_MESSAGE 0xc0000000
 #define PPC64_TERM_MESSAGE 0xb0000000
 #define PPC64_ATTN_MESSAGE 0xa0000000
 #define PPC64_DUMP_MESSAGE 0xd0000000
 static void ppc64_do_msg(unsigned int src, const char *msg)
 {
 	if (ppc_md.progress) {
 		char buf[128];
 		sprintf(buf, "%08X\n", src);
 		ppc_md.progress(buf, 0);
 		snprintf(buf, 128, "%s", msg);
 		ppc_md.progress(buf, 0);
 	}
 }
 /* Print a boot progress message. */
 void ppc64_boot_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);
 	printk("[boot]%04x %s\n", src, msg);
 }
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);
 	printk("[terminate]%04x %s\n", src, msg);
 }
 /* Print something that needs attention (device error, etc) */
 void ppc64_attention_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_ATTN_MESSAGE|src, msg);
 	printk("[attention]%04x %s\n", src, msg);
 }
 /* Print a dump progress message. */
 void ppc64_dump_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_DUMP_MESSAGE|src, msg);
 	printk("[dump]%04x %s\n", src, msg);
 }
 /* This should only be called on processor 0 during calibrate decr */
 void __init setup_default_decr(void)
 {
 	struct paca_struct *lpaca = get_paca();
 	lpaca->default_decr = tb_ticks_per_jiffy;
 	lpaca->next_jiffy_update_tb = get_tb() + tb_ticks_per_jiffy;
 }
 #ifndef CONFIG_PPC_ISERIES
 /*
  * This function can be used by platforms to "find" legacy serial ports.
  * It works for "serial" nodes under an "isa" node, and will try to
  * respect the "ibm,aix-loc" property if any. It works with up to 8
  * ports.
  */
 #define MAX_LEGACY_SERIAL_PORTS	8
 static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
 static unsigned int old_serial_count;
 void __init generic_find_legacy_serial_ports(u64 *physport,
 		unsigned int *default_speed)
 {
 	struct device_node *np;
 	u32 *sizeprop;
 	struct isa_reg_property {
 		u32 space;
 		u32 address;
 		u32 size;
 	};
 	struct pci_reg_property {
 		struct pci_address addr;
 		u32 size_hi;
 		u32 size_lo;
 	};
 	DBG(" -> generic_find_legacy_serial_port()\n");
 	*physport = 0;
 	if (default_speed)
 		*default_speed = 0;
 	np = of_find_node_by_path("/");
 	if (!np)
 		return;
 	/* First fill our array */
 	for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {
 		struct device_node *isa, *pci;
 		struct isa_reg_property *reg;
 		unsigned long phys_size, addr_size, io_base;
 		u32 *rangesp;
 		u32 *interrupts, *clk, *spd;
 		char *typep;
 		int index, rlen, rentsize;
 		/* Ok, first check if it's under an "isa" parent */
 		isa = of_get_parent(np);
 		if (!isa || strcmp(isa->name, "isa")) {
 			DBG("%s: no isa parent found\n", np->full_name);
 			continue;
 		}
 		/* Now look for an "ibm,aix-loc" property that gives us ordering
 		 * if any...
 		 */
 	 	typep = (char *)get_property(np, "ibm,aix-loc", NULL);
 		/* Get the ISA port number */
 		reg = (struct isa_reg_property *)get_property(np, "reg", NULL);
 		if (reg == NULL)
 			goto next_port;
 		/* We assume the interrupt number isn't translated ... */
 		interrupts = (u32 *)get_property(np, "interrupts", NULL);
 		/* get clock freq. if present */
 		clk = (u32 *)get_property(np, "clock-frequency", NULL);
 		/* get default speed if present */
 		spd = (u32 *)get_property(np, "current-speed", NULL);
 		/* Default to locate at end of array */
 		index = old_serial_count; /* end of the array by default */
 		/* If we have a location index, then use it */
 		if (typep && *typep == 'S') {
 			index = simple_strtol(typep+1, NULL, 0) - 1;
 			/* if index is out of range, use end of array instead */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				index = old_serial_count;
 			/* if our index is still out of range, that mean that
 			 * array is full, we could scan for a free slot but that
 			 * make little sense to bother, just skip the port
 			 */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				goto next_port;
 			if (index >= old_serial_count)
 				old_serial_count = index + 1;
 			/* Check if there is a port who already claimed our slot */
 			if (serial_ports[index].iobase != 0) {
 				/* if we still have some room, move it, else override */
 				if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {
 					DBG("Moved legacy port %d -> %d\n", index,
 					    old_serial_count);
 					serial_ports[old_serial_count++] =
 						serial_ports[index];
 				} else {
 					DBG("Replacing legacy port %d\n", index);
 				}
 			}
 		}
 		if (index >= MAX_LEGACY_SERIAL_PORTS)
 			goto next_port;
 		if (index >= old_serial_count)
 			old_serial_count = index + 1;
 		/* Now fill the entry */
 		memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));
 		serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;
 		serial_ports[index].iobase = reg->address;
 		serial_ports[index].irq = interrupts ? interrupts[0] : 0;
 		serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;
 		DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",
 		    index,
 		    serial_ports[index].iobase,
 		    serial_ports[index].irq,
 		    serial_ports[index].uartclk);
 		/* Get phys address of IO reg for port 1 */
 		if (index != 0)
 			goto next_port;
 		pci = of_get_parent(isa);
 		if (!pci) {
 			DBG("%s: no pci parent found\n", np->full_name);
 			goto next_port;
 		}
 		rangesp = (u32 *)get_property(pci, "ranges", &rlen);
 		if (rangesp == NULL) {
 			of_node_put(pci);
 			goto next_port;
 		}
 		rlen /= 4;
 		/* we need the #size-cells of the PCI bridge node itself */
 		phys_size = 1;
 		sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);
 		if (sizeprop != NULL)
 			phys_size = *sizeprop;
 		/* we need the parent #addr-cells */
 		addr_size = prom_n_addr_cells(pci);
 		rentsize = 3 + addr_size + phys_size;
 		io_base = 0;
 		for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {
 			if (((rangesp[0] >> 24) & 0x3) != 1)
 				continue; /* not IO space */
 			io_base = rangesp[3];
 			if (addr_size == 2)
 				io_base = (io_base << 32) | rangesp[4];
 		}
 		if (io_base != 0) {
 			*physport = io_base + reg->address;
 			if (default_speed && spd)
 				*default_speed = *spd;
 		}
 		of_node_put(pci);
 	next_port:
 		of_node_put(isa);
 	}
 	DBG(" <- generic_find_legacy_serial_port()\n");
 }
 static struct platform_device serial_device = {
 	.name	= "serial8250",
 	.id	= 0,
 	.dev	= {
 		.platform_data = serial_ports,
 	},
 };
 static int __init serial_dev_init(void)
 {
 	return platform_device_register(&serial_device);
 }
 arch_initcall(serial_dev_init);
 #endif /* CONFIG_PPC_ISERIES */
 int check_legacy_ioport(unsigned long base_port)
 {
 	if (ppc_md.check_legacy_ioport == NULL)
 		return 0;
 	return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
 #ifdef CONFIG_XMON
 static int __init early_xmon(char *p)
 {
 	/* ensure xmon is enabled */
 	if (p) {
 		if (strncmp(p, "on", 2) == 0)
 			xmon_init();
 		if (strncmp(p, "early", 5) != 0)
 			return 0;
 	}
 	xmon_init();
 	debugger(NULL);
 	return 0;
 }
 early_param("xmon", early_xmon);
 #endif
 void cpu_die(void)
 {
 	if (ppc_md.cpu_die)
 		ppc_md.cpu_die();
 }

arch/s390/kernel/setup.c

Diff comments View file @ 59586e5

 /*
  *  arch/s390/kernel/setup.c
  *
  *  S390 version
  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  *
  *  Derived from "arch/i386/kernel/setup.c"
  *    Copyright (C) 1995, Linus Torvalds
  */
 /*
  * This file handles the architecture-dependent parts of initialization
  */
 #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/user.h>
 #include <linux/a.out.h>
 #include <linux/tty.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/config.h>
 #include <linux/init.h>
 #include <linux/initrd.h>
 #include <linux/bootmem.h>
 #include <linux/root_dev.h>
 #include <linux/console.h>
 #include <linux/seq_file.h>
 #include <linux/kernel_stat.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/smp.h>
 #include <asm/mmu_context.h>
 #include <asm/cpcmd.h>
 #include <asm/lowcore.h>
 #include <asm/irq.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
 /*
  * Machine setup..
  */
 unsigned int console_mode = 0;
 unsigned int console_devno = -1;
 unsigned int console_irq = -1;
 unsigned long memory_size = 0;
 unsigned long machine_flags = 0;
 struct {
 	unsigned long addr, size, type;
 } memory_chunk[MEMORY_CHUNKS] = { { 0 } };
 #define CHUNK_READ_WRITE 0
 #define CHUNK_READ_ONLY 1
 volatile int __cpu_logical_map[NR_CPUS]; /* logical cpu to cpu address */
 unsigned long __initdata zholes_size[MAX_NR_ZONES];
 static unsigned long __initdata memory_end;
 /*
  * Setup options
  */
 extern int _text,_etext, _edata, _end;
 /*
  * This is set up by the setup-routine at boot-time
  * for S390 need to find out, what we have to setup
  * using address 0x10400 ...
  */
 #include <asm/setup.h>
 static char command_line[COMMAND_LINE_SIZE] = { 0, };
 static struct resource code_resource = {
 	.name  = "Kernel code",
 	.start = (unsigned long) &_text,
 	.end = (unsigned long) &_etext - 1,
 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 static struct resource data_resource = {
 	.name = "Kernel data",
 	.start = (unsigned long) &_etext,
 	.end = (unsigned long) &_edata - 1,
 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 /*
  * cpu_init() initializes state that is per-CPU.
  */
 void __devinit cpu_init (void)
 {
         int addr = hard_smp_processor_id();
         /*
          * Store processor id in lowcore (used e.g. in timer_interrupt)
          */
         asm volatile ("stidp %0": "=m" (S390_lowcore.cpu_data.cpu_id));
         S390_lowcore.cpu_data.cpu_addr = addr;
         /*
          * Force FPU initialization:
          */
         clear_thread_flag(TIF_USEDFPU);
         clear_used_math();
 	atomic_inc(&init_mm.mm_count);
 	current->active_mm = &init_mm;
         if (current->mm)
                 BUG();
         enter_lazy_tlb(&init_mm, current);
 }
 /*
  * VM halt and poweroff setup routines
  */
 char vmhalt_cmd[128] = "";
 char vmpoff_cmd[128] = "";
 static inline void strncpy_skip_quote(char *dst, char *src, int n)
 {
         int sx, dx;
         dx = 0;
         for (sx = 0; src[sx] != 0; sx++) {
                 if (src[sx] == '"') continue;
                 dst[dx++] = src[sx];
                 if (dx >= n) break;
         }
 }
 static int __init vmhalt_setup(char *str)
 {
         strncpy_skip_quote(vmhalt_cmd, str, 127);
         vmhalt_cmd[127] = 0;
         return 1;
 }
 __setup("vmhalt=", vmhalt_setup);
 static int __init vmpoff_setup(char *str)
 {
         strncpy_skip_quote(vmpoff_cmd, str, 127);
         vmpoff_cmd[127] = 0;
         return 1;
 }
 __setup("vmpoff=", vmpoff_setup);
 /*
  * condev= and conmode= setup parameter.
  */
 static int __init condev_setup(char *str)
 {
 	int vdev;
 	vdev = simple_strtoul(str, &str, 0);
 	if (vdev >= 0 && vdev < 65536) {
 		console_devno = vdev;
 		console_irq = -1;
 	}
 	return 1;
 }
 __setup("condev=", condev_setup);
 static int __init conmode_setup(char *str)
 {
 #if defined(CONFIG_SCLP_CONSOLE)
 	if (strncmp(str, "hwc", 4) == 0 || strncmp(str, "sclp", 5) == 0)
                 SET_CONSOLE_SCLP;
 #endif
 #if defined(CONFIG_TN3215_CONSOLE)
 	if (strncmp(str, "3215", 5) == 0)
 		SET_CONSOLE_3215;
 #endif
 #if defined(CONFIG_TN3270_CONSOLE)
 	if (strncmp(str, "3270", 5) == 0)
 		SET_CONSOLE_3270;
 #endif
         return 1;
 }
 __setup("conmode=", conmode_setup);
 static void __init conmode_default(void)
 {
 	char query_buffer[1024];
 	char *ptr;
         if (MACHINE_IS_VM) {
 		__cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);
 		console_devno = simple_strtoul(query_buffer + 5, NULL, 16);
 		ptr = strstr(query_buffer, "SUBCHANNEL =");
 		console_irq = simple_strtoul(ptr + 13, NULL, 16);
 		__cpcmd("QUERY TERM", query_buffer, 1024, NULL);
 		ptr = strstr(query_buffer, "CONMODE");
 		/*
 		 * Set the conmode to 3215 so that the device recognition
 		 * will set the cu_type of the console to 3215. If the
 		 * conmode is 3270 and we don't set it back then both
 		 * 3215 and the 3270 driver will try to access the console
 		 * device (3215 as console and 3270 as normal tty).
 		 */
 		__cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
 		if (ptr == NULL) {
 #if defined(CONFIG_SCLP_CONSOLE)
 			SET_CONSOLE_SCLP;
 #endif
 			return;
 		}
 		if (strncmp(ptr + 8, "3270", 4) == 0) {
 #if defined(CONFIG_TN3270_CONSOLE)
 			SET_CONSOLE_3270;
 #elif defined(CONFIG_TN3215_CONSOLE)
 			SET_CONSOLE_3215;
 #elif defined(CONFIG_SCLP_CONSOLE)
 			SET_CONSOLE_SCLP;
 #endif
 		} else if (strncmp(ptr + 8, "3215", 4) == 0) {
 #if defined(CONFIG_TN3215_CONSOLE)
 			SET_CONSOLE_3215;
 #elif defined(CONFIG_TN3270_CONSOLE)
 			SET_CONSOLE_3270;
 #elif defined(CONFIG_SCLP_CONSOLE)
 			SET_CONSOLE_SCLP;
 #endif
 		}
         } else if (MACHINE_IS_P390) {
 #if defined(CONFIG_TN3215_CONSOLE)
 		SET_CONSOLE_3215;
 #elif defined(CONFIG_TN3270_CONSOLE)
 		SET_CONSOLE_3270;
 #endif
 	} else {
 #if defined(CONFIG_SCLP_CONSOLE)
 		SET_CONSOLE_SCLP;
 #endif
 	}
 }
 #ifdef CONFIG_SMP
 extern void machine_restart_smp(char *);
 extern void machine_halt_smp(void);
 extern void machine_power_off_smp(void);
 void (*_machine_restart)(char *command) = machine_restart_smp;
 void (*_machine_halt)(void) = machine_halt_smp;
 void (*_machine_power_off)(void) = machine_power_off_smp;
 #else
 /*
  * Reboot, halt and power_off routines for non SMP.
  */
 extern void reipl(unsigned long devno);
 static void do_machine_restart_nonsmp(char * __unused)
 {
 	if (MACHINE_IS_VM)
 		cpcmd ("IPL", NULL, 0);
 	else
 		reipl (0x10000 | S390_lowcore.ipl_device);
 }
 static void do_machine_halt_nonsmp(void)
 {
         if (MACHINE_IS_VM && strlen(vmhalt_cmd) > 0)
                 cpcmd(vmhalt_cmd, NULL, 0);
         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 }
 static void do_machine_power_off_nonsmp(void)
 {
         if (MACHINE_IS_VM && strlen(vmpoff_cmd) > 0)
                 cpcmd(vmpoff_cmd, NULL, 0);
         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 }
 void (*_machine_restart)(char *command) = do_machine_restart_nonsmp;
 void (*_machine_halt)(void) = do_machine_halt_nonsmp;
 void (*_machine_power_off)(void) = do_machine_power_off_nonsmp;
 #endif
  /*
  * Reboot, halt and power_off stubs. They just call _machine_restart,
  * _machine_halt or _machine_power_off.
  */
 void machine_restart(char *command)
 {
 	console_unblank();
 	_machine_restart(command);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 	console_unblank();
 	_machine_halt();
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	console_unblank();
 	_machine_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);
 static void __init
 add_memory_hole(unsigned long start, unsigned long end)
 {
 	unsigned long dma_pfn = MAX_DMA_ADDRESS >> PAGE_SHIFT;
 	if (end <= dma_pfn)
 		zholes_size[ZONE_DMA] += end - start + 1;
 	else if (start > dma_pfn)
 		zholes_size[ZONE_NORMAL] += end - start + 1;
 	else {
 		zholes_size[ZONE_DMA] += dma_pfn - start + 1;
 		zholes_size[ZONE_NORMAL] += end - dma_pfn;
 	}
 }
 static void __init
 parse_cmdline_early(char **cmdline_p)
 {
 	char c = ' ', cn, *to = command_line, *from = COMMAND_LINE;
 	unsigned long delay = 0;
 	/* Save unparsed command line copy for /proc/cmdline */
 	memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
 	saved_command_line[COMMAND_LINE_SIZE-1] = '\0';
 	for (;;) {
 		/*
 		 * "mem=XXX[kKmM]" sets memsize
 		 */
 		if (c == ' ' && strncmp(from, "mem=", 4) == 0) {
 			memory_end = simple_strtoul(from+4, &from, 0);
 			if ( *from == 'K' || *from == 'k' ) {
 				memory_end = memory_end << 10;
 				from++;
 			} else if ( *from == 'M' || *from == 'm' ) {
 				memory_end = memory_end << 20;
 				from++;
 			}
 		}
 		/*
 		 * "ipldelay=XXX[sm]" sets ipl delay in seconds or minutes
 		 */
 		if (c == ' ' && strncmp(from, "ipldelay=", 9) == 0) {
 			delay = simple_strtoul(from+9, &from, 0);
 			if (*from == 's' || *from == 'S') {
 				delay = delay*1000000;
 				from++;
 			} else if (*from == 'm' || *from == 'M') {
 				delay = delay*60*1000000;
 				from++;
 			}
 			/* now wait for the requested amount of time */
 			udelay(delay);
 		}
 		cn = *(from++);
 		if (!cn)
 			break;
 		if (cn == '\n')
 			cn = ' ';  /* replace newlines with space */
 		if (cn == 0x0d)
 			cn = ' ';  /* replace 0x0d with space */
 		if (cn == ' ' && c == ' ')
 			continue;  /* remove additional spaces */
 		c = cn;
 		if (to - command_line >= COMMAND_LINE_SIZE)
 			break;
 		*(to++) = c;
 	}
 	if (c == ' ' && to > command_line) to--;
 	*to = '\0';
 	*cmdline_p = command_line;
 }
 static void __init
 setup_lowcore(void)
 {
 	struct _lowcore *lc;
 	int lc_pages;
 	/*
 	 * Setup lowcore for boot cpu
 	 */
 	lc_pages = sizeof(void *) == 8 ? 2 : 1;
 	lc = (struct _lowcore *)
 		__alloc_bootmem(lc_pages * PAGE_SIZE, lc_pages * PAGE_SIZE, 0);
 	memset(lc, 0, lc_pages * PAGE_SIZE);
 	lc->restart_psw.mask = PSW_BASE_BITS | PSW_DEFAULT_KEY;
 	lc->restart_psw.addr =
 		PSW_ADDR_AMODE | (unsigned long) restart_int_handler;
 	lc->external_new_psw.mask = PSW_KERNEL_BITS;
 	lc->external_new_psw.addr =
 		PSW_ADDR_AMODE | (unsigned long) ext_int_handler;
 	lc->svc_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_IO | PSW_MASK_EXT;
 	lc->svc_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) system_call;
 	lc->program_new_psw.mask = PSW_KERNEL_BITS;
 	lc->program_new_psw.addr =
 		PSW_ADDR_AMODE | (unsigned long)pgm_check_handler;
 	lc->mcck_new_psw.mask =
 		PSW_KERNEL_BITS & ~PSW_MASK_MCHECK & ~PSW_MASK_DAT;
 	lc->mcck_new_psw.addr =
 		PSW_ADDR_AMODE | (unsigned long) mcck_int_handler;
 	lc->io_new_psw.mask = PSW_KERNEL_BITS;
 	lc->io_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) io_int_handler;
 	lc->ipl_device = S390_lowcore.ipl_device;
 	lc->jiffy_timer = -1LL;
 	lc->kernel_stack = ((unsigned long) &init_thread_union) + THREAD_SIZE;
 	lc->async_stack = (unsigned long)
 		__alloc_bootmem(ASYNC_SIZE, ASYNC_SIZE, 0) + ASYNC_SIZE;
 	lc->panic_stack = (unsigned long)
 		__alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0) + PAGE_SIZE;
 	lc->current_task = (unsigned long) init_thread_union.thread_info.task;
 	lc->thread_info = (unsigned long) &init_thread_union;
 #ifndef CONFIG_ARCH_S390X
 	if (MACHINE_HAS_IEEE) {
 		lc->extended_save_area_addr = (__u32)
 			__alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0);
 		/* enable extended save area */
 		ctl_set_bit(14, 29);
 	}
 #endif
 #ifdef CONFIG_ARCH_S390X
 	if (MACHINE_HAS_DIAG44)
 		lc->diag44_opcode = 0x83000044;
 	else
 		lc->diag44_opcode = 0x07000700;
 #endif /* CONFIG_ARCH_S390X */
 	set_prefix((u32)(unsigned long) lc);
 }
 static void __init
 setup_resources(void)
 {
 	struct resource *res;
 	int i;
 	for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
 		res = alloc_bootmem_low(sizeof(struct resource));
 		res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
 		switch (memory_chunk[i].type) {
 		case CHUNK_READ_WRITE:
 			res->name = "System RAM";
 			break;
 		case CHUNK_READ_ONLY:
 			res->name = "System ROM";
 			res->flags |= IORESOURCE_READONLY;
 			break;
 		default:
 			res->name = "reserved";
 		}
 		res->start = memory_chunk[i].addr;
 		res->end = memory_chunk[i].addr +  memory_chunk[i].size - 1;
 		request_resource(&iomem_resource, res);
 		request_resource(res, &code_resource);
 		request_resource(res, &data_resource);
 	}
 }
 static void __init
 setup_memory(void)
 {
         unsigned long bootmap_size;
 	unsigned long start_pfn, end_pfn, init_pfn;
 	unsigned long last_rw_end;
 	int i;
 	/*
 	 * partially used pages are not usable - thus
 	 * we are rounding upwards:
 	 */
 	start_pfn = (__pa(&_end) + PAGE_SIZE - 1) >> PAGE_SHIFT;
 	end_pfn = max_pfn = memory_end >> PAGE_SHIFT;
 	/* Initialize storage key for kernel pages */
 	for (init_pfn = 0 ; init_pfn < start_pfn; init_pfn++)
 		page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
 	/*
 	 * Initialize the boot-time allocator (with low memory only):
 	 */
 	bootmap_size = init_bootmem(start_pfn, end_pfn);
 	/*
 	 * Register RAM areas with the bootmem allocator.
 	 */
 	last_rw_end = start_pfn;
 	for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
 		unsigned long start_chunk, end_chunk;
 		if (memory_chunk[i].type != CHUNK_READ_WRITE)
 			continue;
 		start_chunk = (memory_chunk[i].addr + PAGE_SIZE - 1);
 		start_chunk >>= PAGE_SHIFT;
 		end_chunk = (memory_chunk[i].addr + memory_chunk[i].size);
 		end_chunk >>= PAGE_SHIFT;
 		if (start_chunk < start_pfn)
 			start_chunk = start_pfn;
 		if (end_chunk > end_pfn)
 			end_chunk = end_pfn;
 		if (start_chunk < end_chunk) {
 			/* Initialize storage key for RAM pages */
 			for (init_pfn = start_chunk ; init_pfn < end_chunk;
 			     init_pfn++)
 				page_set_storage_key(init_pfn << PAGE_SHIFT,
 						     PAGE_DEFAULT_KEY);
 			free_bootmem(start_chunk << PAGE_SHIFT,
 				     (end_chunk - start_chunk) << PAGE_SHIFT);
 			if (last_rw_end < start_chunk)
 				add_memory_hole(last_rw_end, start_chunk - 1);
 			last_rw_end = end_chunk;
 		}
 	}
 	psw_set_key(PAGE_DEFAULT_KEY);
 	if (last_rw_end < end_pfn - 1)
 		add_memory_hole(last_rw_end, end_pfn - 1);
 	/*
 	 * Reserve the bootmem bitmap itself as well. We do this in two
 	 * steps (first step was init_bootmem()) because this catches
 	 * the (very unlikely) case of us accidentally initializing the
 	 * bootmem allocator with an invalid RAM area.
 	 */
 	reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size);
 #ifdef CONFIG_BLK_DEV_INITRD
 	if (INITRD_START) {
 		if (INITRD_START + INITRD_SIZE <= memory_end) {
 			reserve_bootmem(INITRD_START, INITRD_SIZE);
 			initrd_start = INITRD_START;
 			initrd_end = initrd_start + INITRD_SIZE;
 		} else {
 			printk("initrd extends beyond end of memory "
 			       "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
 			       initrd_start + INITRD_SIZE, memory_end);
 			initrd_start = initrd_end = 0;
 		}
 	}
 #endif
 }
 /*
  * Setup function called from init/main.c just after the banner
  * was printed.
  */
 void __init
 setup_arch(char **cmdline_p)
 {
         /*
          * print what head.S has found out about the machine
          */
 #ifndef CONFIG_ARCH_S390X
 	printk((MACHINE_IS_VM) ?
 	       "We are running under VM (31 bit mode)\n" :
 	       "We are running native (31 bit mode)\n");
 	printk((MACHINE_HAS_IEEE) ?
 	       "This machine has an IEEE fpu\n" :
 	       "This machine has no IEEE fpu\n");
 #else /* CONFIG_ARCH_S390X */
 	printk((MACHINE_IS_VM) ?
 	       "We are running under VM (64 bit mode)\n" :
 	       "We are running native (64 bit mode)\n");
 #endif /* CONFIG_ARCH_S390X */
         ROOT_DEV = Root_RAM0;
 #ifndef CONFIG_ARCH_S390X
 	memory_end = memory_size & ~0x400000UL;  /* align memory end to 4MB */
         /*
          * We need some free virtual space to be able to do vmalloc.
          * On a machine with 2GB memory we make sure that we have at
          * least 128 MB free space for vmalloc.
          */
         if (memory_end > 1920*1024*1024)
                 memory_end = 1920*1024*1024;
 #else /* CONFIG_ARCH_S390X */
 	memory_end = memory_size & ~0x200000UL;  /* detected in head.s */
 #endif /* CONFIG_ARCH_S390X */
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) &_etext;
 	init_mm.end_data = (unsigned long) &_edata;
 	init_mm.brk = (unsigned long) &_end;
 	parse_cmdline_early(cmdline_p);
 	setup_memory();
 	setup_resources();
 	setup_lowcore();
         cpu_init();
         __cpu_logical_map[0] = S390_lowcore.cpu_data.cpu_addr;
 	/*
 	 * Create kernel page tables and switch to virtual addressing.
 	 */
         paging_init();
         /* Setup default console */
 	conmode_default();
 }
 void print_cpu_info(struct cpuinfo_S390 *cpuinfo)
 {
    printk("cpu %d "
 #ifdef CONFIG_SMP
            "phys_idx=%d "
 #endif
            "vers=%02X ident=%06X machine=%04X unused=%04X\n",
            cpuinfo->cpu_nr,
 #ifdef CONFIG_SMP
            cpuinfo->cpu_addr,
 #endif
            cpuinfo->cpu_id.version,
            cpuinfo->cpu_id.ident,
            cpuinfo->cpu_id.machine,
            cpuinfo->cpu_id.unused);
 }
 /*
  * show_cpuinfo - Get information on one CPU for use by procfs.
  */
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
         struct cpuinfo_S390 *cpuinfo;
 	unsigned long n = (unsigned long) v - 1;
 	if (!n) {
 		seq_printf(m, "vendor_id       : IBM/S390\n"
 			       "# processors    : %i\n"
 			       "bogomips per cpu: %lu.%02lu\n",
 			       num_online_cpus(), loops_per_jiffy/(500000/HZ),
 			       (loops_per_jiffy/(5000/HZ))%100);
 	}
 	if (cpu_online(n)) {
 #ifdef CONFIG_SMP
 		if (smp_processor_id() == n)
 			cpuinfo = &S390_lowcore.cpu_data;
 		else
 			cpuinfo = &lowcore_ptr[n]->cpu_data;
 #else
 		cpuinfo = &S390_lowcore.cpu_data;
 #endif
 		seq_printf(m, "processor %li: "
 			       "version = %02X,  "
 			       "identification = %06X,  "
 			       "machine = %04X\n",
 			       n, cpuinfo->cpu_id.version,
 			       cpuinfo->cpu_id.ident,
 			       cpuinfo->cpu_id.machine);
 	}
         return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	return *pos < NR_CPUS ? (void *)((unsigned long) *pos + 1) : NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 struct seq_operations cpuinfo_op = {
 	.start	= c_start,
 	.next	= c_next,
 	.stop	= c_stop,
 	.show	= show_cpuinfo,
 };

arch/sh/kernel/process.c

Diff comments View file @ 59586e5

 /* $Id: process.c,v 1.28 2004/05/05 16:54:23 lethal Exp $
  *
  *  linux/arch/sh/kernel/process.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  *
  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <linux/module.h>
 #include <linux/unistd.h>
 #include <linux/mm.h>
 #include <linux/elfcore.h>
 #include <linux/slab.h>
 #include <linux/a.out.h>
 #include <linux/ptrace.h>
 #include <linux/platform.h>
 #include <linux/kallsyms.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/elf.h>
 #if defined(CONFIG_SH_HS7751RVOIP)
 #include <asm/hs7751rvoip/hs7751rvoip.h>
 #elif defined(CONFIG_SH_RTS7751R2D)
 #include <asm/rts7751r2d/rts7751r2d.h>
 #endif
 static int hlt_counter=0;
 int ubc_usercnt = 0;
 #define HARD_IDLE_TIMEOUT (HZ / 3)
 void disable_hlt(void)
 {
 	hlt_counter++;
 }
 EXPORT_SYMBOL(disable_hlt);
 void enable_hlt(void)
 {
 	hlt_counter--;
 }
 EXPORT_SYMBOL(enable_hlt);
 void default_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	while (1) {
 		if (hlt_counter) {
 			while (1)
 				if (need_resched())
 					break;
 		} else {
 			while (!need_resched())
 				cpu_sleep();
 		}
 		schedule();
 	}
 }
 void cpu_idle(void)
 {
 	default_idle();
 }
 void machine_restart(char * __unused)
 {
 	/* SR.BL=1 and invoke address error to let CPU reset (manual reset) */
 	asm volatile("ldc %0, sr\n\t"
 		     "mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 #if defined(CONFIG_SH_HS7751RVOIP)
 	unsigned short value;
 	value = ctrl_inw(PA_OUTPORTR);
 	ctrl_outw((value & 0xffdf), PA_OUTPORTR);
 #elif defined(CONFIG_SH_RTS7751R2D)
 	ctrl_outw(0x0001, PA_POWOFF);
 #endif
 	while (1)
 		cpu_sleep();
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 #if defined(CONFIG_SH_HS7751RVOIP)
 	unsigned short value;
 	value = ctrl_inw(PA_OUTPORTR);
 	ctrl_outw((value & 0xffdf), PA_OUTPORTR);
 #elif defined(CONFIG_SH_RTS7751R2D)
 	ctrl_outw(0x0001, PA_POWOFF);
 #endif
 }
-EXPORT_SYMBOL(machine_power_off);
 void show_regs(struct pt_regs * regs)
 {
 	printk("\n");
 	printk("Pid : %d, Comm: %20s\n", current->pid, current->comm);
 	print_symbol("PC is at %s\n", regs->pc);
 	printk("PC  : %08lx SP  : %08lx SR  : %08lx ",
 	       regs->pc, regs->regs[15], regs->sr);
 #ifdef CONFIG_MMU
 	printk("TEA : %08x    ", ctrl_inl(MMU_TEA));
 #else
 	printk("                  ");
 #endif
 	printk("%s\n", print_tainted());
 	printk("R0  : %08lx R1  : %08lx R2  : %08lx R3  : %08lx\n",
 	       regs->regs[0],regs->regs[1],
 	       regs->regs[2],regs->regs[3]);
 	printk("R4  : %08lx R5  : %08lx R6  : %08lx R7  : %08lx\n",
 	       regs->regs[4],regs->regs[5],
 	       regs->regs[6],regs->regs[7]);
 	printk("R8  : %08lx R9  : %08lx R10 : %08lx R11 : %08lx\n",
 	       regs->regs[8],regs->regs[9],
 	       regs->regs[10],regs->regs[11]);
 	printk("R12 : %08lx R13 : %08lx R14 : %08lx\n",
 	       regs->regs[12],regs->regs[13],
 	       regs->regs[14]);
 	printk("MACH: %08lx MACL: %08lx GBR : %08lx PR  : %08lx\n",
 	       regs->mach, regs->macl, regs->gbr, regs->pr);
 	/*
 	 * If we're in kernel mode, dump the stack too..
 	 */
 	if (!user_mode(regs)) {
 		extern void show_task(unsigned long *sp);
 		unsigned long sp = regs->regs[15];
 		show_task((unsigned long *)sp);
 	}
 }
 /*
  * Create a kernel thread
  */
 /*
  * This is the mechanism for creating a new kernel thread.
  *
  */
 extern void kernel_thread_helper(void);
 __asm__(".align 5\n"
 	"kernel_thread_helper:\n\t"
 	"jsr	@r5\n\t"
 	" nop\n\t"
 	"mov.l	1f, r1\n\t"
 	"jsr	@r1\n\t"
 	" mov	r0, r4\n\t"
 	".align 2\n\t"
 	"1:.long do_exit");
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {	/* Don't use this in BL=1(cli).  Or else, CPU resets! */
 	struct pt_regs regs;
 	memset(&regs, 0, sizeof(regs));
 	regs.regs[4] = (unsigned long) arg;
 	regs.regs[5] = (unsigned long) fn;
 	regs.pc = (unsigned long) kernel_thread_helper;
 	regs.sr = (1 << 30);
 	/* 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)
 {
 	if (current->thread.ubc_pc) {
 		current->thread.ubc_pc = 0;
 		ubc_usercnt -= 1;
 	}
 }
 void flush_thread(void)
 {
 #if defined(CONFIG_SH_FPU)
 	struct task_struct *tsk = current;
 	struct pt_regs *regs = (struct pt_regs *)
 				((unsigned long)tsk->thread_info
 				 + THREAD_SIZE - sizeof(struct pt_regs)
 				 - sizeof(unsigned long));
 	/* Forget lazy FPU state */
 	clear_fpu(tsk, regs);
 	clear_used_math();
 #endif
 }
 void release_thread(struct task_struct *dead_task)
 {
 	/* do nothing */
 }
 /* Fill in the fpu structure for a core dump.. */
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 {
 	int fpvalid = 0;
 #if defined(CONFIG_SH_FPU)
 	struct task_struct *tsk = current;
 	fpvalid = !!tsk_used_math(tsk);
 	if (fpvalid) {
 		unlazy_fpu(tsk, regs);
 		memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
 	}
 #endif
 	return fpvalid;
 }
 /*
  * Capture the user space registers if the task is not running (in user space)
  */
 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
 {
 	struct pt_regs ptregs;
 	ptregs = *(struct pt_regs *)
 		((unsigned long)tsk->thread_info + THREAD_SIZE
 		 - sizeof(struct pt_regs)
 #ifdef CONFIG_SH_DSP
 		 - sizeof(struct pt_dspregs)
 #endif
 		 - sizeof(unsigned long));
 	elf_core_copy_regs(regs, &ptregs);
 	return 1;
 }
 int
 dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *fpu)
 {
 	int fpvalid = 0;
 #if defined(CONFIG_SH_FPU)
 	fpvalid = !!tsk_used_math(tsk);
 	if (fpvalid) {
 		struct pt_regs *regs = (struct pt_regs *)
 					((unsigned long)tsk->thread_info
 					 + THREAD_SIZE - sizeof(struct pt_regs)
 					 - sizeof(unsigned long));
 		unlazy_fpu(tsk, regs);
 		memcpy(fpu, &tsk->thread.fpu.hard, sizeof(*fpu));
 	}
 #endif
 	return fpvalid;
 }
 asmlinkage void ret_from_fork(void);
 int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
 		unsigned long unused,
 		struct task_struct *p, struct pt_regs *regs)
 {
 	struct pt_regs *childregs;
 #if defined(CONFIG_SH_FPU)
 	struct task_struct *tsk = current;
 	unlazy_fpu(tsk, regs);
 	p->thread.fpu = tsk->thread.fpu;
 	copy_to_stopped_child_used_math(p);
 #endif
 	childregs = ((struct pt_regs *)
 		(THREAD_SIZE + (unsigned long) p->thread_info)
 #ifdef CONFIG_SH_DSP
 		- sizeof(struct pt_dspregs)
 #endif
 		- sizeof(unsigned long)) - 1;
 	*childregs = *regs;
 	if (user_mode(regs)) {
 		childregs->regs[15] = usp;
 	} else {
 		childregs->regs[15] = (unsigned long)p->thread_info + THREAD_SIZE;
 	}
         if (clone_flags & CLONE_SETTLS) {
 		childregs->gbr = childregs->regs[0];
 	}
 	childregs->regs[0] = 0; /* Set return value for child */
 	p->thread.sp = (unsigned long) childregs;
 	p->thread.pc = (unsigned long) ret_from_fork;
 	p->thread.ubc_pc = 0;
 	return 0;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	dump->magic = CMAGIC;
 	dump->start_code = current->mm->start_code;
 	dump->start_data  = current->mm->start_data;
 	dump->start_stack = regs->regs[15] & ~(PAGE_SIZE - 1);
 	dump->u_tsize = (current->mm->end_code - dump->start_code) >> PAGE_SHIFT;
 	dump->u_dsize = (current->mm->brk + (PAGE_SIZE-1) - dump->start_data) >> PAGE_SHIFT;
 	dump->u_ssize = (current->mm->start_stack - dump->start_stack +
 			 PAGE_SIZE - 1) >> PAGE_SHIFT;
 	/* Debug registers will come here. */
 	dump->regs = *regs;
 	dump->u_fpvalid = dump_fpu(regs, &dump->fpu);
 }
 /* Tracing by user break controller.  */
 static void
 ubc_set_tracing(int asid, unsigned long pc)
 {
 	ctrl_outl(pc, UBC_BARA);
 	/* We don't have any ASID settings for the SH-2! */
 	if (cpu_data->type != CPU_SH7604)
 		ctrl_outb(asid, UBC_BASRA);
 	ctrl_outl(0, UBC_BAMRA);
 	if (cpu_data->type == CPU_SH7729) {
 		ctrl_outw(BBR_INST | BBR_READ | BBR_CPU, UBC_BBRA);
 		ctrl_outl(BRCR_PCBA | BRCR_PCTE, UBC_BRCR);
 	} else {
 		ctrl_outw(BBR_INST | BBR_READ, UBC_BBRA);
 		ctrl_outw(BRCR_PCBA, UBC_BRCR);
 	}
 }
 /*
  *	switch_to(x,y) should switch tasks from x to y.
  *
  */
 struct task_struct *__switch_to(struct task_struct *prev, struct task_struct *next)
 {
 #if defined(CONFIG_SH_FPU)
 	struct pt_regs *regs = (struct pt_regs *)
 				((unsigned long)prev->thread_info
 				 + THREAD_SIZE - sizeof(struct pt_regs)
 				 - sizeof(unsigned long));
 	unlazy_fpu(prev, regs);
 #endif
 #ifdef CONFIG_PREEMPT
 	{
 		unsigned long flags;
 		struct pt_regs *regs;
 		local_irq_save(flags);
 		regs = (struct pt_regs *)
 			((unsigned long)prev->thread_info
 			 + THREAD_SIZE - sizeof(struct pt_regs)
 #ifdef CONFIG_SH_DSP
 			 - sizeof(struct pt_dspregs)
 #endif
 			 - sizeof(unsigned long));
 		if (user_mode(regs) && regs->regs[15] >= 0xc0000000) {
 			int offset = (int)regs->regs[15];
 			/* Reset stack pointer: clear critical region mark */
 			regs->regs[15] = regs->regs[1];
 			if (regs->pc < regs->regs[0])
 				/* Go to rewind point */
 				regs->pc = regs->regs[0] + offset;
 		}
 		local_irq_restore(flags);
 	}
 #endif
 	/*
 	 * Restore the kernel mode register
 	 *   	k7 (r7_bank1)
 	 */
 	asm volatile("ldc	%0, r7_bank"
 		     : /* no output */
 		     : "r" (next->thread_info));
 #ifdef CONFIG_MMU
 	/* If no tasks are using the UBC, we're done */
 	if (ubc_usercnt == 0)
 		/* If no tasks are using the UBC, we're done */;
 	else if (next->thread.ubc_pc && next->mm) {
 		ubc_set_tracing(next->mm->context & MMU_CONTEXT_ASID_MASK,
 				next->thread.ubc_pc);
 	} else {
 		ctrl_outw(0, UBC_BBRA);
 		ctrl_outw(0, UBC_BBRB);
 	}
 #endif
 	return prev;
 }
 asmlinkage int sys_fork(unsigned long r4, unsigned long r5,
 			unsigned long r6, unsigned long r7,
 			struct pt_regs regs)
 {
 #ifdef CONFIG_MMU
 	return do_fork(SIGCHLD, regs.regs[15], &regs, 0, NULL, NULL);
 #else
 	/* fork almost works, enough to trick you into looking elsewhere :-( */
 	return -EINVAL;
 #endif
 }
 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
 			 unsigned long parent_tidptr,
 			 unsigned long child_tidptr,
 			 struct pt_regs regs)
 {
 	if (!newsp)
 		newsp = regs.regs[15];
 	return do_fork(clone_flags, newsp, &regs, 0,
 			(int __user *)parent_tidptr, (int __user *)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.
  */
 asmlinkage int sys_vfork(unsigned long r4, unsigned long r5,
 			 unsigned long r6, unsigned long r7,
 			 struct pt_regs regs)
 {
 	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.regs[15], &regs,
 		       0, NULL, NULL);
 }
 /*
  * sys_execve() executes a new program.
  */
 asmlinkage int sys_execve(char *ufilename, char **uargv,
 			  char **uenvp, unsigned long r7,
 			  struct pt_regs regs)
 {
 	int error;
 	char *filename;
 	filename = getname((char __user *)ufilename);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename,
 			  (char __user * __user *)uargv,
 			  (char __user * __user *)uenvp,
 			  &regs);
 	if (error == 0) {
 		task_lock(current);
 		current->ptrace &= ~PT_DTRACE;
 		task_unlock(current);
 	}
 	putname(filename);
 out:
 	return error;
 }
 unsigned long get_wchan(struct task_struct *p)
 {
 	unsigned long schedule_frame;
 	unsigned long pc;
 	if (!p || p == current || p->state == TASK_RUNNING)
 		return 0;
 	/*
 	 * The same comment as on the Alpha applies here, too ...
 	 */
 	pc = thread_saved_pc(p);
 	if (in_sched_functions(pc)) {
 		schedule_frame = ((unsigned long *)(long)p->thread.sp)[1];
 		return (unsigned long)((unsigned long *)schedule_frame)[1];
 	}
 	return pc;
 }
 asmlinkage void break_point_trap(unsigned long r4, unsigned long r5,
 				 unsigned long r6, unsigned long r7,
 				 struct pt_regs regs)
 {
 	/* Clear tracing.  */
 	ctrl_outw(0, UBC_BBRA);
 	ctrl_outw(0, UBC_BBRB);
 	current->thread.ubc_pc = 0;
 	ubc_usercnt -= 1;
 	force_sig(SIGTRAP, current);
 }
 asmlinkage void break_point_trap_software(unsigned long r4, unsigned long r5,
 					  unsigned long r6, unsigned long r7,
 					  struct pt_regs regs)
 {
 	regs.pc -= 2;
 	force_sig(SIGTRAP, current);
 }

arch/sparc/kernel/process.c

Diff comments View file @ 59586e5

 /*  $Id: process.c,v 1.161 2002/01/23 11:27:32 davem Exp $
  *  linux/arch/sparc/kernel/process.c
  *
  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  *  Copyright (C) 1996 Eddie C. Dost   (ecd@skynet.be)
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <stdarg.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/kallsyms.h>
 #include <linux/mm.h>
 #include <linux/stddef.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/config.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
 #include <asm/auxio.h>
 #include <asm/oplib.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
 #include <asm/delay.h>
 #include <asm/processor.h>
 #include <asm/psr.h>
 #include <asm/elf.h>
 #include <asm/unistd.h>
 /*
  * Power management idle function
  * Set in pm platform drivers (apc.c and pmc.c)
  */
 void (*pm_idle)(void);
 /*
  * Power-off handler instantiation for pm.h compliance
  * This is done via auxio, but could be used as a fallback
  * handler when auxio is not present-- unused for now...
  */
 void (*pm_power_off)(void);
 /*
  * sysctl - toggle power-off restriction for serial console
  * systems in machine_power_off()
  */
 int scons_pwroff = 1;
 extern void fpsave(unsigned long *, unsigned long *, void *, unsigned long *);
 struct task_struct *last_task_used_math = NULL;
 struct thread_info *current_set[NR_CPUS];
 /*
  * default_idle is new in 2.5. XXX Review, currently stolen from sparc64.
  */
 void default_idle(void)
 {
 }
 #ifndef CONFIG_SMP
 #define SUN4C_FAULT_HIGH 100
 /*
  * the idle loop on a Sparc... ;)
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	for (;;) {
 		if (ARCH_SUN4C_SUN4) {
 			static int count = HZ;
 			static unsigned long last_jiffies;
 			static unsigned long last_faults;
 			static unsigned long fps;
 			unsigned long now;
 			unsigned long faults;
 			unsigned long flags;
 			extern unsigned long sun4c_kernel_faults;
 			extern void sun4c_grow_kernel_ring(void);
 			local_irq_save(flags);
 			now = jiffies;
 			count -= (now - last_jiffies);
 			last_jiffies = now;
 			if (count < 0) {
 				count += HZ;
 				faults = sun4c_kernel_faults;
 				fps = (fps + (faults - last_faults)) >> 1;
 				last_faults = faults;
 #if 0
 				printk("kernel faults / second = %ld\n", fps);
 #endif
 				if (fps >= SUN4C_FAULT_HIGH) {
 					sun4c_grow_kernel_ring();
 				}
 			}
 			local_irq_restore(flags);
 		}
 		while((!need_resched()) && pm_idle) {
 			(*pm_idle)();
 		}
 		schedule();
 		check_pgt_cache();
 	}
 }
 #else
 /* This is being executed in task 0 'user space'. */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	while(1) {
 		if(need_resched()) {
 			schedule();
 			check_pgt_cache();
 		}
 		barrier(); /* or else gcc optimizes... */
 	}
 }
 #endif
 extern char reboot_command [];
 extern void (*prom_palette)(int);
 /* XXX cli/sti -> local_irq_xxx here, check this works once SMP is fixed. */
 void machine_halt(void)
 {
 	local_irq_enable();
 	mdelay(8);
 	local_irq_disable();
 	if (!serial_console && prom_palette)
 		prom_palette (1);
 	prom_halt();
 	panic("Halt failed!");
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_restart(char * cmd)
 {
 	char *p;
 	local_irq_enable();
 	mdelay(8);
 	local_irq_disable();
 	p = strchr (reboot_command, '\n');
 	if (p) *p = 0;
 	if (!serial_console && prom_palette)
 		prom_palette (1);
 	if (cmd)
 		prom_reboot(cmd);
 	if (*reboot_command)
 		prom_reboot(reboot_command);
 	prom_feval ("reset");
 	panic("Reboot failed!");
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off(void)
 {
 #ifdef CONFIG_SUN_AUXIO
 	if (auxio_power_register && (!serial_console || scons_pwroff))
 		*auxio_power_register |= AUXIO_POWER_OFF;
 #endif
 	machine_halt();
 }
-EXPORT_SYMBOL(machine_power_off);
 static DEFINE_SPINLOCK(sparc_backtrace_lock);
 void __show_backtrace(unsigned long fp)
 {
 	struct reg_window *rw;
 	unsigned long flags;
 	int cpu = smp_processor_id();
 	spin_lock_irqsave(&sparc_backtrace_lock, flags);
 	rw = (struct reg_window *)fp;
         while(rw && (((unsigned long) rw) >= PAGE_OFFSET) &&
             !(((unsigned long) rw) & 0x7)) {
 		printk("CPU[%d]: ARGS[%08lx,%08lx,%08lx,%08lx,%08lx,%08lx] "
 		       "FP[%08lx] CALLER[%08lx]: ", cpu,
 		       rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 		       rw->ins[4], rw->ins[5],
 		       rw->ins[6],
 		       rw->ins[7]);
 		print_symbol("%s\n", rw->ins[7]);
 		rw = (struct reg_window *) rw->ins[6];
 	}
 	spin_unlock_irqrestore(&sparc_backtrace_lock, flags);
 }
 #define __SAVE __asm__ __volatile__("save %sp, -0x40, %sp\n\t")
 #define __RESTORE __asm__ __volatile__("restore %g0, %g0, %g0\n\t")
 #define __GET_FP(fp) __asm__ __volatile__("mov %%i6, %0" : "=r" (fp))
 void show_backtrace(void)
 {
 	unsigned long fp;
 	__SAVE; __SAVE; __SAVE; __SAVE;
 	__SAVE; __SAVE; __SAVE; __SAVE;
 	__RESTORE; __RESTORE; __RESTORE; __RESTORE;
 	__RESTORE; __RESTORE; __RESTORE; __RESTORE;
 	__GET_FP(fp);
 	__show_backtrace(fp);
 }
 #ifdef CONFIG_SMP
 void smp_show_backtrace_all_cpus(void)
 {
 	xc0((smpfunc_t) show_backtrace);
 	show_backtrace();
 }
 #endif
 #if 0
 void show_stackframe(struct sparc_stackf *sf)
 {
 	unsigned long size;
 	unsigned long *stk;
 	int i;
 	printk("l0: %08lx l1: %08lx l2: %08lx l3: %08lx "
 	       "l4: %08lx l5: %08lx l6: %08lx l7: %08lx\n",
 	       sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
 	       sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
 	printk("i0: %08lx i1: %08lx i2: %08lx i3: %08lx "
 	       "i4: %08lx i5: %08lx fp: %08lx i7: %08lx\n",
 	       sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
 	       sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
 	printk("sp: %08lx x0: %08lx x1: %08lx x2: %08lx "
 	       "x3: %08lx x4: %08lx x5: %08lx xx: %08lx\n",
 	       (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
 	       sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
 	       sf->xxargs[0]);
 	size = ((unsigned long)sf->fp) - ((unsigned long)sf);
 	size -= STACKFRAME_SZ;
 	stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
 	i = 0;
 	do {
 		printk("s%d: %08lx\n", i++, *stk++);
 	} while ((size -= sizeof(unsigned long)));
 }
 #endif
 void show_regs(struct pt_regs *r)
 {
 	struct reg_window *rw = (struct reg_window *) r->u_regs[14];
         printk("PSR: %08lx PC: %08lx NPC: %08lx Y: %08lx    %s\n",
 	       r->psr, r->pc, r->npc, r->y, print_tainted());
 	print_symbol("PC: <%s>\n", r->pc);
 	printk("%%G: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 	       r->u_regs[0], r->u_regs[1], r->u_regs[2], r->u_regs[3],
 	       r->u_regs[4], r->u_regs[5], r->u_regs[6], r->u_regs[7]);
 	printk("%%O: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 	       r->u_regs[8], r->u_regs[9], r->u_regs[10], r->u_regs[11],
 	       r->u_regs[12], r->u_regs[13], r->u_regs[14], r->u_regs[15]);
 	print_symbol("RPC: <%s>\n", r->u_regs[15]);
 	printk("%%L: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 	       rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3],
 	       rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
 	printk("%%I: %08lx %08lx  %08lx %08lx  %08lx %08lx  %08lx %08lx\n",
 	       rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
 	       rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
 }
 /*
  * The show_stack is an external API which we do not use ourselves.
  * The oops is printed in die_if_kernel.
  */
 void show_stack(struct task_struct *tsk, unsigned long *_ksp)
 {
 	unsigned long pc, fp;
 	unsigned long task_base;
 	struct reg_window *rw;
 	int count = 0;
 	if (tsk != NULL)
 		task_base = (unsigned long) tsk->thread_info;
 	else
 		task_base = (unsigned long) current_thread_info();
 	fp = (unsigned long) _ksp;
 	do {
 		/* Bogus frame pointer? */
 		if (fp < (task_base + sizeof(struct thread_info)) ||
 		    fp >= (task_base + (PAGE_SIZE << 1)))
 			break;
 		rw = (struct reg_window *) fp;
 		pc = rw->ins[7];
 		printk("[%08lx : ", pc);
 		print_symbol("%s ] ", pc);
 		fp = rw->ins[6];
 	} while (++count < 16);
 	printk("\n");
 }
 void dump_stack(void)
 {
 	unsigned long *ksp;
 	__asm__ __volatile__("mov	%%fp, %0"
 			     : "=r" (ksp));
 	show_stack(current, ksp);
 }
 EXPORT_SYMBOL(dump_stack);
 /*
  * Note: sparc64 has a pretty intricated thread_saved_pc, check it out.
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	return tsk->thread_info->kpc;
 }
 /*
  * Free current thread data structures etc..
  */
 void exit_thread(void)
 {
 #ifndef CONFIG_SMP
 	if(last_task_used_math == current) {
 #else
 	if(current_thread_info()->flags & _TIF_USEDFPU) {
 #endif
 		/* Keep process from leaving FPU in a bogon state. */
 		put_psr(get_psr() | PSR_EF);
 		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 #ifndef CONFIG_SMP
 		last_task_used_math = NULL;
 #else
 		current_thread_info()->flags &= ~_TIF_USEDFPU;
 #endif
 	}
 }
 void flush_thread(void)
 {
 	current_thread_info()->w_saved = 0;
 	/* No new signal delivery by default */
 	current->thread.new_signal = 0;
 #ifndef CONFIG_SMP
 	if(last_task_used_math == current) {
 #else
 	if(current_thread_info()->flags & _TIF_USEDFPU) {
 #endif
 		/* Clean the fpu. */
 		put_psr(get_psr() | PSR_EF);
 		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 #ifndef CONFIG_SMP
 		last_task_used_math = NULL;
 #else
 		current_thread_info()->flags &= ~_TIF_USEDFPU;
 #endif
 	}
 	/* Now, this task is no longer a kernel thread. */
 	current->thread.current_ds = USER_DS;
 	if (current->thread.flags & SPARC_FLAG_KTHREAD) {
 		current->thread.flags &= ~SPARC_FLAG_KTHREAD;
 		/* We must fixup kregs as well. */
 		/* XXX This was not fixed for ti for a while, worked. Unused? */
 		current->thread.kregs = (struct pt_regs *)
 		    ((char *)current->thread_info + (THREAD_SIZE - TRACEREG_SZ));
 	}
 }
 static __inline__ struct sparc_stackf __user *
 clone_stackframe(struct sparc_stackf __user *dst,
 		 struct sparc_stackf __user *src)
 {
 	unsigned long size, fp;
 	struct sparc_stackf *tmp;
 	struct sparc_stackf __user *sp;
 	if (get_user(tmp, &src->fp))
 		return NULL;
 	fp = (unsigned long) tmp;
 	size = (fp - ((unsigned long) src));
 	fp = (unsigned long) dst;
 	sp = (struct sparc_stackf __user *)(fp - size);
 	/* do_fork() grabs the parent semaphore, we must release it
 	 * temporarily so we can build the child clone stack frame
 	 * without deadlocking.
 	 */
 	if (__copy_user(sp, src, size))
 		sp = NULL;
 	else if (put_user(fp, &sp->fp))
 		sp = NULL;
 	return sp;
 }
 asmlinkage int sparc_do_fork(unsigned long clone_flags,
                              unsigned long stack_start,
                              struct pt_regs *regs,
                              unsigned long stack_size)
 {
 	unsigned long parent_tid_ptr, child_tid_ptr;
 	parent_tid_ptr = regs->u_regs[UREG_I2];
 	child_tid_ptr = regs->u_regs[UREG_I4];
 	return do_fork(clone_flags, stack_start,
 		       regs, stack_size,
 		       (int __user *) parent_tid_ptr,
 		       (int __user *) child_tid_ptr);
 }
 /* Copy a Sparc thread.  The fork() return value conventions
  * under SunOS are nothing short of bletcherous:
  * Parent -->  %o0 == childs  pid, %o1 == 0
  * Child  -->  %o0 == parents pid, %o1 == 1
  *
  * NOTE: We have a separate fork kpsr/kwim because
  *       the parent could change these values between
  *       sys_fork invocation and when we reach here
  *       if the parent should sleep while trying to
  *       allocate the task_struct and kernel stack in
  *       do_fork().
  * XXX See comment above sys_vfork in sparc64. todo.
  */
 extern void ret_from_fork(void);
 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 		unsigned long unused,
 		struct task_struct *p, struct pt_regs *regs)
 {
 	struct thread_info *ti = p->thread_info;
 	struct pt_regs *childregs;
 	char *new_stack;
 #ifndef CONFIG_SMP
 	if(last_task_used_math == current) {
 #else
 	if(current_thread_info()->flags & _TIF_USEDFPU) {
 #endif
 		put_psr(get_psr() | PSR_EF);
 		fpsave(&p->thread.float_regs[0], &p->thread.fsr,
 		       &p->thread.fpqueue[0], &p->thread.fpqdepth);
 #ifdef CONFIG_SMP
 		current_thread_info()->flags &= ~_TIF_USEDFPU;
 #endif
 	}
 	/*
 	 *  p->thread_info         new_stack   childregs
 	 *  !                      !           !             {if(PSR_PS) }
 	 *  V                      V (stk.fr.) V  (pt_regs)  { (stk.fr.) }
 	 *  +----- - - - - - ------+===========+============={+==========}+
 	 */
 	new_stack = (char*)ti + THREAD_SIZE;
 	if (regs->psr & PSR_PS)
 		new_stack -= STACKFRAME_SZ;
 	new_stack -= STACKFRAME_SZ + TRACEREG_SZ;
 	memcpy(new_stack, (char *)regs - STACKFRAME_SZ, STACKFRAME_SZ + TRACEREG_SZ);
 	childregs = (struct pt_regs *) (new_stack + STACKFRAME_SZ);
 	/*
 	 * A new process must start with interrupts closed in 2.5,
 	 * because this is how Mingo's scheduler works (see schedule_tail
 	 * and finish_arch_switch). If we do not do it, a timer interrupt hits
 	 * before we unlock, attempts to re-take the rq->lock, and then we die.
 	 * Thus, kpsr|=PSR_PIL.
 	 */
 	ti->ksp = (unsigned long) new_stack;
 	ti->kpc = (((unsigned long) ret_from_fork) - 0x8);
 	ti->kpsr = current->thread.fork_kpsr | PSR_PIL;
 	ti->kwim = current->thread.fork_kwim;
 	if(regs->psr & PSR_PS) {
 		extern struct pt_regs fake_swapper_regs;
 		p->thread.kregs = &fake_swapper_regs;
 		new_stack += STACKFRAME_SZ + TRACEREG_SZ;
 		childregs->u_regs[UREG_FP] = (unsigned long) new_stack;
 		p->thread.flags |= SPARC_FLAG_KTHREAD;
 		p->thread.current_ds = KERNEL_DS;
 		memcpy(new_stack, (void *)regs->u_regs[UREG_FP], STACKFRAME_SZ);
 		childregs->u_regs[UREG_G6] = (unsigned long) ti;
 	} else {
 		p->thread.kregs = childregs;
 		childregs->u_regs[UREG_FP] = sp;
 		p->thread.flags &= ~SPARC_FLAG_KTHREAD;
 		p->thread.current_ds = USER_DS;
 		if (sp != regs->u_regs[UREG_FP]) {
 			struct sparc_stackf __user *childstack;
 			struct sparc_stackf __user *parentstack;
 			/*
 			 * This is a clone() call with supplied user stack.
 			 * Set some valid stack frames to give to the child.
 			 */
 			childstack = (struct sparc_stackf __user *)
 				(sp & ~0x7UL);
 			parentstack = (struct sparc_stackf __user *)
 				regs->u_regs[UREG_FP];
 #if 0
 			printk("clone: parent stack:\n");
 			show_stackframe(parentstack);
 #endif
 			childstack = clone_stackframe(childstack, parentstack);
 			if (!childstack)
 				return -EFAULT;
 #if 0
 			printk("clone: child stack:\n");
 			show_stackframe(childstack);
 #endif
 			childregs->u_regs[UREG_FP] = (unsigned long)childstack;
 		}
 	}
 #ifdef CONFIG_SMP
 	/* FPU must be disabled on SMP. */
 	childregs->psr &= ~PSR_EF;
 #endif
 	/* Set the return value for the child. */
 	childregs->u_regs[UREG_I0] = current->pid;
 	childregs->u_regs[UREG_I1] = 1;
 	/* Set the return value for the parent. */
 	regs->u_regs[UREG_I1] = 0;
 	if (clone_flags & CLONE_SETTLS)
 		childregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
 	return 0;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	unsigned long first_stack_page;
 	dump->magic = SUNOS_CORE_MAGIC;
 	dump->len = sizeof(struct user);
 	dump->regs.psr = regs->psr;
 	dump->regs.pc = regs->pc;
 	dump->regs.npc = regs->npc;
 	dump->regs.y = regs->y;
 	/* fuck me plenty */
 	memcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
 	dump->uexec = current->thread.core_exec;
 	dump->u_tsize = (((unsigned long) current->mm->end_code) -
 		((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);
 	dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));
 	dump->u_dsize -= dump->u_tsize;
 	dump->u_dsize &= ~(PAGE_SIZE - 1);
 	first_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));
 	dump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);
 	memcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->thread.float_regs[0], (sizeof(unsigned long) * 32));
 	dump->fpu.fpstatus.fsr = current->thread.fsr;
 	dump->fpu.fpstatus.flags = dump->fpu.fpstatus.extra = 0;
 	dump->fpu.fpstatus.fpq_count = current->thread.fpqdepth;
 	memcpy(&dump->fpu.fpstatus.fpq[0], &current->thread.fpqueue[0],
 	       ((sizeof(unsigned long) * 2) * 16));
 	dump->sigcode = 0;
 }
 /*
  * fill in the fpu structure for a core dump.
  */
 int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
 {
 	if (used_math()) {
 		memset(fpregs, 0, sizeof(*fpregs));
 		fpregs->pr_q_entrysize = 8;
 		return 1;
 	}
 #ifdef CONFIG_SMP
 	if (current_thread_info()->flags & _TIF_USEDFPU) {
 		put_psr(get_psr() | PSR_EF);
 		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 		if (regs != NULL) {
 			regs->psr &= ~(PSR_EF);
 			current_thread_info()->flags &= ~(_TIF_USEDFPU);
 		}
 	}
 #else
 	if (current == last_task_used_math) {
 		put_psr(get_psr() | PSR_EF);
 		fpsave(&current->thread.float_regs[0], &current->thread.fsr,
 		       &current->thread.fpqueue[0], &current->thread.fpqdepth);
 		if (regs != NULL) {
 			regs->psr &= ~(PSR_EF);
 			last_task_used_math = NULL;
 		}
 	}
 #endif
 	memcpy(&fpregs->pr_fr.pr_regs[0],
 	       &current->thread.float_regs[0],
 	       (sizeof(unsigned long) * 32));
 	fpregs->pr_fsr = current->thread.fsr;
 	fpregs->pr_qcnt = current->thread.fpqdepth;
 	fpregs->pr_q_entrysize = 8;
 	fpregs->pr_en = 1;
 	if(fpregs->pr_qcnt != 0) {
 		memcpy(&fpregs->pr_q[0],
 		       &current->thread.fpqueue[0],
 		       sizeof(struct fpq) * fpregs->pr_qcnt);
 	}
 	/* Zero out the rest. */
 	memset(&fpregs->pr_q[fpregs->pr_qcnt], 0,
 	       sizeof(struct fpq) * (32 - fpregs->pr_qcnt));
 	return 1;
 }
 /*
  * sparc_execve() executes a new program after the asm stub has set
  * things up for us.  This should basically do what I want it to.
  */
 asmlinkage int sparc_execve(struct pt_regs *regs)
 {
 	int error, base = 0;
 	char *filename;
 	/* Check for indirect call. */
 	if(regs->u_regs[UREG_G1] == 0)
 		base = 1;
 	filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
 	error = PTR_ERR(filename);
 	if(IS_ERR(filename))
 		goto out;
 	error = do_execve(filename,
 			  (char __user * __user *)regs->u_regs[base + UREG_I1],
 			  (char __user * __user *)regs->u_regs[base + UREG_I2],
 			  regs);
 	putname(filename);
 	if (error == 0) {
 		task_lock(current);
 		current->ptrace &= ~PT_DTRACE;
 		task_unlock(current);
 	}
 out:
 	return error;
 }
 /*
  * This is the mechanism for creating a new kernel thread.
  *
  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
  * who haven't done an "execve()") should use this: it will work within
  * a system call from a "real" process, but the process memory space will
  * not be free'd until both the parent and the child have exited.
  */
 pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	long retval;
 	__asm__ __volatile__("mov %4, %%g2\n\t"    /* Set aside fn ptr... */
 			     "mov %5, %%g3\n\t"    /* and arg. */
 			     "mov %1, %%g1\n\t"
 			     "mov %2, %%o0\n\t"    /* Clone flags. */
 			     "mov 0, %%o1\n\t"     /* usp arg == 0 */
 			     "t 0x10\n\t"          /* Linux/Sparc clone(). */
 			     "cmp %%o1, 0\n\t"
 			     "be 1f\n\t"           /* The parent, just return. */
 			     " nop\n\t"            /* Delay slot. */
 			     "jmpl %%g2, %%o7\n\t" /* Call the function. */
 			     " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */
 			     "mov %3, %%g1\n\t"
 			     "t 0x10\n\t"          /* Linux/Sparc exit(). */
 			     /* Notreached by child. */
 			     "1: mov %%o0, %0\n\t" :
 			     "=r" (retval) :
 			     "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
 			     "i" (__NR_exit),  "r" (fn), "r" (arg) :
 			     "g1", "g2", "g3", "o0", "o1", "memory", "cc");
 	return retval;
 }
 unsigned long get_wchan(struct task_struct *task)
 {
 	unsigned long pc, fp, bias = 0;
 	unsigned long task_base = (unsigned long) task;
         unsigned long ret = 0;
 	struct reg_window *rw;
 	int count = 0;
 	if (!task || task == current ||
             task->state == TASK_RUNNING)
 		goto out;
 	fp = task->thread_info->ksp + bias;
 	do {
 		/* Bogus frame pointer? */
 		if (fp < (task_base + sizeof(struct thread_info)) ||
 		    fp >= (task_base + (2 * PAGE_SIZE)))
 			break;
 		rw = (struct reg_window *) fp;
 		pc = rw->ins[7];
 		if (!in_sched_functions(pc)) {
 			ret = pc;
 			goto out;
 		}
 		fp = rw->ins[6] + bias;
 	} while (++count < 16);
 out:
 	return ret;
 }

arch/sparc64/kernel/power.c

Diff comments View file @ 59586e5

 /* $Id: power.c,v 1.10 2001/12/11 01:57:16 davem Exp $
  * power.c: Power management driver.
  *
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
  */
 #define __KERNEL_SYSCALLS__
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/signal.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <asm/system.h>
 #include <asm/ebus.h>
 #include <asm/auxio.h>
 #include <linux/unistd.h>
 /*
  * sysctl - toggle power-off restriction for serial console
  * systems in machine_power_off()
  */
 int scons_pwroff = 1;
 #ifdef CONFIG_PCI
 static void __iomem *power_reg;
 static DECLARE_WAIT_QUEUE_HEAD(powerd_wait);
 static int button_pressed;
 static irqreturn_t power_handler(int irq, void *dev_id, struct pt_regs *regs)
 {
 	if (button_pressed == 0) {
 		button_pressed = 1;
 		wake_up(&powerd_wait);
 	}
 	/* FIXME: Check registers for status... */
 	return IRQ_HANDLED;
 }
 #endif /* CONFIG_PCI */
 extern void machine_halt(void);
 extern void machine_alt_power_off(void);
 static void (*poweroff_method)(void) = machine_alt_power_off;
 void machine_power_off(void)
 {
 	if (!serial_console || scons_pwroff) {
 #ifdef CONFIG_PCI
 		if (power_reg) {
 			/* Both register bits seem to have the
 			 * same effect, so until I figure out
 			 * what the difference is...
 			 */
 			writel(AUXIO_PCIO_CPWR_OFF | AUXIO_PCIO_SPWR_OFF, power_reg);
 		} else
 #endif /* CONFIG_PCI */
 			if (poweroff_method != NULL) {
 				poweroff_method();
 				/* not reached */
 			}
 	}
 	machine_halt();
 }
-EXPORT_SYMBOL(machine_power_off);
 #ifdef CONFIG_PCI
 static int powerd(void *__unused)
 {
 	static char *envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
 	char *argv[] = { "/sbin/shutdown", "-h", "now", NULL };
 	DECLARE_WAITQUEUE(wait, current);
 	daemonize("powerd");
 	add_wait_queue(&powerd_wait, &wait);
 again:
 	for (;;) {
 		set_task_state(current, TASK_INTERRUPTIBLE);
 		if (button_pressed)
 			break;
 		flush_signals(current);
 		schedule();
 	}
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&powerd_wait, &wait);
 	/* Ok, down we go... */
 	button_pressed = 0;
 	if (execve("/sbin/shutdown", argv, envp) < 0) {
 		printk("powerd: shutdown execution failed\n");
 		add_wait_queue(&powerd_wait, &wait);
 		goto again;
 	}
 	return 0;
 }
 static int __init has_button_interrupt(struct linux_ebus_device *edev)
 {
 	if (edev->irqs[0] == PCI_IRQ_NONE)
 		return 0;
 	if (!prom_node_has_property(edev->prom_node, "button"))
 		return 0;
 	return 1;
 }
 void __init power_init(void)
 {
 	struct linux_ebus *ebus;
 	struct linux_ebus_device *edev;
 	static int invoked;
 	if (invoked)
 		return;
 	invoked = 1;
 	for_each_ebus(ebus) {
 		for_each_ebusdev(edev, ebus) {
 			if (!strcmp(edev->prom_name, "power"))
 				goto found;
 		}
 	}
 	return;
 found:
 	power_reg = ioremap(edev->resource[0].start, 0x4);
 	printk("power: Control reg at %p ... ", power_reg);
 	poweroff_method = machine_halt;  /* able to use the standard halt */
 	if (has_button_interrupt(edev)) {
 		if (kernel_thread(powerd, NULL, CLONE_FS) < 0) {
 			printk("Failed to start power daemon.\n");
 			return;
 		}
 		printk("powerd running.\n");
 		if (request_irq(edev->irqs[0],
 				power_handler, SA_SHIRQ, "power", NULL) < 0)
 			printk("power: Error, cannot register IRQ handler.\n");
 	} else {
 		printk("not using powerd.\n");
 	}
 }
 #endif /* CONFIG_PCI */

arch/sparc64/kernel/process.c

Diff comments View file @ 59586e5

 /*  $Id: process.c,v 1.131 2002/02/09 19:49:30 davem Exp $
  *  arch/sparc64/kernel/process.c
  *
  *  Copyright (C) 1995, 1996 David S. Miller (davem@caip.rutgers.edu)
  *  Copyright (C) 1996       Eddie C. Dost   (ecd@skynet.be)
  *  Copyright (C) 1997, 1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
  */
 /*
  * This file handles the architecture-dependent parts of process handling..
  */
 #include <stdarg.h>
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/kallsyms.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/a.out.h>
 #include <linux/config.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/compat.h>
 #include <linux/init.h>
 #include <asm/oplib.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
 #include <asm/processor.h>
 #include <asm/pstate.h>
 #include <asm/elf.h>
 #include <asm/fpumacro.h>
 #include <asm/head.h>
 #include <asm/cpudata.h>
 #include <asm/unistd.h>
 /* #define VERBOSE_SHOWREGS */
 /*
  * Nothing special yet...
  */
 void default_idle(void)
 {
 }
 #ifndef CONFIG_SMP
 /*
  * the idle loop on a Sparc... ;)
  */
 void cpu_idle(void)
 {
 	/* endless idle loop with no priority at all */
 	for (;;) {
 		/* If current->work.need_resched is zero we should really
 		 * setup for a system wakup event and execute a shutdown
 		 * instruction.
 		 *
 		 * But this requires writing back the contents of the
 		 * L2 cache etc. so implement this later. -DaveM
 		 */
 		while (!need_resched())
 			barrier();
 		schedule();
 		check_pgt_cache();
 	}
 }
 #else
 /*
  * the idle loop on a UltraMultiPenguin...
  */
 #define idle_me_harder()	(cpu_data(smp_processor_id()).idle_volume += 1)
 #define unidle_me()		(cpu_data(smp_processor_id()).idle_volume = 0)
 void cpu_idle(void)
 {
 	set_thread_flag(TIF_POLLING_NRFLAG);
 	while(1) {
 		if (need_resched()) {
 			unidle_me();
 			clear_thread_flag(TIF_POLLING_NRFLAG);
 			schedule();
 			set_thread_flag(TIF_POLLING_NRFLAG);
 			check_pgt_cache();
 		}
 		idle_me_harder();
 		/* The store ordering is so that IRQ handlers on
 		 * other cpus see our increasing idleness for the buddy
 		 * redistribution algorithm.  -DaveM
 		 */
 		membar("#StoreStore | #StoreLoad");
 	}
 }
 #endif
 extern char reboot_command [];
 extern void (*prom_palette)(int);
 extern void (*prom_keyboard)(void);
 void machine_halt(void)
 {
 	if (!serial_console && prom_palette)
 		prom_palette (1);
 	if (prom_keyboard)
 		prom_keyboard();
 	prom_halt();
 	panic("Halt failed!");
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_alt_power_off(void)
 {
 	if (!serial_console && prom_palette)
 		prom_palette(1);
 	if (prom_keyboard)
 		prom_keyboard();
 	prom_halt_power_off();
 	panic("Power-off failed!");
 }
 void machine_restart(char * cmd)
 {
 	char *p;
 	p = strchr (reboot_command, '\n');
 	if (p) *p = 0;
 	if (!serial_console && prom_palette)
 		prom_palette (1);
 	if (prom_keyboard)
 		prom_keyboard();
 	if (cmd)
 		prom_reboot(cmd);
 	if (*reboot_command)
 		prom_reboot(reboot_command);
 	prom_reboot("");
 	panic("Reboot failed!");
 }
-EXPORT_SYMBOL(machine_restart);
 static void show_regwindow32(struct pt_regs *regs)
 {
 	struct reg_window32 __user *rw;
 	struct reg_window32 r_w;
 	mm_segment_t old_fs;
 	__asm__ __volatile__ ("flushw");
 	rw = compat_ptr((unsigned)regs->u_regs[14]);
 	old_fs = get_fs();
 	set_fs (USER_DS);
 	if (copy_from_user (&r_w, rw, sizeof(r_w))) {
 		set_fs (old_fs);
 		return;
 	}
 	set_fs (old_fs);
 	printk("l0: %08x l1: %08x l2: %08x l3: %08x "
 	       "l4: %08x l5: %08x l6: %08x l7: %08x\n",
 	       r_w.locals[0], r_w.locals[1], r_w.locals[2], r_w.locals[3],
 	       r_w.locals[4], r_w.locals[5], r_w.locals[6], r_w.locals[7]);
 	printk("i0: %08x i1: %08x i2: %08x i3: %08x "
 	       "i4: %08x i5: %08x i6: %08x i7: %08x\n",
 	       r_w.ins[0], r_w.ins[1], r_w.ins[2], r_w.ins[3],
 	       r_w.ins[4], r_w.ins[5], r_w.ins[6], r_w.ins[7]);
 }
 static void show_regwindow(struct pt_regs *regs)
 {
 	struct reg_window __user *rw;
 	struct reg_window *rwk;
 	struct reg_window r_w;
 	mm_segment_t old_fs;
 	if ((regs->tstate & TSTATE_PRIV) || !(test_thread_flag(TIF_32BIT))) {
 		__asm__ __volatile__ ("flushw");
 		rw = (struct reg_window __user *)
 			(regs->u_regs[14] + STACK_BIAS);
 		rwk = (struct reg_window *)
 			(regs->u_regs[14] + STACK_BIAS);
 		if (!(regs->tstate & TSTATE_PRIV)) {
 			old_fs = get_fs();
 			set_fs (USER_DS);
 			if (copy_from_user (&r_w, rw, sizeof(r_w))) {
 				set_fs (old_fs);
 				return;
 			}
 			rwk = &r_w;
 			set_fs (old_fs);
 		}
 	} else {
 		show_regwindow32(regs);
 		return;
 	}
 	printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lx\n",
 	       rwk->locals[0], rwk->locals[1], rwk->locals[2], rwk->locals[3]);
 	printk("l4: %016lx l5: %016lx l6: %016lx l7: %016lx\n",
 	       rwk->locals[4], rwk->locals[5], rwk->locals[6], rwk->locals[7]);
 	printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lx\n",
 	       rwk->ins[0], rwk->ins[1], rwk->ins[2], rwk->ins[3]);
 	printk("i4: %016lx i5: %016lx i6: %016lx i7: %016lx\n",
 	       rwk->ins[4], rwk->ins[5], rwk->ins[6], rwk->ins[7]);
 	if (regs->tstate & TSTATE_PRIV)
 		print_symbol("I7: <%s>\n", rwk->ins[7]);
 }
 void show_stackframe(struct sparc_stackf *sf)
 {
 	unsigned long size;
 	unsigned long *stk;
 	int i;
 	printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lx\n"
 	       "l4: %016lx l5: %016lx l6: %016lx l7: %016lx\n",
 	       sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
 	       sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
 	printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lx\n"
 	       "i4: %016lx i5: %016lx fp: %016lx ret_pc: %016lx\n",
 	       sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
 	       sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
 	printk("sp: %016lx x0: %016lx x1: %016lx x2: %016lx\n"
 	       "x3: %016lx x4: %016lx x5: %016lx xx: %016lx\n",
 	       (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
 	       sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
 	       sf->xxargs[0]);
 	size = ((unsigned long)sf->fp) - ((unsigned long)sf);
 	size -= STACKFRAME_SZ;
 	stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
 	i = 0;
 	do {
 		printk("s%d: %016lx\n", i++, *stk++);
 	} while ((size -= sizeof(unsigned long)));
 }
 void show_stackframe32(struct sparc_stackf32 *sf)
 {
 	unsigned long size;
 	unsigned *stk;
 	int i;
 	printk("l0: %08x l1: %08x l2: %08x l3: %08x\n",
 	       sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3]);
 	printk("l4: %08x l5: %08x l6: %08x l7: %08x\n",
 	       sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
 	printk("i0: %08x i1: %08x i2: %08x i3: %08x\n",
 	       sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3]);
 	printk("i4: %08x i5: %08x fp: %08x ret_pc: %08x\n",
 	       sf->ins[4], sf->ins[5], sf->fp, sf->callers_pc);
 	printk("sp: %08x x0: %08x x1: %08x x2: %08x\n"
 	       "x3: %08x x4: %08x x5: %08x xx: %08x\n",
 	       sf->structptr, sf->xargs[0], sf->xargs[1],
 	       sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
 	       sf->xxargs[0]);
 	size = ((unsigned long)sf->fp) - ((unsigned long)sf);
 	size -= STACKFRAME32_SZ;
 	stk = (unsigned *)((unsigned long)sf + STACKFRAME32_SZ);
 	i = 0;
 	do {
 		printk("s%d: %08x\n", i++, *stk++);
 	} while ((size -= sizeof(unsigned)));
 }
 #ifdef CONFIG_SMP
 static DEFINE_SPINLOCK(regdump_lock);
 #endif
 void __show_regs(struct pt_regs * regs)
 {
 #ifdef CONFIG_SMP
 	unsigned long flags;
 	/* Protect against xcall ipis which might lead to livelock on the lock */
 	__asm__ __volatile__("rdpr      %%pstate, %0\n\t"
 			     "wrpr      %0, %1, %%pstate"
 			     : "=r" (flags)
 			     : "i" (PSTATE_IE));
 	spin_lock(&regdump_lock);
 #endif
 	printk("TSTATE: %016lx TPC: %016lx TNPC: %016lx Y: %08x    %s\n", regs->tstate,
 	       regs->tpc, regs->tnpc, regs->y, print_tainted());
 	print_symbol("TPC: <%s>\n", regs->tpc);
 	printk("g0: %016lx g1: %016lx g2: %016lx g3: %016lx\n",
 	       regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
 	       regs->u_regs[3]);
 	printk("g4: %016lx g5: %016lx g6: %016lx g7: %016lx\n",
 	       regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
 	       regs->u_regs[7]);
 	printk("o0: %016lx o1: %016lx o2: %016lx o3: %016lx\n",
 	       regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
 	       regs->u_regs[11]);
 	printk("o4: %016lx o5: %016lx sp: %016lx ret_pc: %016lx\n",
 	       regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
 	       regs->u_regs[15]);
 	print_symbol("RPC: <%s>\n", regs->u_regs[15]);
 	show_regwindow(regs);
 #ifdef CONFIG_SMP
 	spin_unlock(&regdump_lock);
 	__asm__ __volatile__("wrpr	%0, 0, %%pstate"
 			     : : "r" (flags));
 #endif
 }
 #ifdef VERBOSE_SHOWREGS
 static void idump_from_user (unsigned int *pc)
 {
 	int i;
 	int code;
 	if((((unsigned long) pc) & 3))
 		return;
 	pc -= 3;
 	for(i = -3; i < 6; i++) {
 		get_user(code, pc);
 		printk("%c%08x%c",i?' ':'<',code,i?' ':'>');
 		pc++;
 	}
 	printk("\n");
 }
 #endif
 void show_regs(struct pt_regs *regs)
 {
 #ifdef VERBOSE_SHOWREGS
 	extern long etrap, etraptl1;
 #endif
 	__show_regs(regs);
 #ifdef CONFIG_SMP
 	{
 		extern void smp_report_regs(void);
 		smp_report_regs();
 	}
 #endif
 #ifdef VERBOSE_SHOWREGS
 	if (regs->tpc >= &etrap && regs->tpc < &etraptl1 &&
 	    regs->u_regs[14] >= (long)current - PAGE_SIZE &&
 	    regs->u_regs[14] < (long)current + 6 * PAGE_SIZE) {
 		printk ("*********parent**********\n");
 		__show_regs((struct pt_regs *)(regs->u_regs[14] + PTREGS_OFF));
 		idump_from_user(((struct pt_regs *)(regs->u_regs[14] + PTREGS_OFF))->tpc);
 		printk ("*********endpar**********\n");
 	}
 #endif
 }
 void show_regs32(struct pt_regs32 *regs)
 {
 	printk("PSR: %08x PC: %08x NPC: %08x Y: %08x    %s\n", regs->psr,
 	       regs->pc, regs->npc, regs->y, print_tainted());
 	printk("g0: %08x g1: %08x g2: %08x g3: %08x ",
 	       regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
 	       regs->u_regs[3]);
 	printk("g4: %08x g5: %08x g6: %08x g7: %08x\n",
 	       regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
 	       regs->u_regs[7]);
 	printk("o0: %08x o1: %08x o2: %08x o3: %08x ",
 	       regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
 	       regs->u_regs[11]);
 	printk("o4: %08x o5: %08x sp: %08x ret_pc: %08x\n",
 	       regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
 	       regs->u_regs[15]);
 }
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	struct thread_info *ti = tsk->thread_info;
 	unsigned long ret = 0xdeadbeefUL;
 	if (ti && ti->ksp) {
 		unsigned long *sp;
 		sp = (unsigned long *)(ti->ksp + STACK_BIAS);
 		if (((unsigned long)sp & (sizeof(long) - 1)) == 0UL &&
 		    sp[14]) {
 			unsigned long *fp;
 			fp = (unsigned long *)(sp[14] + STACK_BIAS);
 			if (((unsigned long)fp & (sizeof(long) - 1)) == 0UL)
 				ret = fp[15];
 		}
 	}
 	return ret;
 }
 /* Free current thread data structures etc.. */
 void exit_thread(void)
 {
 	struct thread_info *t = current_thread_info();
 	if (t->utraps) {
 		if (t->utraps[0] < 2)
 			kfree (t->utraps);
 		else
 			t->utraps[0]--;
 	}
 	if (test_and_clear_thread_flag(TIF_PERFCTR)) {
 		t->user_cntd0 = t->user_cntd1 = NULL;
 		t->pcr_reg = 0;
 		write_pcr(0);
 	}
 }
 void flush_thread(void)
 {
 	struct thread_info *t = current_thread_info();
 	if (t->flags & _TIF_ABI_PENDING)
 		t->flags ^= (_TIF_ABI_PENDING | _TIF_32BIT);
 	if (t->task->mm) {
 		unsigned long pgd_cache = 0UL;
 		if (test_thread_flag(TIF_32BIT)) {
 			struct mm_struct *mm = t->task->mm;
 			pgd_t *pgd0 = &mm->pgd[0];
 			pud_t *pud0 = pud_offset(pgd0, 0);
 			if (pud_none(*pud0)) {
 				pmd_t *page = pmd_alloc_one(mm, 0);
 				pud_set(pud0, page);
 			}
 			pgd_cache = get_pgd_cache(pgd0);
 		}
 		__asm__ __volatile__("stxa %0, [%1] %2\n\t"
 				     "membar #Sync"
 				     : /* no outputs */
 				     : "r" (pgd_cache),
 				     "r" (TSB_REG),
 				     "i" (ASI_DMMU));
 	}
 	set_thread_wsaved(0);
 	/* Turn off performance counters if on. */
 	if (test_and_clear_thread_flag(TIF_PERFCTR)) {
 		t->user_cntd0 = t->user_cntd1 = NULL;
 		t->pcr_reg = 0;
 		write_pcr(0);
 	}
 	/* Clear FPU register state. */
 	t->fpsaved[0] = 0;
 	if (get_thread_current_ds() != ASI_AIUS)
 		set_fs(USER_DS);
 	/* Init new signal delivery disposition. */
 	clear_thread_flag(TIF_NEWSIGNALS);
 }
 /* It's a bit more tricky when 64-bit tasks are involved... */
 static unsigned long clone_stackframe(unsigned long csp, unsigned long psp)
 {
 	unsigned long fp, distance, rval;
 	if (!(test_thread_flag(TIF_32BIT))) {
 		csp += STACK_BIAS;
 		psp += STACK_BIAS;
 		__get_user(fp, &(((struct reg_window __user *)psp)->ins[6]));
 		fp += STACK_BIAS;
 	} else
 		__get_user(fp, &(((struct reg_window32 __user *)psp)->ins[6]));
 	/* Now 8-byte align the stack as this is mandatory in the
 	 * Sparc ABI due to how register windows work.  This hides
 	 * the restriction from thread libraries etc.  -DaveM
 	 */
 	csp &= ~7UL;
 	distance = fp - psp;
 	rval = (csp - distance);
 	if (copy_in_user((void __user *) rval, (void __user *) psp, distance))
 		rval = 0;
 	else if (test_thread_flag(TIF_32BIT)) {
 		if (put_user(((u32)csp),
 			     &(((struct reg_window32 __user *)rval)->ins[6])))
 			rval = 0;
 	} else {
 		if (put_user(((u64)csp - STACK_BIAS),
 			     &(((struct reg_window __user *)rval)->ins[6])))
 			rval = 0;
 		else
 			rval = rval - STACK_BIAS;
 	}
 	return rval;
 }
 /* Standard stuff. */
 static inline void shift_window_buffer(int first_win, int last_win,
 				       struct thread_info *t)
 {
 	int i;
 	for (i = first_win; i < last_win; i++) {
 		t->rwbuf_stkptrs[i] = t->rwbuf_stkptrs[i+1];
 		memcpy(&t->reg_window[i], &t->reg_window[i+1],
 		       sizeof(struct reg_window));
 	}
 }
 void synchronize_user_stack(void)
 {
 	struct thread_info *t = current_thread_info();
 	unsigned long window;
 	flush_user_windows();
 	if ((window = get_thread_wsaved()) != 0) {
 		int winsize = sizeof(struct reg_window);
 		int bias = 0;
 		if (test_thread_flag(TIF_32BIT))
 			winsize = sizeof(struct reg_window32);
 		else
 			bias = STACK_BIAS;
 		window -= 1;
 		do {
 			unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
 			struct reg_window *rwin = &t->reg_window[window];
 			if (!copy_to_user((char __user *)sp, rwin, winsize)) {
 				shift_window_buffer(window, get_thread_wsaved() - 1, t);
 				set_thread_wsaved(get_thread_wsaved() - 1);
 			}
 		} while (window--);
 	}
 }
 void fault_in_user_windows(void)
 {
 	struct thread_info *t = current_thread_info();
 	unsigned long window;
 	int winsize = sizeof(struct reg_window);
 	int bias = 0;
 	if (test_thread_flag(TIF_32BIT))
 		winsize = sizeof(struct reg_window32);
 	else
 		bias = STACK_BIAS;
 	flush_user_windows();
 	window = get_thread_wsaved();
 	if (window != 0) {
 		window -= 1;
 		do {
 			unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
 			struct reg_window *rwin = &t->reg_window[window];
 			if (copy_to_user((char __user *)sp, rwin, winsize))
 				goto barf;
 		} while (window--);
 	}
 	set_thread_wsaved(0);
 	return;
 barf:
 	set_thread_wsaved(window + 1);
 	do_exit(SIGILL);
 }
 asmlinkage long sparc_do_fork(unsigned long clone_flags,
 			      unsigned long stack_start,
 			      struct pt_regs *regs,
 			      unsigned long stack_size)
 {
 	int __user *parent_tid_ptr, *child_tid_ptr;
 #ifdef CONFIG_COMPAT
 	if (test_thread_flag(TIF_32BIT)) {
 		parent_tid_ptr = compat_ptr(regs->u_regs[UREG_I2]);
 		child_tid_ptr = compat_ptr(regs->u_regs[UREG_I4]);
 	} else
 #endif
 	{
 		parent_tid_ptr = (int __user *) regs->u_regs[UREG_I2];
 		child_tid_ptr = (int __user *) regs->u_regs[UREG_I4];
 	}
 	return do_fork(clone_flags, stack_start,
 		       regs, stack_size,
 		       parent_tid_ptr, child_tid_ptr);
 }
 /* Copy a Sparc thread.  The fork() return value conventions
  * under SunOS are nothing short of bletcherous:
  * Parent -->  %o0 == childs  pid, %o1 == 0
  * Child  -->  %o0 == parents pid, %o1 == 1
  */
 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 		unsigned long unused,
 		struct task_struct *p, struct pt_regs *regs)
 {
 	struct thread_info *t = p->thread_info;
 	char *child_trap_frame;
 #ifdef CONFIG_DEBUG_SPINLOCK
 	p->thread.smp_lock_count = 0;
 	p->thread.smp_lock_pc = 0;
 #endif
 	/* Calculate offset to stack_frame & pt_regs */
 	child_trap_frame = ((char *)t) + (THREAD_SIZE - (TRACEREG_SZ+STACKFRAME_SZ));
 	memcpy(child_trap_frame, (((struct sparc_stackf *)regs)-1), (TRACEREG_SZ+STACKFRAME_SZ));
 	t->flags = (t->flags & ~((0xffUL << TI_FLAG_CWP_SHIFT) | (0xffUL << TI_FLAG_CURRENT_DS_SHIFT))) |
 		(((regs->tstate + 1) & TSTATE_CWP) << TI_FLAG_CWP_SHIFT);
 	t->new_child = 1;
 	t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
 	t->kregs = (struct pt_regs *)(child_trap_frame+sizeof(struct sparc_stackf));
 	t->fpsaved[0] = 0;
 	if (regs->tstate & TSTATE_PRIV) {
 		/* Special case, if we are spawning a kernel thread from
 		 * a userspace task (via KMOD, NFS, or similar) we must
 		 * disable performance counters in the child because the
 		 * address space and protection realm are changing.
 		 */
 		if (t->flags & _TIF_PERFCTR) {
 			t->user_cntd0 = t->user_cntd1 = NULL;
 			t->pcr_reg = 0;
 			t->flags &= ~_TIF_PERFCTR;
 		}
 		t->kregs->u_regs[UREG_FP] = t->ksp;
 		t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT);
 		flush_register_windows();
 		memcpy((void *)(t->ksp + STACK_BIAS),
 		       (void *)(regs->u_regs[UREG_FP] + STACK_BIAS),
 		       sizeof(struct sparc_stackf));
 		t->kregs->u_regs[UREG_G6] = (unsigned long) t;
 		t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
 	} else {
 		if (t->flags & _TIF_32BIT) {
 			sp &= 0x00000000ffffffffUL;
 			regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 		}
 		t->kregs->u_regs[UREG_FP] = sp;
 		t->flags |= ((long)ASI_AIUS << TI_FLAG_CURRENT_DS_SHIFT);
 		if (sp != regs->u_regs[UREG_FP]) {
 			unsigned long csp;
 			csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
 			if (!csp)
 				return -EFAULT;
 			t->kregs->u_regs[UREG_FP] = csp;
 		}
 		if (t->utraps)
 			t->utraps[0]++;
 	}
 	/* Set the return value for the child. */
 	t->kregs->u_regs[UREG_I0] = current->pid;
 	t->kregs->u_regs[UREG_I1] = 1;
 	/* Set the second return value for the parent. */
 	regs->u_regs[UREG_I1] = 0;
 	if (clone_flags & CLONE_SETTLS)
 		t->kregs->u_regs[UREG_G7] = regs->u_regs[UREG_I3];
 	return 0;
 }
 /*
  * This is the mechanism for creating a new kernel thread.
  *
  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
  * who haven't done an "execve()") should use this: it will work within
  * a system call from a "real" process, but the process memory space will
  * not be free'd until both the parent and the child have exited.
  */
 pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	long retval;
 	/* If the parent runs before fn(arg) is called by the child,
 	 * the input registers of this function can be clobbered.
 	 * So we stash 'fn' and 'arg' into global registers which
 	 * will not be modified by the parent.
 	 */
 	__asm__ __volatile__("mov %4, %%g2\n\t"	   /* Save FN into global */
 			     "mov %5, %%g3\n\t"	   /* Save ARG into global */
 			     "mov %1, %%g1\n\t"	   /* Clone syscall nr. */
 			     "mov %2, %%o0\n\t"	   /* Clone flags. */
 			     "mov 0, %%o1\n\t"	   /* usp arg == 0 */
 			     "t 0x6d\n\t"	   /* Linux/Sparc clone(). */
 			     "brz,a,pn %%o1, 1f\n\t" /* Parent, just return. */
 			     " mov %%o0, %0\n\t"
 			     "jmpl %%g2, %%o7\n\t"   /* Call the function. */
 			     " mov %%g3, %%o0\n\t"   /* Set arg in delay. */
 			     "mov %3, %%g1\n\t"
 			     "t 0x6d\n\t"	   /* Linux/Sparc exit(). */
 			     /* Notreached by child. */
 			     "1:" :
 			     "=r" (retval) :
 			     "i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
 			     "i" (__NR_exit),  "r" (fn), "r" (arg) :
 			     "g1", "g2", "g3", "o0", "o1", "memory", "cc");
 	return retval;
 }
 /*
  * fill in the user structure for a core dump..
  */
 void dump_thread(struct pt_regs * regs, struct user * dump)
 {
 	/* Only should be used for SunOS and ancient a.out
 	 * SparcLinux binaries...  Not worth implementing.
 	 */
 	memset(dump, 0, sizeof(struct user));
 }
 typedef struct {
 	union {
 		unsigned int	pr_regs[32];
 		unsigned long	pr_dregs[16];
 	} pr_fr;
 	unsigned int __unused;
 	unsigned int	pr_fsr;
 	unsigned char	pr_qcnt;
 	unsigned char	pr_q_entrysize;
 	unsigned char	pr_en;
 	unsigned int	pr_q[64];
 } elf_fpregset_t32;
 /*
  * fill in the fpu structure for a core dump.
  */
 int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
 {
 	unsigned long *kfpregs = current_thread_info()->fpregs;
 	unsigned long fprs = current_thread_info()->fpsaved[0];
 	if (test_thread_flag(TIF_32BIT)) {
 		elf_fpregset_t32 *fpregs32 = (elf_fpregset_t32 *)fpregs;
 		if (fprs & FPRS_DL)
 			memcpy(&fpregs32->pr_fr.pr_regs[0], kfpregs,
 			       sizeof(unsigned int) * 32);
 		else
 			memset(&fpregs32->pr_fr.pr_regs[0], 0,
 			       sizeof(unsigned int) * 32);
 		fpregs32->pr_qcnt = 0;
 		fpregs32->pr_q_entrysize = 8;
 		memset(&fpregs32->pr_q[0], 0,
 		       (sizeof(unsigned int) * 64));
 		if (fprs & FPRS_FEF) {
 			fpregs32->pr_fsr = (unsigned int) current_thread_info()->xfsr[0];
 			fpregs32->pr_en = 1;
 		} else {
 			fpregs32->pr_fsr = 0;
 			fpregs32->pr_en = 0;
 		}
 	} else {
 		if(fprs & FPRS_DL)
 			memcpy(&fpregs->pr_regs[0], kfpregs,
 			       sizeof(unsigned int) * 32);
 		else
 			memset(&fpregs->pr_regs[0], 0,
 			       sizeof(unsigned int) * 32);
 		if(fprs & FPRS_DU)
 			memcpy(&fpregs->pr_regs[16], kfpregs+16,
 			       sizeof(unsigned int) * 32);
 		else
 			memset(&fpregs->pr_regs[16], 0,
 			       sizeof(unsigned int) * 32);
 		if(fprs & FPRS_FEF) {
 			fpregs->pr_fsr = current_thread_info()->xfsr[0];
 			fpregs->pr_gsr = current_thread_info()->gsr[0];
 		} else {
 			fpregs->pr_fsr = fpregs->pr_gsr = 0;
 		}
 		fpregs->pr_fprs = fprs;
 	}
 	return 1;
 }
 /*
  * sparc_execve() executes a new program after the asm stub has set
  * things up for us.  This should basically do what I want it to.
  */
 asmlinkage int sparc_execve(struct pt_regs *regs)
 {
 	int error, base = 0;
 	char *filename;
 	/* User register window flush is done by entry.S */
 	/* Check for indirect call. */
 	if (regs->u_regs[UREG_G1] == 0)
 		base = 1;
 	filename = getname((char __user *)regs->u_regs[base + UREG_I0]);
 	error = PTR_ERR(filename);
 	if (IS_ERR(filename))
 		goto out;
 	error = do_execve(filename,
 			  (char __user * __user *)
 			  regs->u_regs[base + UREG_I1],
 			  (char __user * __user *)
 			  regs->u_regs[base + UREG_I2], regs);
 	putname(filename);
 	if (!error) {
 		fprs_write(0);
 		current_thread_info()->xfsr[0] = 0;
 		current_thread_info()->fpsaved[0] = 0;
 		regs->tstate &= ~TSTATE_PEF;
 		task_lock(current);
 		current->ptrace &= ~PT_DTRACE;
 		task_unlock(current);
 	}
 out:
 	return error;
 }
 unsigned long get_wchan(struct task_struct *task)
 {
 	unsigned long pc, fp, bias = 0;
 	unsigned long thread_info_base;
 	struct reg_window *rw;
         unsigned long ret = 0;
 	int count = 0;
 	if (!task || task == current ||
             task->state == TASK_RUNNING)
 		goto out;
 	thread_info_base = (unsigned long) task->thread_info;
 	bias = STACK_BIAS;
 	fp = task->thread_info->ksp + bias;
 	do {
 		/* Bogus frame pointer? */
 		if (fp < (thread_info_base + sizeof(struct thread_info)) ||
 		    fp >= (thread_info_base + THREAD_SIZE))
 			break;
 		rw = (struct reg_window *) fp;
 		pc = rw->ins[7];
 		if (!in_sched_functions(pc)) {
 			ret = pc;
 			goto out;
 		}
 		fp = rw->ins[6] + bias;
 	} while (++count < 16);
 out:
 	return ret;
 }

arch/um/kernel/reboot.c

Diff comments View file @ 59586e5

 /*
  * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #include "linux/module.h"
 #include "linux/sched.h"
 #include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
 #include "os.h"
 #include "mode.h"
 #include "choose-mode.h"
 #ifdef CONFIG_SMP
 static void kill_idlers(int me)
 {
 #ifdef CONFIG_MODE_TT
 	struct task_struct *p;
 	int i;
 	for(i = 0; i < sizeof(idle_threads)/sizeof(idle_threads[0]); i++){
 		p = idle_threads[i];
 		if((p != NULL) && (p->thread.mode.tt.extern_pid != me))
 			os_kill_process(p->thread.mode.tt.extern_pid, 0);
 	}
 #endif
 }
 #endif
 static void kill_off_processes(void)
 {
 	CHOOSE_MODE(kill_off_processes_tt(), kill_off_processes_skas());
 #ifdef CONFIG_SMP
 	kill_idlers(os_getpid());
 #endif
 }
 void uml_cleanup(void)
 {
         kmalloc_ok = 0;
 	do_uml_exitcalls();
 	kill_off_processes();
 }
 void machine_restart(char * __unused)
 {
         uml_cleanup();
 	CHOOSE_MODE(reboot_tt(), reboot_skas());
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off(void)
 {
         uml_cleanup();
 	CHOOSE_MODE(halt_tt(), halt_skas());
 }
-EXPORT_SYMBOL(machine_power_off);
 void machine_halt(void)
 {
 	machine_power_off();
 }
-EXPORT_SYMBOL(machine_halt);
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
  * adjust the settings for this buffer only.  This must remain at the end
  * of the file.
  * ---------------------------------------------------------------------------
  * Local variables:
  * c-file-style: "linux"
  * End:
  */

arch/v850/kernel/anna.c

Diff comments View file @ 59586e5

 /*
  * arch/v850/kernel/anna.c -- Anna V850E2 evaluation chip/board
  *
  *  Copyright (C) 2002,03  NEC Electronics Corporation
  *  Copyright (C) 2002,03  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/major.h>
 #include <linux/irq.h>
 #include <asm/machdep.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
 #include <asm/v850e_timer_d.h>
 #include <asm/v850e_uart.h>
 #include "mach.h"
 /* SRAM and SDRAM are vaguely contiguous (with a big hole in between; see
    mach_reserve_bootmem for details); use both as one big area.  */
 #define RAM_START 	SRAM_ADDR
 #define RAM_END		(SDRAM_ADDR + SDRAM_SIZE)
 /* The bits of this port are connected to an 8-LED bar-graph.  */
 #define LEDS_PORT	0
 static void anna_led_tick (void);
 void __init mach_early_init (void)
 {
 	ANNA_ILBEN    = 0;
 	V850E2_CSC(0) = 0x402F;
 	V850E2_CSC(1) = 0x4000;
 	V850E2_BPC    = 0;
 	V850E2_BSC    = 0xAAAA;
 	V850E2_BEC    = 0;
 #if 0
 	V850E2_BHC    = 0xFFFF;	/* icache all memory, dcache all */
 #else
 	V850E2_BHC    = 0;	/* cache no memory */
 #endif
 	V850E2_BCT(0) = 0xB088;
 	V850E2_BCT(1) = 0x0008;
 	V850E2_DWC(0) = 0x0027;
 	V850E2_DWC(1) = 0;
 	V850E2_BCC    = 0x0006;
 	V850E2_ASC    = 0;
 	V850E2_LBS    = 0x0089;
 	V850E2_SCR(3) = 0x21A9;
 	V850E2_RFS(3) = 0x8121;
 	v850e_intc_disable_irqs ();
 }
 void __init mach_setup (char **cmdline)
 {
 	ANNA_PORT_PM (LEDS_PORT) = 0;	/* Make all LED pins output pins.  */
 	mach_tick = anna_led_tick;
 }
 void __init mach_get_physical_ram (unsigned long *ram_start,
 				   unsigned long *ram_len)
 {
 	*ram_start = RAM_START;
 	*ram_len = RAM_END - RAM_START;
 }
 void __init mach_reserve_bootmem ()
 {
 	/* The space between SRAM and SDRAM is filled with duplicate
 	   images of SRAM.  Prevent the kernel from using them.  */
 	reserve_bootmem (SRAM_ADDR + SRAM_SIZE,
 			 SDRAM_ADDR - (SRAM_ADDR + SRAM_SIZE));
 }
 void mach_gettimeofday (struct timespec *tv)
 {
 	tv->tv_sec = 0;
 	tv->tv_nsec = 0;
 }
 void __init mach_sched_init (struct irqaction *timer_action)
 {
 	/* Start hardware timer.  */
 	v850e_timer_d_configure (0, HZ);
 	/* Install timer interrupt handler.  */
 	setup_irq (IRQ_INTCMD(0), timer_action);
 }
 static struct v850e_intc_irq_init irq_inits[] = {
 	{ "IRQ", 0, 		NUM_MACH_IRQS,	1, 7 },
 	{ "PIN", IRQ_INTP(0),   IRQ_INTP_NUM,   1, 4 },
 	{ "CCC", IRQ_INTCCC(0),	IRQ_INTCCC_NUM, 1, 5 },
 	{ "CMD", IRQ_INTCMD(0), IRQ_INTCMD_NUM,	1, 5 },
 	{ "DMA", IRQ_INTDMA(0), IRQ_INTDMA_NUM,	1, 2 },
 	{ "DMXER", IRQ_INTDMXER,1,		1, 2 },
 	{ "SRE", IRQ_INTSRE(0), IRQ_INTSRE_NUM,	3, 3 },
 	{ "SR",	 IRQ_INTSR(0),	IRQ_INTSR_NUM, 	3, 4 },
 	{ "ST",  IRQ_INTST(0), 	IRQ_INTST_NUM, 	3, 5 },
 	{ 0 }
 };
 #define NUM_IRQ_INITS ((sizeof irq_inits / sizeof irq_inits[0]) - 1)
 static struct hw_interrupt_type hw_itypes[NUM_IRQ_INITS];
 void __init mach_init_irqs (void)
 {
 	v850e_intc_init_irq_types (irq_inits, hw_itypes);
 }
 void machine_restart (char *__unused)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	asm ("jmp r0"); /* Jump to the reset vector.  */
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt (void)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	local_irq_disable ();	/* Ignore all interrupts.  */
 	ANNA_PORT_IO(LEDS_PORT) = 0xAA;	/* Note that we halted.  */
 	for (;;)
 		asm ("halt; nop; nop; nop; nop; nop");
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off (void)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Called before configuring an on-chip UART.  */
 void anna_uart_pre_configure (unsigned chan, unsigned cflags, unsigned baud)
 {
 	/* The Anna connects some general-purpose I/O pins on the CPU to
 	   the RTS/CTS lines of UART 1's serial connection.  I/O pins P07
 	   and P37 are RTS and CTS respectively.  */
 	if (chan == 1) {
 		ANNA_PORT_PM(0) &= ~0x80; /* P07 in output mode */
 		ANNA_PORT_PM(3) |=  0x80; /* P37 in input mode */
 	}
 }
 /* Minimum and maximum bounds for the moving upper LED boundary in the
    clock tick display.  We can't use the last bit because it's used for
    UART0's CTS output.  */
 #define MIN_MAX_POS 0
 #define MAX_MAX_POS 6
 /* There are MAX_MAX_POS^2 - MIN_MAX_POS^2 cycles in the animation, so if
    we pick 6 and 0 as above, we get 49 cycles, which is when divided into
    the standard 100 value for HZ, gives us an almost 1s total time.  */
 #define TICKS_PER_FRAME \
 	(HZ / (MAX_MAX_POS * MAX_MAX_POS - MIN_MAX_POS * MIN_MAX_POS))
 static void anna_led_tick ()
 {
 	static unsigned counter = 0;
 	if (++counter == TICKS_PER_FRAME) {
 		static int pos = 0, max_pos = MAX_MAX_POS, dir = 1;
 		if (dir > 0 && pos == max_pos) {
 			dir = -1;
 			if (max_pos == MIN_MAX_POS)
 				max_pos = MAX_MAX_POS;
 			else
 				max_pos--;
 		} else {
 			if (dir < 0 && pos == 0)
 				dir = 1;
 			if (pos + dir <= max_pos) {
 				/* Each bit of port 0 has a LED. */
 				clear_bit (pos, &ANNA_PORT_IO(LEDS_PORT));
 				pos += dir;
 				set_bit (pos, &ANNA_PORT_IO(LEDS_PORT));
 			}
 		}
 		counter = 0;
 	}
 }

arch/v850/kernel/as85ep1.c

Diff comments View file @ 59586e5

 /*
  * arch/v850/kernel/as85ep1.c -- AS85EP1 V850E evaluation chip/board
  *
  *  Copyright (C) 2002,03  NEC Electronics Corporation
  *  Copyright (C) 2002,03  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/major.h>
 #include <linux/irq.h>
 #include <asm/machdep.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
 #include <asm/v850e_timer_d.h>
 #include <asm/v850e_uart.h>
 #include "mach.h"
 /* SRAM and SDRAM are vaguely contiguous (with a big hole in between; see
    mach_reserve_bootmem for details); use both as one big area.  */
 #define RAM_START 	SRAM_ADDR
 #define RAM_END		(SDRAM_ADDR + SDRAM_SIZE)
 /* The bits of this port are connected to an 8-LED bar-graph.  */
 #define LEDS_PORT	4
 static void as85ep1_led_tick (void);
 extern char _intv_copy_src_start, _intv_copy_src_end;
 extern char _intv_copy_dst_start;
 void __init mach_early_init (void)
 {
 #ifndef CONFIG_ROM_KERNEL
 	const u32 *src;
 	register u32 *dst asm ("ep");
 #endif
 	AS85EP1_CSC(0) = 0x0403;
 	AS85EP1_BCT(0) = 0xB8B8;
 	AS85EP1_DWC(0) = 0x0104;
 	AS85EP1_BCC    = 0x0012;
 	AS85EP1_ASC    = 0;
 	AS85EP1_LBS    = 0x00A9;
 	AS85EP1_PORT_PMC(6)  = 0xFF; /* valid A0,A1,A20-A25 */
 	AS85EP1_PORT_PMC(7)  = 0x0E; /* valid CS1-CS3       */
 	AS85EP1_PORT_PMC(9)  = 0xFF; /* valid D16-D23       */
 	AS85EP1_PORT_PMC(10) = 0xFF; /* valid D24-D31       */
 	AS85EP1_RFS(1) = 0x800c;
 	AS85EP1_RFS(3) = 0x800c;
 	AS85EP1_SCR(1) = 0x20A9;
 	AS85EP1_SCR(3) = 0x20A9;
 #ifndef CONFIG_ROM_KERNEL
 	/* The early chip we have is buggy, and writing the interrupt
 	   vectors into low RAM may screw up, so for non-ROM kernels, we
 	   only rely on the reset vector being downloaded, and copy the
 	   rest of the interrupt vectors into place here.  The specific bug
 	   is that writing address N, where (N & 0x10) == 0x10, will _also_
 	   write to address (N - 0x10).  We avoid this (effectively) by
 	   writing in 16-byte chunks backwards from the end.  */
 	AS85EP1_IRAMM = 0x3;	/* "write-mode" for the internal instruction memory */
 	src = (u32 *)(((u32)&_intv_copy_src_end - 1) & ~0xF);
 	dst = (u32 *)&_intv_copy_dst_start
 		+ (src - (u32 *)&_intv_copy_src_start);
 	do {
 		u32 t0 = src[0], t1 = src[1], t2 = src[2], t3 = src[3];
 		dst[0] = t0; dst[1] = t1; dst[2] = t2; dst[3] = t3;
 		dst -= 4;
 		src -= 4;
 	} while (src > (u32 *)&_intv_copy_src_start);
 	AS85EP1_IRAMM = 0x0;	/* "read-mode" for the internal instruction memory */
 #endif /* !CONFIG_ROM_KERNEL */
 	v850e_intc_disable_irqs ();
 }
 void __init mach_setup (char **cmdline)
 {
 	AS85EP1_PORT_PMC (LEDS_PORT) = 0; /* Make the LEDs port an I/O port. */
 	AS85EP1_PORT_PM (LEDS_PORT) = 0; /* Make all the bits output pins.  */
 	mach_tick = as85ep1_led_tick;
 }
 void __init mach_get_physical_ram (unsigned long *ram_start,
 				   unsigned long *ram_len)
 {
 	*ram_start = RAM_START;
 	*ram_len = RAM_END - RAM_START;
 }
 /* Convenience macros.  */
 #define SRAM_END	(SRAM_ADDR + SRAM_SIZE)
 #define SDRAM_END	(SDRAM_ADDR + SDRAM_SIZE)
 void __init mach_reserve_bootmem ()
 {
 	if (SDRAM_ADDR < RAM_END && SDRAM_ADDR > RAM_START)
 		/* We can't use the space between SRAM and SDRAM, so
 		   prevent the kernel from trying.  */
 		reserve_bootmem (SRAM_END, SDRAM_ADDR - SRAM_END);
 }
 void mach_gettimeofday (struct timespec *tv)
 {
 	tv->tv_sec = 0;
 	tv->tv_nsec = 0;
 }
 void __init mach_sched_init (struct irqaction *timer_action)
 {
 	/* Start hardware timer.  */
 	v850e_timer_d_configure (0, HZ);
 	/* Install timer interrupt handler.  */
 	setup_irq (IRQ_INTCMD(0), timer_action);
 }
 static struct v850e_intc_irq_init irq_inits[] = {
 	{ "IRQ", 0, 		NUM_MACH_IRQS,	1, 7 },
 	{ "CCC", IRQ_INTCCC(0),	IRQ_INTCCC_NUM, 1, 5 },
 	{ "CMD", IRQ_INTCMD(0), IRQ_INTCMD_NUM,	1, 5 },
 	{ "SRE", IRQ_INTSRE(0), IRQ_INTSRE_NUM,	3, 3 },
 	{ "SR",	 IRQ_INTSR(0),	IRQ_INTSR_NUM, 	3, 4 },
 	{ "ST",  IRQ_INTST(0), 	IRQ_INTST_NUM, 	3, 5 },
 	{ 0 }
 };
 #define NUM_IRQ_INITS ((sizeof irq_inits / sizeof irq_inits[0]) - 1)
 static struct hw_interrupt_type hw_itypes[NUM_IRQ_INITS];
 void __init mach_init_irqs (void)
 {
 	v850e_intc_init_irq_types (irq_inits, hw_itypes);
 }
 void machine_restart (char *__unused)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	asm ("jmp r0"); /* Jump to the reset vector.  */
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt (void)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	local_irq_disable ();	/* Ignore all interrupts.  */
 	AS85EP1_PORT_IO (LEDS_PORT) = 0xAA;	/* Note that we halted.  */
 	for (;;)
 		asm ("halt; nop; nop; nop; nop; nop");
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off (void)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Called before configuring an on-chip UART.  */
 void as85ep1_uart_pre_configure (unsigned chan, unsigned cflags, unsigned baud)
 {
 	/* Make the shared uart/port pins be uart pins.  */
 	AS85EP1_PORT_PMC(3) |= (0x5 << chan);
 	/* The AS85EP1 connects some general-purpose I/O pins on the CPU to
 	   the RTS/CTS lines of UART 1's serial connection.  I/O pins P53
 	   and P54 are RTS and CTS respectively.  */
 	if (chan == 1) {
 		/* Put P53 & P54 in I/O port mode.  */
 		AS85EP1_PORT_PMC(5) &= ~0x18;
 		/* Make P53 an output, and P54 an input.  */
 		AS85EP1_PORT_PM(5) |=  0x10;
 	}
 }
 /* Minimum and maximum bounds for the moving upper LED boundary in the
    clock tick display.  */
 #define MIN_MAX_POS 0
 #define MAX_MAX_POS 7
 /* There are MAX_MAX_POS^2 - MIN_MAX_POS^2 cycles in the animation, so if
    we pick 6 and 0 as above, we get 49 cycles, which is when divided into
    the standard 100 value for HZ, gives us an almost 1s total time.  */
 #define TICKS_PER_FRAME \
 	(HZ / (MAX_MAX_POS * MAX_MAX_POS - MIN_MAX_POS * MIN_MAX_POS))
 static void as85ep1_led_tick ()
 {
 	static unsigned counter = 0;
 	if (++counter == TICKS_PER_FRAME) {
 		static int pos = 0, max_pos = MAX_MAX_POS, dir = 1;
 		if (dir > 0 && pos == max_pos) {
 			dir = -1;
 			if (max_pos == MIN_MAX_POS)
 				max_pos = MAX_MAX_POS;
 			else
 				max_pos--;
 		} else {
 			if (dir < 0 && pos == 0)
 				dir = 1;
 			if (pos + dir <= max_pos) {
 				/* Each bit of port 0 has a LED. */
 				set_bit (pos, &AS85EP1_PORT_IO(LEDS_PORT));
 				pos += dir;
 				clear_bit (pos, &AS85EP1_PORT_IO(LEDS_PORT));
 			}
 		}
 		counter = 0;
 	}
 }

arch/v850/kernel/fpga85e2c.c

Diff comments View file @ 59586e5

 /*
  * arch/v850/kernel/fpga85e2c.h -- Machine-dependent defs for
  *	FPGA implementation of V850E2/NA85E2C
  *
  *  Copyright (C) 2002,03  NEC Electronics Corporation
  *  Copyright (C) 2002,03  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/bootmem.h>
 #include <linux/irq.h>
 #include <linux/bitops.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
 #include <asm/machdep.h>
 #include "mach.h"
 extern void memcons_setup (void);
 #define REG_DUMP_ADDR		0x220000
 extern struct irqaction reg_snap_action; /* fwd decl */
 void __init mach_early_init (void)
 {
 	int i;
 	const u32 *src;
 	register u32 *dst asm ("ep");
 	extern u32 _intv_end, _intv_load_start;
 	/* Set bus sizes: CS0 32-bit, CS1 16-bit, CS7 8-bit,
 	   everything else 32-bit.  */
 	V850E2_BSC = 0x2AA6;
 	for (i = 2; i <= 6; i++)
 		CSDEV(i) = 0;	/* 32 bit */
 	/* Ensure that the simulator halts on a panic, instead of going
 	   into an infinite loop inside the panic function.  */
 	panic_timeout = -1;
 	/* Move the interrupt vectors into their real location.  Note that
 	   any relocations there are relative to the real location, so we
 	   don't have to fix anything up.  We use a loop instead of calling
 	   memcpy to keep this a leaf function (to avoid a function
 	   prologue being generated).  */
 	dst = 0x10;		/* &_intv_start + 0x10.  */
 	src = &_intv_load_start;
 	do {
 		u32 t0 = src[0], t1 = src[1], t2 = src[2], t3 = src[3];
 		u32 t4 = src[4], t5 = src[5], t6 = src[6], t7 = src[7];
 		dst[0] = t0; dst[1] = t1; dst[2] = t2; dst[3] = t3;
 		dst[4] = t4; dst[5] = t5; dst[6] = t6; dst[7] = t7;
 		dst += 8;
 		src += 8;
 	} while (dst < &_intv_end);
 }
 void __init mach_setup (char **cmdline)
 {
 	memcons_setup ();
 	/* Setup up NMI0 to copy the registers to a known memory location.
 	   The FGPA board has a button that produces NMI0 when pressed, so
 	   this allows us to push the button, and then look at memory to see
 	   what's in the registers (there's no other way to easily do so).
 	   We have to use `setup_irq' instead of `request_irq' because it's
 	   still too early to do memory allocation.  */
 	setup_irq (IRQ_NMI (0), &reg_snap_action);
 }
 void mach_get_physical_ram (unsigned long *ram_start, unsigned long *ram_len)
 {
 	*ram_start = ERAM_ADDR;
 	*ram_len = ERAM_SIZE;
 }
 void __init mach_sched_init (struct irqaction *timer_action)
 {
 	/* Setup up the timer interrupt.  The FPGA peripheral control
 	   registers _only_ work with single-bit writes (set1/clr1)!  */
 	__clear_bit (RPU_GTMC_CE_BIT, &RPU_GTMC);
 	__clear_bit (RPU_GTMC_CLK_BIT, &RPU_GTMC);
 	__set_bit (RPU_GTMC_CE_BIT, &RPU_GTMC);
 	/* We use the first RPU interrupt, which occurs every 8.192ms.  */
 	setup_irq (IRQ_RPU (0), timer_action);
 }
 void mach_gettimeofday (struct timespec *tv)
 {
 	tv->tv_sec = 0;
 	tv->tv_nsec = 0;
 }
 void machine_halt (void) __attribute__ ((noreturn));
 void machine_halt (void)
 {
 	for (;;) {
 		DWC(0) = 0x7777;
 		DWC(1) = 0x7777;
 		ASC = 0xffff;
 		FLGREG(0) = 1;	/* Halt immediately.  */
 		asm ("di; halt; nop; nop; nop; nop; nop");
 	}
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_restart (char *__unused)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off (void)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Interrupts */
 struct v850e_intc_irq_init irq_inits[] = {
 	{ "IRQ", 0, 		NUM_MACH_IRQS,	1, 7 },
 	{ "RPU", IRQ_RPU(0),	IRQ_RPU_NUM,	1, 6 },
 	{ 0 }
 };
 #define NUM_IRQ_INITS ((sizeof irq_inits / sizeof irq_inits[0]) - 1)
 struct hw_interrupt_type hw_itypes[NUM_IRQ_INITS];
 /* Initialize interrupts.  */
 void __init mach_init_irqs (void)
 {
 	v850e_intc_init_irq_types (irq_inits, hw_itypes);
 }
 /* An interrupt handler that copies the registers to a known memory location,
    for debugging purposes.  */
 static void make_reg_snap (int irq, void *dummy, struct pt_regs *regs)
 {
 	(*(unsigned *)REG_DUMP_ADDR)++;
 	(*(struct pt_regs *)(REG_DUMP_ADDR + sizeof (unsigned))) = *regs;
 }
 static int reg_snap_dev_id;
 static struct irqaction reg_snap_action = {
 	make_reg_snap, 0, CPU_MASK_NONE, "reg_snap", &reg_snap_dev_id, 0
 };

arch/v850/kernel/rte_cb.c

Diff comments View file @ 59586e5

 /*
  * include/asm-v850/rte_cb.c -- Midas lab RTE-CB series of evaluation boards
  *
  *  Copyright (C) 2001,02,03  NEC Electronics Corporation
  *  Copyright (C) 2001,02,03  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/init.h>
 #include <linux/irq.h>
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <asm/machdep.h>
 #include <asm/v850e_uart.h>
 #include "mach.h"
 static void led_tick (void);
 /* LED access routines.  */
 extern unsigned read_leds (int pos, char *buf, int len);
 extern unsigned write_leds (int pos, const char *buf, int len);
 #ifdef CONFIG_RTE_CB_MULTI
 extern void multi_init (void);
 #endif
 void __init rte_cb_early_init (void)
 {
 	v850e_intc_disable_irqs ();
 #ifdef CONFIG_RTE_CB_MULTI
 	multi_init ();
 #endif
 }
 void __init mach_setup (char **cmdline)
 {
 #ifdef CONFIG_RTE_MB_A_PCI
 	/* Probe for Mother-A, and print a message if we find it.  */
 	*(volatile unsigned long *)MB_A_SRAM_ADDR = 0xDEADBEEF;
 	if (*(volatile unsigned long *)MB_A_SRAM_ADDR == 0xDEADBEEF) {
 		*(volatile unsigned long *)MB_A_SRAM_ADDR = 0x12345678;
 		if (*(volatile unsigned long *)MB_A_SRAM_ADDR == 0x12345678)
 			printk (KERN_INFO
 				"          NEC SolutionGear/Midas lab"
 				" RTE-MOTHER-A motherboard\n");
 	}
 #endif /* CONFIG_RTE_MB_A_PCI */
 	mach_tick = led_tick;
 }
 void machine_restart (char *__unused)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	asm ("jmp r0"); /* Jump to the reset vector.  */
 }
-EXPORT_SYMBOL(machine_restart);
 /* This says `HALt.' in LEDese.  */
 static unsigned char halt_leds_msg[] = { 0x76, 0x77, 0x38, 0xF8 };
 void machine_halt (void)
 {
 #ifdef CONFIG_RESET_GUARD
 	disable_reset_guard ();
 #endif
 	/* Ignore all interrupts.  */
 	local_irq_disable ();
 	/* Write a little message.  */
 	write_leds (0, halt_leds_msg, sizeof halt_leds_msg);
 	/* Really halt.  */
 	for (;;)
 		asm ("halt; nop; nop; nop; nop; nop");
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off (void)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Animated LED display for timer tick.  */
 #define TICK_UPD_FREQ	6
 static int tick_frames[][10] = {
 	{ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, -1 },
 	{ 0x63, 0x5c, -1 },
 	{ 0x5c, 0x00, -1 },
 	{ 0x63, 0x00, -1 },
 	{ -1 }
 };
 static void led_tick ()
 {
 	static unsigned counter = 0;
 	if (++counter == (HZ / TICK_UPD_FREQ)) {
 		/* Which frame we're currently displaying for each digit.  */
 		static unsigned frame_nums[LED_NUM_DIGITS] = { 0 };
 		/* Display image.  */
 		static unsigned char image[LED_NUM_DIGITS] = { 0 };
 		unsigned char prev_image[LED_NUM_DIGITS];
 		int write_to_leds = 1; /* true if we should actually display */
 		int digit;
 		/* We check to see if the physical LEDs contains what we last
 		   wrote to them; if not, we suppress display (this is so that
 		   users can write to the LEDs, and not have their output
 		   overwritten).  As a special case, we start writing again if
 		   all the LEDs are blank, or our display image is all zeros
 		   (indicating that this is the initial update, when the actual
 		   LEDs might contain random data).  */
 		read_leds (0, prev_image, LED_NUM_DIGITS);
 		for (digit = 0; digit < LED_NUM_DIGITS; digit++)
 			if (image[digit] != prev_image[digit]
 			    && image[digit] && prev_image[digit])
 			{
 				write_to_leds = 0;
 				break;
 			}
 		/* Update display image.  */
 		for (digit = 0;
 		     digit < LED_NUM_DIGITS && tick_frames[digit][0] >= 0;
 		     digit++)
 		{
 			int frame = tick_frames[digit][frame_nums[digit]];
 			if (frame < 0) {
 				image[digit] = tick_frames[digit][0];
 				frame_nums[digit] = 1;
 			} else {
 				image[digit] = frame;
 				frame_nums[digit]++;
 				break;
 			}
 		}
 		if (write_to_leds)
 			/* Write the display image to the physical LEDs.  */
 			write_leds (0, image, LED_NUM_DIGITS);
 		counter = 0;
 	}
 }
 /* Mother-A interrupts.  */
 #ifdef CONFIG_RTE_GBUS_INT
 #define L GBUS_INT_PRIORITY_LOW
 #define M GBUS_INT_PRIORITY_MEDIUM
 #define H GBUS_INT_PRIORITY_HIGH
 static struct gbus_int_irq_init gbus_irq_inits[] = {
 #ifdef CONFIG_RTE_MB_A_PCI
 	{ "MB_A_LAN",	IRQ_MB_A_LAN,		1,		     1, L },
 	{ "MB_A_PCI1",	IRQ_MB_A_PCI1(0),	IRQ_MB_A_PCI1_NUM,   1, L },
 	{ "MB_A_PCI2",	IRQ_MB_A_PCI2(0),	IRQ_MB_A_PCI2_NUM,   1, L },
 	{ "MB_A_EXT",	IRQ_MB_A_EXT(0),	IRQ_MB_A_EXT_NUM,    1, L },
 	{ "MB_A_USB_OC",IRQ_MB_A_USB_OC(0),	IRQ_MB_A_USB_OC_NUM, 1, L },
 	{ "MB_A_PCMCIA_OC",IRQ_MB_A_PCMCIA_OC,	1,		     1, L },
 #endif
 	{ 0 }
 };
 #define NUM_GBUS_IRQ_INITS  \
    ((sizeof gbus_irq_inits / sizeof gbus_irq_inits[0]) - 1)
 static struct hw_interrupt_type gbus_hw_itypes[NUM_GBUS_IRQ_INITS];
 #endif /* CONFIG_RTE_GBUS_INT */
 void __init rte_cb_init_irqs (void)
 {
 #ifdef CONFIG_RTE_GBUS_INT
 	gbus_int_init_irqs ();
 	gbus_int_init_irq_types (gbus_irq_inits, gbus_hw_itypes);
 #endif /* CONFIG_RTE_GBUS_INT */
 }

arch/v850/kernel/sim.c

Diff comments View file @ 59586e5

 /*
  * arch/v850/kernel/sim.c -- Machine-specific stuff for GDB v850e simulator
  *
  *  Copyright (C) 2001,02  NEC Corporation
  *  Copyright (C) 2001,02  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/bootmem.h>
 #include <linux/irq.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
 #include <asm/machdep.h>
 #include <asm/simsyscall.h>
 #include "mach.h"
 /* The name of a file containing the root filesystem.  */
 #define ROOT_FS "rootfs.image"
 extern void simcons_setup (void);
 extern void simcons_poll_ttys (void);
 extern void set_mem_root (void *addr, size_t len, char *cmd_line);
 static int read_file (const char *name,
 		      unsigned long *addr, unsigned long *len,
 		      const char **err);
 void __init mach_setup (char **cmdline)
 {
 	const char *err;
 	unsigned long root_dev_addr, root_dev_len;
 	simcons_setup ();
 	printk (KERN_INFO "Reading root filesystem: %s", ROOT_FS);
 	if (read_file (ROOT_FS, &root_dev_addr, &root_dev_len, &err)) {
 		printk (" (size %luK)\n", root_dev_len / 1024);
 		set_mem_root ((void *)root_dev_addr, (size_t)root_dev_len,
 			      *cmdline);
 	} else
 		printk ("...%s failed!\n", err);
 }
 void mach_get_physical_ram (unsigned long *ram_start, unsigned long *ram_len)
 {
 	*ram_start = RAM_ADDR;
 	*ram_len = RAM_SIZE;
 }
 void __init mach_sched_init (struct irqaction *timer_action)
 {
 	/* ...do magic timer initialization?...  */
 	mach_tick = simcons_poll_ttys;
 	setup_irq (0, timer_action);
 }
 static void irq_nop (unsigned irq) { }
 static unsigned irq_zero (unsigned irq) { return 0; }
 static struct hw_interrupt_type sim_irq_type = {
 	"IRQ",
 	irq_zero,		/* startup */
 	irq_nop,		/* shutdown */
 	irq_nop,		/* enable */
 	irq_nop,		/* disable */
 	irq_nop,		/* ack */
 	irq_nop,		/* end */
 };
 void __init mach_init_irqs (void)
 {
 	init_irq_handlers (0, NUM_MACH_IRQS, 1, &sim_irq_type);
 }
 void mach_gettimeofday (struct timespec *tv)
 {
 	long timeval[2], timezone[2];
 	int rval = V850_SIM_SYSCALL (gettimeofday, timeval, timezone);
 	if (rval == 0) {
 		tv->tv_sec = timeval[0];
 		tv->tv_nsec = timeval[1] * 1000;
 	}
 }
 void machine_restart (char *__unused)
 {
 	V850_SIM_SYSCALL (write, 1, "RESTART\n", 8);
 	V850_SIM_SYSCALL (exit, 0);
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt (void)
 {
 	V850_SIM_SYSCALL (write, 1, "HALT\n", 5);
 	V850_SIM_SYSCALL (exit, 0);
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off (void)
 {
 	V850_SIM_SYSCALL (write, 1, "POWER OFF\n", 10);
 	V850_SIM_SYSCALL (exit, 0);
 }
-EXPORT_SYMBOL(machine_power_off);
 /* Load data from a file called NAME into ram.  The address and length
    of the data image are returned in ADDR and LEN.  */
 static int __init
 read_file (const char *name,
 	   unsigned long *addr, unsigned long *len,
 	   const char **err)
 {
 	int rval, fd;
 	unsigned long cur, left;
 	/* Note this is not a normal stat buffer, it's an ad-hoc
 	   structure defined by the simulator.  */
 	unsigned long stat_buf[10];
 	/* Stat the file to find out the length.  */
 	rval = V850_SIM_SYSCALL (stat, name, stat_buf);
 	if (rval < 0) {
 		if (err) *err = "stat";
 		return 0;
 	}
 	*len = stat_buf[4];
 	/* Open the file; `0' is O_RDONLY.  */
 	fd = V850_SIM_SYSCALL (open, name, 0);
 	if (fd < 0) {
 		if (err) *err = "open";
 		return 0;
 	}
 	*addr = (unsigned long)alloc_bootmem(*len);
 	if (! *addr) {
 		V850_SIM_SYSCALL (close, fd);
 		if (err) *err = "alloc_bootmem";
 		return 0;
 	}
 	cur = *addr;
 	left = *len;
 	while (left > 0) {
 		int chunk = V850_SIM_SYSCALL (read, fd, cur, left);
 		if (chunk <= 0)
 			break;
 		cur += chunk;
 		left -= chunk;
 	}
 	V850_SIM_SYSCALL (close, fd);
 	if (left > 0) {
 		/* Some read failed.  */
 		free_bootmem (*addr, *len);
 		if (err) *err = "read";
 		return 0;
 	}
 	return 1;
 }

arch/v850/kernel/sim85e2.c

Diff comments View file @ 59586e5

 /*
  * arch/v850/kernel/sim85e2.c -- Machine-specific stuff for
  *	V850E2 RTL simulator
  *
  *  Copyright (C) 2002,03  NEC Electronics Corporation
  *  Copyright (C) 2002,03  Miles Bader <miles@gnu.org>
  *
  * 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.
  *
  * Written by Miles Bader <miles@gnu.org>
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/bootmem.h>
 #include <linux/irq.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
 #include <asm/machdep.h>
 #include "mach.h"
 /* There are 4 possible areas we can use:
      IRAM (1MB) is fast for instruction fetches, but slow for data
      DRAM (1020KB) is fast for data, but slow for instructions
      ERAM is cached, so should be fast for both insns and data
      SDRAM is external DRAM, similar to ERAM
 */
 #define INIT_MEMC_FOR_SDRAM
 #define USE_SDRAM_AREA
 #define KERNEL_IN_SDRAM_AREA
 #define DCACHE_MODE	V850E2_CACHE_BTSC_DCM_WT
 /*#define DCACHE_MODE	V850E2_CACHE_BTSC_DCM_WB_ALLOC*/
 #ifdef USE_SDRAM_AREA
 #define RAM_START 	SDRAM_ADDR
 #define RAM_END		(SDRAM_ADDR + SDRAM_SIZE)
 #else
 /* When we use DRAM, we need to account for the fact that the end of it is
    used for R0_RAM.  */
 #define RAM_START	DRAM_ADDR
 #define RAM_END		R0_RAM_ADDR
 #endif
 extern void memcons_setup (void);
 #ifdef KERNEL_IN_SDRAM_AREA
 #define EARLY_INIT_SECTION_ATTR __attribute__ ((section (".early.text")))
 #else
 #define EARLY_INIT_SECTION_ATTR __init
 #endif
 void EARLY_INIT_SECTION_ATTR mach_early_init (void)
 {
 	/* The sim85e2 simulator tracks `undefined' values, so to make
 	   debugging easier, we begin by zeroing out all otherwise
 	   undefined registers.  This is not strictly necessary.
 	   The registers we zero are:
 	       Every GPR except:
 	           stack-pointer (r3)
 		   task-pointer (r16)
 		   our return addr (r31)
 	       Every system register (SPR) that we know about except for
 	       the PSW (SPR 5), which we zero except for the
 	       disable-interrupts bit.
 	*/
 	/* GPRs */
 	asm volatile ("             mov r0, r1 ; mov r0, r2              ");
 	asm volatile ("mov r0, r4 ; mov r0, r5 ; mov r0, r6 ; mov r0, r7 ");
 	asm volatile ("mov r0, r8 ; mov r0, r9 ; mov r0, r10; mov r0, r11");
 	asm volatile ("mov r0, r12; mov r0, r13; mov r0, r14; mov r0, r15");
 	asm volatile ("             mov r0, r17; mov r0, r18; mov r0, r19");
 	asm volatile ("mov r0, r20; mov r0, r21; mov r0, r22; mov r0, r23");
 	asm volatile ("mov r0, r24; mov r0, r25; mov r0, r26; mov r0, r27");
 	asm volatile ("mov r0, r28; mov r0, r29; mov r0, r30");
 	/* SPRs */
 	asm volatile ("ldsr r0, 0;  ldsr r0, 1;  ldsr r0, 2;  ldsr r0, 3");
 	asm volatile ("ldsr r0, 4");
 	asm volatile ("addi 0x20, r0, r1; ldsr r1, 5"); /* PSW */
 	asm volatile ("ldsr r0, 16; ldsr r0, 17; ldsr r0, 18; ldsr r0, 19");
 	asm volatile ("ldsr r0, 20");
 #ifdef INIT_MEMC_FOR_SDRAM
 	/* Settings for SDRAM controller.  */
 	V850E2_VSWC   = 0x0042;
 	V850E2_BSC    = 0x9286;
 	V850E2_BCT(0) = 0xb000;	/* was: 0 */
 	V850E2_BCT(1) = 0x000b;
 	V850E2_ASC    = 0;
 	V850E2_LBS    = 0xa9aa;	/* was: 0xaaaa */
 	V850E2_LBC(0) = 0;
 	V850E2_LBC(1) = 0;	/* was: 0x3 */
 	V850E2_BCC    = 0;
 	V850E2_RFS(4) = 0x800a;	/* was: 0xf109 */
 	V850E2_SCR(4) = 0x2091;	/* was: 0x20a1 */
 	V850E2_RFS(3) = 0x800c;
 	V850E2_SCR(3) = 0x20a1;
 	V850E2_DWC(0) = 0;
 	V850E2_DWC(1) = 0;
 #endif
 #if 0
 #ifdef CONFIG_V850E2_SIM85E2S
 	/* Turn on the caches.  */
 	V850E2_CACHE_BTSC = V850E2_CACHE_BTSC_ICM | DCACHE_MODE;
 	V850E2_BHC  = 0x1010;
 #elif CONFIG_V850E2_SIM85E2C
 	V850E2_CACHE_BTSC |= (V850E2_CACHE_BTSC_ICM | V850E2_CACHE_BTSC_DCM0);
 	V850E2_BUSM_BHC = 0xFFFF;
 #endif
 #else
 	V850E2_BHC  = 0;
 #endif
 	/* Don't stop the simulator at `halt' instructions.  */
 	SIM85E2_NOTHAL = 1;
 	/* Ensure that the simulator halts on a panic, instead of going
 	   into an infinite loop inside the panic function.  */
 	panic_timeout = -1;
 }
 void __init mach_setup (char **cmdline)
 {
 	memcons_setup ();
 }
 void mach_get_physical_ram (unsigned long *ram_start, unsigned long *ram_len)
 {
 	*ram_start = RAM_START;
 	*ram_len = RAM_END - RAM_START;
 }
 void __init mach_sched_init (struct irqaction *timer_action)
 {
 	/* The simulator actually cycles through all interrupts
 	   periodically.  We just pay attention to IRQ0, which gives us
 	   1/64 the rate of the periodic interrupts.  */
 	setup_irq (0, timer_action);
 }
 void mach_gettimeofday (struct timespec *tv)
 {
 	tv->tv_sec = 0;
 	tv->tv_nsec = 0;
 }
 /* Interrupts */
 struct v850e_intc_irq_init irq_inits[] = {
 	{ "IRQ", 0, NUM_MACH_IRQS, 1, 7 },
 	{ 0 }
 };
 struct hw_interrupt_type hw_itypes[1];
 /* Initialize interrupts.  */
 void __init mach_init_irqs (void)
 {
 	v850e_intc_init_irq_types (irq_inits, hw_itypes);
 }
 void machine_halt (void) __attribute__ ((noreturn));
 void machine_halt (void)
 {
 	SIM85E2_SIMFIN = 0;	/* Halt immediately.  */
 	for (;;) {}
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_restart (char *__unused)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_power_off (void)
 {
 	machine_halt ();
 }
-EXPORT_SYMBOL(machine_power_off);

arch/x86_64/kernel/reboot.c

Diff comments View file @ 59586e5

 /* Various gunk just to reboot the machine. */
 #include <linux/module.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/kernel.h>
 #include <linux/ctype.h>
 #include <linux/string.h>
 #include <asm/io.h>
 #include <asm/kdebug.h>
 #include <asm/delay.h>
 #include <asm/hw_irq.h>
 #include <asm/system.h>
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/apic.h>
 /*
  * Power off function, if any
  */
 void (*pm_power_off)(void);
 static long no_idt[3];
 static enum {
 	BOOT_TRIPLE = 't',
 	BOOT_KBD = 'k'
 } reboot_type = BOOT_KBD;
 static int reboot_mode = 0;
 int reboot_force;
 /* reboot=t[riple] | k[bd] [, [w]arm | [c]old]
    warm   Don't set the cold reboot flag
    cold   Set the cold reboot flag
    triple Force a triple fault (init)
    kbd    Use the keyboard controller. cold reset (default)
    force  Avoid anything that could hang.
  */
 static int __init reboot_setup(char *str)
 {
 	for (;;) {
 		switch (*str) {
 		case 'w':
 			reboot_mode = 0x1234;
 			break;
 		case 'c':
 			reboot_mode = 0;
 			break;
 		case 't':
 		case 'b':
 		case 'k':
 			reboot_type = *str;
 			break;
 		case 'f':
 			reboot_force = 1;
 			break;
 		}
 		if((str = strchr(str,',')) != NULL)
 			str++;
 		else
 			break;
 	}
 	return 1;
 }
 __setup("reboot=", reboot_setup);
 static inline void kb_wait(void)
 {
 	int i;
 	for (i=0; i<0x10000; i++)
 		if ((inb_p(0x64) & 0x02) == 0)
 			break;
 }
 void machine_shutdown(void)
 {
 	/* Stop the cpus and apics */
 #ifdef CONFIG_SMP
 	int reboot_cpu_id;
 	/* The boot cpu is always logical cpu 0 */
 	reboot_cpu_id = 0;
 	/* Make certain the cpu I'm about to reboot on is online */
 	if (!cpu_isset(reboot_cpu_id, cpu_online_map)) {
 		reboot_cpu_id = smp_processor_id();
 	}
 	/* Make certain I only run on the appropriate processor */
 	set_cpus_allowed(current, cpumask_of_cpu(reboot_cpu_id));
 	/* O.K Now that I'm on the appropriate processor,
 	 * stop all of the others.
 	 */
 	smp_send_stop();
 #endif
 	local_irq_disable();
 #ifndef CONFIG_SMP
 	disable_local_APIC();
 #endif
 	disable_IO_APIC();
 	local_irq_enable();
 }
 void machine_restart(char * __unused)
 {
 	int i;
 	printk("machine restart\n");
 	machine_shutdown();
 	if (!reboot_force) {
 		local_irq_disable();
 #ifndef CONFIG_SMP
 		disable_local_APIC();
 #endif
 		disable_IO_APIC();
 		local_irq_enable();
 	}
 	/* Tell the BIOS if we want cold or warm reboot */
 	*((unsigned short *)__va(0x472)) = reboot_mode;
 	for (;;) {
 		/* Could also try the reset bit in the Hammer NB */
 		switch (reboot_type) {
 		case BOOT_KBD:
 		for (i=0; i<100; i++) {
 			kb_wait();
 			udelay(50);
 			outb(0xfe,0x64);         /* pulse reset low */
 			udelay(50);
 		}
 		case BOOT_TRIPLE:
 			__asm__ __volatile__("lidt (%0)": :"r" (&no_idt));
 			__asm__ __volatile__("int3");
 			reboot_type = BOOT_KBD;
 			break;
 		}
 	}
 }
-EXPORT_SYMBOL(machine_restart);
 void machine_halt(void)
 {
 }
-EXPORT_SYMBOL(machine_halt);
 void machine_power_off(void)
 {
 	if (pm_power_off)
 		pm_power_off();
 }
-EXPORT_SYMBOL(machine_power_off);