From owner-p4-projects@FreeBSD.ORG Sat Feb 9 07:41:51 2008 Return-Path: Delivered-To: p4-projects@freebsd.org Received: by hub.freebsd.org (Postfix, from userid 32767) id D197916A41B; Sat, 9 Feb 2008 07:41:50 +0000 (UTC) Delivered-To: perforce@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 7E90A16A419 for ; Sat, 9 Feb 2008 07:41:50 +0000 (UTC) (envelope-from jb@freebsd.org) Received: from repoman.freebsd.org (repoman.freebsd.org [IPv6:2001:4f8:fff6::29]) by mx1.freebsd.org (Postfix) with ESMTP id 74F9413C44B for ; Sat, 9 Feb 2008 07:41:50 +0000 (UTC) (envelope-from jb@freebsd.org) Received: from repoman.freebsd.org (localhost [127.0.0.1]) by repoman.freebsd.org (8.14.1/8.14.1) with ESMTP id m197foao076941 for ; Sat, 9 Feb 2008 07:41:50 GMT (envelope-from jb@freebsd.org) Received: (from perforce@localhost) by repoman.freebsd.org (8.14.1/8.14.1/Submit) id m197foeJ076938 for perforce@freebsd.org; Sat, 9 Feb 2008 07:41:50 GMT (envelope-from jb@freebsd.org) Date: Sat, 9 Feb 2008 07:41:50 GMT Message-Id: <200802090741.m197foeJ076938@repoman.freebsd.org> X-Authentication-Warning: repoman.freebsd.org: perforce set sender to jb@freebsd.org using -f From: John Birrell To: Perforce Change Reviews Cc: Subject: PERFORCE change 135093 for review X-BeenThere: p4-projects@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: p4 projects tree changes List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 09 Feb 2008 07:41:51 -0000 http://perforce.freebsd.org/chv.cgi?CH=135093 Change 135093 by jb@jb_freebsd1 on 2008/02/09 07:41:07 Make i386 match amd64. Affected files ... .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_asm.S#5 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_isa.c#6 edit .. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_subr.c#10 edit .. //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#36 edit Differences ... ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_asm.S#5 (text+ko) ==== @@ -24,7 +24,27 @@ * Use is subject to license terms. */ -#include +#define _ASM + +#include +#include +#include + +/* +void dtrace_invop_init(void) +*/ + ENTRY(dtrace_invop_init) + /* XXX */ + ret + END(dtrace_invop_init) + +/* +void dtrace_invop_uninit(void) +*/ + ENTRY(dtrace_invop_uninit) + /* XXX */ + ret + END(dtrace_invop_uninit) /* greg_t dtrace_getfp(void) @@ -209,3 +229,187 @@ rep; ret /* use 2 byte return instruction when branch target */ /* AMD Software Optimization Guide - Section 6.2 */ END(dtrace_membar_consumer) + +/* +dtrace_icookie_t dtrace_interrupt_disable(void) +*/ + ENTRY(dtrace_interrupt_disable) + pushfl + popl %eax + cli + ret + END(dtrace_interrupt_disable) + +/* +void dtrace_interrupt_enable(dtrace_icookie_t cookie) +*/ + ENTRY(dtrace_interrupt_enable) + movl 4(%esp), %eax + pushl %eax + popfl + ret + END(dtrace_interrupt_enable) + +/* + * The panic() and cmn_err() functions invoke vpanic() as a common entry point + * into the panic code implemented in panicsys(). vpanic() is responsible + * for passing through the format string and arguments, and constructing a + * regs structure on the stack into which it saves the current register + * values. If we are not dying due to a fatal trap, these registers will + * then be preserved in panicbuf as the current processor state. Before + * invoking panicsys(), vpanic() activates the first panic trigger (see + * common/os/panic.c) and switches to the panic_stack if successful. Note that + * DTrace takes a slightly different panic path if it must panic from probe + * context. Instead of calling panic, it calls into dtrace_vpanic(), which + * sets up the initial stack as vpanic does, calls dtrace_panic_trigger(), and + * branches back into vpanic(). + */ +/* +void vpanic(const char *format, va_list alist) +*/ + ENTRY(vpanic) /* Initial stack layout: */ + + pushl %ebp /* | %eip | 20 */ + movl %esp, %ebp /* | %ebp | 16 */ + pushl %eax /* | %eax | 12 */ + pushl %ebx /* | %ebx | 8 */ + pushl %ecx /* | %ecx | 4 */ + pushl %edx /* | %edx | 0 */ + + movl %esp, %ebx /* %ebx = current stack pointer */ + + lea panic_quiesce, %eax /* %eax = &panic_quiesce */ + pushl %eax /* push &panic_quiesce */ + call panic_trigger /* %eax = panic_trigger() */ + addl $4, %esp /* reset stack pointer */ + +vpanic_common: + cmpl $0, %eax /* if (%eax == 0) */ + je 0f /* goto 0f; */ + + /* + * If panic_trigger() was successful, we are the first to initiate a + * panic: we now switch to the reserved panic_stack before continuing. + */ + lea panic_stack, %esp /* %esp = panic_stack */ + addl $PANICSTKSIZE, %esp /* %esp += PANICSTKSIZE */ + +0: subl $REGSIZE, %esp /* allocate struct regs */ + + /* + * Now that we've got everything set up, store the register values as + * they were when we entered vpanic() to the designated location in + * the regs structure we allocated on the stack. + */ +#ifdef DOODAD + mov %gs, %edx + mov %edx, REGOFF_GS(%esp) + mov %fs, %edx + mov %edx, REGOFF_FS(%esp) + mov %es, %edx + mov %edx, REGOFF_ES(%esp) + mov %ds, %edx + mov %edx, REGOFF_DS(%esp) + movl %edi, REGOFF_EDI(%esp) + movl %esi, REGOFF_ESI(%esp) + movl 16(%ebx), %ecx + movl %ecx, REGOFF_EBP(%esp) + movl %ebx, %ecx + addl $20, %ecx + movl %ecx, REGOFF_ESP(%esp) + movl 8(%ebx), %ecx + movl %ecx, REGOFF_EBX(%esp) + movl 0(%ebx), %ecx + movl %ecx, REGOFF_EDX(%esp) + movl 4(%ebx), %ecx + movl %ecx, REGOFF_ECX(%esp) + movl 12(%ebx), %ecx + movl %ecx, REGOFF_EAX(%esp) + movl $0, REGOFF_TRAPNO(%esp) + movl $0, REGOFF_ERR(%esp) + lea vpanic, %ecx + movl %ecx, REGOFF_EIP(%esp) + mov %cs, %edx + movl %edx, REGOFF_CS(%esp) + pushfl + popl %ecx + movl %ecx, REGOFF_EFL(%esp) + movl $0, REGOFF_UESP(%esp) + mov %ss, %edx + movl %edx, REGOFF_SS(%esp) + + movl %esp, %ecx /* %ecx = ®s */ + pushl %eax /* push on_panic_stack */ + pushl %ecx /* push ®s */ + movl 12(%ebp), %ecx /* %ecx = alist */ + pushl %ecx /* push alist */ + movl 8(%ebp), %ecx /* %ecx = format */ + pushl %ecx /* push format */ + call panicsys /* panicsys(); */ + addl $16, %esp /* pop arguments */ + + addl $REGSIZE, %esp +#endif + popl %edx + popl %ecx + popl %ebx + popl %eax + leave + ret + END(vpanic) + +/* +void dtrace_vpanic(const char *format, va_list alist) +*/ + ENTRY(dtrace_vpanic) /* Initial stack layout: */ + + pushl %ebp /* | %eip | 20 */ + movl %esp, %ebp /* | %ebp | 16 */ + pushl %eax /* | %eax | 12 */ + pushl %ebx /* | %ebx | 8 */ + pushl %ecx /* | %ecx | 4 */ + pushl %edx /* | %edx | 0 */ + + movl %esp, %ebx /* %ebx = current stack pointer */ + + lea panic_quiesce, %eax /* %eax = &panic_quiesce */ + pushl %eax /* push &panic_quiesce */ + call dtrace_panic_trigger /* %eax = dtrace_panic_trigger() */ + addl $4, %esp /* reset stack pointer */ + jmp vpanic_common /* jump back to common code */ + + END(dtrace_vpanic) + +/* +int +panic_trigger(int *tp) +*/ + ENTRY(panic_trigger) + xorl %eax, %eax + movl $0xdefacedd, %edx + lock + xchgl %edx, (%edi) + cmpl $0, %edx + je 0f + movl $0, %eax + ret +0: movl $1, %eax + ret + END(panic_trigger) + +/* +int +dtrace_panic_trigger(int *tp) +*/ + ENTRY(dtrace_panic_trigger) + xorl %eax, %eax + movl $0xdefacedd, %edx + lock + xchgl %edx, (%edi) + cmpl $0, %edx + je 0f + movl $0, %eax + ret +0: movl $1, %eax + ret + END(dtrace_panic_trigger) ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_isa.c#6 (text+ko) ==== @@ -57,6 +57,7 @@ dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes, uint32_t *intrpc) { +#ifdef DOODAD int depth = 0; vm_offset_t callpc; register_t ebp; @@ -96,13 +97,14 @@ for (; depth < pcstack_limit; depth++) { pcstack[depth] = 0; } +#endif } +#ifdef DOODAD static int dtrace_getustack_common(uint64_t *pcstack, int pcstack_limit, uintptr_t pc, uintptr_t sp) { -#ifdef DOODAD klwp_t *lwp = ttolwp(curthread); proc_t *p = curproc; uintptr_t oldcontext = lwp->lwp_oldcontext; @@ -174,10 +176,8 @@ } return (ret); -#else -return 0; +} #endif -} void dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit) @@ -388,6 +388,7 @@ uint64_t dtrace_getarg(int arg, int aframes) { +#ifdef DOODAD uintptr_t val; struct frame *fp = (struct frame *)dtrace_getfp(); uintptr_t *stack; @@ -474,12 +475,16 @@ DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); return (val); +#else + return (0); +#endif } /*ARGSUSED*/ int dtrace_getstackdepth(int aframes) { +#ifdef DOODAD int depth = 0; struct frame *frame; vm_offset_t ebp; @@ -505,6 +510,9 @@ return 0; else return depth - aframes; +#else + return (0); +#endif } ulong_t @@ -631,31 +639,35 @@ } void -dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size) +dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size, + volatile uint16_t *flags) { if (dtrace_copycheck(uaddr, kaddr, size)) dtrace_copy(uaddr, kaddr, size); } void -dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size) +dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size, + volatile uint16_t *flags) { if (dtrace_copycheck(uaddr, kaddr, size)) dtrace_copy(kaddr, uaddr, size); } void -dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size) +dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size, + volatile uint16_t *flags) { if (dtrace_copycheck(uaddr, kaddr, size)) - dtrace_copystr(uaddr, kaddr, size); + dtrace_copystr(uaddr, kaddr, size, flags); } void -dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size) +dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size, + volatile uint16_t *flags) { if (dtrace_copycheck(uaddr, kaddr, size)) - dtrace_copystr(kaddr, uaddr, size); + dtrace_copystr(kaddr, uaddr, size, flags); } uint8_t ==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/i386/dtrace_subr.c#10 (text+ko) ==== @@ -50,8 +50,7 @@ struct dtrace_invop_hdlr *dtih_next; } dtrace_invop_hdlr_t; -dtrace_invop_hdlr_t *dtrace_invop_hdlr; -uintptr_t dtrace_invop_addr; +dtrace_invop_hdlr_t *dtrace_invop_hdlr; int dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax) @@ -59,35 +58,9 @@ dtrace_invop_hdlr_t *hdlr; int rval; - /* - * Save the address in a global variable which can be - * read via the kernel debugger in the event that a - * double fault occurs. - * - * From kdb: p *dtrace_invop_addr - * - * Then look up the value in an objdump of the kernel. - */ - dtrace_invop_addr = addr; - - /* - * An invalid opcode fault should not occur while executing - * a probe because only dtrace_ functions are supposed to - * be called by design. Check here if dtrace_probe() is - * in-progress. If so, that's very bad. Very, very bad. We - * can't call any non-dtrace functions to report this, so - * just save the invalid opcode address and hope that the - * dtrace_ioctl will report it. If the DTrace port is - * working according to Sun's design, this should never - * occur. - */ - if (dtrace_in_probe) - dtrace_in_probe_addr = addr; - - for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) { + for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next) if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0) return (rval); - } return (0); } @@ -101,8 +74,6 @@ hdlr->dtih_func = func; hdlr->dtih_next = dtrace_invop_hdlr; dtrace_invop_hdlr = hdlr; - - dtrace_invop_func = dtrace_invop; } void @@ -130,19 +101,6 @@ } kmem_free(hdlr, 0); - - if (dtrace_invop_hdlr == NULL) - dtrace_invop_func = NULL; -} - -int -dtrace_getipl(void) -{ -#ifdef DOODAD - return (CPU->cpu_pri); -#else - return (0); -#endif } /*ARGSUSED*/ @@ -419,6 +377,13 @@ } #endif +uint64_t +dtrace_gethrestime(void) +{ + printf("%s(%d): XXX\n",__func__,__LINE__); + return (0); +} + /* Function to handle DTrace traps during probes. See i386/i386/trap.c */ int dtrace_trap(struct trapframe *frame, u_int type) ==== //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#36 (text) ==== @@ -16126,7 +16126,7 @@ #include #include #include -#if defined(__amd64__) +#if defined(__amd64__) || defined(__i386__) #include #endif