sys/cddl/dev/dtrace/dtrace_load.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  *
  21  * $FreeBSD$
  22  *
  23  */
  24
  25 static void
  26 dtrace_ap_start(void *dummy)
  27 {
  28         int i;
  29
  30         mutex_enter(&cpu_lock);
  31
  32         /* Setup the rest of the CPUs. */
  33         CPU_FOREACH(i) {
  34                 if (i == 0)
  35                         continue;
  36
  37                 (void) dtrace_cpu_setup(CPU_CONFIG, i);
  38         }
  39
  40         mutex_exit(&cpu_lock);
  41 }
  42
  43 SYSINIT(dtrace_ap_start, SI_SUB_SMP, SI_ORDER_ANY, dtrace_ap_start, NULL);
  44
  45 static void
  46 dtrace_load(void *dummy)
  47 {
  48         dtrace_provider_id_t id;
  49
  50         /* Hook into the trap handler. */
  51         dtrace_trap_func = dtrace_trap;
  52
  53         /* Hang our hook for thread switches. */
  54         dtrace_vtime_switch_func = dtrace_vtime_switch;
  55
  56         /* Hang our hook for exceptions. */
  57         dtrace_invop_init();
  58
  59         /*
  60          * XXX This is a short term hack to avoid having to comment
  61          * out lots and lots of lock/unlock calls.
  62          */
  63         mutex_init(&mod_lock,"XXX mod_lock hack", MUTEX_DEFAULT, NULL);
  64
  65         /*
  66          * Initialise the mutexes without 'witness' because the dtrace
  67          * code is mostly written to wait for memory. To have the
  68          * witness code change a malloc() from M_WAITOK to M_NOWAIT
  69          * because a lock is held would surely create a panic in a
  70          * low memory situation. And that low memory situation might be
  71          * the very problem we are trying to trace.
  72          */
  73         mutex_init(&dtrace_lock,"dtrace probe state", MUTEX_DEFAULT, NULL);
  74         mutex_init(&dtrace_provider_lock,"dtrace provider state", MUTEX_DEFAULT, NULL);
  75         mutex_init(&dtrace_meta_lock,"dtrace meta-provider state", MUTEX_DEFAULT, NULL);
  76 #ifdef DEBUG
  77         mutex_init(&dtrace_errlock,"dtrace error lock", MUTEX_DEFAULT, NULL);
  78 #endif
  79
  80         mutex_enter(&dtrace_provider_lock);
  81         mutex_enter(&dtrace_lock);
  82         mutex_enter(&cpu_lock);
  83
  84         ASSERT(MUTEX_HELD(&cpu_lock));
  85
  86         dtrace_arena = new_unrhdr(1, INT_MAX, &dtrace_unr_mtx);
  87
  88         dtrace_state_cache = kmem_cache_create("dtrace_state_cache",
  89             sizeof (dtrace_dstate_percpu_t) * NCPU, DTRACE_STATE_ALIGN,
  90             NULL, NULL, NULL, NULL, NULL, 0);
  91
  92         ASSERT(MUTEX_HELD(&cpu_lock));
  93         dtrace_bymod = dtrace_hash_create(offsetof(dtrace_probe_t, dtpr_mod),
  94             offsetof(dtrace_probe_t, dtpr_nextmod),
  95             offsetof(dtrace_probe_t, dtpr_prevmod));
  96
  97         dtrace_byfunc = dtrace_hash_create(offsetof(dtrace_probe_t, dtpr_func),
  98             offsetof(dtrace_probe_t, dtpr_nextfunc),
  99             offsetof(dtrace_probe_t, dtpr_prevfunc));
 100
 101         dtrace_byname = dtrace_hash_create(offsetof(dtrace_probe_t, dtpr_name),
 102             offsetof(dtrace_probe_t, dtpr_nextname),
 103             offsetof(dtrace_probe_t, dtpr_prevname));
 104
 105         if (dtrace_retain_max < 1) {
 106                 cmn_err(CE_WARN, "illegal value (%lu) for dtrace_retain_max; "
 107                     "setting to 1", dtrace_retain_max);
 108                 dtrace_retain_max = 1;
 109         }
 110
 111         /*
 112          * Now discover our toxic ranges.
 113          */
 114         dtrace_toxic_ranges(dtrace_toxrange_add);
 115
 116         /*
 117          * Before we register ourselves as a provider to our own framework,
 118          * we would like to assert that dtrace_provider is NULL -- but that's
 119          * not true if we were loaded as a dependency of a DTrace provider.
 120          * Once we've registered, we can assert that dtrace_provider is our
 121          * pseudo provider.
 122          */
 123         (void) dtrace_register("dtrace", &dtrace_provider_attr,
 124             DTRACE_PRIV_NONE, 0, &dtrace_provider_ops, NULL, &id);
 125
 126         ASSERT(dtrace_provider != NULL);
 127         ASSERT((dtrace_provider_id_t)dtrace_provider == id);
 128
 129         dtrace_probeid_begin = dtrace_probe_create((dtrace_provider_id_t)
 130             dtrace_provider, NULL, NULL, "BEGIN", 0, NULL);
 131         dtrace_probeid_end = dtrace_probe_create((dtrace_provider_id_t)
 132             dtrace_provider, NULL, NULL, "END", 0, NULL);
 133         dtrace_probeid_error = dtrace_probe_create((dtrace_provider_id_t)
 134             dtrace_provider, NULL, NULL, "ERROR", 1, NULL);
 135
 136         mutex_exit(&cpu_lock);
 137
 138         /*
 139          * If DTrace helper tracing is enabled, we need to allocate the
 140          * trace buffer and initialize the values.
 141          */
 142         if (dtrace_helptrace_enabled) {
 143                 ASSERT(dtrace_helptrace_buffer == NULL);
 144                 dtrace_helptrace_buffer =
 145                     kmem_zalloc(dtrace_helptrace_bufsize, KM_SLEEP);
 146                 dtrace_helptrace_next = 0;
 147         }
 148
 149         mutex_exit(&dtrace_lock);
 150         mutex_exit(&dtrace_provider_lock);
 151
 152         mutex_enter(&cpu_lock);
 153
 154         /* Setup the boot CPU */
 155         (void) dtrace_cpu_setup(CPU_CONFIG, 0);
 156
 157         mutex_exit(&cpu_lock);
 158
 159 #if __FreeBSD_version < 800039
 160         /* Enable device cloning. */
 161         clone_setup(&dtrace_clones);
 162
 163         /* Setup device cloning events. */
 164         eh_tag = EVENTHANDLER_REGISTER(dev_clone, dtrace_clone, 0, 1000);
 165 #else
 166         dtrace_dev = make_dev(&dtrace_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
 167             "dtrace/dtrace");
 168         helper_dev = make_dev(&helper_cdevsw, 0, UID_ROOT, GID_WHEEL, 0660,
 169             "dtrace/helper");
 170 #endif
 171
 172         return;
 173 }