d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add device part of DTrace/MIPS code

Browse Source
This commit is contained in:
gonzo 2012-03-24 05:14:37 +00:00
parent 71511943f0
commit eb11c4850d
6 changed files with 1274 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

303
sys/cddl/dev/dtrace/mips/dtrace_asm.S Normal file
View File

@ -0,0 +1,303 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* $FreeBSD$
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#define _ASM
#define _LOCORE
#define LOCORE
#include <sys/cpuvar_defs.h>
#include <sys/dtrace.h>
#include <machine/asm.h>
#include <machine/cpu.h>
#include <machine/cpuregs.h>
#include <machine/regnum.h>
#include "assym.s"
.set noreorder # Noreorder is default style!
/*
* Primitives
*/
.text
/*
void dtrace_membar_producer(void)
*/
LEAF(dtrace_membar_producer)
j ra
nop
END(dtrace_membar_producer)
/*
void dtrace_membar_consumer(void)
*/
LEAF(dtrace_membar_consumer)
j ra
nop
END(dtrace_membar_consumer)
/*
dtrace_icookie_t dtrace_interrupt_disable(void)
*/
LEAF(dtrace_interrupt_disable)
mfc0 t0, MIPS_COP_0_STATUS
move v0, t0
and v0, v0, MIPS_SR_INT_IE
and t0, t0, ~MIPS_SR_INT_IE
mtc0 t0, MIPS_COP_0_STATUS
j ra
nop
END(dtrace_interrupt_disable)
/*
void dtrace_interrupt_enable(dtrace_icookie_t cookie)
*/
LEAF(dtrace_interrupt_enable)
mfc0 t0, MIPS_COP_0_STATUS
beqz a0, not_enabled
or t0, t0, MIPS_SR_INT_IE
mtc0 t0, MIPS_COP_0_STATUS
not_enabled:
j ra
nop
END(dtrace_interrupt_enable)
/*
uint32_t dtrace_cas32(uint32_t *target, uint32_t cmp, uint32_t new)
*/
LEAF(dtrace_cas32)
1:
move t1, a2
ll t0, 0(a0)
bne t0, a1, 2f
nop
sc t1, 0(a0)
beqz t1, 1b
nop
2: move v0, t0
j ra
nop
END(dtrace_cas32)
/*
void *
dtrace_casptr(void *target, void *cmp, void *new)
*/
LEAF(dtrace_casptr)
1:
move t1, a2
PTR_LL t0, 0(a0)
bne t0, a1, 2f
nop
PTR_SC t1, 0(a0)
beqz t1, 1b
nop
2: move v0, t0
j ra
nop
END(dtrace_casptr)
/*
uintptr_t
dtrace_fulword(void *addr)
*/
LEAF(dtrace_fulword)
END(dtrace_fulword)
/*
uint8_t
dtrace_fuword8_nocheck(void *addr)
*/
LEAF(dtrace_fuword8_nocheck)
lbu v0, 0(a0)
j ra
nop
END(dtrace_fuword8_nocheck)
/*
uint16_t
dtrace_fuword16_nocheck(void *addr)
*/
LEAF(dtrace_fuword16_nocheck)
lhu v0, 0(a0)
j ra
nop
END(dtrace_fuword16_nocheck)
/*
uint32_t
dtrace_fuword32_nocheck(void *addr)
*/
LEAF(dtrace_fuword32_nocheck)
lwu v0, 0(a0)
j ra
nop
END(dtrace_fuword32_nocheck)
/*
uint64_t
dtrace_fuword64_nocheck(void *addr)
*/
LEAF(dtrace_fuword64_nocheck)
#if defined(__mips_n64) || defined(__mips_n32)
ld v0, 0(a0)
#else
lw v1,4(a0)
lw v0,0(a0)
#endif
j ra
nop
END(dtrace_fuword64_nocheck)
/*
XXX: unoptimized
void
dtrace_copy(uintptr_t src, uintptr_t dest, size_t size)
*/
LEAF(dtrace_copy)
1:
beqz a2, 2f
nop
lbu t0, 0(a0)
sb t0, 0(a1)
daddu a0, a0, 1
daddu a1, a1, 1
dsubu a2, a2, 1
j 1b
nop
2:
j ra
nop
END(dtrace_copy)
/*
XXX: Unoptimized. Check for flags on page boundaries only(?)
void
dtrace_copystr(uintptr_t uaddr, uintptr_t kaddr, size_t size,
volatile uint16_t *flags)
*/
LEAF(dtrace_copystr)
1:
lbu t0, 0(a0)
sb t0, 0(a1)
daddu a0, a0, 1
daddu a1, a1, 1
dsubu a2, a2, 1
beqz t0, 2f
nop
lhu t1, (a3)
and t1, t1, CPU_DTRACE_BADADDR
bnez t1, 2f
nop
bnez a2, 1b
nop
2:
j ra
nop
END(dtrace_copystr)
/*
void dtrace_invop_init(void)
*/
LEAF(dtrace_invop_init)
/* XXX: impement it properly */
dla t0, dtrace_invop_jump_addr
/* dla t1, dtrace_invop_start */
sd zero, 0(t0)
j ra
nop
END(dtrace_invop_init)
/*
void dtrace_invop_uninit(void)
*/
LEAF(dtrace_invop_uninit)
dla t0, dtrace_invop_jump_addr
sd zero, 0(t0)
j ra
nop
END(dtrace_invop_uninit)
/*
* 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)
*/
LEAF(vpanic) /* Initial stack layout: */
vpanic_common:
j ra
nop
END(vpanic)
/*
void
dtrace_vpanic(const char *format, va_list alist)
*/
LEAF(dtrace_vpanic) /* Initial stack layout: */
#if 0
jal dtrace_panic_trigger /* %eax = dtrace_panic_trigger() */
nop
#endif
j vpanic_common
nop
END(dtrace_vpanic)
/*
uintptr_t
dtrace_caller(int aframes)
*/
LEAF(dtrace_caller)
li v0, -1
j ra
nop
END(dtrace_caller)

698
sys/cddl/dev/dtrace/mips/dtrace_isa.c Normal file
View File

@ -0,0 +1,698 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* $FreeBSD$
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/stack.h>
#include <sys/pcpu.h>
#include <machine/frame.h>
#include <machine/md_var.h>
#include <machine/reg.h>
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>
#include <machine/db_machdep.h>
#include <machine/md_var.h>
#include <machine/mips_opcode.h>
#include <machine/vmparam.h>
#include <ddb/db_sym.h>
#include <ddb/ddb.h>
#include <sys/kdb.h>
#include "regset.h"
#ifdef __mips_n64
#define MIPS_IS_VALID_KERNELADDR(reg) ((((reg) & 3) == 0) && \
((vm_offset_t)(reg) >= MIPS_XKPHYS_START))
#else
#define MIPS_IS_VALID_KERNELADDR(reg) ((((reg) & 3) == 0) && \
((vm_offset_t)(reg) >= MIPS_KSEG0_START))
#endif
/*
* Wee need some reasonable default to prevent backtrace code
* from wandering too far
*/
#define MAX_FUNCTION_SIZE 0x10000
#define MAX_PROLOGUE_SIZE 0x100
uint8_t dtrace_fuword8_nocheck(void *);
uint16_t dtrace_fuword16_nocheck(void *);
uint32_t dtrace_fuword32_nocheck(void *);
uint64_t dtrace_fuword64_nocheck(void *);
static int dtrace_next_frame(register_t *pc, register_t *sp, register_t *args, int *valid_args);
static int dtrace_next_uframe(register_t *pc, register_t *sp, register_t *ra);
void
dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes,
uint32_t *intrpc)
{
int depth = 0;
vm_offset_t callpc;
pc_t caller = (pc_t) solaris_cpu[curcpu].cpu_dtrace_caller;
register_t sp, ra, pc;
if (intrpc != 0)
pcstack[depth++] = (pc_t) intrpc;
aframes++;
sp = (register_t)(intptr_t)__builtin_frame_address(0);
ra = (register_t)(intptr_t)__builtin_return_address(0);
__asm __volatile(
"jal 99f\n"
"nop\n"
"99:\n"
"move %0, $31\n" /* get ra */
"move $31, %1\n" /* restore ra */
: "=r" (pc)
: "r" (ra));
while (depth < pcstack_limit) {
callpc = pc;
if (aframes > 0) {
aframes--;
if ((aframes == 0) && (caller != 0)) {
pcstack[depth++] = caller;
}
}
else {
pcstack[depth++] = callpc;
}
if (dtrace_next_frame(&pc, &sp, NULL, NULL) < 0)
break;
}
for (; depth < pcstack_limit; depth++) {
pcstack[depth] = 0;
}
}
void
dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
{
proc_t *p = curproc;
struct trapframe *tf;
register_t sp, ra, pc;
volatile uint16_t *flags =
(volatile uint16_t *)&cpu_core[curcpu].cpuc_dtrace_flags;
if (*flags & CPU_DTRACE_FAULT)
return;
if (pcstack_limit <= 0)
return;
/*
* If there's no user context we still need to zero the stack.
*/
if (p == NULL || (tf = curthread->td_frame) == NULL)
goto zero;
*pcstack++ = (uint64_t)p->p_pid;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = (uint64_t)tf->pc;
sp = (uint64_t)tf->sp;
ra = (uint64_t)tf->ra;
*pcstack++ = (uint64_t)tf->pc;
/*
* Unwind, and unwind, and unwind
*/
while (1) {
if (dtrace_next_uframe(&pc, &sp, &ra) < 0)
break;
*pcstack++ = pc;
pcstack_limit--;
if (pcstack_limit <= 0)
break;
}
zero:
while (pcstack_limit-- > 0)
*pcstack++ = 0;
}
int
dtrace_getustackdepth(void)
{
int n = 0;
proc_t *p = curproc;
struct trapframe *tf;
register_t sp, ra, pc;
volatile uint16_t *flags =
(volatile uint16_t *)&cpu_core[curcpu].cpuc_dtrace_flags;
if (*flags & CPU_DTRACE_FAULT)
return (0);
if (p == NULL || (tf = curthread->td_frame) == NULL)
return (0);
pc = (uint64_t)tf->pc;
sp = (uint64_t)tf->sp;
ra = (uint64_t)tf->ra;
n++;
/*
* Unwind, and unwind, and unwind
*/
while (1) {
if (dtrace_next_uframe(&pc, &sp, &ra) < 0)
break;
n++;
}
return (n);
}
void
dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit)
{
printf("IMPLEMENT ME: %s\n", __func__);
}
/*ARGSUSED*/
uint64_t
dtrace_getarg(int arg, int aframes)
{
int i;
register_t sp, ra, pc;
/* XXX: Fix this ugly code */
register_t args[8];
int valid[8];
sp = (register_t)(intptr_t)__builtin_frame_address(0);
ra = (register_t)(intptr_t)__builtin_return_address(0);
__asm __volatile(
"jal 99f\n"
"nop\n"
"99:\n"
"move %0, $31\n" /* get ra */
"move $31, %1\n" /* restore ra */
: "=r" (pc)
: "r" (ra));
for (i = 0; i <= aframes + 1; i++) {
if (dtrace_next_frame(&pc, &sp, args, valid) < 0) {
printf("%s: stack ends at frame #%d\n", __func__, i);
return (0);
}
}
if (arg < 8) {
if (valid[arg])
return (args[arg]);
else
printf("%s: request arg%d is not valid\n", __func__, arg);
}
return (0);
}
int
dtrace_getstackdepth(int aframes)
{
register_t sp, ra, pc;
int depth = 0;
sp = (register_t)(intptr_t)__builtin_frame_address(0);
ra = (register_t)(intptr_t)__builtin_return_address(0);
__asm __volatile(
"jal 99f\n"
"nop\n"
"99:\n"
"move %0, $31\n" /* get ra */
"move $31, %1\n" /* restore ra */
: "=r" (pc)
: "r" (ra));
for (;;) {
if (dtrace_next_frame(&pc, &sp, NULL, NULL) < 0)
break;
depth++;
}
if (depth < aframes)
return 0;
else
return depth - aframes;
}
ulong_t
dtrace_getreg(struct trapframe *rp, uint_t reg)
{
return (0);
}
static int
dtrace_next_frame(register_t *pc, register_t *sp,
register_t *args, int *valid_args)
{
InstFmt i;
/*
* Arrays for a0..a3 registers and flags if content
* of these registers is valid, e.g. obtained from the stack
*/
uintptr_t va;
unsigned instr, mask;
unsigned int frames = 0;
int more, stksize;
register_t ra = 0;
int arg, r;
vm_offset_t addr;
/*
* Invalidate arguments values
*/
if (valid_args) {
for (r = 0; r < 8; r++)
valid_args[r] = 0;
}
/* Jump here after a nonstandard (interrupt handler) frame */
stksize = 0;
if (frames++ > 100) {
/* return breaks stackframe-size heuristics with gcc -O2 */
goto error; /* XXX */
}
/* check for bad SP: could foul up next frame */
if (!MIPS_IS_VALID_KERNELADDR(*sp)) {
goto error;
}
/* check for bad PC */
if (!MIPS_IS_VALID_KERNELADDR(*pc)) {
goto error;
}
/*
* Find the beginning of the current subroutine by scanning
* backwards from the current PC for the end of the previous
* subroutine.
*/
va = *pc - sizeof(int);
while (1) {
instr = kdbpeek((int *)va);
/* [d]addiu sp,sp,-X */
if (((instr & 0xffff8000) == 0x27bd8000)
|| ((instr & 0xffff8000) == 0x67bd8000))
break;
/* jr ra */
if (instr == 0x03e00008) {
/* skip over branch-delay slot instruction */
va += 2 * sizeof(int);
break;
}
va -= sizeof(int);
}
/* skip over nulls which might separate .o files */
while ((instr = kdbpeek((int *)va)) == 0)
va += sizeof(int);
/* scan forwards to find stack size and any saved registers */
stksize = 0;
more = 3;
mask = 0;
for (; more; va += sizeof(int),
more = (more == 3) ? 3 : more - 1) {
/* stop if hit our current position */
if (va >= *pc)
break;
instr = kdbpeek((int *)va);
i.word = instr;
switch (i.JType.op) {
case OP_SPECIAL:
switch (i.RType.func) {
case OP_JR:
case OP_JALR:
more = 2; /* stop after next instruction */
break;
case OP_SYSCALL:
case OP_BREAK:
more = 1; /* stop now */
};
break;
case OP_BCOND:
case OP_J:
case OP_JAL:
case OP_BEQ:
case OP_BNE:
case OP_BLEZ:
case OP_BGTZ:
more = 2; /* stop after next instruction */
break;
case OP_COP0:
case OP_COP1:
case OP_COP2:
case OP_COP3:
switch (i.RType.rs) {
case OP_BCx:
case OP_BCy:
more = 2; /* stop after next instruction */
};
break;
case OP_SW:
/* look for saved registers on the stack */
if (i.IType.rs != 29)
break;
/* only restore the first one */
if (mask & (1 << i.IType.rt))
break;
mask |= (1 << i.IType.rt);
addr = (vm_offset_t)(*sp + (short)i.IType.imm);
switch (i.IType.rt) {
case 4:/* a0 */
case 5:/* a1 */
case 6:/* a2 */
case 7:/* a3 */
#if defined(__mips_n64) || defined(__mips_n32)
case 8:/* a4 */
case 9:/* a5 */
case 10:/* a6 */
case 11:/* a7 */
#endif
arg = i.IType.rt - 4;
if (args)
args[arg] = kdbpeek((int*)addr);
if (valid_args)
valid_args[arg] = 1;
break;
case 31: /* ra */
ra = kdbpeek((int *)addr);
}
break;
case OP_SD:
/* look for saved registers on the stack */
if (i.IType.rs != 29)
break;
/* only restore the first one */
if (mask & (1 << i.IType.rt))
break;
mask |= (1 << i.IType.rt);
addr = (vm_offset_t)(*sp + (short)i.IType.imm);
switch (i.IType.rt) {
case 4:/* a0 */
case 5:/* a1 */
case 6:/* a2 */
case 7:/* a3 */
#if defined(__mips_n64) || defined(__mips_n32)
case 8:/* a4 */
case 9:/* a5 */
case 10:/* a6 */
case 11:/* a7 */
#endif
arg = i.IType.rt - 4;
if (args)
args[arg] = kdbpeekd((int *)addr);
if (valid_args)
valid_args[arg] = 1;
break;
case 31: /* ra */
ra = kdbpeekd((int *)addr);
}
break;
case OP_ADDI:
case OP_ADDIU:
case OP_DADDI:
case OP_DADDIU:
/* look for stack pointer adjustment */
if (i.IType.rs != 29 || i.IType.rt != 29)
break;
stksize = -((short)i.IType.imm);
}
}
if (!MIPS_IS_VALID_KERNELADDR(ra))
return (-1);
*pc = ra;
*sp += stksize;
return (0);
error:
return (-1);
}
static int
dtrace_next_uframe(register_t *pc, register_t *sp, register_t *ra)
{
int offset, registers_on_stack;
uint32_t opcode, mask;
register_t function_start;
int stksize;
InstFmt i;
registers_on_stack = 0;
mask = 0;
function_start = 0;
offset = 0;
stksize = 0;
while (offset < MAX_FUNCTION_SIZE) {
opcode = dtrace_fuword32((void *)(vm_offset_t)(*pc - offset));
/* [d]addiu sp, sp, -X*/
if (((opcode & 0xffff8000) == 0x27bd8000)
|| ((opcode & 0xffff8000) == 0x67bd8000)) {
function_start = *pc - offset;
registers_on_stack = 1;
break;
}
/* lui gp, X */
if ((opcode & 0xffff8000) == 0x3c1c0000) {
/*
* Function might start with this instruction
* Keep an eye on "jr ra" and sp correction
* with positive value further on
*/
function_start = *pc - offset;
}
if (function_start) {
/*
* Stop looking further. Possible end of
* function instruction: it means there is no
* stack modifications, sp is unchanged
*/
/* [d]addiu sp,sp,X */
if (((opcode & 0xffff8000) == 0x27bd0000)
|| ((opcode & 0xffff8000) == 0x67bd0000))
break;
if (opcode == 0x03e00008)
break;
}
offset += sizeof(int);
}
if (!function_start)
return (-1);
if (registers_on_stack) {
offset = 0;
while ((offset < MAX_PROLOGUE_SIZE)
&& ((function_start + offset) < *pc)) {
i.word =
dtrace_fuword32((void *)(vm_offset_t)(function_start + offset));
switch (i.JType.op) {
case OP_SW:
/* look for saved registers on the stack */
if (i.IType.rs != 29)
break;
/* only restore the first one */
if (mask & (1 << i.IType.rt))
break;
mask |= (1 << i.IType.rt);
if (i.IType.rt == 31)
*ra = dtrace_fuword32((void *)(vm_offset_t)(*sp + (short)i.IType.imm));
break;
case OP_SD:
/* look for saved registers on the stack */
if (i.IType.rs != 29)
break;
/* only restore the first one */
if (mask & (1 << i.IType.rt))
break;
mask |= (1 << i.IType.rt);
/* ra */
if (i.IType.rt == 31)
*ra = dtrace_fuword64((void *)(vm_offset_t)(*sp + (short)i.IType.imm));
break;
case OP_ADDI:
case OP_ADDIU:
case OP_DADDI:
case OP_DADDIU:
/* look for stack pointer adjustment */
if (i.IType.rs != 29 || i.IType.rt != 29)
break;
stksize = -((short)i.IType.imm);
}
offset += sizeof(int);
}
}
/*
* We reached the end of backtrace
*/
if (*pc == *ra)
return (-1);
*pc = *ra;
*sp += stksize;
return (0);
}
static int
dtrace_copycheck(uintptr_t uaddr, uintptr_t kaddr, size_t size)
{
if (uaddr + size > VM_MAXUSER_ADDRESS || uaddr + size < uaddr) {
DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
cpu_core[curcpu].cpuc_dtrace_illval = uaddr;
return (0);
}
return (1);
}
void
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,
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,
volatile uint16_t *flags)
{
if (dtrace_copycheck(uaddr, kaddr, size))
dtrace_copystr(uaddr, kaddr, size, flags);
}
void
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, flags);
}
uint8_t
dtrace_fuword8(void *uaddr)
{
if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
return (0);
}
return (dtrace_fuword8_nocheck(uaddr));
}
uint16_t
dtrace_fuword16(void *uaddr)
{
if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
return (0);
}
return (dtrace_fuword16_nocheck(uaddr));
}
uint32_t
dtrace_fuword32(void *uaddr)
{
if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
return (0);
}
return (dtrace_fuword32_nocheck(uaddr));
}
uint64_t
dtrace_fuword64(void *uaddr)
{
if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
return (0);
}
return (dtrace_fuword64_nocheck(uaddr));
}

203
sys/cddl/dev/dtrace/mips/dtrace_subr.c Normal file
View File

@ -0,0 +1,203 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* $FreeBSD$
*
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/kmem.h>
#include <sys/smp.h>
#include <sys/dtrace_impl.h>
#include <sys/dtrace_bsd.h>
#include <machine/clock.h>
#include <machine/frame.h>
#include <machine/trap.h>
#include <vm/pmap.h>
#define DELAYBRANCH(x) ((int)(x) < 0)
extern uintptr_t dtrace_in_probe_addr;
extern int dtrace_in_probe;
extern dtrace_id_t dtrace_probeid_error;
int dtrace_invop(uintptr_t, uintptr_t *, uintptr_t);
typedef struct dtrace_invop_hdlr {
int (*dtih_func)(uintptr_t, uintptr_t *, uintptr_t);
struct dtrace_invop_hdlr *dtih_next;
} dtrace_invop_hdlr_t;
dtrace_invop_hdlr_t *dtrace_invop_hdlr;
int
dtrace_invop(uintptr_t addr, uintptr_t *stack, uintptr_t eax)
{
dtrace_invop_hdlr_t *hdlr;
int rval;
for (hdlr = dtrace_invop_hdlr; hdlr != NULL; hdlr = hdlr->dtih_next)
if ((rval = hdlr->dtih_func(addr, stack, eax)) != 0)
return (rval);
return (0);
}
/*ARGSUSED*/
void
dtrace_toxic_ranges(void (*func)(uintptr_t base, uintptr_t limit))
{
/*
* No toxic regions?
*/
}
void
dtrace_xcall(processorid_t cpu, dtrace_xcall_t func, void *arg)
{
cpuset_t cpus;
if (cpu == DTRACE_CPUALL)
cpus = all_cpus;
else
CPU_SETOF(cpu, &cpus);
smp_rendezvous_cpus(cpus, smp_no_rendevous_barrier, func,
smp_no_rendevous_barrier, arg);
}
static void
dtrace_sync_func(void)
{
}
void
dtrace_sync(void)
{
dtrace_xcall(DTRACE_CPUALL, (dtrace_xcall_t)dtrace_sync_func, NULL);
}
/*
* DTrace needs a high resolution time function which can
* be called from a probe context and guaranteed not to have
* instrumented with probes itself.
*
* Returns nanoseconds since boot.
*/
uint64_t
dtrace_gethrtime()
{
struct timespec curtime;
nanouptime(&curtime);
return (curtime.tv_sec * 1000000000UL + curtime.tv_nsec);
}
uint64_t
dtrace_gethrestime(void)
{
struct timespec curtime;
getnanotime(&curtime);
return (curtime.tv_sec * 1000000000UL + curtime.tv_nsec);
}
/* Function to handle DTrace traps during probes. See amd64/amd64/trap.c */
int
dtrace_trap(struct trapframe *frame, u_int type)
{
/*
* A trap can occur while DTrace executes a probe. Before
* executing the probe, DTrace blocks re-scheduling and sets
* a flag in it's per-cpu flags to indicate that it doesn't
* want to fault. On returning from the probe, the no-fault
* flag is cleared and finally re-scheduling is enabled.
*
* Check if DTrace has enabled 'no-fault' mode:
*
*/
if ((cpu_core[curcpu].cpuc_dtrace_flags & CPU_DTRACE_NOFAULT) != 0) {
/*
* There are only a couple of trap types that are expected.
* All the rest will be handled in the usual way.
*/
switch (type) {
/* Page fault. */
case T_TLB_ST_MISS:
case T_ADDR_ERR_ST:
case T_TLB_LD_MISS:
case T_ADDR_ERR_LD:
case T_BUS_ERR_IFETCH:
/* Flag a bad address. */
cpu_core[curcpu].cpuc_dtrace_flags |= CPU_DTRACE_BADADDR;
cpu_core[curcpu].cpuc_dtrace_illval = frame->badvaddr;
/*
* Offset the instruction pointer to the instruction
* following the one causing the fault.
*/
if (DELAYBRANCH(frame->cause)) /* Check BD bit */
{
/* XXX: check MipsEmulateBranch on MIPS64
frame->pc = MipsEmulateBranch(frame, frame->pc,
0, 0);
*/
panic("%s: delay slot at %jx, badvaddr = %jx\n",
__func__,
(intmax_t)frame->pc, (intmax_t)frame->badvaddr);
}
else
frame->pc += sizeof(int);
return (1);
default:
/* Handle all other traps in the usual way. */
break;
}
}
/* Handle the trap in the usual way. */
return (0);
}
void
dtrace_probe_error(dtrace_state_t *state, dtrace_epid_t epid, int which,
int fault, int fltoffs, uintptr_t illval)
{
dtrace_probe(dtrace_probeid_error, (uint64_t)(uintptr_t)state,
(uintptr_t)epid,
(uintptr_t)which, (uintptr_t)fault, (uintptr_t)fltoffs);
}

62
sys/cddl/dev/dtrace/mips/regset.h Normal file
View File

@ -0,0 +1,62 @@
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
* $FreeBSD$
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#ifndef _REGSET_H
#define _REGSET_H
/*
* #pragma ident "@(#)regset.h 1.11 05/06/08 SMI"
*/
#ifdef __cplusplus
extern "C" {
#endif
/*
* XXXDTRACE: define registers properly
*/
#if 0
#define REG_PC PC
#define REG_FP EBP
#define REG_SP SP
#define REG_PS EFL
#define REG_R0 EAX
#define REG_R1 EDX
#endif
#ifdef __cplusplus
}
#endif
#endif /* _REGSET_H */

2
sys/cddl/dev/lockstat/lockstat.c
View File

@ -45,7 +45,7 @@
#include <sys/dtrace.h>
#include <sys/lockstat.h>
#if defined(__i386__) || defined(__amd64__)
#if defined(__i386__) || defined(__amd64__) || defined(__mips__)
#define LOCKSTAT_AFRAMES 1
#else
#error "architecture not supported"

7
sys/cddl/dev/profile/profile.c
View File

@ -112,6 +112,13 @@
#endif
#endif
#ifdef __mips
/*
* This value is bogus just to make module compilable on mips
*/
#define PROF_ARTIFICIAL_FRAMES 3
#endif
typedef struct profile_probe {
char prof_name[PROF_NAMELEN];
dtrace_id_t prof_id;