OpenSolaris_b135/uts/common/tnf/tnf_probe.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"

#ifdef _KERNEL
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/ddi.h>		/* strchr */
#include <sys/sunddi.h>		/* strchr */
#include <sys/tnf_com.h>
#include <sys/tnf_writer.h>
#include <sys/tnf_probe.h> /* fixed tnf_probe_control_t->index problem */
#include "tnf_types.h"
#include "tnf_trace.h"
#else  /* _KERNEL */
#include <stdlib.h>
#include <string.h>
#include <tnf/com.h>
#include <tnf/writer.h>
#include <tnf/probe.h>
#include "tnf_types.h"
#include <tnf_trace.h>
#endif	/* _KERNEL */


/*
 * Defines
 */

#define	NAME_LIMIT	128
#define	ARRAY_LIMIT	5
#define	NAME_START	5
#define	SLOT_OFFSET	7
#define	CONST_SLOTS	2

/*
 * probe version 1
 */

struct tnf_probe_version  __tnf_probe_version_1_info =  {
	sizeof (struct tnf_probe_version),
	sizeof (tnf_probe_control_t)
};

/*
 * write instances of tnf_probe_type (i.e probe records)
 */

uintptr_t
tnf_probe_tag(tnf_ops_t *ops, tnf_probe_control_t *probe_p)
{
	tnf_tag_data_t		*metatag_data;
	tnf_record_p		metatag_index;
	tnf_probe_prototype_t 	*buffer;
	enum tnf_alloc_mode	saved_mode;
	tnf_uint32_t		*fwp;
	char			probe_name[NAME_LIMIT];
	char			slot_array[ARRAY_LIMIT][NAME_LIMIT];
	char			*slot_args[ARRAY_LIMIT + CONST_SLOTS + 1];
	const char		*nm_start, *nm_end, *slot_start, *slot_end;
	int			nm_len, separator, count;

	saved_mode = ops->mode;
	ops->mode = TNF_ALLOC_FIXED;
#if defined(_LP64)
	/* LINTED assignment of 32-bit integer to 8-bit integer */
	ALLOC2(ops, sizeof (*buffer), buffer, saved_mode);
#else
	ALLOC2(ops, sizeof (*buffer), buffer, saved_mode);
#endif
	probe_p->index = (uintptr_t)buffer;
	fwp = tnfw_b_fw_alloc(&(ops->wcb));
	if (fwp) {
		/* REMIND: can make the next call more efficient */
		*fwp = tnf_ref32(ops, (tnf_record_p) buffer,
						(tnf_record_p)fwp);
		/* fwp - filestart < 64K */
#ifdef _KERNEL
		probe_p->index = (char *)fwp - tnf_buf;
#else
		probe_p->index = (char *)fwp - _tnfw_b_control->tnf_buffer;
#endif
		probe_p->index |= TNF_TAG16_T_ABS;
		probe_p->index = probe_p->index << PROBE_INDEX_SHIFT;
		probe_p->index |= PROBE_INDEX_FILE_PTR;
	}

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

	/* find the name of the probe */
	nm_start = &(probe_p->attrs[NAME_START]);
	separator = ATTR_SEPARATOR;
	nm_end = strchr(probe_p->attrs, separator);
#if defined(_LP64)
	/* LINTED assignment of 64-bit integer to 32-bit integer */
	nm_len = nm_end - nm_start;
#else
	nm_len = nm_end - nm_start;
#endif
	slot_start = nm_end + SLOT_OFFSET;
	nm_len = (nm_len > (NAME_LIMIT - 1)) ? (NAME_LIMIT - 1) : nm_len;
	(void) strncpy(probe_name, nm_start, nm_len);
	probe_name[nm_len] = '\0';

	/* initialize constant part of slot names */
	slot_args[0] = TNF_N_TAG;
	slot_args[1] = TNF_N_TIME_DELTA;

	/*
	 * initialize rest of slot names, if any. This parsing routine is
	 * dependant on a space after "slots" (even for TNF_PROBE_0 and a
	 * space after the last slot name.  It truncates any values that
	 * are larger than 127 chars to 127 chars.  It handles missing slot
	 * names.
	 */
	separator = ATTR_SEPARATOR;
	slot_end = strchr(slot_start, separator);
	nm_start = slot_start;
	separator = VAL_SEPARATOR;
	for (count = 0; nm_start < slot_end; count++) {
		nm_end = strchr(nm_start, separator);
#if defined(_LP64)
		/* LINTED assignment of 64-bit integer to 32-bit integer */
		nm_len = nm_end - nm_start;
#else
		nm_len = nm_end - nm_start;
#endif
		nm_len = (nm_len > (NAME_LIMIT - 1)) ? (NAME_LIMIT - 1) :
							nm_len;
		(void) strncpy(slot_array[count], nm_start, nm_len);
		slot_array[count][nm_len] = '\0';
		slot_args[count+CONST_SLOTS] = slot_array[count];
		/* get next name */
		nm_start = nm_end + 1;
	}
	/* null terminate string vector */
	slot_args[count+CONST_SLOTS] = NULL;

	ASSIGN(buffer, tag, 		metatag_index);
	ASSIGN(buffer, name, 		probe_name);
	/* XXX Fix these properties sometime */
	ASSIGN(buffer, properties, 	&tnf_struct_properties);
	ASSIGN(buffer, slot_types,	probe_p->slot_types);
#if defined(_LP64)
	/* LINTED */
	ASSIGN(buffer, type_size,	probe_p->tnf_event_size);
#else
	ASSIGN(buffer, type_size,	probe_p->tnf_event_size);
#endif
	ASSIGN(buffer, slot_names,	slot_args);
	ASSIGN(buffer, string,		(slot_end + 1));
#if defined(_LP64)
	/* supress lint warning for _KERNEL mode, really need this? */
	/* LINTED assignment of 32-bit integer to 8-bit integer */
	ops->mode = saved_mode;
#else
	ops->mode = saved_mode;
#endif
	return (probe_p->index);
}