Home | History | Annotate | Download | only in tnf
      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	"@(#)tnf_res.c	1.35	05/06/08 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 }
    389