dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / uts / intel / dtrace / fbt.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/modctl.h>
#include <sys/dtrace.h>
#include <sys/kobj.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/conf.h>

#define FBT_PUSHL_EBP           0x55
#define FBT_MOVL_ESP_EBP0_V0    0x8b
#define FBT_MOVL_ESP_EBP1_V0    0xec
#define FBT_MOVL_ESP_EBP0_V1    0x89
#define FBT_MOVL_ESP_EBP1_V1    0xe5
#define FBT_REX_RSP_RBP         0x48

#define FBT_POPL_EBP            0x5d
#define FBT_RET                 0xc3
#define FBT_RET_IMM16           0xc2
#define FBT_LEAVE               0xc9

#ifdef __amd64
#define FBT_PATCHVAL            0xcc
#else
#define FBT_PATCHVAL            0xf0
#endif

#define FBT_ENTRY       "entry"
#define FBT_RETURN      "return"
#define FBT_ADDR2NDX(addr)      ((((uintptr_t)(addr)) >> 4) & fbt_probetab_mask)
#define FBT_PROBETAB_SIZE       0x8000          /* 32k entries -- 128K total */

typedef struct fbt_probe {
        struct fbt_probe *fbtp_hashnext;
        uint8_t         *fbtp_patchpoint;
        int8_t          fbtp_rval;
        uint8_t         fbtp_patchval;
        uint8_t         fbtp_savedval;
        uintptr_t       fbtp_roffset;
        dtrace_id_t     fbtp_id;
        char            *fbtp_name;
        struct modctl   *fbtp_ctl;
        int             fbtp_loadcnt;
        int             fbtp_symndx;
        int             fbtp_primary;
        struct fbt_probe *fbtp_next;
} fbt_probe_t;

static dev_info_t               *fbt_devi;
static dtrace_provider_id_t     fbt_id;
static fbt_probe_t              **fbt_probetab;
static int                      fbt_probetab_size;
static int                      fbt_probetab_mask;
static int                      fbt_verbose = 0;

static int
fbt_invop(uintptr_t addr, uintptr_t *stack, uintptr_t rval)
{
        uintptr_t stack0, stack1, stack2, stack3, stack4;
        fbt_probe_t *fbt = fbt_probetab[FBT_ADDR2NDX(addr)];

        for (; fbt != NULL; fbt = fbt->fbtp_hashnext) {
                if ((uintptr_t)fbt->fbtp_patchpoint == addr) {
                        if (fbt->fbtp_roffset == 0) {
                                int i = 0;
                                /*
                                 * When accessing the arguments on the stack,
                                 * we must protect against accessing beyond
                                 * the stack.  We can safely set NOFAULT here
                                 * -- we know that interrupts are already
                                 * disabled.
                                 */
                                DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
                                CPU->cpu_dtrace_caller = stack[i++];
#ifdef __amd64
                                /*
                                 * On amd64, stack[0] contains the dereferenced
                                 * stack pointer, stack[1] contains savfp,
                                 * stack[2] contains savpc.  We want to step
                                 * over these entries.
                                 */
                                i += 2;
#endif
                                stack0 = stack[i++];
                                stack1 = stack[i++];
                                stack2 = stack[i++];
                                stack3 = stack[i++];
                                stack4 = stack[i++];
                                DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
                                    CPU_DTRACE_BADADDR);

                                dtrace_probe(fbt->fbtp_id, stack0, stack1,
                                    stack2, stack3, stack4);

                                CPU->cpu_dtrace_caller = (uintptr_t)NULL;
                        } else {
#ifdef __amd64
                                /*
                                 * On amd64, we instrument the ret, not the
                                 * leave.  We therefore need to set the caller
                                 * to assure that the top frame of a stack()
                                 * action is correct.
                                 */
                                DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
                                CPU->cpu_dtrace_caller = stack[0];
                                DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT |
                                    CPU_DTRACE_BADADDR);
#endif

                                dtrace_probe(fbt->fbtp_id, fbt->fbtp_roffset,
                                    rval, 0, 0, 0);
                                CPU->cpu_dtrace_caller = (uintptr_t)NULL;
                        }

                        return (fbt->fbtp_rval);
                }
        }

        return (0);
}

/*ARGSUSED*/
static void
fbt_provide_module(void *arg, struct modctl *ctl)
{
        struct module *mp = ctl->mod_mp;
        char *str = mp->strings;
        int nsyms = mp->nsyms;
        Shdr *symhdr = mp->symhdr;
        char *modname = ctl->mod_modname;
        char *name;
        fbt_probe_t *fbt, *retfbt;
        size_t symsize;
        int i, size;

        /*
         * Employees of dtrace and their families are ineligible.  Void
         * where prohibited.
         */
        if (strcmp(modname, "dtrace") == 0)
                return;

        if (ctl->mod_requisites != NULL) {
                struct modctl_list *list;

                list = (struct modctl_list *)ctl->mod_requisites;

                for (; list != NULL; list = list->modl_next) {
                        if (strcmp(list->modl_modp->mod_modname, "dtrace") == 0)
                                return;
                }
        }

        /*
         * KMDB is ineligible for instrumentation -- it may execute in
         * any context, including probe context.
         */
        if (strcmp(modname, "kmdbmod") == 0)
                return;

        if (str == NULL || symhdr == NULL ||
            symhdr->sh_addr == (uintptr_t)NULL) {
                /*
                 * If this module doesn't (yet) have its string or symbol
                 * table allocated, clear out.
                 */
                return;
        }

        symsize = symhdr->sh_entsize;

        if (mp->fbt_nentries) {
                /*
                 * This module has some FBT entries allocated; we're afraid
                 * to screw with it.
                 */
                return;
        }

        for (i = 1; i < nsyms; i++) {
                uint8_t *instr, *limit;
                Sym *sym = (Sym *)(symhdr->sh_addr + i * symsize);
                int j;

                if (ELF_ST_TYPE(sym->st_info) != STT_FUNC)
                        continue;

                /*
                 * Weak symbols are not candidates.  This could be made to
                 * work (where weak functions and their underlying function
                 * appear as two disjoint probes), but it's not simple.
                 */
                if (ELF_ST_BIND(sym->st_info) == STB_WEAK)
                        continue;

                name = str + sym->st_name;

                if (strstr(name, "dtrace_") == name &&
                    strstr(name, "dtrace_safe_") != name) {
                        /*
                         * Anything beginning with "dtrace_" may be called
                         * from probe context unless it explitly indicates
                         * that it won't be called from probe context by
                         * using the prefix "dtrace_safe_".
                         */
                        continue;
                }

                if (strstr(name, "kdi_") == name ||
                    strstr(name, "_kdi_") != NULL) {
                        /*
                         * Any function name beginning with "kdi_" or
                         * containing the string "_kdi_" is a part of the
                         * kernel debugger interface and may be called in
                         * arbitrary context -- including probe context.
                         */
                        continue;
                }

                /*
                 * Due to 4524008, _init and _fini may have a bloated st_size.
                 * While this bug was fixed quite some time ago, old drivers
                 * may be lurking.  We need to develop a better solution to
                 * this problem, such that correct _init and _fini functions
                 * (the vast majority) may be correctly traced.  One solution
                 * may be to scan through the entire symbol table to see if
                 * any symbol overlaps with _init.  If none does, set a bit in
                 * the module structure that this module has correct _init and
                 * _fini sizes.  This will cause some pain the first time a
                 * module is scanned, but at least it would be O(N) instead of
                 * O(N log N)...
                 */
                if (strcmp(name, "_init") == 0)
                        continue;

                if (strcmp(name, "_fini") == 0)
                        continue;

                /*
                 * In order to be eligible, the function must begin with the
                 * following sequence:
                 *
                 *      pushl   %esp
                 *      movl    %esp, %ebp
                 *
                 * Note that there are two variants of encodings that generate
                 * the movl; we must check for both.  For 64-bit, we would
                 * normally insist that a function begin with the following
                 * sequence:
                 *
                 *      pushq   %rbp
                 *      movq    %rsp, %rbp
                 *
                 * However, the compiler for 64-bit often splits these two
                 * instructions -- and the first instruction in the function
                 * is often not the pushq.  As a result, on 64-bit we look
                 * for any "pushq %rbp" in the function and we instrument
                 * this with a breakpoint instruction.
                 */
                instr = (uint8_t *)sym->st_value;
                limit = (uint8_t *)(sym->st_value + sym->st_size);

#ifdef __amd64
                while (instr < limit) {
                        if (*instr == FBT_PUSHL_EBP)
                                break;

                        if ((size = dtrace_instr_size(instr)) <= 0)
                                break;

                        instr += size;
                }

                if (instr >= limit || *instr != FBT_PUSHL_EBP) {
                        /*
                         * We either don't save the frame pointer in this
                         * function, or we ran into some disassembly
                         * screw-up.  Either way, we bail.
                         */
                        continue;
                }
#else
                if (instr[0] != FBT_PUSHL_EBP)
                        continue;

                if (!(instr[1] == FBT_MOVL_ESP_EBP0_V0 &&
                    instr[2] == FBT_MOVL_ESP_EBP1_V0) &&
                    !(instr[1] == FBT_MOVL_ESP_EBP0_V1 &&
                    instr[2] == FBT_MOVL_ESP_EBP1_V1))
                        continue;
#endif

                fbt = kmem_zalloc(sizeof (fbt_probe_t), KM_SLEEP);
                fbt->fbtp_name = name;
                fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
                    name, FBT_ENTRY, 3, fbt);
                fbt->fbtp_patchpoint = instr;
                fbt->fbtp_ctl = ctl;
                fbt->fbtp_loadcnt = ctl->mod_loadcnt;
                fbt->fbtp_rval = DTRACE_INVOP_PUSHL_EBP;
                fbt->fbtp_savedval = *instr;
                fbt->fbtp_patchval = FBT_PATCHVAL;

                fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
                fbt->fbtp_symndx = i;
                fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;

                mp->fbt_nentries++;

                retfbt = NULL;
again:
                if (instr >= limit)
                        continue;

                /*
                 * If this disassembly fails, then we've likely walked off into
                 * a jump table or some other unsuitable area.  Bail out of the
                 * disassembly now.
                 */
                if ((size = dtrace_instr_size(instr)) <= 0)
                        continue;

#ifdef __amd64
                /*
                 * We only instrument "ret" on amd64 -- we don't yet instrument
                 * ret imm16, largely because the compiler doesn't seem to
                 * (yet) emit them in the kernel...
                 */
                if (*instr != FBT_RET) {
                        instr += size;
                        goto again;
                }
#else
                if (!(size == 1 &&
                    (*instr == FBT_POPL_EBP || *instr == FBT_LEAVE) &&
                    (*(instr + 1) == FBT_RET ||
                    *(instr + 1) == FBT_RET_IMM16))) {
                        instr += size;
                        goto again;
                }
#endif

                /*
                 * We (desperately) want to avoid erroneously instrumenting a
                 * jump table, especially given that our markers are pretty
                 * short:  two bytes on x86, and just one byte on amd64.  To
                 * determine if we're looking at a true instruction sequence
                 * or an inline jump table that happens to contain the same
                 * byte sequences, we resort to some heuristic sleeze:  we
                 * treat this instruction as being contained within a pointer,
                 * and see if that pointer points to within the body of the
                 * function.  If it does, we refuse to instrument it.
                 */
                for (j = 0; j < sizeof (uintptr_t); j++) {
                        uintptr_t check = (uintptr_t)instr - j;
                        uint8_t *ptr;

                        if (check < sym->st_value)
                                break;

                        if (check + sizeof (uintptr_t) > (uintptr_t)limit)
                                continue;

                        ptr = *(uint8_t **)check;

                        if (ptr >= (uint8_t *)sym->st_value && ptr < limit) {
                                instr += size;
                                goto again;
                        }
                }

                /*
                 * We have a winner!
                 */
                fbt = kmem_zalloc(sizeof (fbt_probe_t), KM_SLEEP);
                fbt->fbtp_name = name;

                if (retfbt == NULL) {
                        fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
                            name, FBT_RETURN, 3, fbt);
                } else {
                        retfbt->fbtp_next = fbt;
                        fbt->fbtp_id = retfbt->fbtp_id;
                }

                retfbt = fbt;
                fbt->fbtp_patchpoint = instr;
                fbt->fbtp_ctl = ctl;
                fbt->fbtp_loadcnt = ctl->mod_loadcnt;

#ifndef __amd64
                if (*instr == FBT_POPL_EBP) {
                        fbt->fbtp_rval = DTRACE_INVOP_POPL_EBP;
                } else {
                        ASSERT(*instr == FBT_LEAVE);
                        fbt->fbtp_rval = DTRACE_INVOP_LEAVE;
                }
                fbt->fbtp_roffset =
                    (uintptr_t)(instr - (uint8_t *)sym->st_value) + 1;

#else
                ASSERT(*instr == FBT_RET);
                fbt->fbtp_rval = DTRACE_INVOP_RET;
                fbt->fbtp_roffset =
                    (uintptr_t)(instr - (uint8_t *)sym->st_value);
#endif

                fbt->fbtp_savedval = *instr;
                fbt->fbtp_patchval = FBT_PATCHVAL;
                fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
                fbt->fbtp_symndx = i;
                fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;

                mp->fbt_nentries++;

                instr += size;
                goto again;
        }
}

/*ARGSUSED*/
static void
fbt_destroy(void *arg, dtrace_id_t id, void *parg)
{
        fbt_probe_t *fbt = parg, *next, *hash, *last;
        struct modctl *ctl = fbt->fbtp_ctl;
        int ndx;

        do {
                if (ctl != NULL && ctl->mod_loadcnt == fbt->fbtp_loadcnt) {
                        if ((ctl->mod_loadcnt == fbt->fbtp_loadcnt &&
                            ctl->mod_loaded)) {
                                ((struct module *)
                                    (ctl->mod_mp))->fbt_nentries--;
                        }
                }

                /*
                 * Now we need to remove this probe from the fbt_probetab.
                 */
                ndx = FBT_ADDR2NDX(fbt->fbtp_patchpoint);
                last = NULL;
                hash = fbt_probetab[ndx];

                while (hash != fbt) {
                        ASSERT(hash != NULL);
                        last = hash;
                        hash = hash->fbtp_hashnext;
                }

                if (last != NULL) {
                        last->fbtp_hashnext = fbt->fbtp_hashnext;
                } else {
                        fbt_probetab[ndx] = fbt->fbtp_hashnext;
                }

                next = fbt->fbtp_next;
                kmem_free(fbt, sizeof (fbt_probe_t));

                fbt = next;
        } while (fbt != NULL);
}

/*ARGSUSED*/
static int
fbt_enable(void *arg, dtrace_id_t id, void *parg)
{
        fbt_probe_t *fbt = parg;
        struct modctl *ctl = fbt->fbtp_ctl;

        ctl->mod_nenabled++;

        if (!ctl->mod_loaded) {
                if (fbt_verbose) {
                        cmn_err(CE_NOTE, "fbt is failing for probe %s "
                            "(module %s unloaded)",
                            fbt->fbtp_name, ctl->mod_modname);
                }

                return (0);
        }

        /*
         * Now check that our modctl has the expected load count.  If it
         * doesn't, this module must have been unloaded and reloaded -- and
         * we're not going to touch it.
         */
        if (ctl->mod_loadcnt != fbt->fbtp_loadcnt) {
                if (fbt_verbose) {
                        cmn_err(CE_NOTE, "fbt is failing for probe %s "
                            "(module %s reloaded)",
                            fbt->fbtp_name, ctl->mod_modname);
                }

                return (0);
        }

        for (; fbt != NULL; fbt = fbt->fbtp_next)
                *fbt->fbtp_patchpoint = fbt->fbtp_patchval;

        return (0);
}

/*ARGSUSED*/
static void
fbt_disable(void *arg, dtrace_id_t id, void *parg)
{
        fbt_probe_t *fbt = parg;
        struct modctl *ctl = fbt->fbtp_ctl;

        ASSERT(ctl->mod_nenabled > 0);
        ctl->mod_nenabled--;

        if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
                return;

        for (; fbt != NULL; fbt = fbt->fbtp_next)
                *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
}

/*ARGSUSED*/
static void
fbt_suspend(void *arg, dtrace_id_t id, void *parg)
{
        fbt_probe_t *fbt = parg;
        struct modctl *ctl = fbt->fbtp_ctl;

        ASSERT(ctl->mod_nenabled > 0);

        if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
                return;

        for (; fbt != NULL; fbt = fbt->fbtp_next)
                *fbt->fbtp_patchpoint = fbt->fbtp_savedval;
}

/*ARGSUSED*/
static void
fbt_resume(void *arg, dtrace_id_t id, void *parg)
{
        fbt_probe_t *fbt = parg;
        struct modctl *ctl = fbt->fbtp_ctl;

        ASSERT(ctl->mod_nenabled > 0);

        if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
                return;

        for (; fbt != NULL; fbt = fbt->fbtp_next)
                *fbt->fbtp_patchpoint = fbt->fbtp_patchval;
}

/*ARGSUSED*/
static void
fbt_getargdesc(void *arg, dtrace_id_t id, void *parg, dtrace_argdesc_t *desc)
{
        fbt_probe_t *fbt = parg;
        struct modctl *ctl = fbt->fbtp_ctl;
        struct module *mp = ctl->mod_mp;
        ctf_file_t *fp = NULL, *pfp;
        ctf_funcinfo_t f;
        int error;
        ctf_id_t argv[32], type;
        int argc = sizeof (argv) / sizeof (ctf_id_t);
        const char *parent;

        if (!ctl->mod_loaded || (ctl->mod_loadcnt != fbt->fbtp_loadcnt))
                goto err;

        if (fbt->fbtp_roffset != 0 && desc->dtargd_ndx == 0) {
                (void) strcpy(desc->dtargd_native, "int");
                return;
        }

        if ((fp = ctf_modopen(mp, &error)) == NULL) {
                /*
                 * We have no CTF information for this module -- and therefore
                 * no args[] information.
                 */
                goto err;
        }

        /*
         * If we have a parent container, we must manually import it.
         */
        if ((parent = ctf_parent_name(fp)) != NULL) {
                struct modctl *mp = &modules;
                struct modctl *mod = NULL;

                /*
                 * We must iterate over all modules to find the module that
                 * is our parent.
                 */
                do {
                        if (strcmp(mp->mod_modname, parent) == 0) {
                                mod = mp;
                                break;
                        }
                } while ((mp = mp->mod_next) != &modules);

                if (mod == NULL)
                        goto err;

                if ((pfp = ctf_modopen(mod->mod_mp, &error)) == NULL) {
                        goto err;
                }

                /*
                 * If the parent module does not have the label we expect,
                 * ignore it and fail to avoid presenting non-sensical data.
                 */
                if (ctf_label_info(pfp, ctf_parent_label(fp),
                    NULL) == CTF_ERR) {
                        ctf_close(pfp);
                        goto err;
                }

                if (ctf_import(fp, pfp) != 0) {
                        ctf_close(pfp);
                        goto err;
                }

                ctf_close(pfp);
        }

        if (ctf_func_info(fp, fbt->fbtp_symndx, &f) == CTF_ERR)
                goto err;

        if (fbt->fbtp_roffset != 0) {
                if (desc->dtargd_ndx > 1)
                        goto err;

                ASSERT(desc->dtargd_ndx == 1);
                type = f.ctc_return;
        } else {
                if (desc->dtargd_ndx + 1 > f.ctc_argc)
                        goto err;

                if (ctf_func_args(fp, fbt->fbtp_symndx, argc, argv) == CTF_ERR)
                        goto err;

                type = argv[desc->dtargd_ndx];
        }

        if (ctf_type_name(fp, type, desc->dtargd_native,
            DTRACE_ARGTYPELEN) != NULL) {
                ctf_close(fp);
                return;
        }
err:
        if (fp != NULL)
                ctf_close(fp);

        desc->dtargd_ndx = DTRACE_ARGNONE;
}

static dtrace_pattr_t fbt_attr = {
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_ISA },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
};

static dtrace_pops_t fbt_pops = {
        NULL,
        fbt_provide_module,
        fbt_enable,
        fbt_disable,
        fbt_suspend,
        fbt_resume,
        fbt_getargdesc,
        NULL,
        NULL,
        fbt_destroy
};

static void
fbt_cleanup(dev_info_t *devi)
{
        dtrace_invop_remove(fbt_invop);
        ddi_remove_minor_node(devi, NULL);
        kmem_free(fbt_probetab, fbt_probetab_size * sizeof (fbt_probe_t *));
        fbt_probetab = NULL;
        fbt_probetab_mask = 0;
}

static int
fbt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_ATTACH:
                break;
        case DDI_RESUME:
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }

        if (fbt_probetab_size == 0)
                fbt_probetab_size = FBT_PROBETAB_SIZE;

        fbt_probetab_mask = fbt_probetab_size - 1;
        fbt_probetab =
            kmem_zalloc(fbt_probetab_size * sizeof (fbt_probe_t *), KM_SLEEP);

        dtrace_invop_add(fbt_invop);

        if (ddi_create_minor_node(devi, "fbt", S_IFCHR, 0,
            DDI_PSEUDO, 0) == DDI_FAILURE ||
            dtrace_register("fbt", &fbt_attr, DTRACE_PRIV_KERNEL, NULL,
            &fbt_pops, NULL, &fbt_id) != 0) {
                fbt_cleanup(devi);
                return (DDI_FAILURE);
        }

        ddi_report_dev(devi);
        fbt_devi = devi;

        return (DDI_SUCCESS);
}

static int
fbt_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_DETACH:
                break;
        case DDI_SUSPEND:
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }

        if (dtrace_unregister(fbt_id) != 0)
                return (DDI_FAILURE);

        fbt_cleanup(devi);

        return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
fbt_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        int error;

        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                *result = (void *)fbt_devi;
                error = DDI_SUCCESS;
                break;
        case DDI_INFO_DEVT2INSTANCE:
                *result = NULL;
                error = DDI_SUCCESS;
                break;
        default:
                error = DDI_FAILURE;
        }
        return (error);
}

/*ARGSUSED*/
static int
fbt_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
        return (0);
}

static struct cb_ops fbt_cb_ops = {
        fbt_open,               /* open */
        nodev,                  /* close */
        nulldev,                /* strategy */
        nulldev,                /* print */
        nodev,                  /* dump */
        nodev,                  /* read */
        nodev,                  /* write */
        nodev,                  /* ioctl */
        nodev,                  /* devmap */
        nodev,                  /* mmap */
        nodev,                  /* segmap */
        nochpoll,               /* poll */
        ddi_prop_op,            /* cb_prop_op */
        0,                      /* streamtab  */
        D_NEW | D_MP            /* Driver compatibility flag */
};

static struct dev_ops fbt_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* refcnt */
        fbt_info,               /* get_dev_info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        fbt_attach,             /* attach */
        fbt_detach,             /* detach */
        nodev,                  /* reset */
        &fbt_cb_ops,            /* driver operations */
        NULL,                   /* bus operations */
        nodev,                  /* dev power */
        ddi_quiesce_not_needed,         /* quiesce */
};

/*
 * Module linkage information for the kernel.
 */
static struct modldrv modldrv = {
        &mod_driverops,         /* module type (this is a pseudo driver) */
        "Function Boundary Tracing",    /* name of module */
        &fbt_ops,               /* driver ops */
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modldrv,
        NULL
};

int
_init(void)
{
        return (mod_install(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        return (mod_remove(&modlinkage));
}