/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <sys/dtrace.h>
#include <sys/fasttrap.h>
#include <sys/x_call.h>
#include <sys/atomic.h>
#include <sys/machsystm.h>

static void
dtrace_xcall_func(uint64_t arg1, uint64_t arg2)
{
        (*(dtrace_xcall_t)arg1)((void *)(arg2));
}

void
dtrace_xcall(processorid_t cpu, dtrace_xcall_t func, void *arg)
{
        if (cpu == DTRACE_CPUALL) {
                xc_all(dtrace_xcall_func, (uint64_t)func, (uint64_t)arg);
        } else {
                xc_one(cpu, dtrace_xcall_func, (uint64_t)func, (uint64_t)arg);
        }
}

/*ARGSUSED*/
static void
dtrace_sync_func(uint64_t arg1, uint64_t arg2)
{
        membar_consumer();
}

void
dtrace_sync(void)
{
        membar_producer();
        xc_all(dtrace_sync_func, 0, 0);
}

void
dtrace_toxic_ranges(void (*func)(uintptr_t base, uintptr_t limit))
{
        (*func)(PIOMAPBASE, PIOMAPBASE + PIOMAPSIZE);
        (*func)(OFW_START_ADDR, OFW_END_ADDR);

        if (hole_end > hole_start)
                (*func)((uintptr_t)hole_start, (uintptr_t)hole_end);
}

int (*dtrace_pid_probe_ptr)(struct regs *);

void
dtrace_pid_probe(struct regs *rp)
{
        krwlock_t *rwp = &CPU->cpu_ft_lock;
        uint32_t instr;

        /*
         * This trap should only be invoked if there's a corresponding
         * enabled dtrace probe. If there isn't, send SIGILL as though
         * the process had executed an invalid trap instruction.
         */
        rw_enter(rwp, RW_READER);
        if (dtrace_pid_probe_ptr != NULL && (*dtrace_pid_probe_ptr)(rp) == 0) {
                rw_exit(rwp);
                return;
        }
        rw_exit(rwp);

        /*
         * It is possible that we were preempted after entering the kernel,
         * and the tracepoint was removed. If it appears that the process hit
         * our reserved trap instruction, we call send SIGILL just as though
         * the user had executed an unused trap instruction.
         */
        if (fuword32((void *)rp->r_pc, &instr) != 0 ||
            instr == FASTTRAP_INSTR) {
                sigqueue_t *sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
                proc_t *p = curproc;

                sqp->sq_info.si_signo = SIGILL;
                sqp->sq_info.si_code = ILL_ILLTRP;
                sqp->sq_info.si_addr = (caddr_t)rp->r_pc;
                sqp->sq_info.si_trapno = 0x38;

                mutex_enter(&p->p_lock);
                sigaddqa(p, curthread, sqp);
                mutex_exit(&p->p_lock);
                aston(curthread);
        }
}

int (*dtrace_return_probe_ptr)(struct regs *);

void
dtrace_return_probe(struct regs *rp)
{
        krwlock_t *rwp;
        uintptr_t npc = curthread->t_dtrace_npc;
        uint8_t step = curthread->t_dtrace_step;
        uint8_t ret = curthread->t_dtrace_ret;

        if (curthread->t_dtrace_ast) {
                aston(curthread);
                curthread->t_sig_check = 1;
        }

        /*
         * Clear all user tracing flags.
         */
        curthread->t_dtrace_ft = 0;

        /*
         * If we weren't expecting to take a return probe trap, kill the
         * process as though it had just executed an unassigned trap
         * instruction.
         */
        if (step == 0) {
                tsignal(curthread, SIGILL);
                return;
        }

        ASSERT(rp->r_npc == rp->r_pc + 4);

        /*
         * If we hit this trap unrelated to a return probe, we're just here
         * to reset the AST flag since we deferred a signal until after we
         * logically single-stepped the instruction we copied out.
         */
        if (ret == 0) {
                rp->r_pc = npc;
                rp->r_npc = npc + 4;
                return;
        }

        /*
         * We need to wait until after we've called the dtrace_return_probe_ptr
         * function pointer to set %pc and %npc.
         */
        rwp = &CPU->cpu_ft_lock;
        rw_enter(rwp, RW_READER);
        if (dtrace_return_probe_ptr != NULL)
                (void) (*dtrace_return_probe_ptr)(rp);
        rw_exit(rwp);
        rp->r_pc = npc;
        rp->r_npc = npc + 4;
}

void
dtrace_safe_synchronous_signal(void)
{
        kthread_t *t = curthread;
        struct regs *rp = lwptoregs(ttolwp(t));

        ASSERT(t->t_dtrace_on);

        /*
         * If we're not actively tracing an instruction, turn off tracing
         * flags. If the instruction we copied out caused a synchronous
         * trap, reset the pc and npc back to their original values and turn
         * off the flags.
         */
        if (rp->r_pc != t->t_dtrace_scrpc && rp->r_pc != t->t_dtrace_astpc &&
            rp->r_npc != t->t_dtrace_astpc) {
                t->t_dtrace_ft = 0;
        } else if (rp->r_pc == t->t_dtrace_scrpc) {
                rp->r_pc = t->t_dtrace_pc;
                rp->r_npc = t->t_dtrace_npc;
                t->t_dtrace_ft = 0;
        }
}

int
dtrace_safe_defer_signal(void)
{
        kthread_t *t = curthread;
        struct regs *rp = lwptoregs(ttolwp(t));

        ASSERT(t->t_dtrace_on);

        /*
         * If we're not actively tracing an instruction, turn off tracing
         * flags.
         */
        if (rp->r_pc != t->t_dtrace_scrpc && rp->r_pc != t->t_dtrace_astpc &&
            rp->r_npc != t->t_dtrace_astpc) {
                t->t_dtrace_ft = 0;
                return (0);
        }

        /*
         * Otherwise, make sure we'll return to the kernel after executing
         * the instruction we copied out.
         */
        if (!t->t_dtrace_step) {
                ASSERT(rp->r_pc == t->t_dtrace_scrpc);
                rp->r_npc = t->t_dtrace_astpc;
                t->t_dtrace_step = 1;
        }

        t->t_dtrace_ast = 1;

        return (1);
}

/*
 * Additional artificial frames for the machine type. For SPARC, we're already
 * accounted for, so return 0.
 */
int
dtrace_mach_aframes(void)
{
        return (0);
}