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 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #ifndef DEBUG 29 #define NDEBUG 1 30 #endif 31 32 #include <stdlib.h> 33 #include <string.h> 34 #include <tnf/com.h> 35 #include <tnf/writer.h> 36 #include <tnf/probe.h> 37 #include <assert.h> 38 39 #include "tnf_types.h" 40 #include "tnf_trace.h" 41 42 #ifdef TNFWB_DEBUG 43 #ifdef _KERNEL 44 #error TNFWB_DEBUG 45 #else /* _KERNEL */ 46 #include <stdio.h> 47 #include <thread.h> 48 #endif /* _KERNEL */ 49 #endif /* TNFW_DEBUG */ 50 51 52 /* 53 * Defines 54 */ 55 56 #ifdef _KERNEL 57 #define TNF_ASSERT(expr) ASSERT(expr) 58 #else 59 #define TNF_ASSERT(expr) assert(expr) 60 #endif 61 62 /* 63 * New properties need for tracing 64 */ 65 66 static tnf_tag_data_t **derived_tagarg_properties[] = { 67 &TAG_DATA(tnf_derived), 68 &TAG_DATA(tnf_tag_arg), 69 0 70 }; 71 72 static tnf_tag_data_t ***derived_tagarg_properties_ptr = 73 derived_tagarg_properties; 74 75 /* 76 * New derived types for probes 77 */ 78 79 TNF_STD_DERIVED_TAG(tnf_probe_event, tnf_tag, 80 derived_tagarg_properties_ptr, TNF_OPAQUE); 81 82 TNF_STD_DERIVED_TAG(tnf_time_base, tnf_int64, 83 tnf_derived_properties, TNF_INT64); 84 85 TNF_STD_DERIVED_TAG(tnf_time_delta, tnf_uint32, 86 tnf_derived_properties, TNF_UINT32); 87 88 TNF_STD_DERIVED_TAG(tnf_pid, tnf_int32, 89 tnf_derived_properties, TNF_INT32); 90 91 TNF_STD_DERIVED_TAG(tnf_lwpid, tnf_uint32, 92 tnf_derived_properties, TNF_UINT32); 93 94 /* 95 * Schedule records -CAUTION- keep in sync with tnf_internal.h 96 * Note that tnf_schedule_prototype_t has different sizes for 97 * kernel and user. 98 */ 99 100 static char *user_schedule_slot_names[] = { 101 TNF_N_TAG, 102 TNF_N_TID, 103 TNF_N_LWPID, 104 TNF_N_PID, 105 TNF_N_TIME_BASE, 106 0}; 107 108 static tnf_tag_data_t **user_schedule_slots[] = { 109 &TAG_DATA(tnf_tag), /* tag */ 110 &TAG_DATA(tnf_uint32), /* tid XXX */ 111 &TAG_DATA(tnf_lwpid), /* lwpid */ 112 &TAG_DATA(tnf_pid), /* pid */ 113 &TAG_DATA(tnf_time_base), /* time_base */ 114 0}; 115 116 TNF_STD_STRUCT_TAG(tnf_sched_rec, 117 user_schedule_slots, 118 user_schedule_slot_names, 119 sizeof (tnf_schedule_prototype_t)); 120 121 /* 122 * Probe type record (metatag) 123 */ 124 125 static tnf_tag_data_t **probe_type_slots[] = { 126 &TAG_DATA(tnf_tag), 127 &TAG_DATA(tnf_name), 128 &TAG_DATA(tnf_properties), 129 &TAG_DATA(tnf_slot_types), 130 &TAG_DATA(tnf_type_size), 131 &TAG_DATA(tnf_slot_names), 132 &TAG_DATA(tnf_string), /* detail */ 133 0}; 134 135 TNF_STRUCT_TAG(tnf_probe_type, 136 tnf_type_properties, 137 probe_type_slots, 138 0, 139 sizeof (tnf_probe_prototype_t)); 140 141 /* 142 * export all tags 143 */ 144 145 TAG_EXPORT(tnf_probe_event); 146 TAG_EXPORT(tnf_time_base); 147 TAG_EXPORT(tnf_time_delta); 148 TAG_EXPORT(tnf_pid); 149 TAG_EXPORT(tnf_lwpid); 150 151 TAG_EXPORT(tnf_sched_rec); 152 TAG_EXPORT(tnf_probe_type); 153 154 /* 155 * Write a schedule record 156 * Can only be written in reusable data space. 157 */ 158 159 tnf_record_p 160 tnf_schedule_write(tnf_ops_t *ops, tnf_schedule_t *sched) 161 { 162 tnf_tag_data_t *metatag_data; 163 tnf_record_p metatag_index; 164 tnf_schedule_prototype_t *buffer; 165 166 #ifdef _TNF_VERBOSE 167 fprintf(stderr, "tnf_schedule_write: \n"); 168 #endif 169 /* Cannot be called when writing into tag space */ 170 TNF_ASSERT(ops->mode == TNF_ALLOC_REUSABLE); 171 ALLOC(ops, sizeof (*buffer), buffer, sched->record_p, ops->mode); 172 173 metatag_data = TAG_DATA(tnf_sched_rec); 174 175 metatag_index = metatag_data->tag_index ? 176 metatag_data->tag_index : 177 metatag_data->tag_desc(ops, metatag_data); 178 179 ASSIGN(buffer, tag, metatag_index); 180 /* LINTED - tid is 32 bits */ 181 ASSIGN2(buffer, tid, sched->tid, uint32); 182 /* LINTED - lwpid is 32 bits */ 183 ASSIGN(buffer, lwpid, sched->lwpid); 184 /* LINTED - pid is 32 bits */ 185 ASSIGN(buffer, pid, sched->pid); 186 ASSIGN(buffer, time_base, sched->time_base); 187 188 /* 189 * Remember schedule record generation number so the distance 190 * in virtual space can be calculated from an event record 191 */ 192 sched->record_gen = ((tnf_block_header_t *) 193 ((uintptr_t)buffer & TNF_BLOCK_MASK))->generation; 194 /* Cannot have been written into tag space */ 195 TNF_ASSERT(sched->record_gen != TNF_TAG_GENERATION_NUM); 196 197 return ((tnf_record_p) buffer); 198 } 199