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 #ifdef _KERNEL
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/ddi.h> /* strchr */
33 #include <sys/sunddi.h> /* strchr */
34 #include <sys/tnf_com.h>
35 #include <sys/tnf_writer.h>
36 #include <sys/tnf_probe.h> /* fixed tnf_probe_control_t->index problem */
37 #include "tnf_types.h"
38 #include "tnf_trace.h"
39 #else /* _KERNEL */
40 #include <stdlib.h>
41 #include <string.h>
42 #include <tnf/com.h>
43 #include <tnf/writer.h>
44 #include <tnf/probe.h>
45 #include "tnf_types.h"
46 #include <tnf_trace.h>
47 #endif /* _KERNEL */
48
49
50 /*
51 * Defines
52 */
53
54 #define NAME_LIMIT 128
55 #define ARRAY_LIMIT 5
56 #define NAME_START 5
57 #define SLOT_OFFSET 7
58 #define CONST_SLOTS 2
59
60 /*
61 * probe version 1
62 */
63
64 struct tnf_probe_version __tnf_probe_version_1_info = {
65 sizeof (struct tnf_probe_version),
66 sizeof (tnf_probe_control_t)
67 };
68
69 /*
70 * write instances of tnf_probe_type (i.e probe records)
71 */
72
73 uintptr_t
tnf_probe_tag(tnf_ops_t * ops,tnf_probe_control_t * probe_p)74 tnf_probe_tag(tnf_ops_t *ops, tnf_probe_control_t *probe_p)
75 {
76 tnf_tag_data_t *metatag_data;
77 tnf_record_p metatag_index;
78 tnf_probe_prototype_t *buffer;
79 enum tnf_alloc_mode saved_mode;
80 tnf_uint32_t *fwp;
81 char probe_name[NAME_LIMIT];
82 char slot_array[ARRAY_LIMIT][NAME_LIMIT];
83 char *slot_args[ARRAY_LIMIT + CONST_SLOTS + 1];
84 const char *nm_start, *nm_end, *slot_start, *slot_end;
85 int nm_len, separator, count;
86
87 saved_mode = ops->mode;
88 ops->mode = TNF_ALLOC_FIXED;
89 #if defined(_LP64)
90 /* LINTED assignment of 32-bit integer to 8-bit integer */
91 ALLOC2(ops, sizeof (*buffer), buffer, saved_mode);
92 #else
93 ALLOC2(ops, sizeof (*buffer), buffer, saved_mode);
94 #endif
95 probe_p->index = (uintptr_t)buffer;
96 fwp = tnfw_b_fw_alloc(&(ops->wcb));
97 if (fwp) {
98 /* REMIND: can make the next call more efficient */
99 *fwp = tnf_ref32(ops, (tnf_record_p) buffer,
100 (tnf_record_p)fwp);
101 /* fwp - filestart < 64K */
102 #ifdef _KERNEL
103 probe_p->index = (char *)fwp - tnf_buf;
104 #else
105 probe_p->index = (char *)fwp - _tnfw_b_control->tnf_buffer;
106 #endif
107 probe_p->index |= TNF_TAG16_T_ABS;
108 probe_p->index = probe_p->index << PROBE_INDEX_SHIFT;
109 probe_p->index |= PROBE_INDEX_FILE_PTR;
110 }
111
112 metatag_data = TAG_DATA(tnf_probe_type);
113 metatag_index = metatag_data->tag_index ?
114 metatag_data->tag_index :
115 metatag_data->tag_desc(ops, metatag_data);
116
117 /* find the name of the probe */
118 nm_start = &(probe_p->attrs[NAME_START]);
119 separator = ATTR_SEPARATOR;
120 nm_end = strchr(probe_p->attrs, separator);
121 #if defined(_LP64)
122 /* LINTED assignment of 64-bit integer to 32-bit integer */
123 nm_len = nm_end - nm_start;
124 #else
125 nm_len = nm_end - nm_start;
126 #endif
127 slot_start = nm_end + SLOT_OFFSET;
128 nm_len = (nm_len > (NAME_LIMIT - 1)) ? (NAME_LIMIT - 1) : nm_len;
129 (void) strncpy(probe_name, nm_start, nm_len);
130 probe_name[nm_len] = '\0';
131
132 /* initialize constant part of slot names */
133 slot_args[0] = TNF_N_TAG;
134 slot_args[1] = TNF_N_TIME_DELTA;
135
136 /*
137 * initialize rest of slot names, if any. This parsing routine is
138 * dependant on a space after "slots" (even for TNF_PROBE_0 and a
139 * space after the last slot name. It truncates any values that
140 * are larger than 127 chars to 127 chars. It handles missing slot
141 * names.
142 */
143 separator = ATTR_SEPARATOR;
144 slot_end = strchr(slot_start, separator);
145 nm_start = slot_start;
146 separator = VAL_SEPARATOR;
147 for (count = 0; nm_start < slot_end; count++) {
148 nm_end = strchr(nm_start, separator);
149 #if defined(_LP64)
150 /* LINTED assignment of 64-bit integer to 32-bit integer */
151 nm_len = nm_end - nm_start;
152 #else
153 nm_len = nm_end - nm_start;
154 #endif
155 nm_len = (nm_len > (NAME_LIMIT - 1)) ? (NAME_LIMIT - 1) :
156 nm_len;
157 (void) strncpy(slot_array[count], nm_start, nm_len);
158 slot_array[count][nm_len] = '\0';
159 slot_args[count+CONST_SLOTS] = slot_array[count];
160 /* get next name */
161 nm_start = nm_end + 1;
162 }
163 /* null terminate string vector */
164 slot_args[count+CONST_SLOTS] = NULL;
165
166 ASSIGN(buffer, tag, metatag_index);
167 ASSIGN(buffer, name, probe_name);
168 /* XXX Fix these properties sometime */
169 ASSIGN(buffer, properties, &tnf_struct_properties);
170 ASSIGN(buffer, slot_types, probe_p->slot_types);
171 #if defined(_LP64)
172 /* LINTED */
173 ASSIGN(buffer, type_size, probe_p->tnf_event_size);
174 #else
175 ASSIGN(buffer, type_size, probe_p->tnf_event_size);
176 #endif
177 ASSIGN(buffer, slot_names, slot_args);
178 ASSIGN(buffer, string, (slot_end + 1));
179 #if defined(_LP64)
180 /* supress lint warning for _KERNEL mode, really need this? */
181 /* LINTED assignment of 32-bit integer to 8-bit integer */
182 ops->mode = saved_mode;
183 #else
184 ops->mode = saved_mode;
185 #endif
186 return (probe_p->index);
187 }
188