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

Commit f0514ae323f19ba1ad4bea4174ea274c812f7eee

Authored by James Bottomley 2008-09-11 22:17:23 +0800

Committed by Kyle McMartin 2008-10-11 00:32:30 +0800

Exists in master and in 7 other branches

parisc: initialize unwinder much earlier

The unwinder was being initialized way too late to be any use
debugging early boot crashes. Instead of relying on module_init
initcalls to initialize it, let's do it explicitly as early as
we can.

Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Signed-off-by: Kyle McMartin <kyle@mcmartin.ca>

Showing 3 changed files with 5 additions and 3 deletions Inline Diff

arch/parisc/include/asm/unwind.h
arch/parisc/kernel/setup.c
arch/parisc/kernel/unwind.c

arch/parisc/include/asm/unwind.h

Diff comments View file @ f0514ae

 #ifndef _UNWIND_H_
 #define _UNWIND_H_
 #include <linux/list.h>
 /* From ABI specifications */
 struct unwind_table_entry {
 	unsigned int region_start;
 	unsigned int region_end;
 	unsigned int Cannot_unwind:1; /* 0 */
 	unsigned int Millicode:1;	/* 1 */
 	unsigned int Millicode_save_sr0:1;	/* 2 */
 	unsigned int Region_description:2;	/* 3..4 */
 	unsigned int reserved1:1;	/* 5 */
 	unsigned int Entry_SR:1;	/* 6 */
 	unsigned int Entry_FR:4;	/* number saved *//* 7..10 */
 	unsigned int Entry_GR:5;	/* number saved *//* 11..15 */
 	unsigned int Args_stored:1;	/* 16 */
 	unsigned int Variable_Frame:1;	/* 17 */
 	unsigned int Separate_Package_Body:1;	/* 18 */
 	unsigned int Frame_Extension_Millicode:1;	/* 19 */
 	unsigned int Stack_Overflow_Check:1;	/* 20 */
 	unsigned int Two_Instruction_SP_Increment:1;	/* 21 */
 	unsigned int Ada_Region:1;	/* 22 */
 	unsigned int cxx_info:1;	/* 23 */
 	unsigned int cxx_try_catch:1;	/* 24 */
 	unsigned int sched_entry_seq:1;	/* 25 */
 	unsigned int reserved2:1;	/* 26 */
 	unsigned int Save_SP:1;	/* 27 */
 	unsigned int Save_RP:1;	/* 28 */
 	unsigned int Save_MRP_in_frame:1;	/* 29 */
 	unsigned int extn_ptr_defined:1;	/* 30 */
 	unsigned int Cleanup_defined:1;	/* 31 */
 	unsigned int MPE_XL_interrupt_marker:1;	/* 0 */
 	unsigned int HP_UX_interrupt_marker:1;	/* 1 */
 	unsigned int Large_frame:1;	/* 2 */
 	unsigned int Pseudo_SP_Set:1;	/* 3 */
 	unsigned int reserved4:1;	/* 4 */
 	unsigned int Total_frame_size:27;	/* 5..31 */
 };
 struct unwind_table {
 	struct list_head list;
 	const char *name;
 	unsigned long gp;
 	unsigned long base_addr;
 	unsigned long start;
 	unsigned long end;
 	const struct unwind_table_entry *table;
 	unsigned long length;
 };
 struct unwind_frame_info {
 	struct task_struct *t;
 	/* Eventually we would like to be able to get at any of the registers
 	   available; but for now we only try to get the sp and ip for each
 	   frame */
 	/* struct pt_regs regs; */
 	unsigned long sp, ip, rp, r31;
 	unsigned long prev_sp, prev_ip;
 };
 struct unwind_table *
 unwind_table_add(const char *name, unsigned long base_addr,
 		 unsigned long gp, void *start, void *end);
 void
 unwind_table_remove(struct unwind_table *table);
 void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
 		       struct pt_regs *regs);
 void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t);
 void unwind_frame_init_running(struct unwind_frame_info *info, struct pt_regs *regs);
 int unwind_once(struct unwind_frame_info *info);
 int unwind_to_user(struct unwind_frame_info *info);
+int unwind_init(void);
 #endif

arch/parisc/kernel/setup.c

Diff comments View file @ f0514ae

 /*    $Id: setup.c,v 1.8 2000/02/02 04:42:38 prumpf Exp $
  *
  *    Initial setup-routines for HP 9000 based hardware.
  *
  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  *    Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
  *    Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
  *    Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
  *    Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
  *    Modifications copyright 2001 Ryan Bradetich <rbradetich@uswest.net>
  *
  *    Initial PA-RISC Version: 04-23-1999 by Helge Deller
  *
  *    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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  */
 #include <linux/kernel.h>
 #include <linux/initrd.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/seq_file.h>
 #define PCI_DEBUG
 #include <linux/pci.h>
 #undef PCI_DEBUG
 #include <linux/proc_fs.h>
 #include <asm/processor.h>
 #include <asm/pdc.h>
 #include <asm/led.h>
 #include <asm/machdep.h>	/* for pa7300lc_init() proto */
 #include <asm/pdc_chassis.h>
 #include <asm/io.h>
 #include <asm/setup.h>
+#include <asm/unwind.h>
 static char __initdata command_line[COMMAND_LINE_SIZE];
 /* Intended for ccio/sba/cpu statistics under /proc/bus/{runway|gsc} */
 struct proc_dir_entry * proc_runway_root __read_mostly = NULL;
 struct proc_dir_entry * proc_gsc_root __read_mostly = NULL;
 struct proc_dir_entry * proc_mckinley_root __read_mostly = NULL;
 #if !defined(CONFIG_PA20) && (defined(CONFIG_IOMMU_CCIO) || defined(CONFIG_IOMMU_SBA))
 int parisc_bus_is_phys __read_mostly = 1;	/* Assume no IOMMU is present */
 EXPORT_SYMBOL(parisc_bus_is_phys);
 #endif
 /* This sets the vmerge boundary and size, it's here because it has to
  * be available on all platforms (zero means no-virtual merging) */
 unsigned long parisc_vmerge_boundary = 0;
 unsigned long parisc_vmerge_max_size = 0;
 void __init setup_cmdline(char **cmdline_p)
 {
 	extern unsigned int boot_args[];
 	/* Collect stuff passed in from the boot loader */
 	/* boot_args[0] is free-mem start, boot_args[1] is ptr to command line */
 	if (boot_args[0] < 64) {
 		/* called from hpux boot loader */
 		boot_command_line[0] = '\0';
 	} else {
 		strcpy(boot_command_line, (char *)__va(boot_args[1]));
 #ifdef CONFIG_BLK_DEV_INITRD
 		if (boot_args[2] != 0) /* did palo pass us a ramdisk? */
 		{
 		    initrd_start = (unsigned long)__va(boot_args[2]);
 		    initrd_end = (unsigned long)__va(boot_args[3]);
 		}
 #endif
 	}
 	strcpy(command_line, boot_command_line);
 	*cmdline_p = command_line;
 }
 #ifdef CONFIG_PA11
 void __init dma_ops_init(void)
 {
 	switch (boot_cpu_data.cpu_type) {
 	case pcx:
 		/*
 		 * We've got way too many dependencies on 1.1 semantics
 		 * to support 1.0 boxes at this point.
 		 */
 		panic(	"PA-RISC Linux currently only supports machines that conform to\n"
 			"the PA-RISC 1.1 or 2.0 architecture specification.\n");
 	case pcxs:
 	case pcxt:
 		hppa_dma_ops = &pcx_dma_ops;
 		break;
 	case pcxl2:
 		pa7300lc_init();
 	case pcxl: /* falls through */
 		hppa_dma_ops = &pcxl_dma_ops;
 		break;
 	default:
 		break;
 	}
 }
 #endif
 extern int init_per_cpu(int cpuid);
 extern void collect_boot_cpu_data(void);
 void __init setup_arch(char **cmdline_p)
 {
 #ifdef CONFIG_64BIT
 	extern int parisc_narrow_firmware;
 #endif
+	unwind_init();
 	init_per_cpu(smp_processor_id());	/* Set Modes & Enable FP */
 #ifdef CONFIG_64BIT
 	printk(KERN_INFO "The 64-bit Kernel has started...\n");
 #else
 	printk(KERN_INFO "The 32-bit Kernel has started...\n");
 #endif
 	pdc_console_init();
 #ifdef CONFIG_64BIT
 	if(parisc_narrow_firmware) {
 		printk(KERN_INFO "Kernel is using PDC in 32-bit mode.\n");
 	}
 #endif
 	setup_pdc();
 	setup_cmdline(cmdline_p);
 	collect_boot_cpu_data();
 	do_memory_inventory();  /* probe for physical memory */
 	parisc_cache_init();
 	paging_init();
 #ifdef CONFIG_CHASSIS_LCD_LED
 	/* initialize the LCD/LED after boot_cpu_data is available ! */
 	led_init();		/* LCD/LED initialization */
 #endif
 #ifdef CONFIG_PA11
 	dma_ops_init();
 #endif
 #if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE)
 	conswitchp = &dummy_con;	/* we use take_over_console() later ! */
 #endif
 }
 /*
  * Display CPU info for all CPUs.
  * for parisc this is in processor.c
  */
 extern int show_cpuinfo (struct seq_file *m, void *v);
 static void *
 c_start (struct seq_file *m, loff_t *pos)
 {
     	/* Looks like the caller will call repeatedly until we return
 	 * 0, signaling EOF perhaps.  This could be used to sequence
 	 * through CPUs for example.  Since we print all cpu info in our
 	 * show_cpuinfo() disregarding 'pos' (which I assume is 'v' above)
 	 * we only allow for one "position".  */
 	return ((long)*pos < 1) ? (void *)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)
 {
 }
 const struct seq_operations cpuinfo_op = {
 	.start	= c_start,
 	.next	= c_next,
 	.stop	= c_stop,
 	.show	= show_cpuinfo
 };
 static void __init parisc_proc_mkdir(void)
 {
 	/*
 	** Can't call proc_mkdir() until after proc_root_init() has been
 	** called by start_kernel(). In other words, this code can't
 	** live in arch/.../setup.c because start_parisc() calls
 	** start_kernel().
 	*/
 	switch (boot_cpu_data.cpu_type) {
 	case pcxl:
 	case pcxl2:
 		if (NULL == proc_gsc_root)
 		{
 			proc_gsc_root = proc_mkdir("bus/gsc", NULL);
 		}
 		break;
         case pcxt_:
         case pcxu:
         case pcxu_:
         case pcxw:
         case pcxw_:
         case pcxw2:
                 if (NULL == proc_runway_root)
                 {
                         proc_runway_root = proc_mkdir("bus/runway", NULL);
                 }
                 break;
 	case mako:
 	case mako2:
                 if (NULL == proc_mckinley_root)
                 {
                         proc_mckinley_root = proc_mkdir("bus/mckinley", NULL);
                 }
                 break;
 	default:
 		/* FIXME: this was added to prevent the compiler
 		 * complaining about missing pcx, pcxs and pcxt
 		 * I'm assuming they have neither gsc nor runway */
 		break;
 	}
 }
 static struct resource central_bus = {
 	.name	= "Central Bus",
 	.start	= F_EXTEND(0xfff80000),
 	.end    = F_EXTEND(0xfffaffff),
 	.flags	= IORESOURCE_MEM,
 };
 static struct resource local_broadcast = {
 	.name	= "Local Broadcast",
 	.start	= F_EXTEND(0xfffb0000),
 	.end	= F_EXTEND(0xfffdffff),
 	.flags	= IORESOURCE_MEM,
 };
 static struct resource global_broadcast = {
 	.name	= "Global Broadcast",
 	.start	= F_EXTEND(0xfffe0000),
 	.end	= F_EXTEND(0xffffffff),
 	.flags	= IORESOURCE_MEM,
 };
 static int __init parisc_init_resources(void)
 {
 	int result;
 	result = request_resource(&iomem_resource, &central_bus);
 	if (result < 0) {
 		printk(KERN_ERR
 		       "%s: failed to claim %s address space!\n",
 		       __FILE__, central_bus.name);
 		return result;
 	}
 	result = request_resource(&iomem_resource, &local_broadcast);
 	if (result < 0) {
 		printk(KERN_ERR
 		       "%s: failed to claim %saddress space!\n",
 		       __FILE__, local_broadcast.name);
 		return result;
 	}
 	result = request_resource(&iomem_resource, &global_broadcast);
 	if (result < 0) {
 		printk(KERN_ERR
 		       "%s: failed to claim %s address space!\n",
 		       __FILE__, global_broadcast.name);
 		return result;
 	}
 	return 0;
 }
 extern void gsc_init(void);
 extern void processor_init(void);
 extern void ccio_init(void);
 extern void hppb_init(void);
 extern void dino_init(void);
 extern void iosapic_init(void);
 extern void lba_init(void);
 extern void sba_init(void);
 extern void eisa_init(void);
 static int __init parisc_init(void)
 {
 	u32 osid = (OS_ID_LINUX << 16);
 	parisc_proc_mkdir();
 	parisc_init_resources();
 	do_device_inventory();                  /* probe for hardware */
 	parisc_pdc_chassis_init();
 	/* set up a new led state on systems shipped LED State panel */
 	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_BSTART);
 	/* tell PDC we're Linux. Nevermind failure. */
 	pdc_stable_write(0x40, &osid, sizeof(osid));
 	processor_init();
 	printk(KERN_INFO "CPU(s): %d x %s at %d.%06d MHz\n",
 			boot_cpu_data.cpu_count,
 			boot_cpu_data.cpu_name,
 			boot_cpu_data.cpu_hz / 1000000,
 			boot_cpu_data.cpu_hz % 1000000	);
 	parisc_setup_cache_timing();
 	/* These are in a non-obvious order, will fix when we have an iotree */
 #if defined(CONFIG_IOSAPIC)
 	iosapic_init();
 #endif
 #if defined(CONFIG_IOMMU_SBA)
 	sba_init();
 #endif
 #if defined(CONFIG_PCI_LBA)
 	lba_init();
 #endif
 	/* CCIO before any potential subdevices */
 #if defined(CONFIG_IOMMU_CCIO)
 	ccio_init();
 #endif
 	/*
 	 * Need to register Asp & Wax before the EISA adapters for the IRQ
 	 * regions.  EISA must come before PCI to be sure it gets IRQ region
 	 * 0.
 	 */
 #if defined(CONFIG_GSC_LASI) || defined(CONFIG_GSC_WAX)
 	gsc_init();
 #endif
 #ifdef CONFIG_EISA
 	eisa_init();
 #endif
 #if defined(CONFIG_HPPB)
 	hppb_init();
 #endif
 #if defined(CONFIG_GSC_DINO)
 	dino_init();
 #endif
 #ifdef CONFIG_CHASSIS_LCD_LED
 	register_led_regions();	/* register LED port info in procfs */
 #endif
 	return 0;
 }
 arch_initcall(parisc_init);
 void start_parisc(void)
 {
 	extern void start_kernel(void);
 	int ret, cpunum;
 	struct pdc_coproc_cfg coproc_cfg;
 	cpunum = smp_processor_id();
 	set_firmware_width_unlocked();
 	ret = pdc_coproc_cfg_unlocked(&coproc_cfg);
 	if (ret >= 0 && coproc_cfg.ccr_functional) {
 		mtctl(coproc_cfg.ccr_functional, 10);
 		cpu_data[cpunum].fp_rev = coproc_cfg.revision;
 		cpu_data[cpunum].fp_model = coproc_cfg.model;
 		asm volatile ("fstd	%fr0,8(%sp)");
 	} else {
 		panic("must have an fpu to boot linux");
 	}
 	start_kernel();
 	// not reached
 }

arch/parisc/kernel/unwind.c

Diff comments View file @ f0514ae

 /*
  * Kernel unwinding support
  *
  * (c) 2002-2004 Randolph Chung <tausq@debian.org>
  *
  * Derived partially from the IA64 implementation. The PA-RISC
  * Runtime Architecture Document is also a useful reference to
  * understand what is happening here
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/kallsyms.h>
 #include <asm/uaccess.h>
 #include <asm/assembly.h>
 #include <asm/asm-offsets.h>
 #include <asm/ptrace.h>
 #include <asm/unwind.h>
 /* #define DEBUG 1 */
 #ifdef DEBUG
 #define dbg(x...) printk(x)
 #else
 #define dbg(x...)
 #endif
 #define KERNEL_START (KERNEL_BINARY_TEXT_START - 0x1000)
 extern struct unwind_table_entry __start___unwind[];
 extern struct unwind_table_entry __stop___unwind[];
 static spinlock_t unwind_lock;
 /*
  * the kernel unwind block is not dynamically allocated so that
  * we can call unwind_init as early in the bootup process as
  * possible (before the slab allocator is initialized)
  */
 static struct unwind_table kernel_unwind_table __read_mostly;
 static LIST_HEAD(unwind_tables);
 static inline const struct unwind_table_entry *
 find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
 {
 	const struct unwind_table_entry *e = NULL;
 	unsigned long lo, hi, mid;
 	lo = 0;
 	hi = table->length - 1;
 	while (lo <= hi) {
 		mid = (hi - lo) / 2 + lo;
 		e = &table->table[mid];
 		if (addr < e->region_start)
 			hi = mid - 1;
 		else if (addr > e->region_end)
 			lo = mid + 1;
 		else
 			return e;
 	}
 	return NULL;
 }
 static const struct unwind_table_entry *
 find_unwind_entry(unsigned long addr)
 {
 	struct unwind_table *table;
 	const struct unwind_table_entry *e = NULL;
 	if (addr >= kernel_unwind_table.start &&
 	    addr <= kernel_unwind_table.end)
 		e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
 	else
 		list_for_each_entry(table, &unwind_tables, list) {
 			if (addr >= table->start &&
 			    addr <= table->end)
 				e = find_unwind_entry_in_table(table, addr);
 			if (e)
 				break;
 		}
 	return e;
 }
 static void
 unwind_table_init(struct unwind_table *table, const char *name,
 		  unsigned long base_addr, unsigned long gp,
 		  void *table_start, void *table_end)
 {
 	struct unwind_table_entry *start = table_start;
 	struct unwind_table_entry *end =
 		(struct unwind_table_entry *)table_end - 1;
 	table->name = name;
 	table->base_addr = base_addr;
 	table->gp = gp;
 	table->start = base_addr + start->region_start;
 	table->end = base_addr + end->region_end;
 	table->table = (struct unwind_table_entry *)table_start;
 	table->length = end - start + 1;
 	INIT_LIST_HEAD(&table->list);
 	for (; start <= end; start++) {
 		if (start < end &&
 		    start->region_end > (start+1)->region_start) {
 			printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
 		}
 		start->region_start += base_addr;
 		start->region_end += base_addr;
 	}
 }
 static void
 unwind_table_sort(struct unwind_table_entry *start,
 		  struct unwind_table_entry *finish)
 {
 	struct unwind_table_entry el, *p, *q;
 	for (p = start + 1; p < finish; ++p) {
 		if (p[0].region_start < p[-1].region_start) {
 			el = *p;
 			q = p;
 			do {
 				q[0] = q[-1];
 				--q;
 			} while (q > start &&
 				 el.region_start < q[-1].region_start);
 			*q = el;
 		}
 	}
 }
 struct unwind_table *
 unwind_table_add(const char *name, unsigned long base_addr,
 		 unsigned long gp,
                  void *start, void *end)
 {
 	struct unwind_table *table;
 	unsigned long flags;
 	struct unwind_table_entry *s = (struct unwind_table_entry *)start;
 	struct unwind_table_entry *e = (struct unwind_table_entry *)end;
 	unwind_table_sort(s, e);
 	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
 	if (table == NULL)
 		return NULL;
 	unwind_table_init(table, name, base_addr, gp, start, end);
 	spin_lock_irqsave(&unwind_lock, flags);
 	list_add_tail(&table->list, &unwind_tables);
 	spin_unlock_irqrestore(&unwind_lock, flags);
 	return table;
 }
 void unwind_table_remove(struct unwind_table *table)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&unwind_lock, flags);
 	list_del(&table->list);
 	spin_unlock_irqrestore(&unwind_lock, flags);
 	kfree(table);
 }
 /* Called from setup_arch to import the kernel unwind info */
-static int unwind_init(void)
+int unwind_init(void)
 {
 	long start, stop;
 	register unsigned long gp __asm__ ("r27");
 	start = (long)&__start___unwind[0];
 	stop = (long)&__stop___unwind[0];
 	spin_lock_init(&unwind_lock);
 	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
 	    start, stop,
 	    (stop - start) / sizeof(struct unwind_table_entry));
 	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
 			  gp,
 			  &__start___unwind[0], &__stop___unwind[0]);
 #if 0
 	{
 		int i;
 		for (i = 0; i < 10; i++)
 		{
 			printk("region 0x%x-0x%x\n",
 				__start___unwind[i].region_start,
 				__start___unwind[i].region_end);
 		}
 	}
 #endif
 	return 0;
 }
 #ifdef CONFIG_64BIT
 #define get_func_addr(fptr) fptr[2]
 #else
 #define get_func_addr(fptr) fptr[0]
 #endif
 static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
 {
 	extern void handle_interruption(int, struct pt_regs *);
 	static unsigned long *hi = (unsigned long *)&handle_interruption;
 	if (pc == get_func_addr(hi)) {
 		struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
 		dbg("Unwinding through handle_interruption()\n");
 		info->prev_sp = regs->gr[30];
 		info->prev_ip = regs->iaoq[0];
 		return 1;
 	}
 	return 0;
 }
 static void unwind_frame_regs(struct unwind_frame_info *info)
 {
 	const struct unwind_table_entry *e;
 	unsigned long npc;
 	unsigned int insn;
 	long frame_size = 0;
 	int looking_for_rp, rpoffset = 0;
 	e = find_unwind_entry(info->ip);
 	if (e == NULL) {
 		unsigned long sp;
 		extern char _stext[], _etext[];
 		dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);
 #ifdef CONFIG_KALLSYMS
 		/* Handle some frequent special cases.... */
 		{
 			char symname[KSYM_NAME_LEN];
 			char *modname;
 			kallsyms_lookup(info->ip, NULL, NULL, &modname,
 				symname);
 			dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);
 			if (strcmp(symname, "_switch_to_ret") == 0) {
 				info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
 				info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
 				dbg("_switch_to_ret @ %lx - setting "
 				    "prev_sp=%lx prev_ip=%lx\n",
 				    info->ip, info->prev_sp,
 				    info->prev_ip);
 				return;
 			} else if (strcmp(symname, "ret_from_kernel_thread") == 0 ||
 				   strcmp(symname, "syscall_exit") == 0) {
 				info->prev_ip = info->prev_sp = 0;
 				return;
 			}
 		}
 #endif
 		/* Since we are doing the unwinding blind, we don't know if
 		   we are adjusting the stack correctly or extracting the rp
 		   correctly. The rp is checked to see if it belongs to the
 		   kernel text section, if not we assume we don't have a
 		   correct stack frame and we continue to unwind the stack.
 		   This is not quite correct, and will fail for loadable
 		   modules. */
 		sp = info->sp & ~63;
 		do {
 			unsigned long tmp;
 			info->prev_sp = sp - 64;
 			info->prev_ip = 0;
 			if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
 				break;
 			info->prev_ip = tmp;
 			sp = info->prev_sp;
 		} while (info->prev_ip < (unsigned long)_stext ||
 			 info->prev_ip > (unsigned long)_etext);
 		info->rp = 0;
 		dbg("analyzing func @ %lx with no unwind info, setting "
 		    "prev_sp=%lx prev_ip=%lx\n", info->ip,
 		    info->prev_sp, info->prev_ip);
 	} else {
 		dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
 		    "Save_RP = %d, Millicode = %d size = %u\n",
 		    e->region_start, e->region_end, e->Save_SP, e->Save_RP,
 		    e->Millicode, e->Total_frame_size);
 		looking_for_rp = e->Save_RP;
 		for (npc = e->region_start;
 		     (frame_size < (e->Total_frame_size << 3) ||
 		      looking_for_rp) &&
 		     npc < info->ip;
 		     npc += 4) {
 			insn = *(unsigned int *)npc;
 			if ((insn & 0xffffc000) == 0x37de0000 ||
 			    (insn & 0xffe00000) == 0x6fc00000) {
 				/* ldo X(sp), sp, or stwm X,D(sp) */
 				frame_size += (insn & 0x1 ? -1 << 13 : 0) |
 					((insn & 0x3fff) >> 1);
 				dbg("analyzing func @ %lx, insn=%08x @ "
 				    "%lx, frame_size = %ld\n", info->ip,
 				    insn, npc, frame_size);
 			} else if ((insn & 0xffe00008) == 0x73c00008) {
 				/* std,ma X,D(sp) */
 				frame_size += (insn & 0x1 ? -1 << 13 : 0) |
 					(((insn >> 4) & 0x3ff) << 3);
 				dbg("analyzing func @ %lx, insn=%08x @ "
 				    "%lx, frame_size = %ld\n", info->ip,
 				    insn, npc, frame_size);
 			} else if (insn == 0x6bc23fd9) {
 				/* stw rp,-20(sp) */
 				rpoffset = 20;
 				looking_for_rp = 0;
 				dbg("analyzing func @ %lx, insn=stw rp,"
 				    "-20(sp) @ %lx\n", info->ip, npc);
 			} else if (insn == 0x0fc212c1) {
 				/* std rp,-16(sr0,sp) */
 				rpoffset = 16;
 				looking_for_rp = 0;
 				dbg("analyzing func @ %lx, insn=std rp,"
 				    "-16(sp) @ %lx\n", info->ip, npc);
 			}
 		}
 		if (!unwind_special(info, e->region_start, frame_size)) {
 			info->prev_sp = info->sp - frame_size;
 			if (e->Millicode)
 				info->rp = info->r31;
 			else if (rpoffset)
 				info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
 			info->prev_ip = info->rp;
 			info->rp = 0;
 		}
 		dbg("analyzing func @ %lx, setting prev_sp=%lx "
 		    "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
 		    info->prev_ip, npc);
 	}
 }
 void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
 		       struct pt_regs *regs)
 {
 	memset(info, 0, sizeof(struct unwind_frame_info));
 	info->t = t;
 	info->sp = regs->gr[30];
 	info->ip = regs->iaoq[0];
 	info->rp = regs->gr[2];
 	info->r31 = regs->gr[31];
 	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
 	    t ? (int)t->pid : -1, info->sp, info->ip);
 }
 void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
 {
 	struct pt_regs *r = &t->thread.regs;
 	struct pt_regs *r2;
 	r2 = kmalloc(sizeof(struct pt_regs), GFP_KERNEL);
 	if (!r2)
 		return;
 	*r2 = *r;
 	r2->gr[30] = r->ksp;
 	r2->iaoq[0] = r->kpc;
 	unwind_frame_init(info, t, r2);
 	kfree(r2);
 }
 void unwind_frame_init_running(struct unwind_frame_info *info, struct pt_regs *regs)
 {
 	unwind_frame_init(info, current, regs);
 }
 int unwind_once(struct unwind_frame_info *next_frame)
 {
 	unwind_frame_regs(next_frame);
 	if (next_frame->prev_sp == 0 ||
 	    next_frame->prev_ip == 0)
 		return -1;
 	next_frame->sp = next_frame->prev_sp;
 	next_frame->ip = next_frame->prev_ip;
 	next_frame->prev_sp = 0;
 	next_frame->prev_ip = 0;
 	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
 	    next_frame->t ? (int)next_frame->t->pid : -1,
 	    next_frame->sp, next_frame->ip);
 	return 0;
 }
 int unwind_to_user(struct unwind_frame_info *info)
 {
 	int ret;
 	do {
 		ret = unwind_once(info);
 	} while (!ret && !(info->ip & 3));
 	return ret;
 }
-module_init(unwind_init);