xref: /titanic_51/usr/src/uts/common/tnf/tnf_res.c (revision 5a7763bf3e9db4cfe6cb523b096cb74af71e3793)
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 }
389