usr/src/uts/common/tnf/tnf_res.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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * "Resident" part of TNF -- this has to be around even when the
  31  * driver is not loaded.
  32  */
  33
  34 #ifndef NPROBE
  35 #include <sys/types.h>
  36 #include <sys/systm.h>
  37 #include <sys/thread.h>
  38 #include <sys/klwp.h>
  39 #include <sys/proc.h>
  40 #include <sys/kmem.h>
  41 #include <sys/msacct.h>
  42 #include <sys/tnf_com.h>
  43 #include <sys/tnf_writer.h>
  44 #include <sys/tnf_probe.h>
  45 #include <sys/tnf.h>
  46 #include <sys/debug.h>
  47 #include <sys/modctl.h>
  48 #include <sys/kobj.h>
  49
  50 #include "tnf_buf.h"
  51 #include "tnf_types.h"
  52 #include "tnf_trace.h"
  53
  54 /*
  55  * Defines
  56  */
  57
  58 #define TNF_PC_COUNT    8
  59
  60 /*
  61  * Declarations
  62  */
  63
  64 /*
  65  * TNF kernel probe management externs
  66  */
  67 extern tnf_probe_control_t      *__tnf_probe_list_head;
  68 extern tnf_tag_data_t           *__tnf_tag_list_head;
  69 extern int                      tnf_changed_probe_list;
  70
  71 /*
  72  * This makes the state of the TNFW_B_STOPPED bit externally visible
  73  * in the kernel.
  74  */
  75 volatile int tnf_tracing_active = 0;
  76
  77 /*
  78  * The trace buffer pointer
  79  */
  80 caddr_t tnf_buf;
  81
  82 /*
  83  * Stub definitions for tag data pointers
  84  */
  85
  86 /* tnf_writer module */
  87 tnf_tag_data_t *tnf_inline_tag_data = NULL;
  88 tnf_tag_data_t *tnf_tagged_tag_data = NULL;
  89 tnf_tag_data_t *tnf_scalar_tag_data = NULL;
  90 tnf_tag_data_t *tnf_char_tag_data = NULL;
  91 tnf_tag_data_t *tnf_int8_tag_data = NULL;
  92 tnf_tag_data_t *tnf_uint8_tag_data = NULL;
  93 tnf_tag_data_t *tnf_int16_tag_data = NULL;
  94 tnf_tag_data_t *tnf_uint16_tag_data = NULL;
  95 tnf_tag_data_t *tnf_int32_tag_data = NULL;
  96 tnf_tag_data_t *tnf_uint32_tag_data = NULL;
  97 tnf_tag_data_t *tnf_int64_tag_data = NULL;
  98 tnf_tag_data_t *tnf_uint64_tag_data = NULL;
  99 tnf_tag_data_t *tnf_float32_tag_data = NULL;
 100 tnf_tag_data_t *tnf_float64_tag_data = NULL;
 101 tnf_tag_data_t *tnf_array_tag_data = NULL;
 102 tnf_tag_data_t *tnf_string_tag_data = NULL;
 103 tnf_tag_data_t *tnf_type_array_tag_data = NULL;
 104 tnf_tag_data_t *tnf_name_array_tag_data = NULL;
 105 tnf_tag_data_t *tnf_derived_tag_data = NULL;
 106 tnf_tag_data_t *tnf_align_tag_data = NULL;
 107 tnf_tag_data_t *tnf_derived_base_tag_data = NULL;
 108 tnf_tag_data_t *tnf_element_type_tag_data = NULL;
 109 tnf_tag_data_t *tnf_header_size_tag_data = NULL;
 110 tnf_tag_data_t *tnf_name_tag_data = NULL;
 111 tnf_tag_data_t *tnf_opaque_tag_data = NULL;
 112 tnf_tag_data_t *tnf_properties_tag_data = NULL;
 113 tnf_tag_data_t *tnf_self_size_tag_data = NULL;
 114 tnf_tag_data_t *tnf_size_tag_data = NULL;
 115 tnf_tag_data_t *tnf_slot_names_tag_data = NULL;
 116 tnf_tag_data_t *tnf_slot_types_tag_data = NULL;
 117 tnf_tag_data_t *tnf_tag_tag_data = NULL;
 118 tnf_tag_data_t *tnf_tag_arg_tag_data = NULL;
 119 tnf_tag_data_t *tnf_type_size_tag_data = NULL;
 120 tnf_tag_data_t *tnf_struct_tag_data = NULL;
 121 tnf_tag_data_t *tnf_file_header_tag_data = NULL;
 122 tnf_tag_data_t *tnf_block_header_tag_data = NULL;
 123 tnf_tag_data_t *tnf_type_tag_data = NULL;
 124 tnf_tag_data_t *tnf_array_type_tag_data = NULL;
 125 tnf_tag_data_t *tnf_derived_type_tag_data = NULL;
 126 tnf_tag_data_t *tnf_scalar_type_tag_data = NULL;
 127 tnf_tag_data_t *tnf_struct_type_tag_data = NULL;
 128
 129 /* tnf_trace module */
 130 tnf_tag_data_t *tnf_probe_event_tag_data = NULL;
 131 tnf_tag_data_t *tnf_time_base_tag_data = NULL;
 132 tnf_tag_data_t *tnf_time_delta_tag_data = NULL;
 133 tnf_tag_data_t *tnf_pid_tag_data = NULL;
 134 tnf_tag_data_t *tnf_lwpid_tag_data = NULL;
 135 tnf_tag_data_t *tnf_kthread_id_tag_data = NULL;
 136 tnf_tag_data_t *tnf_cpuid_tag_data = NULL;
 137 tnf_tag_data_t *tnf_device_tag_data = NULL;
 138 tnf_tag_data_t *tnf_symbol_tag_data = NULL;
 139 tnf_tag_data_t *tnf_symbols_tag_data = NULL;
 140 tnf_tag_data_t *tnf_sysnum_tag_data = NULL;
 141 tnf_tag_data_t *tnf_microstate_tag_data = NULL;
 142 tnf_tag_data_t *tnf_offset_tag_data = NULL;
 143 tnf_tag_data_t *tnf_fault_type_tag_data = NULL;
 144 tnf_tag_data_t *tnf_seg_access_tag_data = NULL;
 145 tnf_tag_data_t *tnf_bioflags_tag_data = NULL;
 146 tnf_tag_data_t *tnf_diskaddr_tag_data = NULL;
 147 tnf_tag_data_t *tnf_kernel_schedule_tag_data = NULL;
 148
 149 tnf_tag_data_t *tnf_probe_type_tag_data = NULL;
 150
 151 /* Exported properties */
 152 tnf_tag_data_t  ***tnf_user_struct_properties = NULL;
 153
 154 /*
 155  * tnf_thread_create()
 156  * Called from thread_create() to initialize thread's tracing state.
 157  * XXX Do this when tracing is first turned on
 158  */
 159
 160 void
 161 tnf_thread_create(kthread_t *t)
 162 {
 163         /* If the allocation fails, this thread doesn't trace */
 164         t->t_tnf_tpdp = kmem_zalloc(sizeof (tnf_ops_t), KM_NOSLEEP);
 165
 166         TNF_PROBE_3(thread_create, "thread", /* CSTYLED */,
 167                 tnf_kthread_id, tid,            t,
 168                 tnf_pid,        pid,            ttoproc(t)->p_pid,
 169                 tnf_symbol,     start_pc,       t->t_startpc);
 170 }
 171
 172 /*
 173  * tnf_thread_exit()
 174  * Called from thread_exit() and lwp_exit() if thread has a tpdp.
 175  * From this point on, we're off the allthreads list
 176  */
 177
 178 void
 179 tnf_thread_exit(void)
 180 {
 181         tnf_ops_t *ops;
 182         tnf_block_header_t *block;
 183
 184         TNF_PROBE_0(thread_exit, "thread", /* CSTYLED */);
 185         /* LINTED pointer cast may result in improper alignment */
 186         ops = (tnf_ops_t *)curthread->t_tnf_tpdp;
 187         /*
 188          * Mark ops as busy from now on, so it will never be used
 189          * again.  If we fail on the busy lock, the buffer
 190          * deallocation code is cleaning our ops, so we don't need to
 191          * do anything.  If we get the lock and the buffer exists,
 192          * release all blocks we hold.  Once we're off allthreads,
 193          * the deallocator will not examine our ops.
 194          */
 195         if (ops->busy)
 196                 return;
 197         LOCK_INIT_HELD(&ops->busy);
 198         if (tnf_buf != NULL) {
 199                 /* Release any A-locks held */
 200                 block = ops->wcb.tnfw_w_pos.tnfw_w_block;
 201                 ops->wcb.tnfw_w_pos.tnfw_w_block = NULL;
 202                 if (block != NULL)
 203                         lock_clear(&block->A_lock);
 204                 block = ops->wcb.tnfw_w_tag_pos.tnfw_w_block;
 205                 ops->wcb.tnfw_w_tag_pos.tnfw_w_block = NULL;
 206                 if (block != NULL)
 207                         lock_clear(&block->A_lock);
 208         }
 209 }
 210
 211 /*
 212  * Called from thread_free() if thread has tpdp.
 213  */
 214
 215 void
 216 tnf_thread_free(kthread_t *t)
 217 {
 218         tnf_ops_t *ops;
 219         /* LINTED pointer cast may result in improper alignment */
 220         ops = (tnf_ops_t *)t->t_tnf_tpdp;
 221         t->t_tnf_tpdp = NULL;
 222         kmem_free(ops, sizeof (*ops));
 223 }
 224
 225 /*
 226  * tnf_thread_queue()
 227  * Probe wrapper called when tracing is enabled and a thread is
 228  * placed on some dispatch queue.
 229  */
 230
 231 void
 232 tnf_thread_queue(kthread_t *t, cpu_t *cp, pri_t tpri)
 233 {
 234         TNF_PROBE_4(thread_queue, "dispatcher", /* CSTYLED */,
 235                 tnf_kthread_id,         tid,            t,
 236                 tnf_cpuid,              cpuid,          cp->cpu_id,
 237                 tnf_long,               priority,       tpri,
 238                 tnf_ulong,              queue_length,
 239                         /* cp->cpu_disp->disp_q[tpri].dq_sruncnt */
 240                         cp->cpu_disp->disp_nrunnable);
 241
 242         TNF_PROBE_2(thread_state, "thread", /* CSTYLED */,
 243                 tnf_kthread_id,         tid,            t,
 244                 tnf_microstate,         state,          LMS_WAIT_CPU);
 245 }
 246
 247 /*
 248  * pcstack(): fill in, NULL-terminate and return pc stack.
 249  */
 250
 251 static pc_t *
 252 pcstack(pc_t *pcs)
 253 {
 254         uint_t n;
 255
 256         n = getpcstack(pcs, TNF_PC_COUNT);
 257         pcs[n] = 0;
 258         return (pcs);
 259 }
 260
 261 /*
 262  * tnf_thread_switch()
 263  * Probe wrapper called when tracing enabled and curthread is about to
 264  * switch to the next thread.
 265  * XXX Simple sleepstate and runstate calculations
 266  */
 267
 268 #define SLPSTATE(t, ts)                                 \
 269         (((ts) == TS_STOPPED) ? LMS_STOPPED :           \
 270             ((t)->t_wchan0 ? LMS_USER_LOCK : LMS_SLEEP))
 271
 272 #define RUNSTATE(next, lwp)                             \
 273         ((((lwp = ttolwp(next)) != NULL) &&             \
 274                 lwp->lwp_state == LWP_USER) ?           \
 275                 LMS_USER : LMS_SYSTEM)
 276
 277 void
 278 tnf_thread_switch(kthread_t *next)
 279 {
 280         kthread_t       *t;
 281         klwp_t          *lwp;
 282         caddr_t         ztpdp;
 283         int             borrow;
 284         uint_t          ts;
 285         pc_t            pcs[TNF_PC_COUNT + 1];
 286
 287         t = curthread;
 288         ts = t->t_state;
 289
 290         /*
 291          * If we're a zombie, borrow idle thread's tpdp.  This lets
 292          * the driver decide whether the buffer is busy by examining
 293          * allthreads (idle threads are always on the list).
 294          */
 295         if ((borrow = (ts == TS_ZOMB)) != 0) {
 296                 ztpdp = t->t_tnf_tpdp;
 297                 t->t_tnf_tpdp = CPU->cpu_idle_thread->t_tnf_tpdp;
 298                 goto do_next;
 299         }
 300
 301         /*
 302          * If we're blocked, test the blockage probe
 303          */
 304         if (ts == TS_SLEEP && t->t_wchan)
 305 #if defined(__sparc)
 306                 TNF_PROBE_2(thread_block, "synch", /* CSTYLED */,
 307                     tnf_opaque,   reason,       t->t_wchan,
 308                     tnf_symbols,  stack,        (pc_t *)pcstack(pcs));
 309 #else /* defined(__sparc) */
 310                 TNF_PROBE_2(thread_block, "synch", /* CSTYLED */,
 311                     tnf_opaque,   reason,       t->t_wchan,
 312                     tnf_symbols,  stack,        (tnf_opaque_t *)pcstack(pcs));
 313 #endif /* defined(__sparc) */
 314
 315         /*
 316          * Record outgoing thread's state
 317          * Kernel thread ID is implicit in schedule record
 318          * supress lint: cast from 32-bit integer to 8-bit integer
 319          * tnf_microstate_t = tnf_uint8_t
 320          */
 321 #if defined(_LP64)
 322         /* LINTED */
 323         TNF_PROBE_1(thread_state, "thread", /* CSTYLED */,
 324             tnf_microstate,     state,          SLPSTATE(t, ts));
 325 #else
 326         TNF_PROBE_1(thread_state, "thread", /* CSTYLED */,
 327                 tnf_microstate, state,  SLPSTATE(t, ts));
 328 #endif
 329
 330 do_next:
 331         /*
 332          * Record incoming thread's state
 333          *
 334          * supress lint: cast from 32-bit integer to 8-bit integer
 335          * tnf_microstate_t = tnf_uint8_t
 336          */
 337 #if defined(_LP64)
 338         /* LINTED */
 339         TNF_PROBE_2(thread_state, "thread", /* CSTYLED */,
 340             tnf_kthread_id,     tid,            next,
 341             tnf_microstate,     state,          RUNSTATE(next, lwp));
 342 #else
 343         TNF_PROBE_2(thread_state, "thread", /* CSTYLED */,
 344                 tnf_kthread_id, tid,    next,
 345                 tnf_microstate, state,  RUNSTATE(next, lwp));
 346 #endif
 347
 348         /*
 349          * If we borrowed idle thread's tpdp above, restore the zombies
 350          * tpdp so that it will be freed from tnf_thread_free().
 351          */
 352         if (borrow)
 353                 t->t_tnf_tpdp = ztpdp;
 354
 355 }
 356
 357 #endif  /* NPROBE */
 358
 359 /*
 360  * tnf_mod_load (and tnf_mod_unload), when called from a client module's _init
 361  * (and _fini) entry points are insufficient mechanisms for maintaining the
 362  * consistency of __tnf_probe_list_head and __tnf_tag_list_head whenever that
 363  * module is loaded or unloaded.  The problem occurs because loading a module,
 364  * at which time the modules probes are linked into the two lists, and
 365  * installing that module are separate operations.  This means that it is
 366  * possible for a module to be loaded, not installed, and unloaded without
 367  * calling _init and _fini.  If the module contains TNF probes, the probe and
 368  * tag lists will contain references to data addresses freed when the module
 369  * is unloaded.
 370  *
 371  * The implemented solution for maintaining the lists is to perform the
 372  * unsplicing when the module is unloaded. (Splicing into the lists, "probe
 373  * discovery", is done when krtld processes relocation references when it
 374  * loads the module; this information is not available for subsequent
 375  * operations on the module.
 376  */
 377 int
 378 tnf_mod_load()
 379 {
 380         return (0);
 381 }
 382
 383 /* ARGSUSED */
 384 int
 385 tnf_mod_unload(struct modlinkage *mlp)
 386 {
 387         return (0);
 388 }