common/tnf/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 1994, 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#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>
#include <sys/debug.h>

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

/*
 * New derived types for probes
 */

TNF_STD_DERIVED_TAG(tnf_probe_event, tnf_tag,
        tnf_derived_properties, 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);

TNF_STD_DERIVED_TAG(tnf_kthread_id, tnf_opaque,
        tnf_derived_properties, TNF_OPAQUE);

TNF_STD_DERIVED_TAG(tnf_cpuid, tnf_int32,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_device, tnf_ulong,
        tnf_derived_properties, TNF_ULONG);

TNF_STD_DERIVED_TAG(tnf_symbol, tnf_opaque,
        tnf_derived_properties, TNF_OPAQUE);

TNF_STD_ARRAY_TAG(tnf_symbols, tnf_symbol, TNF_ARRAY);

TNF_STD_DERIVED_TAG(tnf_sysnum, tnf_int16,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_microstate, tnf_int32,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_offset, tnf_int64,
        tnf_derived_properties, TNF_INT64);

TNF_STD_DERIVED_TAG(tnf_fault_type, tnf_int32,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_seg_access, tnf_int32,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_bioflags, tnf_int32,
        tnf_derived_properties, TNF_INT32);

TNF_STD_DERIVED_TAG(tnf_diskaddr, tnf_int64,
        tnf_derived_properties, TNF_INT64);

static char *kernel_schedule_slot_names[] = {
    TNF_N_TAG,
    TNF_N_TID,
    TNF_N_LWPID,
    TNF_N_PID,
    TNF_N_TIME_BASE,
    "cpuid",        /* XXX */
    0};

static tnf_tag_data_t   **kernel_schedule_slots[] = {
    &TAG_DATA(tnf_tag),
    &TAG_DATA(tnf_kthread_id),
    &TAG_DATA(tnf_lwpid),
    &TAG_DATA(tnf_pid),
    &TAG_DATA(tnf_time_base),
    &TAG_DATA(tnf_cpuid),
    0};

TNF_STD_STRUCT_TAG(tnf_kernel_schedule,
        kernel_schedule_slots,
        kernel_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_METATAG(tnf_probe_type, tnf_type_properties,
    probe_type_slots, tnf_struct_tag_1);

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

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

    t = curthread;

    /* Cannot be called when writing into tag space */
    ASSERT(ops->mode == TNF_ALLOC_REUSABLE);

    ALLOC(ops, sizeof (*buffer), buffer, sched->record_p,
        TNF_ALLOC_REUSABLE); /* XXX see comment above */

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

    ASSIGN(buffer,  tag,        metatag_index);
    ASSIGN2(buffer, tid,        t,      kthread_id);
    ASSIGN(buffer,  lwpid,      t->t_tid);
    ASSIGN(buffer,  pid,        ttoproc(t)->p_pid);
    ASSIGN(buffer,  time_base,  sched->time_base);
    ASSIGN(buffer,  cpuid,      sched->cpuid);

    /*
     * 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 */
    ASSERT(sched->record_gen != TNF_TAG_GENERATION_NUM);

    return ((tnf_record_p)buffer);
}

/*
 * Array of addresses and derivatives
 */

tnf_reference_t
tnf_opaque_array_1(tnf_ops_t *ops, tnf_opaque_t *opaques,
    tnf_record_p reference, tnf_tag_data_t *tag_data)
{
    tnf_record_p    tag_index;
    size_t      record_size;
    tnf_opaque_t    *tmp;
    tnf_opaque_t    *ref_p;
    tnf_array_header_t  *bufhdr;

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

    if (!opaques)
        return (TNF_NULL);

    record_size = sizeof (*bufhdr);
    tmp = opaques;
    while (*tmp++)
        record_size += sizeof (*ref_p);

    ALLOC2(ops, record_size, bufhdr, ops->mode);

    ASSIGN(bufhdr, tag,         tag_index);
    /* LINTED assignment of 64-bit integer to 32-bit integer */
    ASSIGN(bufhdr, self_size,   record_size);

    tmp = opaques;
    /* LINTED pointer cast may result in improper alignment */
    ref_p = (tnf_opaque_t *)((char *)bufhdr + sizeof (*bufhdr));
    while (*tmp) {
        *ref_p = tnf_opaque(ops, *tmp, (tnf_reference_t *)ref_p);
        tmp++;
        ref_p++;
    }

    return (tnf_ref32(ops, (tnf_record_p) bufhdr, reference));
}

#ifdef __sparc

tnf_reference_t
tnf_opaque32_array_1(tnf_ops_t *ops, tnf_uint32_t *opaques,
    tnf_record_p reference, tnf_tag_data_t *tag_data)
{
    tnf_record_p    tag_index;
    size_t      record_size;
    tnf_uint32_t    *tmp;
    tnf_uint32_t    *ref_p;
    tnf_array_header_t  *bufhdr;

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

    if (!opaques)
        return (TNF_NULL);

    record_size = sizeof (*bufhdr);
    tmp = opaques;
    while (*tmp++)
        record_size += sizeof (*ref_p);

    ALLOC2(ops, record_size, bufhdr, ops->mode);

    ASSIGN(bufhdr, tag,         tag_index);
    /* LINTED assignment of 64-bit integer to 32-bit integer */
    ASSIGN(bufhdr, self_size,   record_size);

    tmp = opaques;
    /* LINTED pointer cast may result in improper alignment */
    ref_p = (tnf_uint32_t *)((char *)bufhdr + sizeof (*bufhdr));
    while (*tmp) {
        *ref_p = tnf_uint32(ops, *tmp, (tnf_reference_t *)ref_p);
        tmp++;
        ref_p++;
    }

    return (tnf_ref32(ops, (tnf_record_p) bufhdr, reference));
}

#endif /* __sparc */

/*
 * Tag initializer
 */

void
tnf_tag_trace_init(void)
{

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

    TAG_SNAP(tnf_kthread_id);
    TAG_SNAP(tnf_cpuid);
    TAG_SNAP(tnf_device);
    TAG_SNAP(tnf_symbol);
    TAG_SNAP(tnf_symbols);
    TAG_SNAP(tnf_sysnum);
    TAG_SNAP(tnf_microstate);
    TAG_SNAP(tnf_offset);
    TAG_SNAP(tnf_fault_type);
    TAG_SNAP(tnf_seg_access);
    TAG_SNAP(tnf_bioflags);
    TAG_SNAP(tnf_diskaddr);
    TAG_SNAP(tnf_kernel_schedule);

    TAG_SNAP(tnf_probe_type);

}