PERFORCE change 135093 for review
John Birrell
jb at FreeBSD.org
Fri Feb 8 23:41:51 PST 2008
http://perforce.freebsd.org/chv.cgi?CH=135093
Change 135093 by jb at 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 <machine/asm.h>
+#define _ASM
+
+#include <machine/asmacros.h>
+#include <sys/cpuvar_defs.h>
+#include <sys/dtrace.h>
+
+/*
+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 <dtrace_unload.c>
#include <dtrace_vtime.c>
#include <dtrace_hacks.c>
-#if defined(__amd64__)
+#if defined(__amd64__) || defined(__i386__)
#include <amd64/dtrace_isa.c>
#endif
More information about the p4-projects
mailing list