]> git.saurik.com Git - apple/xnu.git/blobdiff - bsd/dev/dtrace/systrace.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-7195.101.1.tar.gz
[apple/xnu.git] / bsd / dev / dtrace / systrace.c
diff --git a/bsd/dev/dtrace/systrace.c b/bsd/dev/dtrace/systrace.c
index 9c0c34f6317dfd79eb05e2ac4fec39ce64bef188..1342e7785875b4d3a1cf25f8662cfc431bda6ba9 100644 (file)
--- a/bsd/dev/dtrace/systrace.c
+++ b/bsd/dev/dtrace/systrace.c
@@ -23,13 +23,7 @@
  * Use is subject to license terms.
  */
 
  * Use is subject to license terms.
  */
 
-/* #pragma ident       "@(#)systrace.c 1.6     06/09/19 SMI" */
-
-#ifdef KERNEL
-#ifndef _KERNEL
-#define _KERNEL /* Solaris vs. Darwin */
-#endif
-#endif
+#include <ptrauth.h>
 
 #include <kern/thread.h>
 #include <mach/thread_status.h>
 
 #include <kern/thread.h>
 #include <mach/thread_status.h>
@@ -64,7 +58,7 @@
 #include <machine/pal_routines.h>
 
 #if defined (__x86_64__)
 #include <machine/pal_routines.h>
 
 #if defined (__x86_64__)
-#define        SYSTRACE_ARTIFICIAL_FRAMES      2
+#define SYSTRACE_ARTIFICIAL_FRAMES      2
 #define MACHTRACE_ARTIFICIAL_FRAMES 3
 #elif defined(__arm__) || defined(__arm64__)
 #define SYSTRACE_ARTIFICIAL_FRAMES  2
 #define MACHTRACE_ARTIFICIAL_FRAMES 3
 #elif defined(__arm__) || defined(__arm64__)
 #define SYSTRACE_ARTIFICIAL_FRAMES  2
@@ -88,9 +82,8 @@ extern const char *syscallnames[];
 #define LOADABLE_SYSCALL(a) 0 /* Not pertinent to Darwin. */
 #define LOADED_SYSCALL(a) 1 /* Not pertinent to Darwin. */
 
 #define LOADABLE_SYSCALL(a) 0 /* Not pertinent to Darwin. */
 #define LOADED_SYSCALL(a) 1 /* Not pertinent to Darwin. */
 
-extern lck_attr_t* dtrace_lck_attr;
-extern lck_grp_t* dtrace_lck_grp;
-static lck_mtx_t       dtrace_systrace_lock;           /* probe state lock */
+static LCK_MTX_DECLARE_ATTR(dtrace_systrace_lock,
+    &dtrace_lck_grp, &dtrace_lck_attr);           /* probe state lock */
 
 systrace_sysent_t *systrace_sysent = NULL;
 void (*systrace_probe)(dtrace_id_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
 
 systrace_sysent_t *systrace_sysent = NULL;
 void (*systrace_probe)(dtrace_id_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
@@ -108,7 +101,7 @@ systrace_stub(dtrace_id_t id, uint64_t arg0, uint64_t arg1,
 int32_t
 dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
 {
 int32_t
 dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
 {
-       unsigned short      code;       /* The system call number */
+       unsigned short      code;       /* The system call number */
 
        systrace_sysent_t *sy;
        dtrace_id_t id;
 
        systrace_sysent_t *sy;
        dtrace_id_t id;
@@ -135,7 +128,7 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
                        code = saved_state32(tagged_regs)->eax & I386_SYSCALL_NUMBER_MASK;
 
                        if (code == 0) {
                        code = saved_state32(tagged_regs)->eax & I386_SYSCALL_NUMBER_MASK;
 
                        if (code == 0) {
-                               vm_offset_t params = (vm_offset_t) (saved_state32(tagged_regs)->uesp + sizeof (int));
+                               vm_offset_t params = (vm_offset_t) (saved_state32(tagged_regs)->uesp + sizeof(int));
                                code = fuword(params);
                        }
                }
                                code = fuword(params);
                        }
                }
@@ -151,10 +144,11 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
                arm_saved_state_t *arm_regs = (arm_saved_state_t *) find_user_regs(current_thread());
 
                /* Check for indirect system call */
                arm_saved_state_t *arm_regs = (arm_saved_state_t *) find_user_regs(current_thread());
 
                /* Check for indirect system call */
-               if (arm_regs->r[12] != 0)
+               if (arm_regs->r[12] != 0) {
                        code = arm_regs->r[12];
                        code = arm_regs->r[12];
-               else
+               } else {
                        code = arm_regs->r[0];
                        code = arm_regs->r[0];
+               }
        }
 #elif defined(__arm64__)
        {
        }
 #elif defined(__arm64__)
        {
@@ -164,23 +158,21 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
                 * ... and for u64 can be in either x0 or x16
                 */
 
                 * ... and for u64 can be in either x0 or x16
                 */
 
-               /* see bsd/dev/arm/systemcalls.c:arm_get_syscall_number */              
+               /* see bsd/dev/arm/systemcalls.c:arm_get_syscall_number */
                arm_saved_state_t *arm_regs = (arm_saved_state_t *) find_user_regs(current_thread());
 
                if (is_saved_state32(arm_regs)) {
                arm_saved_state_t *arm_regs = (arm_saved_state_t *) find_user_regs(current_thread());
 
                if (is_saved_state32(arm_regs)) {
-                       /* Check for indirect system call */                    
+                       /* Check for indirect system call */
                        if (saved_state32(arm_regs)->r[12] != 0) {
                                code = saved_state32(arm_regs)->r[12];
                        if (saved_state32(arm_regs)->r[12] != 0) {
                                code = saved_state32(arm_regs)->r[12];
-                       }
-                       else {
+                       } else {
                                code = saved_state32(arm_regs)->r[0];
                        }
                } else {
                        /* Check for indirect system call */
                                code = saved_state32(arm_regs)->r[0];
                        }
                } else {
                        /* Check for indirect system call */
-                       if (saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM] != 0 ) {
+                       if (saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM] != 0) {
                                code = saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM];
                                code = saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM];
-                       }
-                       else {
+                       } else {
                                code = saved_state64(arm_regs)->x[0];
                        }
                }
                                code = saved_state64(arm_regs)->x[0];
                        }
                }
@@ -195,15 +187,17 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
        systrace_args(code, ip, uargs);
 
        if ((id = sy->stsy_entry) != DTRACE_IDNONE) {
        systrace_args(code, ip, uargs);
 
        if ((id = sy->stsy_entry) != DTRACE_IDNONE) {
-               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());            
-               if (uthread)
+               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
+               if (uthread) {
                        uthread->t_dtrace_syscall_args = uargs;
                        uthread->t_dtrace_syscall_args = uargs;
-               
+               }
+
                static_assert(SYSTRACE_NARGS >= 5, "not enough system call arguments");
                (*systrace_probe)(id, uargs[0], uargs[1], uargs[2], uargs[3], uargs[4]);
                static_assert(SYSTRACE_NARGS >= 5, "not enough system call arguments");
                (*systrace_probe)(id, uargs[0], uargs[1], uargs[2], uargs[3], uargs[4]);
-               
-               if (uthread)
+
+               if (uthread) {
                        uthread->t_dtrace_syscall_args = NULL;
                        uthread->t_dtrace_syscall_args = NULL;
+               }
        }
 
 
        }
 
 
@@ -227,14 +221,14 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
 
        if ((id = sy->stsy_return) != DTRACE_IDNONE) {
                uint64_t munged_rv0, munged_rv1;
 
        if ((id = sy->stsy_return) != DTRACE_IDNONE) {
                uint64_t munged_rv0, munged_rv1;
-       uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
+               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
 
 
-               if (uthread)
+               if (uthread) {
                        uthread->t_dtrace_errno = rval; /* Establish t_dtrace_errno now in case this enabling refers to it. */
                        uthread->t_dtrace_errno = rval; /* Establish t_dtrace_errno now in case this enabling refers to it. */
-
+               }
                /*
                /*
-                * "Decode" rv for use in the call to dtrace_probe()
-                */
+                * "Decode" rv for use in the call to dtrace_probe()
+                */
                if (rval == ERESTART) {
                        munged_rv0 = -1LL; /* System call will be reissued in user mode. Make DTrace report a -1 return. */
                        munged_rv1 = -1LL;
                if (rval == ERESTART) {
                        munged_rv0 = -1LL; /* System call will be reissued in user mode. Make DTrace report a -1 return. */
                        munged_rv1 = -1LL;
@@ -284,20 +278,20 @@ dtrace_systrace_syscall(struct proc *pp, void *uap, int *rv)
                 * "This is a bit of an historical artifact. At first, the syscall provider just
                 * had its return value in arg0, and the fbt and pid providers had their return
                 * values in arg1 (so that we could use arg0 for the offset of the return site).
                 * "This is a bit of an historical artifact. At first, the syscall provider just
                 * had its return value in arg0, and the fbt and pid providers had their return
                 * values in arg1 (so that we could use arg0 for the offset of the return site).
-                * 
+                *
                 * We inevitably started writing scripts where we wanted to see the return
                 * values from probes in all three providers, and we made this script easier
                 * to write by replicating the syscall return values in arg1 to match fbt and
                 * pid. We debated briefly about removing the return value from arg0, but
                 * decided that it would be less confusing to have the same data in two places
                 * than to have some non-helpful, non-intuitive value in arg0.
                 * We inevitably started writing scripts where we wanted to see the return
                 * values from probes in all three providers, and we made this script easier
                 * to write by replicating the syscall return values in arg1 to match fbt and
                 * pid. We debated briefly about removing the return value from arg0, but
                 * decided that it would be less confusing to have the same data in two places
                 * than to have some non-helpful, non-intuitive value in arg0.
-                * 
+                *
                 * This change was made 4/23/2003 according to the DTrace project's putback log."
                 * This change was made 4/23/2003 according to the DTrace project's putback log."
-                */ 
+                */
                (*systrace_probe)(id, munged_rv0, munged_rv0, munged_rv1, (uint64_t)rval, 0);
        }
 
                (*systrace_probe)(id, munged_rv0, munged_rv0, munged_rv1, (uint64_t)rval, 0);
        }
 
-       return (rval);
+       return rval;
 }
 
 void
 }
 
 void
@@ -311,14 +305,14 @@ dtrace_systrace_syscall_return(unsigned short code, int rval, int *rv)
 
        if ((id = sy->stsy_return) != DTRACE_IDNONE) {
                uint64_t munged_rv0, munged_rv1;
 
        if ((id = sy->stsy_return) != DTRACE_IDNONE) {
                uint64_t munged_rv0, munged_rv1;
-       uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
+               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
 
 
-               if (uthread)
+               if (uthread) {
                        uthread->t_dtrace_errno = rval; /* Establish t_dtrace_errno now in case this enabling refers to it. */
                        uthread->t_dtrace_errno = rval; /* Establish t_dtrace_errno now in case this enabling refers to it. */
-
+               }
                /*
                /*
-                * "Decode" rv for use in the call to dtrace_probe()
-                */
+                * "Decode" rv for use in the call to dtrace_probe()
+                */
                if (rval == ERESTART) {
                        munged_rv0 = -1LL; /* System call will be reissued in user mode. Make DTrace report a -1 return. */
                        munged_rv1 = -1LL;
                if (rval == ERESTART) {
                        munged_rv0 = -1LL; /* System call will be reissued in user mode. Make DTrace report a -1 return. */
                        munged_rv1 = -1LL;
@@ -366,17 +360,16 @@ dtrace_systrace_syscall_return(unsigned short code, int rval, int *rv)
        }
 }
 
        }
 }
 
-#define        SYSTRACE_SHIFT                  16
-#define        SYSTRACE_ISENTRY(x)             ((int)(x) >> SYSTRACE_SHIFT)
-#define        SYSTRACE_SYSNUM(x)              ((int)(x) & ((1 << SYSTRACE_SHIFT) - 1))
-#define        SYSTRACE_ENTRY(id)              ((1 << SYSTRACE_SHIFT) | (id))
-#define        SYSTRACE_RETURN(id)             (id)
+#define SYSTRACE_SHIFT                  16
+#define SYSTRACE_ISENTRY(x)             ((int)(x) >> SYSTRACE_SHIFT)
+#define SYSTRACE_SYSNUM(x)              ((int)(x) & ((1 << SYSTRACE_SHIFT) - 1))
+#define SYSTRACE_ENTRY(id)              ((1 << SYSTRACE_SHIFT) | (id))
+#define SYSTRACE_RETURN(id)             (id)
 
 #if ((1 << SYSTRACE_SHIFT) <= NSYSCALL)
 #error 1 << SYSTRACE_SHIFT must exceed number of system calls
 #endif
 
 
 #if ((1 << SYSTRACE_SHIFT) <= NSYSCALL)
 #error 1 << SYSTRACE_SHIFT must exceed number of system calls
 #endif
 
-static dev_info_t *systrace_devi;
 static dtrace_provider_id_t systrace_id;
 
 /*
 static dtrace_provider_id_t systrace_id;
 
 /*
@@ -386,32 +379,32 @@ static dtrace_provider_id_t systrace_id;
 #define systrace_init _systrace_init
 
 static void
 #define systrace_init _systrace_init
 
 static void
-systrace_init(struct sysent *actual, systrace_sysent_t **interposed)
+systrace_init(const struct sysent *actual, systrace_sysent_t **interposed)
 {
 {
-
        systrace_sysent_t *ssysent = *interposed;  /* Avoid sysent shadow warning
        systrace_sysent_t *ssysent = *interposed;  /* Avoid sysent shadow warning
-                                                          from bsd/sys/sysent.h */
+                                                   *       from bsd/sys/sysent.h */
        unsigned int i;
 
        if (ssysent == NULL) {
        unsigned int i;
 
        if (ssysent == NULL) {
-               *interposed = ssysent = kmem_zalloc(sizeof (systrace_sysent_t) *
+               *interposed = ssysent = kmem_zalloc(sizeof(systrace_sysent_t) *
                    NSYSCALL, KM_SLEEP);
        }
 
        for (i = 0; i < NSYSCALL; i++) {
                    NSYSCALL, KM_SLEEP);
        }
 
        for (i = 0; i < NSYSCALL; i++) {
-               struct sysent *a = &actual[i];
+               const struct sysent *a = &actual[i];
                systrace_sysent_t *s = &ssysent[i];
 
                systrace_sysent_t *s = &ssysent[i];
 
-               if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
+               if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a)) {
                        continue;
                        continue;
+               }
 
 
-               if (a->sy_callc == dtrace_systrace_syscall)
+               if (a->sy_callc == dtrace_systrace_syscall) {
                        continue;
                        continue;
+               }
 
                s->stsy_underlying = a->sy_callc;
                s->stsy_return_type = a->sy_return_type;
        }
 
                s->stsy_underlying = a->sy_callc;
                s->stsy_return_type = a->sy_return_type;
        }
-       lck_mtx_init(&dtrace_systrace_lock, dtrace_lck_grp, dtrace_lck_attr);
 }
 
 
 }
 
 
@@ -422,18 +415,21 @@ systrace_provide(void *arg, const dtrace_probedesc_t *desc)
 #pragma unused(arg) /* __APPLE__ */
        unsigned int i;
 
 #pragma unused(arg) /* __APPLE__ */
        unsigned int i;
 
-       if (desc != NULL)
+       if (desc != NULL) {
                return;
                return;
+       }
 
        systrace_init(sysent, &systrace_sysent);
 
        for (i = 0; i < NSYSCALL; i++) {
 
        systrace_init(sysent, &systrace_sysent);
 
        for (i = 0; i < NSYSCALL; i++) {
-               if (systrace_sysent[i].stsy_underlying == NULL)
+               if (systrace_sysent[i].stsy_underlying == NULL) {
                        continue;
                        continue;
+               }
 
                if (dtrace_probe_lookup(systrace_id, NULL,
 
                if (dtrace_probe_lookup(systrace_id, NULL,
-                   syscallnames[i], "entry") != 0)
+                   syscallnames[i], "entry") != 0) {
                        continue;
                        continue;
+               }
 
                (void) dtrace_probe_create(systrace_id, NULL, syscallnames[i],
                    "entry", SYSTRACE_ARTIFICIAL_FRAMES,
 
                (void) dtrace_probe_create(systrace_id, NULL, syscallnames[i],
                    "entry", SYSTRACE_ARTIFICIAL_FRAMES,
@@ -473,7 +469,7 @@ static int
 systrace_enable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg) /* __APPLE__ */
 systrace_enable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg) /* __APPLE__ */
-    
+
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int enabled = (systrace_sysent[sysnum].stsy_entry != DTRACE_IDNONE ||
            systrace_sysent[sysnum].stsy_return != DTRACE_IDNONE);
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int enabled = (systrace_sysent[sysnum].stsy_entry != DTRACE_IDNONE ||
            systrace_sysent[sysnum].stsy_return != DTRACE_IDNONE);
@@ -486,16 +482,18 @@ systrace_enable(void *arg, dtrace_id_t id, void *parg)
 
        if (enabled) {
                ASSERT(sysent[sysnum].sy_callc == dtrace_systrace_syscall);
 
        if (enabled) {
                ASSERT(sysent[sysnum].sy_callc == dtrace_systrace_syscall);
-               return(0);
+               return 0;
        }
 
        lck_mtx_lock(&dtrace_systrace_lock);
        if (sysent[sysnum].sy_callc == systrace_sysent[sysnum].stsy_underlying) {
        }
 
        lck_mtx_lock(&dtrace_systrace_lock);
        if (sysent[sysnum].sy_callc == systrace_sysent[sysnum].stsy_underlying) {
-               vm_offset_t dss = (vm_offset_t)&dtrace_systrace_syscall;
+               /* It is not possible to write to sysent[] directly because it is const. */
+               vm_offset_t dss = ptrauth_nop_cast(vm_offset_t, &dtrace_systrace_syscall);
                ml_nofault_copy((vm_offset_t)&dss, (vm_offset_t)&sysent[sysnum].sy_callc, sizeof(vm_offset_t));
        }
        lck_mtx_unlock(&dtrace_systrace_lock);
                ml_nofault_copy((vm_offset_t)&dss, (vm_offset_t)&sysent[sysnum].sy_callc, sizeof(vm_offset_t));
        }
        lck_mtx_unlock(&dtrace_systrace_lock);
-       return (0);
+
+       return 0;
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/
@@ -503,17 +501,28 @@ static void
 systrace_disable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg,id) /* __APPLE__ */
 systrace_disable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg,id) /* __APPLE__ */
-    
+
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int disable = (systrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE ||
            systrace_sysent[sysnum].stsy_return == DTRACE_IDNONE);
 
        if (disable) {
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int disable = (systrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE ||
            systrace_sysent[sysnum].stsy_return == DTRACE_IDNONE);
 
        if (disable) {
+               /*
+                * Usage of volatile protects the if statement below from being optimized away.
+                *
+                * Compilers are clever and know that const array values can't change in time
+                * and the if below is always false. That is because it can't see that DTrace
+                * injects dtrace_systrace_syscall dynamically and violates constness of the
+                * array.
+                */
+               volatile const struct sysent *syscallent = &sysent[sysnum];
+
                lck_mtx_lock(&dtrace_systrace_lock);
                lck_mtx_lock(&dtrace_systrace_lock);
-               if (sysent[sysnum].sy_callc == dtrace_systrace_syscall)
-                       ml_nofault_copy((vm_offset_t)&systrace_sysent[sysnum].stsy_underlying, (vm_offset_t)&sysent[sysnum].sy_callc, sizeof(systrace_sysent[sysnum].stsy_underlying));
+               if (syscallent->sy_callc == dtrace_systrace_syscall) {
+                       ml_nofault_copy((vm_offset_t)&systrace_sysent[sysnum].stsy_underlying,
+                           (vm_offset_t)&syscallent->sy_callc, sizeof(vm_offset_t));
+               }
                lck_mtx_unlock(&dtrace_systrace_lock);
                lck_mtx_unlock(&dtrace_systrace_lock);
-
        }
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
        }
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
@@ -524,39 +533,30 @@ systrace_disable(void *arg, dtrace_id_t id, void *parg)
 }
 
 static dtrace_pattr_t systrace_attr = {
 }
 
 static dtrace_pattr_t systrace_attr = {
-{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
-{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
+       { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
+       { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
 };
 
 static dtrace_pops_t systrace_pops = {
 };
 
 static dtrace_pops_t systrace_pops = {
-       systrace_provide,
-       NULL,
-       systrace_enable,
-       systrace_disable,
-       NULL,
-       NULL,
-       systrace_getargdesc,
-       systrace_getargval,
-       NULL,
-       systrace_destroy
+       .dtps_provide =         systrace_provide,
+       .dtps_provide_module =  NULL,
+       .dtps_enable =          systrace_enable,
+       .dtps_disable =         systrace_disable,
+       .dtps_suspend =         NULL,
+       .dtps_resume =          NULL,
+       .dtps_getargdesc =      systrace_getargdesc,
+       .dtps_getargval =       systrace_getargval,
+       .dtps_usermode =        NULL,
+       .dtps_destroy =         systrace_destroy
 };
 
 static int
 };
 
 static int
-systrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
+systrace_attach(dev_info_t *devi)
 {
 {
-       switch (cmd) {
-       case DDI_ATTACH:
-               break;
-       case DDI_RESUME:
-               return (DDI_SUCCESS);
-       default:
-               return (DDI_FAILURE);
-       }
-
-       systrace_probe = (void(*))&dtrace_probe;
+       systrace_probe = (void*)&dtrace_probe;
        membar_enter();
 
        if (ddi_create_minor_node(devi, "systrace", S_IFCHR, 0,
        membar_enter();
 
        if (ddi_create_minor_node(devi, "systrace", S_IFCHR, 0,
@@ -565,13 +565,10 @@ systrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
            &systrace_pops, NULL, &systrace_id) != 0) {
                systrace_probe = systrace_stub;
                ddi_remove_minor_node(devi, NULL);
            &systrace_pops, NULL, &systrace_id) != 0) {
                systrace_probe = systrace_stub;
                ddi_remove_minor_node(devi, NULL);
-               return (DDI_FAILURE);
+               return DDI_FAILURE;
        }
 
        }
 
-       ddi_report_dev(devi);
-       systrace_devi = devi;
-
-       return (DDI_SUCCESS);
+       return DDI_SUCCESS;
 }
 
 
 }
 
 
@@ -586,17 +583,18 @@ systrace_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
        case DDI_DETACH:
                break;
        case DDI_SUSPEND:
        case DDI_DETACH:
                break;
        case DDI_SUSPEND:
-               return (DDI_SUCCESS);
+               return DDI_SUCCESS;
        default:
        default:
-               return (DDI_FAILURE);
+               return DDI_FAILURE;
        }
 
        }
 
-       if (dtrace_unregister(systrace_id) != 0)
-               return (DDI_FAILURE);
+       if (dtrace_unregister(systrace_id) != 0) {
+               return DDI_FAILURE;
+       }
 
        ddi_remove_minor_node(devi, NULL);
        systrace_probe = systrace_stub;
 
        ddi_remove_minor_node(devi, NULL);
        systrace_probe = systrace_stub;
-       return (DDI_SUCCESS);
+       return DDI_SUCCESS;
 }
 #endif /* __APPLE__ */
 
 }
 #endif /* __APPLE__ */
 
@@ -607,33 +605,33 @@ typedef kern_return_t (*mach_call_t)(void *);
 typedef void    mach_munge_t(void *);
 
 typedef struct {
 typedef void    mach_munge_t(void *);
 
 typedef struct {
-       int                     mach_trap_arg_count;
-       kern_return_t           (*mach_trap_function)(void *);
+       int                     mach_trap_arg_count;
+       kern_return_t           (*mach_trap_function)(void *);
 #if defined(__arm64__) || defined(__x86_64__)
 #if defined(__arm64__) || defined(__x86_64__)
-       mach_munge_t            *mach_trap_arg_munge32; /* system call arguments for 32-bit */
+       mach_munge_t            *mach_trap_arg_munge32; /* system call arguments for 32-bit */
 #endif
 #endif
-       int                     mach_trap_u32_words;
-#if    MACH_ASSERT
-       const char*             mach_trap_name;
+       int                     mach_trap_u32_words;
+#if     MACH_ASSERT
+       const char*             mach_trap_name;
 #endif /* MACH_ASSERT */
 } mach_trap_t;
 
 #endif /* MACH_ASSERT */
 } mach_trap_t;
 
-extern const mach_trap_t              mach_trap_table[]; /* syscall_sw.h now declares this as const */
-extern int                      mach_trap_count;
+extern const mach_trap_t mach_trap_table[]; /* syscall_sw.h now declares this as const */
+extern const int         mach_trap_count;
 
 
-extern const char *mach_syscall_name_table[];
+extern const char *const mach_syscall_name_table[];
 
 /* XXX From osfmk/i386/bsd_i386.c */
 struct mach_call_args {
 
 /* XXX From osfmk/i386/bsd_i386.c */
 struct mach_call_args {
-        syscall_arg_t arg1;
-        syscall_arg_t arg2;
-        syscall_arg_t arg3;
-        syscall_arg_t arg4;
-        syscall_arg_t arg5;
-        syscall_arg_t arg6;
-        syscall_arg_t arg7;
-        syscall_arg_t arg8;
-        syscall_arg_t arg9;
+       syscall_arg_t arg1;
+       syscall_arg_t arg2;
+       syscall_arg_t arg3;
+       syscall_arg_t arg4;
+       syscall_arg_t arg5;
+       syscall_arg_t arg6;
+       syscall_arg_t arg7;
+       syscall_arg_t arg8;
+       syscall_arg_t arg9;
 };
 
 #undef NSYSCALL
 };
 
 #undef NSYSCALL
@@ -644,10 +642,10 @@ struct mach_call_args {
 #endif
 
 typedef struct machtrace_sysent {
 #endif
 
 typedef struct machtrace_sysent {
-       dtrace_id_t     stsy_entry;
-       dtrace_id_t     stsy_return;
-       kern_return_t   (*stsy_underlying)(void *);
-       int32_t         stsy_return_type;
+       dtrace_id_t     stsy_entry;
+       dtrace_id_t     stsy_return;
+       kern_return_t   (*stsy_underlying)(void *);
+       int32_t         stsy_return_type;
 } machtrace_sysent_t;
 
 static machtrace_sysent_t *machtrace_sysent = NULL;
 } machtrace_sysent_t;
 
 static machtrace_sysent_t *machtrace_sysent = NULL;
@@ -655,15 +653,14 @@ static machtrace_sysent_t *machtrace_sysent = NULL;
 void (*machtrace_probe)(dtrace_id_t, uint64_t, uint64_t,
     uint64_t, uint64_t, uint64_t);
 
 void (*machtrace_probe)(dtrace_id_t, uint64_t, uint64_t,
     uint64_t, uint64_t, uint64_t);
 
-static uint64_t machtrace_getarg(void *, dtrace_id_t, void *, int, int);       
+static uint64_t machtrace_getarg(void *, dtrace_id_t, void *, int, int);
 
 
-static dev_info_t *machtrace_devi;
 static dtrace_provider_id_t machtrace_id;
 
 static kern_return_t
 dtrace_machtrace_syscall(struct mach_call_args *args)
 {
 static dtrace_provider_id_t machtrace_id;
 
 static kern_return_t
 dtrace_machtrace_syscall(struct mach_call_args *args)
 {
-       int code;       /* The mach call number */
+       int code;       /* The mach call number */
 
        machtrace_sysent_t *sy;
        dtrace_id_t id;
 
        machtrace_sysent_t *sy;
        dtrace_id_t id;
@@ -703,9 +700,9 @@ dtrace_machtrace_syscall(struct mach_call_args *args)
                        code = (int)saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM];
                }
 
                        code = (int)saved_state64(arm_regs)->x[ARM64_SYSCALL_CODE_REG_NUM];
                }
 
-                /* From bsd/arm64.c:mach_syscall */
+               /* From bsd/arm64.c:mach_syscall */
                ASSERT(code < 0);    /* Otherwise it would be a Unix syscall */
                ASSERT(code < 0);    /* Otherwise it would be a Unix syscall */
-               code = -code;           
+               code = -code;
        }
 #else
 #error Unknown Architecture
        }
 #else
 #error Unknown Architecture
@@ -714,15 +711,17 @@ dtrace_machtrace_syscall(struct mach_call_args *args)
        sy = &machtrace_sysent[code];
 
        if ((id = sy->stsy_entry) != DTRACE_IDNONE) {
        sy = &machtrace_sysent[code];
 
        if ((id = sy->stsy_entry) != DTRACE_IDNONE) {
-               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());    
+               uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
 
 
-               if (uthread)
+               if (uthread) {
                        uthread->t_dtrace_syscall_args = (void *)ip;
                        uthread->t_dtrace_syscall_args = (void *)ip;
-               
-               (*machtrace_probe)(id, *ip, *(ip+1), *(ip+2), *(ip+3), *(ip+4));
-               
-               if (uthread)
-                       uthread->t_dtrace_syscall_args = (void *)0;             
+               }
+
+               (*machtrace_probe)(id, *ip, *(ip + 1), *(ip + 2), *(ip + 3), *(ip + 4));
+
+               if (uthread) {
+                       uthread->t_dtrace_syscall_args = (void *)0;
+               }
        }
 
 #if 0 /* XXX */
        }
 
 #if 0 /* XXX */
@@ -743,10 +742,11 @@ dtrace_machtrace_syscall(struct mach_call_args *args)
        mach_call = (mach_call_t)(*sy->stsy_underlying);
        rval = mach_call(args);
 
        mach_call = (mach_call_t)(*sy->stsy_underlying);
        rval = mach_call(args);
 
-       if ((id = sy->stsy_return) != DTRACE_IDNONE)
+       if ((id = sy->stsy_return) != DTRACE_IDNONE) {
                (*machtrace_probe)(id, (uint64_t)rval, 0, 0, 0, 0);
                (*machtrace_probe)(id, (uint64_t)rval, 0, 0, 0, 0);
+       }
 
 
-       return (rval);
+       return rval;
 }
 
 static void
 }
 
 static void
@@ -756,19 +756,21 @@ machtrace_init(const mach_trap_t *actual, machtrace_sysent_t **interposed)
        int i;
 
        if (msysent == NULL) {
        int i;
 
        if (msysent == NULL) {
-               *interposed = msysent = kmem_zalloc(sizeof (machtrace_sysent_t) *
-                               NSYSCALL, KM_SLEEP);
+               *interposed = msysent = kmem_zalloc(sizeof(machtrace_sysent_t) *
+                   NSYSCALL, KM_SLEEP);
        }
 
        for (i = 0; i < NSYSCALL; i++) {
                const mach_trap_t *a = &actual[i];
                machtrace_sysent_t *s = &msysent[i];
 
        }
 
        for (i = 0; i < NSYSCALL; i++) {
                const mach_trap_t *a = &actual[i];
                machtrace_sysent_t *s = &msysent[i];
 
-               if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
+               if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a)) {
                        continue;
                        continue;
+               }
 
 
-               if (a->mach_trap_function == (mach_call_t)(dtrace_machtrace_syscall))
+               if (a->mach_trap_function == (mach_call_t)(dtrace_machtrace_syscall)) {
                        continue;
                        continue;
+               }
 
                s->stsy_underlying = a->mach_trap_function;
        }
 
                s->stsy_underlying = a->mach_trap_function;
        }
@@ -779,29 +781,31 @@ static void
 machtrace_provide(void *arg, const dtrace_probedesc_t *desc)
 {
 #pragma unused(arg) /* __APPLE__ */
 machtrace_provide(void *arg, const dtrace_probedesc_t *desc)
 {
 #pragma unused(arg) /* __APPLE__ */
-    
+
        int i;
 
        int i;
 
-       if (desc != NULL)
+       if (desc != NULL) {
                return;
                return;
+       }
 
        machtrace_init(mach_trap_table, &machtrace_sysent);
 
        for (i = 0; i < NSYSCALL; i++) {
 
        machtrace_init(mach_trap_table, &machtrace_sysent);
 
        for (i = 0; i < NSYSCALL; i++) {
-               
-               if (machtrace_sysent[i].stsy_underlying == NULL)
+               if (machtrace_sysent[i].stsy_underlying == NULL) {
                        continue;
                        continue;
+               }
 
                if (dtrace_probe_lookup(machtrace_id, NULL,
 
                if (dtrace_probe_lookup(machtrace_id, NULL,
-                                       mach_syscall_name_table[i], "entry") != 0)
+                   mach_syscall_name_table[i], "entry") != 0) {
                        continue;
                        continue;
+               }
 
                (void) dtrace_probe_create(machtrace_id, NULL, mach_syscall_name_table[i],
 
                (void) dtrace_probe_create(machtrace_id, NULL, mach_syscall_name_table[i],
-                                          "entry", MACHTRACE_ARTIFICIAL_FRAMES,
-                                          (void *)((uintptr_t)SYSTRACE_ENTRY(i)));
+                   "entry", MACHTRACE_ARTIFICIAL_FRAMES,
+                   (void *)((uintptr_t)SYSTRACE_ENTRY(i)));
                (void) dtrace_probe_create(machtrace_id, NULL, mach_syscall_name_table[i],
                (void) dtrace_probe_create(machtrace_id, NULL, mach_syscall_name_table[i],
-                                          "return", MACHTRACE_ARTIFICIAL_FRAMES,
-                                          (void *)((uintptr_t)SYSTRACE_RETURN(i)));
+                   "return", MACHTRACE_ARTIFICIAL_FRAMES,
+                   (void *)((uintptr_t)SYSTRACE_RETURN(i)));
 
                machtrace_sysent[i].stsy_entry = DTRACE_IDNONE;
                machtrace_sysent[i].stsy_return = DTRACE_IDNONE;
 
                machtrace_sysent[i].stsy_entry = DTRACE_IDNONE;
                machtrace_sysent[i].stsy_return = DTRACE_IDNONE;
@@ -814,7 +818,7 @@ machtrace_destroy(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg,id) /* __APPLE__ */
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
 {
 #pragma unused(arg,id) /* __APPLE__ */
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
-       
+
 #pragma unused(sysnum) /* __APPLE__ */
 
        /*
 #pragma unused(sysnum) /* __APPLE__ */
 
        /*
@@ -833,10 +837,10 @@ static int
 machtrace_enable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg) /* __APPLE__ */
 machtrace_enable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg) /* __APPLE__ */
-    
+
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int enabled = (machtrace_sysent[sysnum].stsy_entry != DTRACE_IDNONE ||
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int enabled = (machtrace_sysent[sysnum].stsy_entry != DTRACE_IDNONE ||
-                       machtrace_sysent[sysnum].stsy_return != DTRACE_IDNONE);
+           machtrace_sysent[sysnum].stsy_return != DTRACE_IDNONE);
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
                machtrace_sysent[sysnum].stsy_entry = id;
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
                machtrace_sysent[sysnum].stsy_entry = id;
@@ -845,20 +849,21 @@ machtrace_enable(void *arg, dtrace_id_t id, void *parg)
        }
 
        if (enabled) {
        }
 
        if (enabled) {
-           ASSERT(mach_trap_table[sysnum].mach_trap_function == (void *)dtrace_machtrace_syscall);
-           return(0);
+               ASSERT(mach_trap_table[sysnum].mach_trap_function == (void *)dtrace_machtrace_syscall);
+               return 0;
        }
 
        lck_mtx_lock(&dtrace_systrace_lock);
 
        if (mach_trap_table[sysnum].mach_trap_function == machtrace_sysent[sysnum].stsy_underlying) {
        }
 
        lck_mtx_lock(&dtrace_systrace_lock);
 
        if (mach_trap_table[sysnum].mach_trap_function == machtrace_sysent[sysnum].stsy_underlying) {
-               vm_offset_t dss = (vm_offset_t)&dtrace_machtrace_syscall;
+               /* It is not possible to write to mach_trap_table[] directly because it is const. */
+               vm_offset_t dss = ptrauth_nop_cast(vm_offset_t, &dtrace_machtrace_syscall);
                ml_nofault_copy((vm_offset_t)&dss, (vm_offset_t)&mach_trap_table[sysnum].mach_trap_function, sizeof(vm_offset_t));
        }
 
        lck_mtx_unlock(&dtrace_systrace_lock);
 
                ml_nofault_copy((vm_offset_t)&dss, (vm_offset_t)&mach_trap_table[sysnum].mach_trap_function, sizeof(vm_offset_t));
        }
 
        lck_mtx_unlock(&dtrace_systrace_lock);
 
-       return(0);
+       return 0;
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/
@@ -866,17 +871,26 @@ static void
 machtrace_disable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg,id) /* __APPLE__ */
 machtrace_disable(void *arg, dtrace_id_t id, void *parg)
 {
 #pragma unused(arg,id) /* __APPLE__ */
-      
+
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int disable = (machtrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE ||
        int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg);
        int disable = (machtrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE ||
-                       machtrace_sysent[sysnum].stsy_return == DTRACE_IDNONE);
+           machtrace_sysent[sysnum].stsy_return == DTRACE_IDNONE);
 
        if (disable) {
 
        if (disable) {
+               /*
+                * Usage of volatile protects the if statement below from being optimized away.
+                *
+                * Compilers are clever and know that const array values can't change in time
+                * and the if below is always false. That is because it can't see that DTrace
+                * injects dtrace_machtrace_syscall dynamically and violates constness of the
+                * array.
+                */
+               volatile const mach_trap_t *machtrap = &mach_trap_table[sysnum];
 
                lck_mtx_lock(&dtrace_systrace_lock);
 
                lck_mtx_lock(&dtrace_systrace_lock);
-
-               if (mach_trap_table[sysnum].mach_trap_function == (mach_call_t)dtrace_machtrace_syscall) {
-                       ml_nofault_copy((vm_offset_t)&machtrace_sysent[sysnum].stsy_underlying, (vm_offset_t)&mach_trap_table[sysnum].mach_trap_function, sizeof(vm_offset_t));
+               if (machtrap->mach_trap_function == (mach_call_t)dtrace_machtrace_syscall) {
+                       ml_nofault_copy((vm_offset_t)&machtrace_sysent[sysnum].stsy_underlying,
+                           (vm_offset_t)&machtrap->mach_trap_function, sizeof(vm_offset_t));
                }
                lck_mtx_unlock(&dtrace_systrace_lock);
        }
                }
                lck_mtx_unlock(&dtrace_systrace_lock);
        }
@@ -889,59 +903,48 @@ machtrace_disable(void *arg, dtrace_id_t id, void *parg)
 }
 
 static dtrace_pattr_t machtrace_attr = {
 }
 
 static dtrace_pattr_t machtrace_attr = {
-{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
-{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
-{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
+       { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
+       { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
+       { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA },
 };
 
 static dtrace_pops_t machtrace_pops = {
 };
 
 static dtrace_pops_t machtrace_pops = {
-       machtrace_provide,
-       NULL,
-       machtrace_enable,
-       machtrace_disable,
-       NULL,
-       NULL,
-       NULL,
-       machtrace_getarg,
-       NULL,
-       machtrace_destroy
+       .dtps_provide =         machtrace_provide,
+       .dtps_provide_module =  NULL,
+       .dtps_enable =          machtrace_enable,
+       .dtps_disable =         machtrace_disable,
+       .dtps_suspend =         NULL,
+       .dtps_resume =          NULL,
+       .dtps_getargdesc =      NULL,
+       .dtps_getargval =       machtrace_getarg,
+       .dtps_usermode =        NULL,
+       .dtps_destroy =         machtrace_destroy
 };
 
 static int
 };
 
 static int
-machtrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
+machtrace_attach(dev_info_t *devi)
 {
 {
-       switch (cmd) {
-               case DDI_ATTACH:
-                       break;
-               case DDI_RESUME:
-                       return (DDI_SUCCESS);
-               default:
-                       return (DDI_FAILURE);
-       }
-
        machtrace_probe = dtrace_probe;
        membar_enter();
        machtrace_probe = dtrace_probe;
        membar_enter();
-       
+
        if (ddi_create_minor_node(devi, "machtrace", S_IFCHR, 0,
        if (ddi_create_minor_node(devi, "machtrace", S_IFCHR, 0,
-                               DDI_PSEUDO, 0) == DDI_FAILURE ||
-                       dtrace_register("mach_trap", &machtrace_attr, DTRACE_PRIV_USER, NULL,
-                               &machtrace_pops, NULL, &machtrace_id) != 0) {
-                machtrace_probe = (void (*))&systrace_stub;
+           DDI_PSEUDO, 0) == DDI_FAILURE ||
+           dtrace_register("mach_trap", &machtrace_attr, DTRACE_PRIV_USER, NULL,
+           &machtrace_pops, NULL, &machtrace_id) != 0) {
+               machtrace_probe = (void*)&systrace_stub;
                ddi_remove_minor_node(devi, NULL);
                ddi_remove_minor_node(devi, NULL);
-               return (DDI_FAILURE);
+               return DDI_FAILURE;
        }
 
        }
 
-       ddi_report_dev(devi);
-       machtrace_devi = devi;
-
-       return (DDI_SUCCESS);
+       return DDI_SUCCESS;
 }
 
 d_open_t _systrace_open;
 
 }
 
 d_open_t _systrace_open;
 
-int _systrace_open(dev_t dev, int flags, int devtype, struct proc *p)
+int
+_systrace_open(dev_t dev, int flags, int devtype, struct proc *p)
 {
 #pragma unused(dev,flags,devtype,p)
        return 0;
 {
 #pragma unused(dev,flags,devtype,p)
        return 0;
@@ -949,53 +952,40 @@ int _systrace_open(dev_t dev, int flags, int devtype, struct proc *p)
 
 #define SYSTRACE_MAJOR  -24 /* let the kernel pick the device number */
 
 
 #define SYSTRACE_MAJOR  -24 /* let the kernel pick the device number */
 
-/*
- * A struct describing which functions will get invoked for certain
- * actions.
- */
 static struct cdevsw systrace_cdevsw =
 {
 static struct cdevsw systrace_cdevsw =
 {
-       _systrace_open,         /* open */
-       eno_opcl,               /* close */
-       eno_rdwrt,                      /* read */
-       eno_rdwrt,                      /* write */
-       eno_ioctl,              /* ioctl */
-       (stop_fcn_t *)nulldev, /* stop */
-       (reset_fcn_t *)nulldev, /* reset */
-       NULL,                           /* tty's */
-       eno_select,                     /* select */
-       eno_mmap,                       /* mmap */
-       eno_strat,                      /* strategy */
-       eno_getc,                       /* getc */
-       eno_putc,                       /* putc */
-       0                                       /* type */
+       .d_open = _systrace_open,
+       .d_close = eno_opcl,
+       .d_read = eno_rdwrt,
+       .d_write = eno_rdwrt,
+       .d_ioctl = eno_ioctl,
+       .d_stop = (stop_fcn_t *)nulldev,
+       .d_reset = (reset_fcn_t *)nulldev,
+       .d_select = eno_select,
+       .d_mmap = eno_mmap,
+       .d_strategy = eno_strat,
+       .d_reserved_1 = eno_getc,
+       .d_reserved_2 = eno_putc,
 };
 
 };
 
-static int gSysTraceInited = 0;
-
 void systrace_init( void );
 
 void systrace_init( void );
 
-void systrace_init( void )
+void
+systrace_init( void )
 {
 {
-       if (0 == gSysTraceInited) {
-               if (dtrace_sdt_probes_restricted()) {
-                       return;
-               }
-
-               int majdevno = cdevsw_add(SYSTRACE_MAJOR, &systrace_cdevsw);
+       if (dtrace_sdt_probes_restricted()) {
+               return;
+       }
 
 
-               if (majdevno < 0) {
-                       printf("systrace_init: failed to allocate a major number!\n");
-                       gSysTraceInited = 0;
-                       return;
-               }
+       int majdevno = cdevsw_add(SYSTRACE_MAJOR, &systrace_cdevsw);
 
 
-               systrace_attach( (dev_info_t    *)(uintptr_t)majdevno, DDI_ATTACH );
-               machtrace_attach( (dev_info_t   *)(uintptr_t)majdevno, DDI_ATTACH );
+       if (majdevno < 0) {
+               printf("systrace_init: failed to allocate a major number!\n");
+               return;
+       }
 
 
-               gSysTraceInited = 1;
-       } else
-               panic("systrace_init: called twice!\n");
+       systrace_attach((dev_info_t*)(uintptr_t)majdevno);
+       machtrace_attach((dev_info_t*)(uintptr_t)majdevno);
 }
 #undef SYSTRACE_MAJOR
 
 }
 #undef SYSTRACE_MAJOR
 
@@ -1006,24 +996,27 @@ systrace_getargval(void *arg, dtrace_id_t id, void *parg, int argno, int aframes
        uint64_t val = 0;
        uint64_t *uargs = NULL;
 
        uint64_t val = 0;
        uint64_t *uargs = NULL;
 
-       uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());    
+       uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
 
 
-       if (uthread)
+       if (uthread) {
                uargs = uthread->t_dtrace_syscall_args;
                uargs = uthread->t_dtrace_syscall_args;
-       if (!uargs)
-               return(0);
-       if (argno < 0 || argno > SYSTRACE_NARGS)
-               return(0);
+       }
+       if (!uargs) {
+               return 0;
+       }
+       if (argno < 0 || argno >= SYSTRACE_NARGS) {
+               return 0;
+       }
 
        DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
        val = uargs[argno];
        DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT);
 
        DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
        val = uargs[argno];
        DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT);
-       return (val);
+       return val;
 }
 
 static void
 systrace_getargdesc(void *arg, dtrace_id_t id, void *parg,
 }
 
 static void
 systrace_getargdesc(void *arg, dtrace_id_t id, void *parg,
-       dtrace_argdesc_t *desc)
+    dtrace_argdesc_t *desc)
 {
 #pragma unused(arg, id)
        int sysnum = SYSTRACE_SYSNUM(parg);
 {
 #pragma unused(arg, id)
        int sysnum = SYSTRACE_SYSNUM(parg);
@@ -1039,15 +1032,15 @@ systrace_getargdesc(void *arg, dtrace_id_t id, void *parg,
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
                systrace_entry_setargdesc(sysnum, desc->dtargd_ndx,
 
        if (SYSTRACE_ISENTRY((uintptr_t)parg)) {
                systrace_entry_setargdesc(sysnum, desc->dtargd_ndx,
-                       desc->dtargd_native, sizeof(desc->dtargd_native));
-       }
-       else {
+                   desc->dtargd_native, sizeof(desc->dtargd_native));
+       } else {
                systrace_return_setargdesc(sysnum, desc->dtargd_ndx,
                systrace_return_setargdesc(sysnum, desc->dtargd_ndx,
-                       desc->dtargd_native, sizeof(desc->dtargd_native));
+                   desc->dtargd_native, sizeof(desc->dtargd_native));
        }
 
        }
 
-       if (desc->dtargd_native[0] == '\0')
+       if (desc->dtargd_native[0] == '\0') {
                desc->dtargd_ndx = DTRACE_ARGNONE;
                desc->dtargd_ndx = DTRACE_ARGNONE;
+       }
 }
 
 static uint64_t
 }
 
 static uint64_t
@@ -1058,17 +1051,18 @@ machtrace_getarg(void *arg, dtrace_id_t id, void *parg, int argno, int aframes)
        syscall_arg_t *stack = (syscall_arg_t *)NULL;
 
        uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
        syscall_arg_t *stack = (syscall_arg_t *)NULL;
 
        uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread());
-       
-       if (uthread)
+
+       if (uthread) {
                stack = (syscall_arg_t *)uthread->t_dtrace_syscall_args;
                stack = (syscall_arg_t *)uthread->t_dtrace_syscall_args;
-       
-       if (!stack)
-               return(0);
+       }
+
+       if (!stack) {
+               return 0;
+       }
 
        DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
        /* dtrace_probe arguments arg0 .. arg4 are 64bits wide */
 
        DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
        /* dtrace_probe arguments arg0 .. arg4 are 64bits wide */
-       val = (uint64_t)*(stack+argno); 
+       val = (uint64_t)*(stack + argno);
        DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT);
        DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT);
-       return (val);
+       return val;
 }
 }
-
mirror of XNU