VirtualBox

Changeset 53640 in vbox for trunk


Ignore:
Timestamp:
Jan 2, 2015 12:13:55 PM (10 years ago)
Author:
vboxsync
Message:

VBoxDTrace: Got the first 5700 to compile... (r10)

Location:
trunk/src/VBox/ExtPacks/VBoxDTrace
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/ExtPacks/VBoxDTrace/include/VBoxDTraceTypes.h

    r53636 r53640  
    4242typedef uintptr_t               pc_t;
    4343typedef uint32_t                zoneid_t;
    44 typedef uintptr_t               caddr_t;
     44typedef char                   *caddr_t;
    4545typedef uint64_t                hrtime_t;
    4646typedef RTCPUID                 processorid_t;
    4747typedef RTCCUINTREG             greg_t;
     48typedef unsigned int            model_t;
    4849
    4950typedef struct VBoxDtCred
    … …  
    6061typedef struct VBoxDtVMem       vmem_t;
    6162typedef struct VBoxDtCyclicId  *cyclic_id_t;
    62 typedef struct VBoxDtThread     kthread_t;
    63 typedef struct VBoxDtThread     proc_t;
     63
     64typedef struct VBoxDtThread
     65{
     66    hrtime_t                t_dtrace_vtime;
     67    hrtime_t                t_dtrace_start;
     68    uint8_t                 t_dtrace_stop;
     69    uintptr_t               t_dtrace_scrpc;
     70    uintptr_t               t_dtrace_astpc;
     71    uint32_t                t_predcache;
     72} kthread_t;
     73extern kthread_t *VBoxDtGetCurrentThread(void);
     74#define curthread               (VBoxDtGetCurrentThread())
     75
     76
     77typedef struct VBoxDtProcess
     78{
     79    uint32_t                p_flag;
     80} proc_t;
     81
     82#define SNOCD                   RT_BIT(0)
     83
     84
    6485typedef struct VBoxDtDevInfo    dev_info_t;
    6586typedef struct VBoxDtTaskQueue  taskq_t;
    … …  
    7495{
    7596    RTCPUID             cpu_id;
    76     void               *cpuc_dtrace_illval;
     97    uintptr_t           cpuc_dtrace_illval;
    7798    uint16_t volatile   cpuc_dtrace_flags;
    7899
    79100} cpucore_t;
    80101
    81 #define CPU_DTRACE_BADADDR  RT_BIT(0)
    82 #define CPU_DTRACE_BADALIGN RT_BIT(1)
    83 #define CPU_DTRACE_NOFAULT  RT_BIT(2)
    84 #define CPU_DTRACE_FAULT    RT_BIT(3)
    85 #define CPU_DTRACE_KPRIV    RT_BIT(4)
    86 #define CPU_DTRACE_DROP     RT_BIT(5)
     102#define CPU_DTRACE_BADADDR      RT_BIT(0)
     103#define CPU_DTRACE_BADALIGN     RT_BIT(1)
     104#define CPU_DTRACE_BADSTACK     RT_BIT(2)
     105#define CPU_DTRACE_KPRIV        RT_BIT(3)
     106#define CPU_DTRACE_DIVZERO      RT_BIT(4)
     107#define CPU_DTRACE_ILLOP        RT_BIT(5)
     108#define CPU_DTRACE_NOSCRATCH    RT_BIT(6)
     109#define CPU_DTRACE_UPRIV        RT_BIT(7)
     110#define CPU_DTRACE_TUPOFLOW     RT_BIT(8)
     111#define CPU_DTRACE_ENTRY        RT_BIT(9)
     112#define CPU_DTRACE_FAULT        UINT16_C(0x03ff)
     113#define CPU_DTRACE_DROP         RT_BIT(12)
     114#define CPU_DTRACE_ERROR        UINT16_C(0x13ff)
     115#define CPU_DTRACE_NOFAULT      RT_BIT(15)
    87116
    88 extern cpucore_t  g_aVBoxDtCpuCores[RTCPUSET_MAX_CPUS];
    89 #define cpu_core (g_aVBoxDtCpuCores)
     117extern cpucore_t                g_aVBoxDtCpuCores[RTCPUSET_MAX_CPUS];
     118#define cpu_core                (g_aVBoxDtCpuCores)
     119
     120cred_t *VBoxDtGetCurrentCreds(void);
     121#define CRED()                  VBoxDtGetCurrentCreds()
     122
     123proc_t *VBoxDtThreadToProc(kthread_t *);
     124
     125
     126#define ASSERT(a_Expr)          Assert(a_Expr)
    90127
    91128#if 1 /* */
    92129
    93 typedef RTUID               uid_t;
    94 typedef RTPROCESS           pid_t;
    95 typedef RTDEV               dev_t;
     130typedef RTUID                   uid_t;
     131typedef RTPROCESS               pid_t;
     132typedef RTDEV                   dev_t;
    96133#endif
    97134
    98 #define NANOSEC             RT_NS_1SEC
    99 #define MILLISEC            RT_MS_1SEC
    100 #define NBBY                8
     135#define NANOSEC                 RT_NS_1SEC
     136#define MILLISEC                RT_MS_1SEC
     137#define NBBY                    8
     138#define NCPU                    RTCPUSET_MAX_CPUS
     139#define P2ROUNDUP(uWhat, uAlign) ( ((uWhat) + (uAlign) - 1) & ~(uAlign - 1) )
     140#define CPU_ON_INTR(a_pCpu)     (false)
    101141
     142
     143#if defined(RT_ARCH_X86)
     144# ifndef __i386
     145#  define __i386            1
     146# endif
     147
     148#elif defined(RT_ARCH_AMD64)
     149# ifndef __x86_64
     150#  define __x86_64          1
     151# endif
     152
     153#else
     154# error "unsupported arch!"
     155#endif
     156
     157/** Mark a cast added when porting the code to VBox.
     158 * Avoids lots of \#ifdef VBOX otherwise needed to mark up the changes. */
     159#define VBDTCAST(a_Type)        (a_Type)
    102160
    103161RT_C_DECLS_END

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/dtrace/dtrace.c

    r53636 r53640  
    9494
    9595#else  /* VBOX */
    96 # include <iprt/types.h>
    9796# include <sys/dtrace_impl.h>
     97# include <iprt/assert.h>
    9898# include <iprt/mp.h>
     99# include <iprt/process.h>
     100# include <iprt/thread.h>
     101
     102# undef NULL
     103# define NULL (0)
    99104#endif /* VBOX */
    100105
    … …  
    340345 * signature.
    341346 */
     347#ifndef VBOX
    342348#define DTRACE_TLS_THRKEY(where) { \
    343349        uint_t intr = 0; \
    … …  
    349355            (((uint64_t)1 << 61) - 1)) | ((uint64_t)intr << 61); \
    350356}
     357#else
     358#define DTRACE_TLS_THRKEY(where) do { \
     359        (where) = (((uintptr_t)RTThreadNativeSelf() + DIF_VARIABLE_MAX) & (RT_BIT_64(61) - 1)) \
     360                        | (RTThreadIsInInterrupt(NIL_RTTHREAD) ? RT_BIT_64(61) : 0); \
     361} while (0)
     362#endif
    351363
    352364#define DT_BSWAP_8(x)   ((x) & 0xff)
    … …  
    11051117        proc_t *proc;
    11061118
    1107         if ((proc = ttoproc(curthread)) != NULL &&
     1119        if ((proc = VBDT_GET_PROC()) != NULL &&
    11081120            !(proc->p_flag & SNOCD))
    11091121                return (1);
    … …  
    22352247                return;
    22362248
    2237         if (which > state->dts_nspeculations) {
     2249        if (which > VBDTCAST(unsigned)state->dts_nspeculations) {
    22382250                cpu_core[cpu].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
    22392251                return;
    … …  
    23712383                return;
    23722384
    2373         if (which > state->dts_nspeculations) {
     2385        if (which > VBDTCAST(unsigned)state->dts_nspeculations) {
    23742386                cpu_core[cpu].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
    23752387                return;
    … …  
    24342446        }
    24352447
    2436         for (i = 0; i < state->dts_nspeculations; i++) {
     2448        for (i = 0; i < VBDTCAST(unsigned)state->dts_nspeculations; i++) {
    24372449                dtrace_speculation_t *spec = &state->dts_speculations[i];
    24382450                dtrace_buffer_t *src = &spec->dtsp_buffer[cpu];
    … …  
    24722484        dtrace_specid_t i;
    24732485
    2474         for (i = 0; i < state->dts_nspeculations; i++) {
     2486        for (i = 0; i < VBDTCAST(unsigned)state->dts_nspeculations; i++) {
    24752487                dtrace_speculation_t *spec = &state->dts_speculations[i];
    24762488
    … …  
    24962508         * to inactive.
    24972509         */
    2498         for (i = 0; i < state->dts_nspeculations; i++) {
     2510        for (i = 0; i < VBDTCAST(unsigned)state->dts_nspeculations; i++) {
    24992511                dtrace_speculation_t *spec = &state->dts_speculations[i];
    25002512                dtrace_speculation_state_t current, new;
    … …  
    25332545                return (NULL);
    25342546
    2535         if (which > state->dts_nspeculations) {
     2547        if (which > VBDTCAST(unsigned)state->dts_nspeculations) {
    25362548                cpu_core[cpuid].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
    25372549                return (NULL);
    … …  
    26822694
    26832695        case DIF_VAR_UREGS: {
     2696#ifndef VBOX
    26842697                klwp_t *lwp;
    26852698
    … …  
    26942707
    26952708                return (dtrace_getreg(lwp->lwp_regs, ndx));
     2709#else
     2710                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     2711                return (0);
     2712#endif
    26962713        }
    26972714
    … …  
    26992716                if (!dtrace_priv_kernel(state))
    27002717                        return (0);
     2718#ifndef VBOX
    27012719                return ((uint64_t)(uintptr_t)curthread);
     2720#else
     2721                return ((uintptr_t)RTThreadNativeSelf());
     2722#endif
    27022723
    27032724        case DIF_VAR_TIMESTAMP:
    … …  
    28542875                        return (0);
    28552876
     2877#ifndef VBOX
    28562878                /*
    28572879                 * Note that we are assuming that an unanchored probe is
    … …  
    28712893                 */
    28722894                return ((uint64_t)curthread->t_procp->p_pidp->pid_id);
     2895#else
     2896                return (RTProcSelf());
     2897#endif
    28732898
    28742899        case DIF_VAR_PPID:
    … …  
    28762901                        return (0);
    28772902
     2903#ifndef VBOX
    28782904                /*
    28792905                 * See comment in DIF_VAR_PID.
    … …  
    28892915                 */
    28902916                return ((uint64_t)curthread->t_procp->p_ppid);
     2917#else
     2918                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     2919                return (0); /** @todo parent pid? */
     2920#endif
    28912921
    28922922        case DIF_VAR_TID:
     2923#ifndef VBOX
    28932924                /*
    28942925                 * See comment in DIF_VAR_PID.
    … …  
    28982929
    28992930                return ((uint64_t)curthread->t_tid);
     2931#else
     2932                return (RTThreadNativeSelf()); /** @todo proper tid? */
     2933#endif
    29002934
    29012935        case DIF_VAR_EXECNAME:
    … …  
    29032937                        return (0);
    29042938
     2939#ifndef VBOX
    29052940                /*
    29062941                 * See comment in DIF_VAR_PID.
    … …  
    29182953                    (uintptr_t)curthread->t_procp->p_user.u_comm,
    29192954                    state, mstate));
     2955#else
     2956                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     2957                return (0); /** @todo execname */
     2958#endif
    29202959
    29212960        case DIF_VAR_ZONENAME:
    … …  
    29232962                        return (0);
    29242963
     2964#ifndef VBOX
    29252965                /*
    29262966                 * See comment in DIF_VAR_PID.
    … …  
    29382978                    (uintptr_t)curthread->t_procp->p_zone->zone_name,
    29392979                    state, mstate));
     2980#else
     2981                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     2982                return (0);
     2983#endif
    29402984
    29412985        case DIF_VAR_UID:
    … …  
    29432987                        return (0);
    29442988
     2989#ifndef VBOX
    29452990                /*
    29462991                 * See comment in DIF_VAR_PID.
    … …  
    29593004                 */
    29603005                return ((uint64_t)curthread->t_procp->p_cred->cr_uid);
     3006#else
     3007                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     3008                return (0);
     3009#endif
    29613010
    29623011        case DIF_VAR_GID:
    … …  
    29643013                        return (0);
    29653014
     3015#ifndef VBOX
    29663016                /*
    29673017                 * See comment in DIF_VAR_PID.
    … …  
    29803030                 */
    29813031                return ((uint64_t)curthread->t_procp->p_cred->cr_gid);
     3032#else
     3033                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     3034                return (0);
     3035#endif
    29823036
    29833037        case DIF_VAR_ERRNO: {
     3038#ifndef VBOX
    29843039                klwp_t *lwp;
     3040#endif
    29853041                if (!dtrace_priv_proc(state))
    29863042                        return (0);
    29873043
     3044#ifndef VBOX
    29883045                /*
    29893046                 * See comment in DIF_VAR_PID.
    … …  
    30023059
    30033060                return ((uint64_t)lwp->lwp_errno);
     3061#else
     3062                cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags |= CPU_DTRACE_ILLOP;
     3063                return (0);
     3064#endif
    30043065        }
    30053066        default:
    … …  
    30253086        dtrace_vstate_t *vstate = &state->dts_vstate;
    30263087
     3088#ifndef VBOX
    30273089        union {
    30283090                mutex_impl_t mi;
    … …  
    30343096                uintptr_t rw;
    30353097        } r;
     3098#endif
    30363099
    30373100        switch (subr) {
    … …  
    30413104
    30423105        case DIF_SUBR_MUTEX_OWNED:
     3106#ifndef VBOX
    30433107                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
    30443108                    mstate, vstate)) {
    … …  
    30523116                else
    30533117                        regs[rd] = LOCK_HELD(&m.mi.m_spin.m_spinlock);
     3118#else
     3119                regs[rd] = 0;
     3120                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3121#endif
    30543122                break;
    30553123
    30563124        case DIF_SUBR_MUTEX_OWNER:
     3125#ifndef VBOX
    30573126                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
    30583127                    mstate, vstate)) {
    … …  
    30673136                else
    30683137                        regs[rd] = 0;
     3138#else
     3139                regs[rd] = 0;
     3140                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3141#endif
    30693142                break;
    30703143
    30713144        case DIF_SUBR_MUTEX_TYPE_ADAPTIVE:
     3145#ifndef VBOX
    30723146                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
    30733147                    mstate, vstate)) {
    … …  
    30783152                m.mx = dtrace_load64(tupregs[0].dttk_value);
    30793153                regs[rd] = MUTEX_TYPE_ADAPTIVE(&m.mi);
     3154#else
     3155                regs[rd] = 0;
     3156                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3157#endif
    30803158                break;
    30813159
    30823160        case DIF_SUBR_MUTEX_TYPE_SPIN:
     3161#ifndef VBOX
    30833162                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
    30843163                    mstate, vstate)) {
    … …  
    30893168                m.mx = dtrace_load64(tupregs[0].dttk_value);
    30903169                regs[rd] = MUTEX_TYPE_SPIN(&m.mi);
     3170#else
     3171                regs[rd] = 0;
     3172                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3173#endif
    30913174                break;
    30923175
    30933176        case DIF_SUBR_RW_READ_HELD: {
     3177#ifndef VBOX
    30943178                uintptr_t tmp;
    30953179
    … …  
    31023186                r.rw = dtrace_loadptr(tupregs[0].dttk_value);
    31033187                regs[rd] = _RW_READ_HELD(&r.ri, tmp);
     3188#else
     3189                regs[rd] = 0;
     3190                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3191#endif
    31043192                break;
    31053193        }
    31063194
    31073195        case DIF_SUBR_RW_WRITE_HELD:
     3196#ifndef VBOX
    31083197                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t),
    31093198                    mstate, vstate)) {
    … …  
    31143203                r.rw = dtrace_loadptr(tupregs[0].dttk_value);
    31153204                regs[rd] = _RW_WRITE_HELD(&r.ri);
     3205#else
     3206                regs[rd] = 0;
     3207                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3208#endif
    31163209                break;
    31173210
    31183211        case DIF_SUBR_RW_ISWRITER:
     3212#ifndef VBOX
    31193213                if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t),
    31203214                    mstate, vstate)) {
    … …  
    31253219                r.rw = dtrace_loadptr(tupregs[0].dttk_value);
    31263220                regs[rd] = _RW_ISWRITER(&r.ri);
     3221#else
     3222                regs[rd] = 0;
     3223                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3224#endif
    31273225                break;
    31283226
    … …  
    32373335        case DIF_SUBR_MSGSIZE:
    32383336        case DIF_SUBR_MSGDSIZE: {
     3337#ifndef VBOX
    32393338                uintptr_t baddr = tupregs[0].dttk_value, daddr;
    32403339                uintptr_t wptr, rptr;
    … …  
    32903389                        regs[rd] = count;
    32913390
     3391#else
     3392                regs[rd] = 0;
     3393                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3394#endif
    32923395                break;
    32933396        }
    32943397
    32953398        case DIF_SUBR_PROGENYOF: {
     3399#ifndef VBOX
    32963400                pid_t pid = tupregs[0].dttk_value;
    32973401                proc_t *p;
    … …  
    33103414
    33113415                regs[rd] = rval;
     3416#else
     3417                regs[rd] = 0;
     3418                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3419#endif
    33123420                break;
    33133421        }
    … …  
    35053613                                        }
    35063614
    3507                                         if (pos > len)
     3615                                        if (VBDTCAST(uint64_t)pos > len)
    35083616                                                pos = len;
    35093617                                } else {
    … …  
    35113619                                                pos = 0;
    35123620
    3513                                         if (pos >= len) {
     3621                                        if (VBDTCAST(uint64_t)pos >= len) {
    35143622                                                if (sublen == 0)
    35153623                                                        regs[rd] = len;
    … …  
    36893797                }
    36903798
    3691                 if (index >= len || index < 0) {
     3799                if (VBDTCAST(uint64_t)index >= len || index < 0) {
    36923800                        remaining = 0;
    36933801                } else if (remaining < 0) {
    36943802                        remaining += len - index;
    3695                 } else if (index + remaining > size) {
     3803                } else if (VBDTCAST(uint64_t)index + remaining > size) {
    36963804                        remaining = size - index;
    36973805                }
    … …  
    37103818
    37113819        case DIF_SUBR_GETMAJOR:
     3820#ifndef VBOX
    37123821#ifdef _LP64
    37133822                regs[rd] = (tupregs[0].dttk_value >> NBITSMINOR64) & MAXMAJ64;
    … …  
    37153824                regs[rd] = (tupregs[0].dttk_value >> NBITSMINOR) & MAXMAJ;
    37163825#endif
     3826#else
     3827                regs[rd] = 0;
     3828                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3829#endif
    37173830                break;
    37183831
    37193832        case DIF_SUBR_GETMINOR:
     3833#ifndef VBOX
    37203834#ifdef _LP64
    37213835                regs[rd] = tupregs[0].dttk_value & MAXMIN64;
    … …  
    37233837                regs[rd] = tupregs[0].dttk_value & MAXMIN;
    37243838#endif
     3839#else
     3840                regs[rd] = 0;
     3841                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     3842#endif
    37253843                break;
    37263844
    37273845        case DIF_SUBR_DDI_PATHNAME: {
     3846#ifndef VBOX
    37283847                /*
    37293848                 * This one is a galactic mess.  We are going to roughly
    … …  
    39154034                }
    39164035
     4036#else
     4037                regs[rd] = 0;
     4038                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     4039#endif
    39174040                break;
    39184041        }
    … …  
    40304153                uint64_t size = state->dts_options[DTRACEOPT_STRSIZE];
    40314154                uintptr_t src = tupregs[0].dttk_value;
    4032                 int i, j, len = dtrace_strlen((char *)src, size);
     4155                int i, j, len = VBDTCAST(int)dtrace_strlen((char *)src, size);
    40334156                int lastbase = -1, firstbase = -1, lastdir = -1;
    40344157                int start, end;
    … …  
    42674390        case DIF_SUBR_INET_NTOA6:
    42684391        case DIF_SUBR_INET_NTOP: {
     4392#ifndef VBOX
    42694393                size_t size;
    42704394                int af, argi, i;
    … …  
    44654589inetout:        regs[rd] = (uintptr_t)end + 1;
    44664590                mstate->dtms_scratch_ptr += size;
     4591#else  /* VBOX */
     4592                regs[rd] = 0;
     4593                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     4594#endif /* VBOX */
    44674595                break;
    44684596        }
    … …  
    48694997                        id -= DIF_VAR_OTHER_UBASE;
    48704998
    4871                         ASSERT(id < vstate->dtvs_nlocals);
     4999                        ASSERT(VBDTCAST(int64_t)id < vstate->dtvs_nlocals);
    48725000                        ASSERT(vstate->dtvs_locals != NULL);
    48735001
    … …  
    49085036                        ASSERT(id >= DIF_VAR_OTHER_UBASE);
    49095037                        id -= DIF_VAR_OTHER_UBASE;
    4910                         ASSERT(id < vstate->dtvs_nlocals);
     5038                        ASSERT(VBDTCAST(int64_t)id < vstate->dtvs_nlocals);
    49115039
    49125040                        ASSERT(vstate->dtvs_locals != NULL);
    … …  
    52625390}
    52635391
     5392#ifndef VBOX /* no destructive stuff */
     5393
    52645394static void
    52655395dtrace_action_breakpoint(dtrace_ecb_t *ecb)
    … …  
    54335563}
    54345564
     5565#endif /* !VBOX */
     5566
    54355567static void
    54365568dtrace_action_ustack(dtrace_mstate_t *mstate, dtrace_state_t *state,
    … …  
    54435575        int size, offs = 0, i, j;
    54445576        uintptr_t old = mstate->dtms_scratch_ptr, saved;
     5577#ifndef VBOX
    54455578        uint16_t *flags = &cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags;
     5579#else
     5580        uint16_t volatile *flags = &cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags;
     5581#endif
    54465582        char *sym;
    54475583
    … …  
    58395975                        switch (act->dta_kind) {
    58405976                        case DTRACEACT_STOP:
     5977#ifndef VBOX
    58415978                                if (dtrace_priv_proc_destructive(state))
    58425979                                        dtrace_action_stop();
     5980#else
     5981                                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     5982#endif
    58435983                                continue;
    58445984
    58455985                        case DTRACEACT_BREAKPOINT:
     5986#ifndef VBOX
    58465987                                if (dtrace_priv_kernel_destructive(state))
    58475988                                        dtrace_action_breakpoint(ecb);
     5989#else
     5990                                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     5991#endif
    58485992                                continue;
    58495993
    58505994                        case DTRACEACT_PANIC:
     5995#ifndef VBOX
    58515996                                if (dtrace_priv_kernel_destructive(state))
    58525997                                        dtrace_action_panic(ecb);
     5998#endif
    58535999                                continue;
    58546000
    … …  
    59476093
    59486094                        case DTRACEACT_CHILL:
     6095#ifndef VBOX
    59496096                                if (dtrace_priv_kernel_destructive(state))
    59506097                                        dtrace_action_chill(&mstate, val);
     6098#else
     6099                                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     6100#endif
    59516101                                continue;
    59526102
    59536103                        case DTRACEACT_RAISE:
     6104#ifndef VBOX
    59546105                                if (dtrace_priv_proc_destructive(state))
    59556106                                        dtrace_action_raise(val);
     6107#else
     6108                                DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
     6109#endif
    59566110                                continue;
    59576111

  • trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace.h

    r53636 r53640  
    22362236#ifndef VBOX
    22372237# define VBDT_GET_CPUID()               (CPU->cpu_id)
     2238# define VBDT_GET_PROC()                (ttoproc(curthread))
    22382239#else
    22392240# define VBDT_GET_CPUID()               (RTMpCpuId())
     2241# define VBDT_GET_PROC()                (VBoxDtGetCurrentProc())
     2242proc_t *VBoxDtGetCurrentProc(void);
    22402243#endif
    2241 
    22422244
    22432245#define DTRACE_CPUFLAG_ISSET(flag) \
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette