xref: /illumos-gate/usr/src/uts/common/sys/tnf_probe.h (revision 7c478bd9)
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 (c) 1994, by Sun Microsytems, Inc.
24  */
25 
26 #ifndef _SYS_TNF_PROBE_H
27 #define	_SYS_TNF_PROBE_H
28 
29 #pragma ident	"%Z%%M%	%I%	%E% SMI"
30 
31 #include <sys/tnf_writer.h>
32 
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36 
37 /*
38  * These macros are used to convert the __LINE__ directive to a
39  * string in the probe macros below.
40  */
41 
42 #define	TNF_STRINGIFY(x) #x
43 #define	TNF_STRINGVALUE(x) TNF_STRINGIFY(x)
44 
45 /*
46  * Alignment of tnf_ref32_t
47  */
48 
49 struct _tnf_ref32_align {
50 	char		c;
51 	tnf_ref32_t	t;
52 };
53 #define	TNF_REF32_ALIGN		TNF_OFFSETOF(struct _tnf_ref32_align, t)
54 
55 /*
56  * Probe versioning
57  */
58 
59 struct tnf_probe_version {
60 	size_t	version_size;		/* sizeof(struct tnf_probe_version) */
61 	size_t	probe_control_size;	/* sizeof(tnf_probe_control_t) */
62 };
63 
64 extern struct tnf_probe_version __tnf_probe_version_1;
65 #pragma weak __tnf_probe_version_1
66 
67 /*
68  * Typedefs
69  */
70 
71 typedef struct tnf_probe_control tnf_probe_control_t;
72 typedef struct tnf_probe_setup tnf_probe_setup_t;
73 
74 /* returns pointer to buffer */
75 typedef void * (*tnf_probe_test_func_t)(void *,
76 					tnf_probe_control_t *,
77 					tnf_probe_setup_t *);
78 
79 /* returns buffer pointer */
80 typedef void * (*tnf_probe_alloc_func_t)(tnf_ops_t *,	/* tpd	*/
81 					tnf_probe_control_t *,
82 					tnf_probe_setup_t *);
83 
84 typedef void (*tnf_probe_func_t)(tnf_probe_setup_t *);
85 
86 /*
87  * Probe argument block
88  */
89 
90 struct tnf_probe_setup {
91 	tnf_ops_t		*tpd_p;
92 	void			*buffer_p;
93 	tnf_probe_control_t	*probe_p;
94 };
95 
96 /*
97  * Probe control block
98  */
99 
100 struct tnf_probe_control {
101 	const struct tnf_probe_version	*version;
102 	tnf_probe_control_t	*next;
103 	tnf_probe_test_func_t	test_func;
104 	tnf_probe_alloc_func_t	alloc_func;
105 	tnf_probe_func_t	probe_func;
106 	tnf_probe_func_t	commit_func;
107 	uintptr_t		index;
108 	const char		*attrs;
109 	tnf_tag_data_t		***slot_types;
110 	unsigned long		tnf_event_size;
111 };
112 
113 #ifdef _KERNEL
114 
115 #define	TNF_NEXT_INIT	0
116 
117 #else
118 
119 #define	TNF_NEXT_INIT	-1
120 
121 #endif	/* _KERNEL */
122 
123 /*
124  * TNF Type extension
125  */
126 
127 #ifdef NPROBE
128 
129 #define	TNF_DECLARE_RECORD(ctype, record)				\
130 	typedef tnf_reference_t record##_t
131 
132 #else
133 
134 #define	TNF_DECLARE_RECORD(ctype, record)				\
135 	typedef tnf_reference_t record##_t;				\
136 	extern tnf_tag_data_t *record##_tag_data;			\
137 	extern record##_t record(tnf_ops_t *, ctype *, tnf_record_p)
138 
139 #endif	/* NPROBE */
140 
141 #ifdef NPROBE
142 
143 /* CSTYLED */
144 #define	TNF_DEFINE_RECORD_1(ctype, ctype_record, t1, n1)
145 
146 #else
147 
148 /* CSTYLED */
149 #define	TNF_DEFINE_RECORD_1(ctype, ctype_record, t1, n1) \
150 typedef struct {						\
151 	tnf_tag_t	tag;					\
152 	t1##_t		data_1;				\
153 } ctype_record##_prototype_t;					\
154 static tnf_tag_data_t **ctype_record##_type_slots[] = {		\
155 	&tnf_tag_tag_data,					\
156 	&t1##_tag_data,					\
157 	0 };							\
158 static char *ctype_record##_slot_names[] = {			\
159 	"tnf_tag",						\
160 	""#n1,						\
161 	0 };							\
162 static tnf_tag_data_t ctype_record##_tag_data_rec = {		\
163 	TNF_TAG_VERSION, &tnf_struct_tag_1,			\
164 	0, #ctype_record, &tnf_user_struct_properties,		\
165 	sizeof (ctype_record##_prototype_t),			\
166 	TNF_REF32_ALIGN,					\
167 	sizeof (ctype_record##_t), TNF_STRUCT, 0,		\
168 	ctype_record##_type_slots, ctype_record##_slot_names	\
169 };								\
170 tnf_tag_data_t *ctype_record##_tag_data =			\
171 			&ctype_record##_tag_data_rec;		\
172 ctype_record##_t						\
173 ctype_record(tnf_ops_t *ops, ctype * the_ctype,			\
174 				tnf_record_p reference)	\
175 {								\
176 	tnf_tag_data_t			*metatag_data;		\
177 	tnf_record_p			metatag_index;		\
178 	ctype_record##_prototype_t	*buffer;		\
179 								\
180 	if (the_ctype == NULL)					\
181 		return (0);					\
182 	buffer = (ctype_record##_prototype_t *) tnf_allocate(ops, \
183 			sizeof (ctype_record##_prototype_t));	\
184 	if (buffer == NULL)					\
185 		return (0);					\
186 								\
187 	metatag_data = ctype_record##_tag_data;			\
188 	metatag_index = metatag_data->tag_index ?		\
189 		metatag_data->tag_index:			\
190 		metatag_data->tag_desc(ops, metatag_data);	\
191 	buffer->tag = tnf_tag(ops, metatag_index,		\
192 		(tnf_record_p) &buffer->tag);		\
193 	buffer->data_1 = t1(ops, the_ctype->n1,		\
194 			(tnf_record_p) &(buffer->data_1));	\
195 	return (tnf_ref32(ops, (tnf_record_p) buffer, reference)); \
196 }
197 
198 #endif /* NPROBE */
199 
200 #ifdef NPROBE
201 
202 /* CSTYLED */
203 #define	TNF_DEFINE_RECORD_2(ctype, ctype_record, t1, n1, t2, n2)
204 
205 #else
206 
207 /* CSTYLED */
208 #define	TNF_DEFINE_RECORD_2(ctype, ctype_record, t1, n1, t2, n2) \
209 typedef struct {						\
210 	tnf_tag_t	tag;					\
211 	t1##_t		data_1;				\
212 	t2##_t		data_2;				\
213 } ctype_record##_prototype_t;					\
214 static tnf_tag_data_t **ctype_record##_type_slots[] = {		\
215 	&tnf_tag_tag_data,					\
216 	&t1##_tag_data,					\
217 	&t2##_tag_data,					\
218 	0 };							\
219 static char *ctype_record##_slot_names[] = {			\
220 	"tnf_tag",						\
221 	""#n1,						\
222 	""#n2,						\
223 	0 };							\
224 static tnf_tag_data_t ctype_record##_tag_data_rec = {		\
225 	TNF_TAG_VERSION, &tnf_struct_tag_1,			\
226 	0, #ctype_record, &tnf_user_struct_properties,		\
227 	sizeof (ctype_record##_prototype_t),			\
228 	TNF_REF32_ALIGN,					\
229 	sizeof (ctype_record##_t), TNF_STRUCT, 0,		\
230 	ctype_record##_type_slots, ctype_record##_slot_names	\
231 };								\
232 tnf_tag_data_t *ctype_record##_tag_data =			\
233 			&ctype_record##_tag_data_rec;		\
234 ctype_record##_t						\
235 ctype_record(tnf_ops_t *ops, ctype * the_ctype,			\
236 				tnf_record_p reference)	\
237 {								\
238 	tnf_tag_data_t			*metatag_data;		\
239 	tnf_record_p			metatag_index;		\
240 	ctype_record##_prototype_t	*buffer;		\
241 								\
242 	if (the_ctype == NULL)					\
243 		return (0);					\
244 	buffer = (ctype_record##_prototype_t *) tnf_allocate(ops, \
245 			sizeof (ctype_record##_prototype_t));	\
246 	if (buffer == NULL)					\
247 		return (0);					\
248 								\
249 	metatag_data = ctype_record##_tag_data;			\
250 	metatag_index = metatag_data->tag_index ?		\
251 		metatag_data->tag_index:			\
252 		metatag_data->tag_desc(ops, metatag_data);	\
253 	buffer->tag = tnf_tag(ops, metatag_index,		\
254 		(tnf_record_p) &buffer->tag);		\
255 	buffer->data_1 = t1(ops, the_ctype->n1,		\
256 			(tnf_record_p) &(buffer->data_1));	\
257 	buffer->data_2 = t2(ops, the_ctype->n2,		\
258 			(tnf_record_p) &(buffer->data_2));	\
259 	return (tnf_ref32(ops, (tnf_record_p) buffer, reference)); \
260 }
261 
262 #endif /* NPROBE */
263 
264 #ifdef NPROBE
265 
266 /* CSTYLED */
267 #define	TNF_DEFINE_RECORD_3(ctype, ctype_record, t1, n1, t2, n2, t3, n3)
268 
269 #else
270 
271 /* CSTYLED */
272 #define	TNF_DEFINE_RECORD_3(ctype, ctype_record, t1, n1, t2, n2, t3, n3) \
273 typedef struct {						\
274 	tnf_tag_t	tag;					\
275 	t1##_t		data_1;				\
276 	t2##_t		data_2;				\
277 	t3##_t		data_3;				\
278 } ctype_record##_prototype_t;					\
279 static tnf_tag_data_t **ctype_record##_type_slots[] = {		\
280 	&tnf_tag_tag_data,					\
281 	&t1##_tag_data,					\
282 	&t2##_tag_data,					\
283 	&t3##_tag_data,					\
284 	0 };							\
285 static char *ctype_record##_slot_names[] = {			\
286 	"tnf_tag",						\
287 	""#n1,						\
288 	""#n2,						\
289 	""#n3,						\
290 	0 };							\
291 static tnf_tag_data_t ctype_record##_tag_data_rec = {		\
292 	TNF_TAG_VERSION, &tnf_struct_tag_1,			\
293 	0, #ctype_record, &tnf_user_struct_properties,		\
294 	sizeof (ctype_record##_prototype_t),			\
295 	TNF_REF32_ALIGN,					\
296 	sizeof (ctype_record##_t), TNF_STRUCT, 0,		\
297 	ctype_record##_type_slots, ctype_record##_slot_names	\
298 };								\
299 tnf_tag_data_t *ctype_record##_tag_data =			\
300 			&ctype_record##_tag_data_rec;		\
301 ctype_record##_t						\
302 ctype_record(tnf_ops_t *ops, ctype * the_ctype,			\
303 				tnf_record_p reference)	\
304 {								\
305 	tnf_tag_data_t			*metatag_data;		\
306 	tnf_record_p			metatag_index;		\
307 	ctype_record##_prototype_t	*buffer;		\
308 								\
309 	if (the_ctype == NULL)					\
310 		return (0);					\
311 	buffer = (ctype_record##_prototype_t *) tnf_allocate(ops, \
312 			sizeof (ctype_record##_prototype_t));	\
313 	if (buffer == NULL)					\
314 		return (0);					\
315 								\
316 	metatag_data = ctype_record##_tag_data;			\
317 	metatag_index = metatag_data->tag_index ?		\
318 		metatag_data->tag_index:			\
319 		metatag_data->tag_desc(ops, metatag_data);	\
320 	buffer->tag = tnf_tag(ops, metatag_index,		\
321 		(tnf_record_p) &buffer->tag);		\
322 	buffer->data_1 = t1(ops, the_ctype->n1,		\
323 			(tnf_record_p) &(buffer->data_1));	\
324 	buffer->data_2 = t2(ops, the_ctype->n2,		\
325 			(tnf_record_p) &(buffer->data_2));	\
326 	buffer->data_3 = t3(ops, the_ctype->n3,		\
327 			(tnf_record_p) &(buffer->data_3));	\
328 	return (tnf_ref32(ops, (tnf_record_p) buffer, reference)); \
329 }
330 
331 #endif /* NPROBE */
332 
333 #ifdef NPROBE
334 
335 /* CSTYLED */
336 #define	TNF_DEFINE_RECORD_4(ctype, ctype_record, t1, n1, t2, n2, t3, n3, t4, n4)
337 
338 #else
339 
340 /* CSTYLED */
341 #define	TNF_DEFINE_RECORD_4(ctype, ctype_record, t1, n1, t2, n2, t3, n3, t4, n4) \
342 typedef struct {						\
343 	tnf_tag_t	tag;					\
344 	t1##_t		data_1;				\
345 	t2##_t		data_2;				\
346 	t3##_t		data_3;				\
347 	t4##_t		data_4;				\
348 } ctype_record##_prototype_t;					\
349 static tnf_tag_data_t **ctype_record##_type_slots[] = {		\
350 	&tnf_tag_tag_data,					\
351 	&t1##_tag_data,					\
352 	&t2##_tag_data,					\
353 	&t3##_tag_data,					\
354 	&t4##_tag_data,					\
355 	0 };							\
356 static char *ctype_record##_slot_names[] = {			\
357 	"tnf_tag",						\
358 	""#n1,						\
359 	""#n2,						\
360 	""#n3,						\
361 	""#n4,						\
362 	0 };							\
363 static tnf_tag_data_t ctype_record##_tag_data_rec = {		\
364 	TNF_TAG_VERSION, &tnf_struct_tag_1,			\
365 	0, #ctype_record, &tnf_user_struct_properties,		\
366 	sizeof (ctype_record##_prototype_t),			\
367 	TNF_REF32_ALIGN,					\
368 	sizeof (ctype_record##_t), TNF_STRUCT, 0,		\
369 	ctype_record##_type_slots, ctype_record##_slot_names	\
370 };								\
371 tnf_tag_data_t *ctype_record##_tag_data =			\
372 			&ctype_record##_tag_data_rec;		\
373 ctype_record##_t						\
374 ctype_record(tnf_ops_t *ops, ctype * the_ctype,			\
375 				tnf_record_p reference)	\
376 {								\
377 	tnf_tag_data_t			*metatag_data;		\
378 	tnf_record_p			metatag_index;		\
379 	ctype_record##_prototype_t	*buffer;		\
380 								\
381 	if (the_ctype == NULL)					\
382 		return (0);					\
383 	buffer = (ctype_record##_prototype_t *) tnf_allocate(ops, \
384 			sizeof (ctype_record##_prototype_t));	\
385 	if (buffer == NULL)					\
386 		return (0);					\
387 								\
388 	metatag_data = ctype_record##_tag_data;			\
389 	metatag_index = metatag_data->tag_index ?		\
390 		metatag_data->tag_index:			\
391 		metatag_data->tag_desc(ops, metatag_data);	\
392 	buffer->tag = tnf_tag(ops, metatag_index,		\
393 		(tnf_record_p) &buffer->tag);		\
394 	buffer->data_1 = t1(ops, the_ctype->n1,		\
395 			(tnf_record_p) &(buffer->data_1));	\
396 	buffer->data_2 = t2(ops, the_ctype->n2,		\
397 			(tnf_record_p) &(buffer->data_2));	\
398 	buffer->data_3 = t3(ops, the_ctype->n3,		\
399 			(tnf_record_p) &(buffer->data_3));	\
400 	buffer->data_4 = t4(ops, the_ctype->n4,		\
401 			(tnf_record_p) &(buffer->data_4));	\
402 	return (tnf_ref32(ops, (tnf_record_p) buffer, reference)); \
403 }
404 
405 #endif /* NPROBE */
406 
407 #ifdef NPROBE
408 
409 /* CSTYLED */
410 #define	TNF_DEFINE_RECORD_5(ctype, ctype_record, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5)
411 
412 #else
413 
414 /* CSTYLED */
415 #define	TNF_DEFINE_RECORD_5(ctype, ctype_record, t1, n1, t2, n2, t3, n3, t4, n4, t5, n5) \
416 typedef struct {						\
417 	tnf_tag_t	tag;					\
418 	t1##_t		data_1;				\
419 	t2##_t		data_2;				\
420 	t3##_t		data_3;				\
421 	t4##_t		data_4;				\
422 	t5##_t		data_5;				\
423 } ctype_record##_prototype_t;					\
424 static tnf_tag_data_t **ctype_record##_type_slots[] = {		\
425 	&tnf_tag_tag_data,					\
426 	&t1##_tag_data,					\
427 	&t2##_tag_data,					\
428 	&t3##_tag_data,					\
429 	&t4##_tag_data,					\
430 	&t5##_tag_data,					\
431 	0 };							\
432 static char *ctype_record##_slot_names[] = {			\
433 	"tnf_tag",						\
434 	""#n1,						\
435 	""#n2,						\
436 	""#n3,						\
437 	""#n4,						\
438 	""#n5,						\
439 	0 };							\
440 static tnf_tag_data_t ctype_record##_tag_data_rec = {		\
441 	TNF_TAG_VERSION, &tnf_struct_tag_1,			\
442 	0, #ctype_record, &tnf_user_struct_properties,		\
443 	sizeof (ctype_record##_prototype_t),			\
444 	TNF_REF32_ALIGN,					\
445 	sizeof (ctype_record##_t), TNF_STRUCT, 0,		\
446 	ctype_record##_type_slots, ctype_record##_slot_names	\
447 };								\
448 tnf_tag_data_t *ctype_record##_tag_data =			\
449 			&ctype_record##_tag_data_rec;		\
450 ctype_record##_t						\
451 ctype_record(tnf_ops_t *ops, ctype * the_ctype,			\
452 				tnf_record_p reference)	\
453 {								\
454 	tnf_tag_data_t			*metatag_data;		\
455 	tnf_record_p			metatag_index;		\
456 	ctype_record##_prototype_t	*buffer;		\
457 								\
458 	if (the_ctype == NULL)					\
459 		return (0);					\
460 	buffer = (ctype_record##_prototype_t *) tnf_allocate(ops, \
461 			sizeof (ctype_record##_prototype_t));	\
462 	if (buffer == NULL)					\
463 		return (0);					\
464 								\
465 	metatag_data = ctype_record##_tag_data;			\
466 	metatag_index = metatag_data->tag_index ?		\
467 		metatag_data->tag_index:			\
468 		metatag_data->tag_desc(ops, metatag_data);	\
469 	buffer->tag = tnf_tag(ops, metatag_index,		\
470 		(tnf_record_p) &buffer->tag);		\
471 	buffer->data_1 = t1(ops, the_ctype->n1,		\
472 			(tnf_record_p) &(buffer->data_1));	\
473 	buffer->data_2 = t2(ops, the_ctype->n2,		\
474 			(tnf_record_p) &(buffer->data_2));	\
475 	buffer->data_3 = t3(ops, the_ctype->n3,		\
476 			(tnf_record_p) &(buffer->data_3));	\
477 	buffer->data_4 = t4(ops, the_ctype->n4,		\
478 			(tnf_record_p) &(buffer->data_4));	\
479 	buffer->data_5 = t5(ops, the_ctype->n5,		\
480 			(tnf_record_p) &(buffer->data_5));	\
481 	return (tnf_ref32(ops, (tnf_record_p) buffer, reference)); \
482 }
483 
484 #endif /* NPROBE */
485 
486 /*
487  * Probe Macros
488  */
489 
490 #ifdef NPROBE
491 
492 /* CSTYLED */
493 #define	TNF_PROBE_0(namearg, keysarg, detail) \
494 		((void)0)
495 
496 #else
497 
498 /* CSTYLED */
499 #define	TNF_PROBE_0(namearg, keysarg, detail)	\
500 {								\
501 	struct tnf_v_buf_0 {					\
502 		tnf_probe_event_t	probe_event;		\
503 		tnf_time_delta_t	time_delta;		\
504 	};							\
505 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
506 		&tnf_probe_event_tag_data,			\
507 		&tnf_time_delta_tag_data,			\
508 		0 };						\
509 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
510 		&__tnf_probe_version_1,				\
511 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
512 		(tnf_probe_test_func_t) 0,			\
513 		(tnf_probe_alloc_func_t) 0,			\
514 		(tnf_probe_func_t) 0,				\
515 		(tnf_probe_func_t) 0,				\
516 		(tnf_uint32_t) 0,				\
517 			/* attribute string */			\
518 			"name " TNF_STRINGVALUE(namearg) ";" \
519 			"slots "				\
520 			";"					\
521 			"keys " keysarg ";"			\
522 			"file " __FILE__ ";"		\
523 			"line " TNF_STRINGVALUE(__LINE__) ";" \
524 			detail,					\
525 		tnf_v_##namearg##_info,					\
526 		sizeof (struct tnf_v_buf_0)			\
527 	};							\
528 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
529 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
530 	tnf_probe_setup_t	tnf_v_set_p;			\
531 	struct tnf_v_buf_0	*tnf_v_probe_buffer;		\
532 								\
533 	if (tnf_v_probe_test) {					\
534 		tnf_v_probe_buffer = (struct tnf_v_buf_0 *)	\
535 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
536 		if (tnf_v_probe_buffer) {			\
537 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
538 		}						\
539 	}							\
540 }
541 
542 #endif /* NPROBE */
543 
544 #ifdef NPROBE
545 
546 /* CSTYLED */
547 #define	TNF_PROBE_1(namearg, keysarg, detail, type_1, namearg_1, valarg_1) \
548 		((void)0)
549 
550 #else
551 
552 /* CSTYLED */
553 #define	TNF_PROBE_1(namearg, keysarg, detail, type_1, namearg_1, valarg_1)	\
554 {								\
555 	struct tnf_v_buf_1 {					\
556 		tnf_probe_event_t	probe_event;		\
557 		tnf_time_delta_t	time_delta;		\
558 		type_1##_t		data_1;		\
559 	};							\
560 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
561 		&tnf_probe_event_tag_data,			\
562 		&tnf_time_delta_tag_data,			\
563 		&type_1##_tag_data,				\
564 		0 };						\
565 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
566 		&__tnf_probe_version_1,				\
567 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
568 		(tnf_probe_test_func_t) 0,			\
569 		(tnf_probe_alloc_func_t) 0,			\
570 		(tnf_probe_func_t) 0,				\
571 		(tnf_probe_func_t) 0,				\
572 		(tnf_uint32_t) 0,				\
573 			/* attribute string */			\
574 			"name " TNF_STRINGVALUE(namearg) ";" \
575 			"slots "				\
576 			""#namearg_1" "			\
577 			";"					\
578 			"keys " keysarg ";"			\
579 			"file " __FILE__ ";"		\
580 			"line " TNF_STRINGVALUE(__LINE__) ";" \
581 			detail,					\
582 		tnf_v_##namearg##_info,					\
583 		sizeof (struct tnf_v_buf_1)			\
584 	};							\
585 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
586 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
587 	tnf_probe_setup_t	tnf_v_set_p;			\
588 	struct tnf_v_buf_1	*tnf_v_probe_buffer;		\
589 								\
590 	if (tnf_v_probe_test) {					\
591 		tnf_v_probe_buffer = (struct tnf_v_buf_1 *)	\
592 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
593 		if (tnf_v_probe_buffer) {			\
594 		    tnf_v_probe_buffer->data_1 = type_1(	\
595 			tnf_v_set_p.tpd_p, valarg_1,		\
596 			(tnf_record_p) &(tnf_v_probe_buffer->data_1)); \
597 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
598 		}						\
599 	}							\
600 }
601 
602 #endif /* NPROBE */
603 
604 #ifdef NPROBE
605 
606 /* CSTYLED */
607 #define	TNF_PROBE_2(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2) \
608 		((void)0)
609 
610 #else
611 
612 /* CSTYLED */
613 #define	TNF_PROBE_2(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2)	\
614 {								\
615 	struct tnf_v_buf_2 {					\
616 		tnf_probe_event_t	probe_event;		\
617 		tnf_time_delta_t	time_delta;		\
618 		type_1##_t		data_1;		\
619 		type_2##_t		data_2;		\
620 	};							\
621 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
622 		&tnf_probe_event_tag_data,			\
623 		&tnf_time_delta_tag_data,			\
624 		&type_1##_tag_data,				\
625 		&type_2##_tag_data,				\
626 		0 };						\
627 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
628 		&__tnf_probe_version_1,				\
629 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
630 		(tnf_probe_test_func_t) 0,			\
631 		(tnf_probe_alloc_func_t) 0,			\
632 		(tnf_probe_func_t) 0,				\
633 		(tnf_probe_func_t) 0,				\
634 		(tnf_uint32_t) 0,				\
635 			/* attribute string */			\
636 			"name " TNF_STRINGVALUE(namearg) ";" \
637 			"slots "				\
638 			""#namearg_1" "			\
639 			""#namearg_2" "			\
640 			";"					\
641 			"keys " keysarg ";"			\
642 			"file " __FILE__ ";"		\
643 			"line " TNF_STRINGVALUE(__LINE__) ";" \
644 			detail,					\
645 		tnf_v_##namearg##_info,					\
646 		sizeof (struct tnf_v_buf_2)			\
647 	};							\
648 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
649 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
650 	tnf_probe_setup_t	tnf_v_set_p;			\
651 	struct tnf_v_buf_2	*tnf_v_probe_buffer;		\
652 								\
653 	if (tnf_v_probe_test) {					\
654 		tnf_v_probe_buffer = (struct tnf_v_buf_2 *)	\
655 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
656 		if (tnf_v_probe_buffer) {			\
657 		    tnf_v_probe_buffer->data_1 = type_1(	\
658 			tnf_v_set_p.tpd_p, valarg_1,		\
659 			(tnf_record_p) &(tnf_v_probe_buffer->data_1)); \
660 		    tnf_v_probe_buffer->data_2 = type_2(	\
661 			tnf_v_set_p.tpd_p, valarg_2,		\
662 			(tnf_record_p) &(tnf_v_probe_buffer->data_2)); \
663 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
664 		}						\
665 	}							\
666 }
667 
668 #endif /* NPROBE */
669 
670 #ifdef NPROBE
671 
672 /* CSTYLED */
673 #define	TNF_PROBE_3(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3) \
674 		((void)0)
675 
676 #else
677 
678 /* CSTYLED */
679 #define	TNF_PROBE_3(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3)	\
680 {								\
681 	struct tnf_v_buf_3 {					\
682 		tnf_probe_event_t	probe_event;		\
683 		tnf_time_delta_t	time_delta;		\
684 		type_1##_t		data_1;		\
685 		type_2##_t		data_2;		\
686 		type_3##_t		data_3;		\
687 	};							\
688 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
689 		&tnf_probe_event_tag_data,			\
690 		&tnf_time_delta_tag_data,			\
691 		&type_1##_tag_data,				\
692 		&type_2##_tag_data,				\
693 		&type_3##_tag_data,				\
694 		0 };						\
695 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
696 		&__tnf_probe_version_1,				\
697 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
698 		(tnf_probe_test_func_t) 0,			\
699 		(tnf_probe_alloc_func_t) 0,			\
700 		(tnf_probe_func_t) 0,				\
701 		(tnf_probe_func_t) 0,				\
702 		(tnf_uint32_t) 0,				\
703 			/* attribute string */			\
704 			"name " TNF_STRINGVALUE(namearg) ";" \
705 			"slots "				\
706 			""#namearg_1" "			\
707 			""#namearg_2" "			\
708 			""#namearg_3" "			\
709 			";"					\
710 			"keys " keysarg ";"			\
711 			"file " __FILE__ ";"		\
712 			"line " TNF_STRINGVALUE(__LINE__) ";" \
713 			detail,					\
714 		tnf_v_##namearg##_info,					\
715 		sizeof (struct tnf_v_buf_3)			\
716 	};							\
717 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
718 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
719 	tnf_probe_setup_t	tnf_v_set_p;			\
720 	struct tnf_v_buf_3	*tnf_v_probe_buffer;		\
721 								\
722 	if (tnf_v_probe_test) {					\
723 		tnf_v_probe_buffer = (struct tnf_v_buf_3 *)	\
724 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
725 		if (tnf_v_probe_buffer) {			\
726 		    tnf_v_probe_buffer->data_1 = type_1(	\
727 			tnf_v_set_p.tpd_p, valarg_1,		\
728 			(tnf_record_p) &(tnf_v_probe_buffer->data_1)); \
729 		    tnf_v_probe_buffer->data_2 = type_2(	\
730 			tnf_v_set_p.tpd_p, valarg_2,		\
731 			(tnf_record_p) &(tnf_v_probe_buffer->data_2)); \
732 		    tnf_v_probe_buffer->data_3 = type_3(	\
733 			tnf_v_set_p.tpd_p, valarg_3,		\
734 			(tnf_record_p) &(tnf_v_probe_buffer->data_3)); \
735 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
736 		}						\
737 	}							\
738 }
739 
740 #endif /* NPROBE */
741 
742 #ifdef NPROBE
743 
744 /* CSTYLED */
745 #define	TNF_PROBE_4(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4) \
746 		((void)0)
747 
748 #else
749 
750 /* CSTYLED */
751 #define	TNF_PROBE_4(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4)	\
752 {								\
753 	struct tnf_v_buf_4 {					\
754 		tnf_probe_event_t	probe_event;		\
755 		tnf_time_delta_t	time_delta;		\
756 		type_1##_t		data_1;		\
757 		type_2##_t		data_2;		\
758 		type_3##_t		data_3;		\
759 		type_4##_t		data_4;		\
760 	};							\
761 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
762 		&tnf_probe_event_tag_data,			\
763 		&tnf_time_delta_tag_data,			\
764 		&type_1##_tag_data,				\
765 		&type_2##_tag_data,				\
766 		&type_3##_tag_data,				\
767 		&type_4##_tag_data,				\
768 		0 };						\
769 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
770 		&__tnf_probe_version_1,				\
771 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
772 		(tnf_probe_test_func_t) 0,			\
773 		(tnf_probe_alloc_func_t) 0,			\
774 		(tnf_probe_func_t) 0,				\
775 		(tnf_probe_func_t) 0,				\
776 		(tnf_uint32_t) 0,				\
777 			/* attribute string */			\
778 			"name " TNF_STRINGVALUE(namearg) ";" \
779 			"slots "				\
780 			""#namearg_1" "			\
781 			""#namearg_2" "			\
782 			""#namearg_3" "			\
783 			""#namearg_4" "			\
784 			";"					\
785 			"keys " keysarg ";"			\
786 			"file " __FILE__ ";"		\
787 			"line " TNF_STRINGVALUE(__LINE__) ";" \
788 			detail,					\
789 		tnf_v_##namearg##_info,					\
790 		sizeof (struct tnf_v_buf_4)			\
791 	};							\
792 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
793 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
794 	tnf_probe_setup_t	tnf_v_set_p;			\
795 	struct tnf_v_buf_4	*tnf_v_probe_buffer;		\
796 								\
797 	if (tnf_v_probe_test) {					\
798 		tnf_v_probe_buffer = (struct tnf_v_buf_4 *)	\
799 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
800 		if (tnf_v_probe_buffer) {			\
801 		    tnf_v_probe_buffer->data_1 = type_1(	\
802 			tnf_v_set_p.tpd_p, valarg_1,		\
803 			(tnf_record_p) &(tnf_v_probe_buffer->data_1)); \
804 		    tnf_v_probe_buffer->data_2 = type_2(	\
805 			tnf_v_set_p.tpd_p, valarg_2,		\
806 			(tnf_record_p) &(tnf_v_probe_buffer->data_2)); \
807 		    tnf_v_probe_buffer->data_3 = type_3(	\
808 			tnf_v_set_p.tpd_p, valarg_3,		\
809 			(tnf_record_p) &(tnf_v_probe_buffer->data_3)); \
810 		    tnf_v_probe_buffer->data_4 = type_4(	\
811 			tnf_v_set_p.tpd_p, valarg_4,		\
812 			(tnf_record_p) &(tnf_v_probe_buffer->data_4)); \
813 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
814 		}						\
815 	}							\
816 }
817 
818 #endif /* NPROBE */
819 
820 #ifdef NPROBE
821 
822 /* CSTYLED */
823 #define	TNF_PROBE_5(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4, type_5, namearg_5, valarg_5) \
824 		((void)0)
825 
826 #else
827 
828 /* CSTYLED */
829 #define	TNF_PROBE_5(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4, type_5, namearg_5, valarg_5)	\
830 {								\
831 	struct tnf_v_buf_5 {					\
832 		tnf_probe_event_t	probe_event;		\
833 		tnf_time_delta_t	time_delta;		\
834 		type_1##_t		data_1;		\
835 		type_2##_t		data_2;		\
836 		type_3##_t		data_3;		\
837 		type_4##_t		data_4;		\
838 		type_5##_t		data_5;		\
839 	};							\
840 	static tnf_tag_data_t ** tnf_v_##namearg##_info[] = {		\
841 		&tnf_probe_event_tag_data,			\
842 		&tnf_time_delta_tag_data,			\
843 		&type_1##_tag_data,				\
844 		&type_2##_tag_data,				\
845 		&type_3##_tag_data,				\
846 		&type_4##_tag_data,				\
847 		&type_5##_tag_data,				\
848 		0 };						\
849 	static struct tnf_probe_control tnf_v_##namearg##_probe = {	\
850 		&__tnf_probe_version_1,				\
851 		(tnf_probe_control_t *) TNF_NEXT_INIT,		\
852 		(tnf_probe_test_func_t) 0,			\
853 		(tnf_probe_alloc_func_t) 0,			\
854 		(tnf_probe_func_t) 0,				\
855 		(tnf_probe_func_t) 0,				\
856 		(tnf_uint32_t) 0,				\
857 			/* attribute string */			\
858 			"name " TNF_STRINGVALUE(namearg) ";" \
859 			"slots "				\
860 			""#namearg_1" "			\
861 			""#namearg_2" "			\
862 			""#namearg_3" "			\
863 			""#namearg_4" "			\
864 			""#namearg_5" "			\
865 			";"					\
866 			"keys " keysarg ";"			\
867 			"file " __FILE__ ";"		\
868 			"line " TNF_STRINGVALUE(__LINE__) ";" \
869 			detail,					\
870 		tnf_v_##namearg##_info,					\
871 		sizeof (struct tnf_v_buf_5)			\
872 	};							\
873 	tnf_probe_control_t	*tnf_v_probe_p = &tnf_v_##namearg##_probe; \
874 	tnf_probe_test_func_t	tnf_v_probe_test = tnf_v_probe_p->test_func; \
875 	tnf_probe_setup_t	tnf_v_set_p;			\
876 	struct tnf_v_buf_5	*tnf_v_probe_buffer;		\
877 								\
878 	if (tnf_v_probe_test) {					\
879 		tnf_v_probe_buffer = (struct tnf_v_buf_5 *)	\
880 		    tnf_v_probe_test(0, tnf_v_probe_p, &tnf_v_set_p); \
881 		if (tnf_v_probe_buffer) {			\
882 		    tnf_v_probe_buffer->data_1 = type_1(	\
883 			tnf_v_set_p.tpd_p, valarg_1,		\
884 			(tnf_record_p) &(tnf_v_probe_buffer->data_1)); \
885 		    tnf_v_probe_buffer->data_2 = type_2(	\
886 			tnf_v_set_p.tpd_p, valarg_2,		\
887 			(tnf_record_p) &(tnf_v_probe_buffer->data_2)); \
888 		    tnf_v_probe_buffer->data_3 = type_3(	\
889 			tnf_v_set_p.tpd_p, valarg_3,		\
890 			(tnf_record_p) &(tnf_v_probe_buffer->data_3)); \
891 		    tnf_v_probe_buffer->data_4 = type_4(	\
892 			tnf_v_set_p.tpd_p, valarg_4,		\
893 			(tnf_record_p) &(tnf_v_probe_buffer->data_4)); \
894 		    tnf_v_probe_buffer->data_5 = type_5(	\
895 			tnf_v_set_p.tpd_p, valarg_5,		\
896 			(tnf_record_p) &(tnf_v_probe_buffer->data_5)); \
897 		    (tnf_v_probe_p->probe_func)(&tnf_v_set_p);	\
898 		}						\
899 	}							\
900 }
901 
902 #endif /* NPROBE */
903 
904 /*
905  * Debug Probe Macros (contain an additional "debug" attribute)
906  */
907 
908 #if defined(TNF_DEBUG)
909 
910 /* CSTYLED */
911 #define	TNF_PROBE_0_DEBUG(namearg, keysarg, detail)	TNF_PROBE_0(namearg, keysarg, "debug;" detail)
912 
913 #else
914 
915 /* CSTYLED */
916 #define	TNF_PROBE_0_DEBUG(namearg, keysarg, detail) \
917 		((void)0)
918 
919 #endif /* defined(TNF_DEBUG) */
920 
921 #if defined(TNF_DEBUG)
922 
923 /* CSTYLED */
924 #define	TNF_PROBE_1_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1)	TNF_PROBE_1(namearg, keysarg, "debug;" detail, type_1, namearg_1, valarg_1)
925 
926 #else
927 
928 /* CSTYLED */
929 #define	TNF_PROBE_1_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1) \
930 		((void)0)
931 
932 #endif /* defined(TNF_DEBUG) */
933 
934 #if defined(TNF_DEBUG)
935 
936 /* CSTYLED */
937 #define	TNF_PROBE_2_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2)	TNF_PROBE_2(namearg, keysarg, "debug;" detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2)
938 
939 #else
940 
941 /* CSTYLED */
942 #define	TNF_PROBE_2_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2) \
943 		((void)0)
944 
945 #endif /* defined(TNF_DEBUG) */
946 
947 #if defined(TNF_DEBUG)
948 
949 /* CSTYLED */
950 #define	TNF_PROBE_3_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3)	TNF_PROBE_3(namearg, keysarg, "debug;" detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3)
951 
952 #else
953 
954 /* CSTYLED */
955 #define	TNF_PROBE_3_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3) \
956 		((void)0)
957 
958 #endif /* defined(TNF_DEBUG) */
959 
960 #if defined(TNF_DEBUG)
961 
962 /* CSTYLED */
963 #define	TNF_PROBE_4_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4)	TNF_PROBE_4(namearg, keysarg, "debug;" detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4)
964 
965 #else
966 
967 /* CSTYLED */
968 #define	TNF_PROBE_4_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4) \
969 		((void)0)
970 
971 #endif /* defined(TNF_DEBUG) */
972 
973 #if defined(TNF_DEBUG)
974 
975 /* CSTYLED */
976 #define	TNF_PROBE_5_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4, type_5, namearg_5, valarg_5)	TNF_PROBE_5(namearg, keysarg, "debug;" detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4, type_5, namearg_5, valarg_5)
977 
978 #else
979 
980 /* CSTYLED */
981 #define	TNF_PROBE_5_DEBUG(namearg, keysarg, detail, type_1, namearg_1, valarg_1, type_2, namearg_2, valarg_2, type_3, namearg_3, valarg_3, type_4, namearg_4, valarg_4, type_5, namearg_5, valarg_5) \
982 		((void)0)
983 
984 #endif /* defined(TNF_DEBUG) */
985 
986 #ifdef __cplusplus
987 }
988 #endif
989 
990 #endif /* _SYS_TNF_PROBE_H */
991