usr/src/lib/libtnfprobe/tnf_trace.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 *	Copyright (c) 1994, by Sun Microsytems, Inc.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#ifndef DEBUG
#define	NDEBUG	1
#endif

#include <stdlib.h>
#include <string.h>
#include <tnf/com.h>
#include <tnf/writer.h>
#include <tnf/probe.h>
#include <assert.h>

#include "tnf_types.h"
#include "tnf_trace.h"

#ifdef TNFWB_DEBUG
#ifdef _KERNEL
#error TNFWB_DEBUG
#else  /* _KERNEL */
#include <stdio.h>
#include <thread.h>
#endif /* _KERNEL */
#endif /* TNFW_DEBUG */


/*
 * Defines
 */

#ifdef _KERNEL
#define	TNF_ASSERT(expr)	ASSERT(expr)
#else
#define	TNF_ASSERT(expr)	assert(expr)
#endif

/*
 * New properties need for tracing
 */

static tnf_tag_data_t	**derived_tagarg_properties[] = {
	&TAG_DATA(tnf_derived),
	&TAG_DATA(tnf_tag_arg),
	0
};

static tnf_tag_data_t	***derived_tagarg_properties_ptr =
					derived_tagarg_properties;

/*
 * New derived types for probes
 */

TNF_STD_DERIVED_TAG(tnf_probe_event, tnf_tag,
		derived_tagarg_properties_ptr, TNF_OPAQUE);

TNF_STD_DERIVED_TAG(tnf_time_base, tnf_int64,
		tnf_derived_properties, TNF_INT64);

TNF_STD_DERIVED_TAG(tnf_time_delta, tnf_uint32,
		tnf_derived_properties, TNF_UINT32);

TNF_STD_DERIVED_TAG(tnf_pid, tnf_int32,
		tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_lwpid, tnf_uint32,
		tnf_derived_properties, TNF_UINT32);

/*
 * Schedule records -CAUTION- keep in sync with tnf_internal.h
 * Note that tnf_schedule_prototype_t has different sizes for
 * kernel and user.
 */

static char	*user_schedule_slot_names[] = {
	TNF_N_TAG,
	TNF_N_TID,
	TNF_N_LWPID,
	TNF_N_PID,
	TNF_N_TIME_BASE,
	0};

static tnf_tag_data_t	**user_schedule_slots[] = {
	&TAG_DATA(tnf_tag),		/* tag			*/
	&TAG_DATA(tnf_uint32),		/* tid XXX		*/
	&TAG_DATA(tnf_lwpid),		/* lwpid 		*/
	&TAG_DATA(tnf_pid),		/* pid 			*/
	&TAG_DATA(tnf_time_base),	/* time_base 		*/
	0};

TNF_STD_STRUCT_TAG(tnf_sched_rec,
		user_schedule_slots,
		user_schedule_slot_names,
		sizeof (tnf_schedule_prototype_t));

/*
 * Probe type record (metatag)
 */

static tnf_tag_data_t	**probe_type_slots[] = {
	&TAG_DATA(tnf_tag),
	&TAG_DATA(tnf_name),
	&TAG_DATA(tnf_properties),
	&TAG_DATA(tnf_slot_types),
	&TAG_DATA(tnf_type_size),
	&TAG_DATA(tnf_slot_names),
	&TAG_DATA(tnf_string),  	/* detail */
	0};

TNF_STRUCT_TAG(tnf_probe_type,
		tnf_type_properties,
		probe_type_slots,
		0,
		sizeof (tnf_probe_prototype_t));

/*
 * export all tags
 */

TAG_EXPORT(tnf_probe_event);
TAG_EXPORT(tnf_time_base);
TAG_EXPORT(tnf_time_delta);
TAG_EXPORT(tnf_pid);
TAG_EXPORT(tnf_lwpid);

TAG_EXPORT(tnf_sched_rec);
TAG_EXPORT(tnf_probe_type);

/*
 * Write a schedule record
 * Can only be written in reusable data space.
 */

tnf_record_p
tnf_schedule_write(tnf_ops_t *ops, tnf_schedule_t *sched)
{
	tnf_tag_data_t *metatag_data;
	tnf_record_p metatag_index;
	tnf_schedule_prototype_t *buffer;

#ifdef _TNF_VERBOSE
	fprintf(stderr, "tnf_schedule_write: \n");
#endif
	/* Cannot be called when writing into tag space */
	TNF_ASSERT(ops->mode == TNF_ALLOC_REUSABLE);
	ALLOC(ops, sizeof (*buffer), buffer, sched->record_p, ops->mode);

	metatag_data = TAG_DATA(tnf_sched_rec);

	metatag_index = metatag_data->tag_index ?
		metatag_data->tag_index :
		metatag_data->tag_desc(ops, metatag_data);

	ASSIGN(buffer,	tag, 		metatag_index);
	/* LINTED - tid is 32 bits */
	ASSIGN2(buffer, tid, 		sched->tid,		uint32);
	/* LINTED - lwpid is 32 bits */
	ASSIGN(buffer,	lwpid, 		sched->lwpid);
	/* LINTED - pid is 32 bits */
	ASSIGN(buffer,	pid, 		sched->pid);
	ASSIGN(buffer,	time_base, 	sched->time_base);

	/*
	 * Remember schedule record generation number so the distance
	 * in virtual space can be calculated from an event record
	 */
	sched->record_gen = ((tnf_block_header_t *)
	    ((uintptr_t)buffer & TNF_BLOCK_MASK))->generation;
	/* Cannot have been written into tag space */
	TNF_ASSERT(sched->record_gen != TNF_TAG_GENERATION_NUM);

	return ((tnf_record_p) buffer);
}