Based on original work by Karl Volz <karl.volz(a)oracle.com&gt; --- Makefile | 9 +- configure.c | 23 + defs.h | 190 ++++++++- diskdump.c | 36 ++- lkcd_vmdump_v2_v3.h | 2 +- sparc64.c | 1186 +++++++++++++++++++++++++++++++++++++++++++++++++++ symbols.c | 10 + task.c | 11 +- 8 files changed, 1459 insertions(+), 8 deletions(-) create mode 100644 sparc64.c diff --git a/Makefile b/Makefile index e3e4d7d..ed5b43a 100644 --- a/Makefile +++ b/Makefile @@ -20,7 +20,7 @@ PROGRAM=crash # -# Supported targets: X86 ALPHA PPC IA64 PPC64 +# Supported targets: X86 ALPHA PPC IA64 PPC64 SPARC64 # TARGET and GDB_CONF_FLAGS will be configured automatically by configure # TARGET= @@ -62,7 +62,7 @@ VMWARE_HFILES=vmware_vmss.h CFILES=main.c tools.c global_data.c memory.c filesys.c help.c task.c \ kernel.c test.c gdb_interface.c configure.c net.c dev.c \ alpha.c x86.c ppc.c ia64.c s390.c s390x.c s390dbf.c ppc64.c x86_64.c \ - arm.c arm64.c mips.c \ + arm.c arm64.c mips.c sparc64.c \ extensions.c remote.c va_server.c va_server_v1.c symbols.c cmdline.c \ lkcd_common.c lkcd_v1.c lkcd_v2_v3.c lkcd_v5.c lkcd_v7.c lkcd_v8.c\ lkcd_fix_mem.c s390_dump.c lkcd_x86_trace.c \ @@ -81,7 +81,7 @@ SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \ OBJECT_FILES=main.o tools.o global_data.o memory.o filesys.o help.o task.o \ build_data.o kernel.o test.o gdb_interface.o net.o dev.o \ alpha.o x86.o ppc.o ia64.o s390.o s390x.o s390dbf.o ppc64.o x86_64.o \ - arm.o arm64.o mips.o \ + arm.o arm64.o mips.o sparc64.o \ extensions.o remote.o va_server.o va_server_v1.o symbols.o cmdline.o \ lkcd_common.o lkcd_v1.o lkcd_v2_v3.o lkcd_v5.o lkcd_v7.o lkcd_v8.o \ lkcd_fix_mem.o s390_dump.o netdump.o diskdump.o makedumpfile.o xendump.o \ @@ -422,6 +422,9 @@ arm64.o: ${GENERIC_HFILES} ${REDHAT_HFILES} arm64.c mips.o: ${GENERIC_HFILES} ${REDHAT_HFILES} mips.c ${CC} -c ${CRASH_CFLAGS} mips.c ${WARNING_OPTIONS} ${WARNING_ERROR} +sparc64.o: ${GENERIC_HFILES} ${REDHAT_HFILES} sparc64.c + ${CC} -c ${CRASH_CFLAGS} sparc64.c ${WARNING_OPTIONS} ${WARNING_ERROR} + s390.o: ${GENERIC_HFILES} ${IBM_HFILES} s390.c ${CC} -c ${CRASH_CFLAGS} s390.c ${WARNING_OPTIONS} ${WARNING_ERROR} diff --git a/configure.c b/configure.c index a5167db..a416b86 100644 --- a/configure.c +++ b/configure.c @@ -104,6 +104,7 @@ void add_extra_lib(char *); #undef X86_64 #undef ARM #undef ARM64 +#undef SPARC64 #define UNKNOWN 0 #define X86 1 @@ -117,6 +118,7 @@ void add_extra_lib(char *); #define ARM 9 #define ARM64 10 #define MIPS 11 +#define SPARC64 12 #define TARGET_X86 "TARGET=X86" #define TARGET_ALPHA "TARGET=ALPHA" @@ -129,6 +131,7 @@ void add_extra_lib(char *); #define TARGET_ARM "TARGET=ARM" #define TARGET_ARM64 "TARGET=ARM64" #define TARGET_MIPS "TARGET=MIPS" +#define TARGET_SPARC64 "TARGET=SPARC64" #define TARGET_CFLAGS_X86 "TARGET_CFLAGS=-D_FILE_OFFSET_BITS=64" #define TARGET_CFLAGS_ALPHA "TARGET_CFLAGS=" @@ -149,6 +152,7 @@ void add_extra_lib(char *); #define TARGET_CFLAGS_MIPS "TARGET_CFLAGS=-D_FILE_OFFSET_BITS=64" #define TARGET_CFLAGS_MIPS_ON_X86 "TARGET_CFLAGS=-D_FILE_OFFSET_BITS=64" #define TARGET_CFLAGS_MIPS_ON_X86_64 "TARGET_CFLAGS=-m32 -D_FILE_OFFSET_BITS=64" +#define TARGET_CFLAGS_SPARC64 "TARGET_CFLAGS=-mcpu=v9 -fPIC -fno-builtin" #define GDB_TARGET_DEFAULT "GDB_CONF_FLAGS=" #define GDB_TARGET_ARM_ON_X86 "GDB_CONF_FLAGS=--target=arm-elf-linux" @@ -378,6 +382,9 @@ get_current_configuration(struct supported_gdb_version *sp) #ifdef __mips__ target_data.target = MIPS; #endif +#if defined(__sparc__) && defined(__arch64__) + target_data.target = SPARC64; +#endif set_initial_target(sp); @@ -510,6 +517,10 @@ get_current_configuration(struct supported_gdb_version *sp) if ((target_data.target == PPC) && (target_data.initial_gdb_target != PPC)) arch_mismatch(sp); + + if ((target_data.target == SPARC64) && + (target_data.initial_gdb_target != SPARC64)) + arch_mismatch(sp); } if ((fp = fopen("Makefile", "r")) == NULL) { @@ -620,6 +631,9 @@ show_configuration(void) case MIPS: printf("TARGET: MIPS\n"); break; + case SPARC64: + printf("TARGET: SPARC64\n"); + break; } if (strlen(target_data.program)) { @@ -729,6 +743,10 @@ build_configure(struct supported_gdb_version *sp) } else target_CFLAGS = TARGET_CFLAGS_MIPS; break; + case SPARC64: + target = TARGET_SPARC64; + target_CFLAGS = TARGET_CFLAGS_SPARC64; + break; } ldflags = get_extra_flags("LDFLAGS.extra", NULL); @@ -1554,6 +1572,8 @@ set_initial_target(struct supported_gdb_version *sp) target_data.initial_gdb_target = ARM; else if (strncmp(buf, "MIPS", strlen("MIPS")) == 0) target_data.initial_gdb_target = MIPS; + else if (strncmp(buf, "SPARC64", strlen("SPARC64")) == 0) + target_data.initial_gdb_target = SPARC64; } char * @@ -1572,6 +1592,7 @@ target_to_name(int target) case ARM: return("ARM"); case ARM64: return("ARM64"); case MIPS: return("MIPS"); + case SPARC64: return("SPARC64"); } return "UNKNOWN"; @@ -1630,6 +1651,8 @@ name_to_target(char *name) return MIPS; else if (strncmp(name, "MIPS", strlen("MIPS")) == 0) return MIPS; + else if (strncmp(name, "sparc64", strlen("sparc64")) == 0) + return SPARC64; return UNKNOWN; } diff --git a/defs.h b/defs.h index 2ecfa03..18aaa79 100644 --- a/defs.h +++ b/defs.h @@ -71,7 +71,7 @@ #if !defined(X86) && !defined(X86_64) && !defined(ALPHA) && !defined(PPC) && \ !defined(IA64) && !defined(PPC64) && !defined(S390) && !defined(S390X) && \ - !defined(ARM) && !defined(ARM64) && !defined(MIPS) + !defined(ARM) && !defined(ARM64) && !defined(MIPS) && !defined(SPARC64) #ifdef __alpha__ #define ALPHA #endif @@ -106,6 +106,9 @@ #ifdef __mipsel__ #define MIPS #endif +#ifdef __sparc_v9__ +#define SPARC64 +#endif #endif #ifdef X86 @@ -141,6 +144,14 @@ #ifdef MIPS #define NR_CPUS (32) #endif +#ifdef SPARC64 +#define NR_CPUS (4096) +#endif + +/* Some architectures require memory accesses to be aligned. */ +#if defined(SPARC64) +#define NEED_ALIGNED_MEM_ACCESS +#endif #define BUFSIZE (1500) #define NULLCHAR ('\0') @@ -2184,6 +2195,45 @@ struct builtin_debug_table { * Facilitators for pulling correctly-sized data out of a buffer at a * known address. */ + +#ifdef NEED_ALIGNED_MEM_ACCESS + +#define DEF_LOADER(TYPE) \ +static inline TYPE \ +load_##TYPE (char *addr) \ +{ \ + TYPE ret; \ + size_t i = sizeof(TYPE); \ + while (i--) \ + ((char *)&ret)[i] = addr[i]; \ + return ret; \ +} + +DEF_LOADER(int); +DEF_LOADER(uint); +DEF_LOADER(long); +DEF_LOADER(ulong); +DEF_LOADER(ulonglong); +DEF_LOADER(ushort); +DEF_LOADER(short); +typedef void *pointer_t; +DEF_LOADER(pointer_t); + +#define LOADER(TYPE) load_##TYPE + +#define INT(ADDR) LOADER(int) ((char *)(ADDR)) +#define UINT(ADDR) LOADER(uint) ((char *)(ADDR)) +#define LONG(ADDR) LOADER(long) ((char *)(ADDR)) +#define ULONG(ADDR) LOADER(ulong) ((char *)(ADDR)) +#define ULONGLONG(ADDR) LOADER(ulonglong) ((char *)(ADDR)) +#define ULONG_PTR(ADDR) ((ulong *) (LOADER(pointer_t) ((char *)(ADDR)))) +#define USHORT(ADDR) LOADER(ushort) ((char *)(ADDR)) +#define SHORT(ADDR) LOADER(short) ((char *)(ADDR)) +#define UCHAR(ADDR) *((unsigned char *)((char *)(ADDR))) +#define VOID_PTR(ADDR) ((void *) (LOADER(pointer_t) ((char *)(ADDR)))) + +#else + #define INT(ADDR) *((int *)((char *)(ADDR))) #define UINT(ADDR) *((uint *)((char *)(ADDR))) #define LONG(ADDR) *((long *)((char *)(ADDR))) @@ -2195,6 +2245,8 @@ struct builtin_debug_table { #define UCHAR(ADDR) *((unsigned char *)((char *)(ADDR))) #define VOID_PTR(ADDR) *((void **)((char *)(ADDR))) +#endif /* NEED_ALIGNED_MEM_ACCESS */ + struct node_table { int node_id; ulong pgdat; @@ -3799,6 +3851,121 @@ struct efi_memory_desc_t { #endif /* S390X */ +#ifdef SPARC64 +#define _64BIT_ +#define MACHINE_TYPE "SPARC64" + +#define PTOV(X) \ + ((unsigned long)(X)-(machdep->machspec->phys_offset)+(machdep->kvbase)) +#define VTOP(X) \ + ((unsigned long)(X)-(machdep->kvbase)+(machdep->machspec->phys_offset)) + +#define USERSPACE_TOP (machdep->machspec->userspace_top) +#define PAGE_OFFSET (machdep->machspec->page_offset) +#define VMALLOC_START (machdep->machspec->vmalloc_start_addr) +#define VMALLOC_END (machdep->machspec->vmalloc_end) +#define MODULES_VADDR (machdep->machspec->modules_vaddr) +#define MODULES_END (machdep->machspec->modules_end) + +extern int sparc64_IS_VMALLOC_ADDR(ulong vaddr); +#define IS_VMALLOC_ADDR(X) sparc64_IS_VMALLOC_ADDR((ulong)(X)) +#define PAGE_SHIFT (13) +#define PAGE_SIZE (1UL << PAGE_SHIFT) +#define PAGE_MASK (~(PAGE_SIZE-1)) +#define PAGEBASE(X) (((ulong)(X)) & (ulong)machdep->pagemask) +#define THREAD_SIZE (2*PAGE_SIZE) + +/* S3 Core + * Core 48-bit physical address supported. + * Bit 47 distinguishes memory or I/O. When set to "1" it is I/O. + */ +#define PHYS_MASK_SHIFT (47) +#define PHYS_MASK (((1UL) << PHYS_MASK_SHIFT) - 1) + +typedef signed int s32; + +/* + * This next two defines are convenience defines for normal page table. + */ +#define PTES_PER_PAGE (1UL << (PAGE_SHIFT - 3)) +#define PTES_PER_PAGE_MASK (PTES_PER_PAGE - 1) + +/* 4-levels / 8K pages */ +#define PG_LVL4_PDIRS_BITS (53) +#define PG_LVL4_PGDIR_SHIFT (43) +#define PG_LVL4_PTRS_PER_PGD (1024) +#define PG_LVL4_PUD_SHIFT (33) +#define PG_LVL4_PTRS_PER_PUD (1024) +#define PG_LVL4_PMD_SHIFT (23) +#define PG_LVL4_PTRS_PER_PMD (1024) +#define PG_LVL4_PTRS_PER_PTE (1UL << (PAGE_SHIFT-3)) +/* Down one huge page */ +#define PG_LVL4_SPARC64_USERSPACE_TOP (-(1UL << 23UL)) +#define PAGE_PMD_HUGE (0x0100000000000000UL) +#define HPAGE_SHIFT (23) + +/* These are for SUN4V. */ +#define _PAGE_VALID (0x8000000000000000UL) +#define _PAGE_NFO_4V (0x4000000000000000UL) +#define _PAGE_MODIFIED_4V (0x2000000000000000UL) +#define _PAGE_ACCESSED_4V (0x1000000000000000UL) +#define _PAGE_READ_4V (0x0800000000000000UL) +#define _PAGE_WRITE_4V (0x0400000000000000UL) +#define _PAGE_PADDR_4V (0x00FFFFFFFFFFE000UL) +#define _PAGE_PFN_MASK (_PAGE_PADDR_4V) +#define _PAGE_P_4V (0x0000000000000100UL) +#define _PAGE_EXEC_4V (0x0000000000000080UL) +#define _PAGE_W_4V (0x0000000000000040UL) +#define _PAGE_PRESENT_4V (0x0000000000000010UL) +#define _PAGE_SZALL_4V (0x0000000000000007UL) +/* There are other page sizes. Some supported. */ +#define _PAGE_SZ4MB_4V (0x0000000000000003UL) +#define _PAGE_SZ512K_4V (0x0000000000000002UL) +#define _PAGE_SZ64K_4V (0x0000000000000001UL) +#define _PAGE_SZ8K_4V (0x0000000000000000UL) + +#define SPARC64_MODULES_VADDR (0x0000000010000000UL) +#define SPARC64_MODULES_END (0x00000000f0000000UL) +#define LOW_OBP_ADDRESS (0x00000000f0000000UL) +#define HI_OBP_ADDRESS (0x0000000100000000UL) +#define SPARC64_VMALLOC_START (0x0000000100000000UL) + +#define SPARC64_STACK_SIZE 0x4000 +#define PTRS_PER_PGD (1024) + +/* sparsemem */ +#define _SECTION_SIZE_BITS 30 +#define _MAX_PHYSMEM_BITS_LVL4 53 + +#define STACK_BIAS 2047 + +struct machine_specific { + ulong flags; + ulong userspace_top; + ulong page_offset; + ulong vmalloc_start; + ulong vmalloc_end; + ulong modules_vaddr; + ulong modules_end; + ulong phys_offset; + ulong __exception_text_start; + ulong __exception_text_end; + struct pt_regs *panic_task_regs; + ulong pte_protnone; + ulong pte_file; + uint pgd_shift; + uint pud_shift; + uint pmd_shift; + uint ptes_per_pte; +}; + +#define TIF_SIGPENDING (2) +#define SWP_OFFSET(E) ((E) >> (13UL+8UL)) +#define SWP_TYPE(E) (((E) >> (13UL)) & 0xffUL) +#define __swp_type(E) SWP_TYPE(E) +#define __swp_offset(E) SWP_OFFSET(E) +#endif /* SPARC64 */ + #ifdef PLATFORM #define SWP_TYPE(entry) (error("PLATFORM_SWP_TYPE: TBD\n")) @@ -3863,6 +4030,10 @@ struct efi_memory_desc_t { #define MAX_HEXADDR_STRLEN (8) #define UVADDR_PRLEN (8) #endif +#ifdef SPARC64 +#define MAX_HEXADDR_STRLEN (16) +#define UVADDR_PRLEN (16) +#endif #define BADADDR ((ulong)(-1)) #define BADVAL ((ulong)(-1)) @@ -4404,6 +4575,9 @@ void dump_build_data(void); #ifdef MIPS #define machdep_init(X) mips_init(X) #endif +#ifdef SPARC64 +#define machdep_init(X) sparc64_init(X) +#endif int clean_exit(int); int untrusted_file(FILE *, char *); char *readmem_function_name(void); @@ -4838,6 +5012,9 @@ void display_help_screen(char *); #ifdef MIPS #define dump_machdep_table(X) mips_dump_machdep_table(X) #endif +#ifdef SPARC64 +#define dump_machdep_table(X) sparc64_dump_machdep_table(X) +#endif extern char *help_pointer[]; extern char *help_alias[]; extern char *help_ascii[]; @@ -5690,6 +5867,17 @@ struct machine_specific { #endif /* MIPS */ /* + * sparc64.c + */ +#ifdef SPARC64 +void sparc64_init(int); +void sparc64_dump_machdep_table(ulong); +int sparc64_vmalloc_addr(ulong); +#define display_idt_table() \ + error(FATAL, "The -d option is not applicable to sparc64.\n") +#endif + +/* * netdump.c */ int is_netdump(char *, ulong); diff --git a/diskdump.c b/diskdump.c index f5ec23d..48667ad 100644 --- a/diskdump.c +++ b/diskdump.c @@ -730,6 +730,8 @@ restart: dd->machine_type = EM_S390; else if (machine_type("ARM64")) dd->machine_type = EM_AARCH64; + else if (machine_type("SPARC64")) + dd->machine_type = EM_SPARCV9; else { error(INFO, "%s: unsupported machine type: %s\n", DISKDUMP_VALID() ? "diskdump" : "compressed kdump", @@ -1382,6 +1384,31 @@ get_diskdump_regs_arm64(struct bt_info *bt, ulong *eip, ulong *esp) machdep->get_stack_frame(bt, eip, esp); } +static void +get_diskdump_regs_sparc64(struct bt_info *bt, ulong *eip, ulong *esp) +{ + Elf64_Nhdr *note; + int len; + + if (KDUMP_CMPRS_VALID() && + (bt->task == tt->panic_task || + (is_task_active(bt->task) && dd->num_prstatus_notes > 1))) { + note = (Elf64_Nhdr *)dd->nt_prstatus_percpu[bt->tc->processor]; + if (!note) + error(FATAL, + "cannot determine NT_PRSTATUS ELF note " + "for %s task: %lx\n", + (bt->task == tt->panic_task) ? + "panic" : "active", bt->task); + len = sizeof(Elf64_Nhdr); + len = roundup(len + note->n_namesz, 4); + bt->machdep = (void *)((char *)note + len + + MEMBER_OFFSET("elf_prstatus", "pr_reg")); + } + + machdep->get_stack_frame(bt, eip, esp); +} + /* * Send the request to the proper architecture hander. */ @@ -1432,6 +1459,10 @@ get_diskdump_regs(struct bt_info *bt, ulong *eip, ulong *esp) get_diskdump_regs_arm64(bt, eip, esp); break; + case EM_SPARCV9: + get_diskdump_regs_sparc64(bt, eip, esp); + break; + default: error(FATAL, "%s: unsupported machine type: %s\n", DISKDUMP_VALID() ? "diskdump" : "compressed kdump", @@ -1577,7 +1608,8 @@ dump_note_offsets(FILE *fp) for (tot = cnt = 0; tot < size; tot += len) { qemu = FALSE; if (machine_type("X86_64") || machine_type("S390X") || - machine_type("ARM64") || machine_type("PPC64")) { + machine_type("ARM64") || machine_type("PPC64") || + machine_type("SPARC64")) { note64 = (void *)dd->notes_buf + tot; len = sizeof(Elf64_Nhdr); if (STRNEQ((char *)note64 + len, "QEMU")) @@ -1684,6 +1716,8 @@ __diskdump_memory_dump(FILE *fp) fprintf(fp, "(EM_S390)\n"); break; case EM_AARCH64: fprintf(fp, "(EM_AARCH64)\n"); break; + case EM_SPARCV9: + fprintf(fp, "(EM_SPARCV9)\n"); break; default: fprintf(fp, "(unknown)\n"); break; } diff --git a/lkcd_vmdump_v2_v3.h b/lkcd_vmdump_v2_v3.h index 7b014ec..8d5eae4 100644 --- a/lkcd_vmdump_v2_v3.h +++ b/lkcd_vmdump_v2_v3.h @@ -36,7 +36,7 @@ #endif #if defined(ARM) || defined(X86) || defined(PPC) || defined(S390) || \ - defined(S390X) || defined(ARM64) || defined(MIPS) + defined(S390X) || defined(ARM64) || defined(MIPS) || defined(SPARC64) /* * Kernel header file for Linux crash dumps. diff --git a/sparc64.c b/sparc64.c new file mode 100644 index 0000000..7d26137 --- /dev/null +++ b/sparc64.c @@ -0,0 +1,1186 @@ +#ifdef SPARC64 + +#include "defs.h" +#include <stdio.h> +#include <elf.h> +#include <asm/ptrace.h> +#include <linux/const.h> + +/* Things not done, debugged or tested at this point: + * 1) uvtop swap handling + * 2) uniform page table layout - like we had in 1st quarter of 2013 + * 3) and whatever can't be thought of. + */ +#define true (1) +#define false (0) + +static const unsigned long not_valid_pte = ~0UL; +static struct machine_specific sparc64_machine_specific; +static unsigned long sparc64_ksp_offset; +#define MAGIC_TT (0x1ff) + +static unsigned long __va(unsigned long paddr) +{ + return paddr + PAGE_OFFSET; +} + +static unsigned long __pa(unsigned long vaddr) +{ + return vaddr - PAGE_OFFSET; +} + +static uint page_size(void) +{ + return machdep->pagesize; +} + +static void sparc64_parse_cmdline_args(void) +{ +} + +/* This interface might not be required. */ +static void sparc64_clear_machdep_cache(void) +{ +} + +/* + * "mach" command output. + */ +static void +sparc64_display_machine_stats(void) +{ + int c; + struct new_utsname *uts; + char buf[BUFSIZE]; + ulong mhz; + + uts = &kt->utsname; + + fprintf(fp, " MACHINE TYPE: %s\n", uts->machine); + fprintf(fp, " MEMORY SIZE: %s\n", get_memory_size(buf)); + fprintf(fp, " CPUS: %d\n", kt->cpus); + fprintf(fp, " PROCESSOR SPEED: "); + if ((mhz = machdep->processor_speed())) + fprintf(fp, "%ld Mhz\n", mhz); + else + fprintf(fp, "(unknown)\n"); + fprintf(fp, " HZ: %d\n", machdep->hz); + fprintf(fp, " PAGE SIZE: %d\n", PAGESIZE()); + fprintf(fp, " KERNEL VIRTUAL BASE: %lx\n", machdep->kvbase); + fprintf(fp, " KERNEL VMALLOC BASE: %lx\n", vt->vmalloc_start); + fprintf(fp, " KERNEL MODULES BASE: %lx\n", MODULES_VADDR); + fprintf(fp, " KERNEL STACK SIZE: %ld\n", STACKSIZE()); + + fprintf(fp, "HARD IRQ STACK SIZE: %ld\n", THREAD_SIZE); + fprintf(fp, " HARD IRQ STACKS:\n"); + + for (c = 0; c < kt->cpus; c++) { + if (!tt->hardirq_ctx[c]) + continue; + sprintf(buf, "CPU %d", c); + fprintf(fp, "%19s: %lx\n", buf, tt->hardirq_ctx[c]); + } + + fprintf(fp, "SOFT IRQ STACK SIZE: %ld\n", THREAD_SIZE); + fprintf(fp, " SOFT IRQ STACKS:\n"); + for (c = 0; c < kt->cpus; c++) { + if (!tt->softirq_ctx[c]) + continue; + sprintf(buf, "CPU %d", c); + fprintf(fp, "%19s: %lx\n", buf, tt->softirq_ctx[c]); + } +} + +static void sparc64_display_memmap(void) +{ + unsigned long iomem_resource; + unsigned long resource; + unsigned long start, end, nameptr; + int size = STRUCT_SIZE("resource"); + char *buf = GETBUF(size); + char name[32]; + + iomem_resource = symbol_value("iomem_resource"); + + readmem(iomem_resource + MEMBER_OFFSET("resource", "child"), KVADDR, + &resource, sizeof(resource), "iomem_resource", FAULT_ON_ERROR); + + fprintf(fp, " PHYSICAL ADDRESS RANGE TYPE\n"); + + while (resource) { + readmem(resource, KVADDR, buf, size, "resource", + FAULT_ON_ERROR); + start = ULONG(buf + MEMBER_OFFSET("resource", "start")); + end = ULONG(buf + MEMBER_OFFSET("resource", "end")); + nameptr = ULONG(buf + MEMBER_OFFSET("resource", "name")); + + readmem(nameptr, KVADDR, name, sizeof(name), "resource.name", + FAULT_ON_ERROR); + + fprintf(fp, "%016lx - %016lx %-32s\n", start, end, name); + + resource = ULONG(buf + MEMBER_OFFSET("resource", "sibling")); + } +} + +static void sparc64_cmd_mach(void) +{ + int c; + int mflag = 0; + + while ((c = getopt(argcnt, args, "cm")) != EOF) { + switch (c) { + case 'm': + mflag++; + sparc64_display_memmap(); + break; + case 'c': + fprintf(fp, "SPARC64: '-%c' option is not supported\n", + c); + break; + default: + argerrs++; + break; + } + } + + if (argerrs) + cmd_usage(pc->curcmd, SYNOPSIS); + + if (!mflag) + sparc64_display_machine_stats(); +} + +struct sparc64_mem_ranges { + unsigned long start; + unsigned long end; +}; + +#define NR_PHYS_RANGES (128) +static unsigned int nr_phys_ranges; +struct sparc64_mem_ranges phys_ranges[NR_PHYS_RANGES]; + +#define NR_IMAGE_RANGES (16) +static unsigned int nr_kimage_ranges; +struct sparc64_mem_ranges kimage_ranges[NR_IMAGE_RANGES]; + +/* There are three live cases: + * one) normal kernel + * two) --load-panic kernel + * and + * three) --load kernel + * One and two can be treated the same because the kernel is physically + * contiguous. Three isn't contiguous. The kernel is allocated in order + * nine allocation pages. We don't handle case three yet. + */ + +static int sparc64_phys_live_valid(unsigned long paddr) +{ + unsigned int nr; + int rc = false; + + for (nr = 0U; nr != nr_phys_ranges; nr++) { + if (paddr >= phys_ranges[nr].start && + paddr < phys_ranges[nr].end) { + rc = true; + break; + } + } + return rc; +} + +static int sparc64_phys_kdump_valid(unsigned long paddr) +{ + return true; +} + +static int sparc64_verify_paddr(unsigned long paddr) +{ + int rc; + + if (ACTIVE()) + rc = sparc64_phys_live_valid(paddr); + else + rc = sparc64_phys_kdump_valid(paddr); + + return rc; +} + +static void sparc6_phys_base_live_limits(void) +{ + if (nr_phys_ranges >= NR_PHYS_RANGES) + error(FATAL, "sparc6_phys_base_live_limits: " + "NR_PHYS_RANGES exceeded.\n"); + else if (nr_kimage_ranges >= NR_IMAGE_RANGES) + error(FATAL, "sparc6_phys_base_live_limits: " + "NR_IMAGE_RANGES exceeded.\n"); +} + +static void sparc64_phys_base_live_valid(void) +{ + if (!nr_phys_ranges) + error(FATAL, "No physical memory ranges."); + else if (!nr_kimage_ranges) + error(FATAL, "No vmlinux memory ranges."); +} + +static void sparc64_phys_base_live(void) +{ + char line[BUFSIZE]; + FILE *fp; + + fp = fopen("/proc/iomem", "r"); + if (fp == NULL) + error(FATAL, "Can't open /proc/iomem. We can't proceed."); + + while (fgets(line, sizeof(line), fp) != 0) { + unsigned long start, end; + int count, consumed; + char *ch; + + sparc6_phys_base_live_limits(); + count = sscanf(line, "%lx-%lx : %n", &start, &end, &consumed); + if (count != 2) + continue; + ch = line + consumed; + if (memcmp(ch, "System RAM\n", 11) == 0) { + end = end + 1; + phys_ranges[nr_phys_ranges].start = start; + phys_ranges[nr_phys_ranges].end = end; + nr_phys_ranges++; + } else if ((memcmp(ch, "Kernel code\n", 12) == 0) || + (memcmp(ch, "Kernel data\n", 12) == 0) || + (memcmp(ch, "Kernel bss\n", 11) == 0)) { + kimage_ranges[nr_kimage_ranges].start = start; + kimage_ranges[nr_kimage_ranges].end = end; + nr_kimage_ranges++; + } + } + + (void) fclose(fp); + sparc64_phys_base_live_valid(); +} + +static void sparc64_phys_base_kdump(void) +{ +} + +static void sparc64_phys_base(void) +{ + if (ACTIVE()) + return sparc64_phys_base_live(); + else + return sparc64_phys_base_kdump(); +} + +static unsigned long kva_start, kva_end; +static unsigned long kpa_start, kpa_end; + +static void sparc64_kimage_limits_live(void) +{ + kpa_start = kimage_ranges[0].start; + kpa_end = kpa_start + (kva_end - kva_start); +} + +static void sparc64_kimage_limits_kdump(void) +{ + unsigned long phys_base; + + if (DISKDUMP_DUMPFILE()) { + if (diskdump_phys_base(&phys_base)) { + kpa_start = phys_base | (kva_start & 0xffff); + kpa_end = kpa_start + (kva_end - kva_start); + return; + } + } + fprintf(stderr, "Can't determine phys_base\n"); +} + +static unsigned long kimage_va_translate(unsigned long addr) +{ + unsigned long paddr = (addr - kva_start) + kpa_start; + + return paddr; +} + +static int kimage_va_range(unsigned long addr) +{ + if (addr >= kva_start && addr < kva_end) + return true; + else + return false; +} + +static void sparc64_kimage_limits(void) +{ + kva_start = symbol_value("_stext"); + kva_end = symbol_value("_end"); + + if (ACTIVE()) + sparc64_kimage_limits_live(); + else + sparc64_kimage_limits_kdump(); +} + +static int sparc64_is_linear_mapped(unsigned long vaddr) +{ + int rc = 0; + + if ((vaddr & PAGE_OFFSET) == PAGE_OFFSET) + rc = 1; + return rc; +} + +static unsigned long pte_to_pa(unsigned long pte) +{ + unsigned long paddr = pte & _PAGE_PFN_MASK; + + return paddr; +} + +static unsigned long fetch_page_table_level(unsigned long pte_kva, + unsigned long vaddr, unsigned int shift, + unsigned int mask, const char *name, + int verbose) +{ + unsigned int pte_index = (vaddr >> shift) & mask; + unsigned long page_table[PTES_PER_PAGE]; + unsigned long pte = 0UL; + int rc; + + rc = readmem(pte_kva, KVADDR, page_table, sizeof(page_table), + (char *)name, RETURN_ON_ERROR); + if (!rc) + goto out; + pte = page_table[pte_index]; + if (verbose) + fprintf(fp, + "%s(0x%.16lx) fetch of pte @index[0x%.4x]=0x%.16lx\n", + name, pte_kva, pte_index, pte); +out: + return pte; +} + +static unsigned int ptes_per_page_mask(void) +{ + return PTES_PER_PAGE_MASK; +} + +static unsigned long pmd_is_huge(unsigned long pmd, unsigned long vaddr, + int verbose) +{ + unsigned long hpage_mask; + unsigned long paddr = 0UL; + + /* We use the pud_shift again to check for uniform versus + * non-uniform page table layout. + */ + if ((pmd & PAGE_PMD_HUGE) == 0UL) + goto out; + hpage_mask = ~((1UL << HPAGE_SHIFT) - 1UL); + paddr = pte_to_pa(pmd) + (vaddr & ~hpage_mask); + if (verbose) + fprintf(fp, "Huge Page/THP pmd=0x%.16lx paddr=0x%.16lx\n", + pmd, paddr); +out: + return paddr; +} + +static unsigned long sparc64_page_table_walk(unsigned long pgd, + unsigned long vaddr, int verbose) +{ + struct machine_specific *ms = &sparc64_machine_specific; + static const char *pgd_text = "pgd fetch"; + static const char *pud_text = "pud fetch"; + static const char *pmd_text = "pmd fetch"; + static const char *pte_text = "pte fetch"; + unsigned long kva = pgd; + unsigned long paddr; + unsigned long pte; + + if (!sparc64_is_linear_mapped(kva)) + error(FATAL, + "sparc64_page_table_walk: pgd must be identity mapped" + " but isn't (0xlx).", pgd); + + pte = fetch_page_table_level(kva, vaddr, ms->pgd_shift, + ptes_per_page_mask(), pgd_text, verbose); + if (!pte) + goto bad; + kva = __va(pte); + /* For PUD folding skip this step. */ + if (ms->pud_shift) { + pte = fetch_page_table_level(kva, vaddr, ms->pud_shift, + ptes_per_page_mask(), pud_text, + verbose); + if (!pte) + goto bad; + } + kva = __va(pte); + pte = fetch_page_table_level(kva, vaddr, ms->pmd_shift, + ptes_per_page_mask(), pmd_text, verbose); + if (!pte) + goto bad; + /* Check for a huge/THP page */ + paddr = pmd_is_huge(pte, vaddr, verbose); + if (paddr) + goto out; + kva = __va(pte); + pte = fetch_page_table_level(kva, vaddr, PAGE_SHIFT, + ms->ptes_per_pte - 1, pte_text, verbose); + if ((pte & _PAGE_VALID) == 0UL) + goto bad; + paddr = pte_to_pa(pte); + paddr = paddr | (vaddr & ~PAGE_MASK); +out: + return paddr; +bad: + return not_valid_pte; +} + +static void sparc64_init_kernel_pgd(void) +{ + int cpu, rc; + ulong v; + + v = symbol_value("init_mm"); + rc = readmem(v + OFFSET(mm_struct_pgd), KVADDR, &v, sizeof(v), + "init_mm.pgd", RETURN_ON_ERROR); + if (!rc) { + error(WARNING, "Can not determine pgd location.\n"); + goto out; + } + + for (cpu = 0; cpu < NR_CPUS; cpu++) + vt->kernel_pgd[cpu] = v; +out: + return; +} + +static int sparc64_get_smp_cpus(void) +{ + int ncpu = MAX(get_cpus_online(), get_highest_cpu_online() + 1); + + return ncpu; +} + +static void sparc64_init_level4(void) +{ + struct machine_specific *machspec = &sparc64_machine_specific; + + machspec->userspace_top = PG_LVL4_SPARC64_USERSPACE_TOP; + machspec->pgd_shift = PG_LVL4_PGDIR_SHIFT; + machspec->pud_shift = PG_LVL4_PUD_SHIFT; + machspec->pmd_shift = PG_LVL4_PMD_SHIFT; + machspec->ptes_per_pte = PG_LVL4_PTRS_PER_PTE; + machdep->max_physmem_bits = _MAX_PHYSMEM_BITS_LVL4; +} + +static ulong sparc64_vmalloc_start(void) +{ + return machdep->machspec->vmalloc_start; +} + +int sparc64_IS_VMALLOC_ADDR(ulong vaddr) +{ + int ret = (vaddr >= machdep->machspec->vmalloc_start && + vaddr < machdep->machspec->vmalloc_end); + + return ret; +} + +static void pt_clear_cache(void) +{ + machdep->last_pgd_read = 0UL; + machdep->last_pud_read = 0UL; + machdep->last_pmd_read = 0UL; + machdep->last_ptbl_read = 0UL; +} + +static void pt_level_alloc(char **lvl, char *name) +{ + size_t sz = page_size(); + void *pointer = malloc(sz); + + if (!pointer) + error(FATAL, name); + *lvl = pointer; +} + +static int sparc64_verify_symbol(const char *name, unsigned long value, + char type) +{ + return true; +} + +static int sparc64_verify_line_number(unsigned long pc, unsigned long low, + unsigned long high) +{ + return true; +} + +static int sparc64_dis_filter(ulong vaddr, char *inbuf, unsigned int radix) +{ + return false; +} + +static int sparc64_eframe_search(struct bt_info *bt) +{ + struct {struct sparc_stackf sf; struct pt_regs pr; } + exception_frame_data; + unsigned long exception_frame = bt->stacktop; + unsigned long first_frame; + struct reg_window one_down; + int rc; + + exception_frame = exception_frame - TRACEREG_SZ - STACKFRAME_SZ; + rc = readmem(exception_frame, KVADDR, &exception_frame_data, + sizeof(exception_frame_data), "EF fetch.", RETURN_ON_ERROR); + if (!rc) + goto out; + if (exception_frame_data.pr.magic != 0x57ac6c00) + goto out; + first_frame = exception_frame - sizeof(struct reg_window); + + rc = readmem(first_frame, KVADDR, &one_down, sizeof(struct reg_window), + "Stack fetch.", RETURN_ON_ERROR); + if (!rc) + goto out; + /* Extra arguments. */ + first_frame = first_frame - (6 * 8); + + rc = readmem(first_frame, KVADDR, &one_down, sizeof(struct reg_window), + "Stack fetch.", RETURN_ON_ERROR); + if (!rc) + goto out; +out: + return rc; +} + +/* Need to handle hardirq and softirq stacks. */ +static int kstack_valid(struct bt_info *bt, unsigned long sp) +{ + unsigned long thread_info = SIZE(thread_info); + unsigned long base = bt->stackbase + thread_info; + unsigned long top = bt->stacktop - sizeof(struct sparc_stackf) - + sizeof(struct pt_regs); + int rc = false; + + if (sp & (16U - 1)) + goto out; + + if ((sp >= base) && (sp <= top)) + rc = true; +out: + return rc; +} + +static void sparc64_print_eframe(struct bt_info *bt, unsigned long stack_top) +{ + struct {struct sparc_stackf sf; struct pt_regs pr; } k_entry; + struct pt_regs *regs = &k_entry.pr; + unsigned long efp; + unsigned int tt; + int rc; + struct reg_window window; + unsigned long rw; + + efp = bt->stkptr + STACK_BIAS - TRACEREG_SZ - STACKFRAME_SZ; + rc = readmem(efp, KVADDR, &k_entry, sizeof(k_entry), + "Stack frame and pt_regs.", RETURN_ON_ERROR); + if (!rc) + goto out; + if ((regs->magic & ~MAGIC_TT) != PT_REGS_MAGIC) { + efp = stack_top - (sizeof(struct pt_regs) + + sizeof(struct sparc_stackf)); + rc = readmem(efp, KVADDR, &k_entry, sizeof(k_entry), + "Stack frame and pt_regs.", RETURN_ON_ERROR); + if (!rc) + goto out; + /* Kernel thread or not in kernel any longer? */ + if ((regs->magic & ~MAGIC_TT) != PT_REGS_MAGIC) + goto out; + } + tt = regs->magic & MAGIC_TT; + fprintf(fp, "TSTATE=0x%lx TT=0x%x TPC=0x%lx TNPC=0x%lx\n", + regs->tstate, tt, regs->tpc, regs->tnpc); + fprintf(fp, " g0=0x%.16lx g1=0x%.16lx g2=0x%.16lx\n", + regs->u_regs[0], + regs->u_regs[1], + regs->u_regs[2]); + fprintf(fp, " g3=0x%.16lx g4=0x%.16lx g5=0x%.16lx\n", + regs->u_regs[3], + regs->u_regs[4], + regs->u_regs[5]); +#define ___INS (8) + fprintf(fp, " g6=0x%.16lx g7=0x%.16lx\n", + regs->u_regs[6], + regs->u_regs[7]); + fprintf(fp, " o0=0x%.16lx o1=0x%.16lx o2=0x%.16lx\n", + regs->u_regs[___INS+0], + regs->u_regs[___INS+1], + regs->u_regs[___INS+2]); + fprintf(fp, " o3=0x%.16lx o4=0x%.16lx o5=0x%.16lx\n", + regs->u_regs[___INS+3], + regs->u_regs[___INS+4], + regs->u_regs[___INS+5]); + fprintf(fp, " sp=0x%.16lx ret_pc=0x%.16lx\n", + regs->u_regs[___INS+6], + regs->u_regs[___INS+7]); +#undef ___INS + rw = bt->stkptr + STACK_BIAS; + if (!kstack_valid(bt, rw)) + goto out; + rc = readmem(rw, KVADDR, &window, sizeof(window), + "Register window.", RETURN_ON_ERROR); + if (!rc) + goto out; + fprintf(fp, " l0=0x%.16lx l1=0x%.16lx l2=0x%.16lx\n", + window.locals[0], window.locals[1], window.locals[2]); + fprintf(fp, " l3=0x%.16lx l4=0x%.16lx l5=0x%.16lx\n", + window.locals[3], window.locals[4], window.locals[5]); + fprintf(fp, " l6=0x%.16lx l7=0x%.16lx\n", + window.locals[6], window.locals[7]); + fprintf(fp, " i0=0x%.16lx i1=0x%.16lx i2=0x%.16lx\n", + window.ins[0], window.ins[1], window.ins[2]); + fprintf(fp, " i3=0x%.16lx i4=0x%.16lx i5=0x%.16lx\n", + window.ins[3], window.ins[4], window.ins[5]); + fprintf(fp, " i6=0x%.16lx i7=0x%.16lx\n", + window.ins[6], window.ins[7]); +out: + return; +} + +static void sparc64_print_frame(struct bt_info *bt, int cnt, unsigned long ip, + unsigned long ksp) +{ + char *symbol = closest_symbol(ip); + + fprintf(fp, "#%d [%lx] %s at %lx\n", cnt, ksp, symbol, ip); + + if (bt->flags & BT_LINE_NUMBERS) { + char buf[BUFSIZE]; + + get_line_number(ip, buf, false); + if (strlen(buf)) + fprintf(fp, "\t%s\n", buf); + } +} + +static void sparc64_back_trace(struct bt_info *bt) +{ + unsigned long stack_top = bt->stacktop; + unsigned long ip = bt->instptr; + unsigned long ksp = bt->stkptr; + struct reg_window window; + int cnt = 0; + int rc; + + do { + if (!kstack_valid(bt, ksp + STACK_BIAS)) + break; + rc = readmem(ksp + STACK_BIAS, KVADDR, &window, sizeof(window), + "KSP window fetch.", RETURN_ON_ERROR); + if (!rc) + goto out; + sparc64_print_frame(bt, cnt, ip, ksp); + ksp = window.ins[6]; + ip = window.ins[7]; + cnt++; + } while (cnt != 50); + sparc64_print_eframe(bt, stack_top); +out: + return; +} + +static ulong sparc64_processor_speed(void) +{ + int cpu; + unsigned long clock_tick; + struct syment *sp; + + if (!MEMBER_EXISTS("cpuinfo_sparc", "clock_tick")) { + error(WARNING, "sparc64 expects clock_tick\n"); + return 0UL; + } + + sp = per_cpu_symbol_search("__cpu_data"); + if (!sp) + return 0UL; + for (cpu = 0; cpu < kt->cpus; cpu++) { + if (!in_cpu_map(ONLINE, cpu)) + continue; + if (!readmem(sp->value + kt->__per_cpu_offset[cpu] + + MEMBER_OFFSET("cpuinfo_sparc", "clock_tick"), + KVADDR, &clock_tick, sizeof(clock_tick), + "clock_tick", QUIET|RETURN_ON_ERROR)) + continue; + return clock_tick/1000000; + } + return 0UL; +} + +static ulong sparc64_get_task_pgd(ulong task) +{ + struct task_context *tc = task_to_context(task); + ulong pgd = NO_TASK; + + if (!tc) + goto out; + readmem(tc->mm_struct + OFFSET(mm_struct_pgd), KVADDR, + &pgd, sizeof(unsigned long), "User pgd.", RETURN_ON_ERROR); +out: + return pgd; +} + +static int sparc64_uvtop(struct task_context *tc, ulong va, physaddr_t *ppaddr, + int verbose) +{ + unsigned long pgd = sparc64_get_task_pgd(tc->task); + unsigned long paddr; + int rc = false; + + if (pgd == NO_TASK) + goto out; + paddr = sparc64_page_table_walk(pgd, va, verbose); + /* For now not_valid_pte skips checking for swap pte. */ + if (paddr == not_valid_pte) { + *ppaddr = 0UL; + goto out; + } + *ppaddr = paddr; + rc = true; +out: + return rc; +} + +static unsigned long sparc64_vmalloc_translate(unsigned long vaddr, int verbose) +{ + unsigned long paddr = sparc64_page_table_walk(vt->kernel_pgd[0], + vaddr, verbose); + + return paddr; +} + +static unsigned long sparc64_linear_translate(unsigned long vaddr) +{ + unsigned long paddr = __pa(vaddr); + + if (sparc64_verify_paddr(paddr) == false) + error(FATAL, + "sparc64_linear_translate: This physical address" + " (0x%lx) is invalid.", paddr); + + return paddr; +} + +static int sparc64_is_vmalloc_mapped(unsigned long vaddr) +{ + struct machine_specific *ms = &sparc64_machine_specific; + int rc = 0; + + /* We exclude OBP range whose TTEs were captured by kernel in + * early boot. It is possible to fetch these but for what purpose? + */ + if ((vaddr >= ms->modules_vaddr && vaddr < ms->modules_end) || + (vaddr >= ms->vmalloc_start && vaddr < ms->vmalloc_end)) + rc = 1; + return rc; +} + +static int sparc64_is_kvaddr(ulong vaddr) +{ + int rc = kimage_va_range(vaddr); + + if (rc) + goto out; + rc = sparc64_is_linear_mapped(vaddr); + if (rc) + goto out; + rc = sparc64_is_vmalloc_mapped(vaddr); +out: + return rc; +} + +static int sparc64_kvtop(struct task_context *tc, ulong vaddr, + physaddr_t *paddr, int verbose) +{ + unsigned long phys_addr; + int rc = false; + + if (kimage_va_range(vaddr)) + phys_addr = kimage_va_translate(vaddr); + else if (sparc64_is_vmalloc_mapped(vaddr)) { + phys_addr = sparc64_vmalloc_translate(vaddr, verbose); + if (phys_addr == not_valid_pte) + goto out; + } else if (sparc64_is_linear_mapped(vaddr)) + phys_addr = sparc64_linear_translate(vaddr); + else { + error(WARNING, + "This is an invalid kernel virtual address=0x%lx.", + vaddr); + goto out; + } + + *paddr = phys_addr; + rc = true; +out: + return rc; +} + +static int sparc64_is_task_addr(ulong task) +{ + int rc = false; + int cpu; + + if (sparc64_is_linear_mapped(task) || kimage_va_range(task)) + rc = true; + else { + for (cpu = 0; cpu < kt->cpus; cpu++) + if (task == tt->idle_threads[cpu]) { + rc = true; + break; + } + } + return rc; +} + +static int sparc64_is_uvaddr(ulong vaddr, struct task_context *tc) +{ + struct machine_specific *ms = &sparc64_machine_specific; + int rc = false; + + if (vaddr < ms->userspace_top) + rc = true; + return rc; +} + +static const char *pte_page_size(unsigned long pte) +{ + static const char *_4Mb = "4Mb"; + static const char *_64Kb = "64Kb"; + static const char *_8Kb = "8Kb"; + static const char *_ns = "Not Supported"; + const char *result; + + switch (pte & _PAGE_SZALL_4V) { + case _PAGE_SZ8K_4V: + result = _8Kb; + break; + case _PAGE_SZ64K_4V: + result = _64Kb; + break; + case _PAGE_SZ4MB_4V: + result = _4Mb; + break; + default: + result = _ns; + } + return result; +} + +static int sparc64_translate_pte(unsigned long pte, void *physaddr, + ulonglong unused) +{ + unsigned long paddr = pte_to_pa(pte); + int rc = false; + int cnt = 0; + + /* Once again not handling swap pte.*/ + if ((pte & _PAGE_VALID) == 0UL) + goto out; + if (pte & _PAGE_NFO_4V) + fprintf(fp, "%sNoFaultOn", cnt++ ? "|" : ""); + if (pte & _PAGE_MODIFIED_4V) + fprintf(fp, "%sModified", cnt++ ? "|" : ""); + if (pte & _PAGE_ACCESSED_4V) + fprintf(fp, "%sAccessed", cnt++ ? "|" : ""); + if (pte & _PAGE_READ_4V) + fprintf(fp, "%sReadSoftware", cnt++ ? "|" : ""); + if (pte & _PAGE_WRITE_4V) + fprintf(fp, "%sWriteSoftware", cnt++ ? "|" : ""); + if (pte & _PAGE_P_4V) + fprintf(fp, "%sPriv", cnt++ ? "|" : ""); + if (pte & _PAGE_EXEC_4V) + fprintf(fp, "%sExecute", cnt++ ? "|" : ""); + if (pte & _PAGE_W_4V) + fprintf(fp, "%sWritable", cnt++ ? "|" : ""); + if (pte & _PAGE_PRESENT_4V) + fprintf(fp, "%sPresent", cnt++ ? "|" : ""); + fprintf(fp, "|PageSize(%s)\n", pte_page_size(pte)); + if (physaddr) + *(unsigned long *)physaddr = paddr; + rc = true; +out: + return rc; +} + +static void sparc64_get_frame(struct bt_info *bt, unsigned long *r14, + unsigned long *r15) +{ + unsigned long ksp_offset = sparc64_ksp_offset + bt->tc->thread_info; + unsigned long ksp; + int rc; + + /* We need thread_info's ksp. This is the stack for sleeping threads + * and captured during switch_to. The rest is fetchable from there. + */ + rc = readmem(ksp_offset, KVADDR, &ksp, sizeof(ksp), "KSP Fetch.", + RETURN_ON_ERROR); + if (!rc) + goto out; + *r14 = ksp; + *r15 = symbol_value("switch_to_pc"); +out: + return; +} + +static void sparc64_get_dumpfile_stack_frame(struct bt_info *bt, + unsigned long *psp, unsigned long *ppc) +{ + unsigned long *pt_regs; + + pt_regs = (unsigned long *)bt->machdep; + + if (!pt_regs) + fprintf(fp, "0%lx: registers not saved\n", bt->task); + + /* pt_regs can be unaligned */ + BCOPY(&pt_regs[30], psp, sizeof(ulong)); + BCOPY(&pt_regs[33], ppc, sizeof(ulong)); +} + +static void sparc64_get_stack_frame(struct bt_info *bt, unsigned long *pcp, + unsigned long *psp) +{ + unsigned long r14, r15; + + if (DUMPFILE() && is_task_active(bt->task)) + sparc64_get_dumpfile_stack_frame(bt, &r14, &r15); + else + sparc64_get_frame(bt, &r14, &r15); + if (pcp) + *pcp = r15; + if (psp) + *psp = r14; +} + +static int sparc64_get_kvaddr_ranges(struct vaddr_range *vrp) +{ + struct machine_specific *ms = machdep->machspec; + + vrp[0].type = KVADDR_UNITY_MAP; + vrp[0].start = ms->page_offset; + vrp[0].end = ~0ULL; + vrp[1].type = KVADDR_VMALLOC; + vrp[1].start = ms->vmalloc_start; + vrp[1].end = ms->vmalloc_end; + vrp[2].type = KVADDR_START_MAP; + vrp[2].start = symbol_value("_start"); + vrp[2].end = symbol_value("_end"); + vrp[3].type = KVADDR_MODULES; + vrp[3].start = ms->modules_vaddr; + vrp[3].end = ms->modules_end; + return 4; +} + +static void sparc64_get_crash_notes(void) +{ + unsigned long *notes_ptrs, size, crash_notes_address; + int ret; + + if (!symbol_exists("crash_notes")) { + error(WARNING, "Could not retrieve crash_notes."); + goto out; + } + + crash_notes_address = symbol_value("crash_notes"); + size = kt->cpus * sizeof(notes_ptrs[0]); + notes_ptrs = (unsigned long *) GETBUF(size); + ret = readmem(crash_notes_address, KVADDR, notes_ptrs, size, + "crash_notes", RETURN_ON_ERROR); + if (!ret) + goto out2; +out2: + FREEBUF(notes_ptrs); +out: + return; +} + +static void sparc64_init_kstack_info(void) +{ + sparc64_ksp_offset = MEMBER_OFFSET("thread_info", "ksp"); +} + +static void sparc64_init_irq_stacks(void) +{ + void *irq_stack; + unsigned long stack_size; + + stack_size = get_array_length("hardirq_stack", NULL, 0) * + sizeof(unsigned long); + irq_stack = malloc(stack_size); + if (!irq_stack) + error(FATAL, "malloc failure in sparc64_init_irq_stacks"); + + get_symbol_data("hardirq_stack", stack_size, irq_stack); + tt->hardirq_ctx = irq_stack; + + stack_size = get_array_length("softirq_stack", NULL, 0) * + sizeof(unsigned long); + irq_stack = malloc(stack_size); + if (!irq_stack) + error(FATAL, "malloc failure in sparc64_init_irq_stacks"); + + get_symbol_data("softirq_stack", stack_size, irq_stack); + tt->softirq_ctx = irq_stack; +} + +static void sparc64_init_vmemmap_info(void) +{ + struct machine_specific *ms = &sparc64_machine_specific; + unsigned long page_struct_size = STRUCT_SIZE("page"); + + /* + * vmemmap memory is addressed as vmalloc memory, so we + * treat it as an etension of the latter. + */ + ms->vmalloc_end += + ((1UL << (machdep->max_physmem_bits - PAGE_SHIFT)) * + page_struct_size); +} + +static void sparc64_init_cpu_info(void) +{ + unsigned long trap_block, per_cpu_base_offset, per_cpu_base; + unsigned long trap_per_cpu; + int cpu; + + if (!symbol_exists("trap_block")) + error(FATAL, "sparc64 requires trap_block symbol.\n"); + + trap_block = symbol_value("trap_block"); + if (!MEMBER_EXISTS("trap_per_cpu", "__per_cpu_base")) + error(FATAL, "sparc64 requires __per_cpu_base.\n"); + trap_per_cpu = STRUCT_SIZE("trap_per_cpu"); + per_cpu_base_offset = MEMBER_OFFSET("trap_per_cpu", "__per_cpu_base"); + for (cpu = 0; cpu < NR_CPUS; cpu++, + trap_block = trap_block + trap_per_cpu) { + + if (!in_cpu_map(POSSIBLE, cpu)) + continue; + readmem(trap_block + per_cpu_base_offset, KVADDR, + &per_cpu_base, sizeof(per_cpu_base), + "sparc64: per_cpu_base", FAULT_ON_ERROR); + kt->__per_cpu_offset[cpu] = per_cpu_base; + } +} + +void sparc64_init(int when) +{ + struct machine_specific *ms = &sparc64_machine_specific; + + switch (when) { + case SETUP_ENV: + machdep->process_elf_notes = process_elf64_notes; + break; + case PRE_SYMTAB: + machdep->machspec = ms; + machdep->verify_paddr = sparc64_verify_paddr; + machdep->verify_symbol = sparc64_verify_symbol; + machdep->verify_line_number = sparc64_verify_line_number; + + if (pc->flags & KERNEL_DEBUG_QUERY) + return; + machdep->flags |= MACHDEP_BT_TEXT; + if (machdep->cmdline_args[0]) + sparc64_parse_cmdline_args(); + break; + + case PRE_GDB: + sparc64_init_level4(); + + machdep->pagesize = memory_page_size(); + machdep->pageshift = ffs(machdep->pagesize) - 1; + machdep->pageoffset = machdep->pagesize - 1; + machdep->pagemask = ~((ulonglong) machdep->pageoffset); + machdep->stacksize = machdep->pagesize * 2; + + machdep->eframe_search = sparc64_eframe_search; + machdep->back_trace = sparc64_back_trace; + machdep->processor_speed = sparc64_processor_speed; + + machdep->uvtop = sparc64_uvtop; + machdep->kvtop = sparc64_kvtop; + machdep->get_task_pgd = sparc64_get_task_pgd; + + machdep->dump_irq = generic_dump_irq; + + machdep->get_stack_frame = sparc64_get_stack_frame; + machdep->get_stackbase = generic_get_stackbase; + machdep->get_stacktop = generic_get_stacktop; + machdep->translate_pte = sparc64_translate_pte; + machdep->memory_size = generic_memory_size; + + machdep->vmalloc_start = sparc64_vmalloc_start; + machdep->is_task_addr = sparc64_is_task_addr; + machdep->is_kvaddr = sparc64_is_kvaddr; + machdep->is_uvaddr = sparc64_is_uvaddr; + machdep->dis_filter = sparc64_dis_filter; + machdep->get_smp_cpus = sparc64_get_smp_cpus; + machdep->clear_machdep_cache = sparc64_clear_machdep_cache; + machdep->get_kvaddr_ranges = sparc64_get_kvaddr_ranges; + machdep->cmd_mach = sparc64_cmd_mach; + machdep->init_kernel_pgd = sparc64_init_kernel_pgd; + machdep->value_to_symbol = generic_machdep_value_to_symbol; + machdep->show_interrupts = generic_show_interrupts; + + pt_level_alloc(&machdep->pgd, "Can't malloc pgd space."); + pt_level_alloc(&machdep->pud, "Can't malloc pud space."); + pt_level_alloc(&machdep->pmd, "Can't malloc pmd space."); + pt_level_alloc(&machdep->ptbl, "Can't malloc ptbl space."); + pt_clear_cache(); + sparc64_phys_base(); + sparc64_kimage_limits(); + break; + + case POST_GDB: + get_symbol_data("PAGE_OFFSET", sizeof(unsigned long), + &machdep->machspec->page_offset); + machdep->kvbase = symbol_value("_stext"); + machdep->identity_map_base = (ulong) PAGE_OFFSET; + machdep->ptrs_per_pgd = PTRS_PER_PGD; + ms->modules_vaddr = SPARC64_MODULES_VADDR; + ms->modules_end = SPARC64_MODULES_END; + ms->vmalloc_start = SPARC64_VMALLOC_START; + get_symbol_data("VMALLOC_END", sizeof(unsigned long), + &ms->vmalloc_end); + machdep->section_size_bits = _SECTION_SIZE_BITS; + if (kernel_symbol_exists("nr_irqs")) + get_symbol_data("nr_irqs", sizeof(unsigned int), + &machdep->nr_irqs); + sparc64_init_vmemmap_info(); + sparc64_init_cpu_info(); + sparc64_init_kstack_info(); + sparc64_init_irq_stacks(); + break; + case POST_VM: + if (!ACTIVE()) + sparc64_get_crash_notes(); + break; + case POST_INIT: + break; + + case LOG_ONLY: + machdep->machspec = &sparc64_machine_specific; + machdep->kvbase = kt->vmcoreinfo._stext_SYMBOL; + break; + } +} + +void sparc64_dump_machdep_table(ulong unused) +{ +} + +#endif /* SPARC64 */ diff --git a/symbols.c b/symbols.c index 51d41d8..75a2194 100644 --- a/symbols.c +++ b/symbols.c @@ -3331,6 +3331,11 @@ is_kernel(char *file) goto bailout; break; + case EM_SPARCV9: + if (machine_type_mismatch(file, "SPARC64", NULL, 0)) + goto bailout; + break; + default: if (machine_type_mismatch(file, "(unknown)", NULL, 0)) goto bailout; @@ -3558,6 +3563,11 @@ is_shared_object(char *file) if (machine_type("ARM64")) return TRUE; break; + + case EM_SPARCV9: + if (machine_type("SPARC64")) + return TRUE; + break; } if (CRASHDEBUG(1)) diff --git a/task.c b/task.c index 7b01951..b2e9fc1 100644 --- a/task.c +++ b/task.c @@ -2368,7 +2368,11 @@ store_context(struct task_context *tc, ulong task, char *tp) tc->pid = (ulong)(*pid_addr); strlcpy(tc->comm, comm_addr, TASK_COMM_LEN); - tc->processor = *processor_addr; +#ifdef SPARC64 + tc->processor = *(unsigned short *) processor_addr; +#else + tc->processor = *processor_addr; +#endif tc->ptask = *parent_addr; tc->mm_struct = *mm_addr; tc->task = task; @@ -5267,7 +5271,7 @@ task_flags(ulong task) fill_task_struct(task); flags = tt->last_task_read ? - ULONG(tt->task_struct + OFFSET(task_struct_flags)) : 0; + UINT(tt->task_struct + OFFSET(task_struct_flags)) : 0; return flags; } @@ -7279,6 +7283,9 @@ get_idle_threads(ulong *tasklist, int nr_cpus) VALID_MEMBER(runqueue_idle)) { runqbuf = GETBUF(SIZE(runqueue)); for (i = 0; i < nr_cpus; i++) { + if (cpu_map_addr("possible") && + !(in_cpu_map(POSSIBLE, i))) + continue; if ((kt->flags & SMP) && (kt->flags & PER_CPU_OFF)) runq = rq_sp->value + kt->__per_cpu_offset[i]; else -- 1.7.1