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 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <unistd.h>
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <libintl.h>
33 #include <unistd.h>
34 #include <string.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <kvm.h>
38 #include <fcntl.h>
39 #include <sys/mman.h>
40 #include <sys/tnf.h>
41 #include <sys/tnf_com.h>
42 #include <nlist.h>
43 #include <errno.h>
44
45 #define TNFDEV "/dev/tnfmap"
46
47 #define MAXFWTRY 5
48
49 typedef struct {
50 boolean_t ever_read;
51 tnf_uint32_t generation;
52 tnf_uint16_t bytes_valid;
53 } BLOCK_STATUS;
54
55 static char *dumpfile; /* Dump file if extracting from crashdump */
56 static char *namelist; /* Symbol tbl. if extracting from crashdump */
57 static kvm_t *kvm_p; /* Handle for kvm_open, kvm_read, ... */
58
59 static struct nlist kvm_syms[] = {
60 { "tnf_buf" },
61 { "tnf_trace_file_size" },
62 { NULL }
63 };
64
65 static uintptr_t dump_bufaddr;
66 static size_t tnf_bufsize;
67 static char *program_name;
68 static int input_fd;
69 static int output_fd;
70 static tnf_file_header_t *tnf_header;
71
72 /*
73 * usage() - gives a description of the arguments, and exits
74 */
75
76 static void
77 usage(char *argv[], const char *msg)
78 {
79 if (msg)
80 (void) fprintf(stderr,
81 gettext("%s: %s\n"), argv[0], msg);
82
83 (void) fprintf(stderr, gettext(
84 "usage: %s [-d <dumpfile> -n <symbolfile> ] "
85 "<output-filename>\n"), argv[0]);
86 exit(1);
87 } /* end usage */
88
89
90 /*
91 * Write 'size' bytes at offset 'offset' from 'addr'
92 * to the output file. Bail out unceremoniously if anything goes wrong.
93 */
94 static void
95 writeout(char *addr, int offset, int size)
96
97 {
98 if (lseek(output_fd, offset, SEEK_SET) < 0) {
99 perror("lseek");
100 exit(1);
101 }
102 if (write(output_fd, addr, size) != size) {
103 perror("write");
104 exit(1);
105 }
106 }
107
108
109 static void
110 dumpfile_init()
111
112 {
113 kvm_p = kvm_open(namelist, dumpfile, NULL, O_RDONLY, program_name);
114 if (kvm_p == NULL) {
115 /* kvm_open prints an error message */
116 exit(1);
117 }
118 if (kvm_nlist(kvm_p, kvm_syms) != 0) {
119 (void) fprintf(stderr, gettext(
120 "Symbol lookup error in %s\n"), namelist);
121 exit(1);
122 }
123 if (kvm_read(kvm_p, kvm_syms[0].n_value, (char *) &dump_bufaddr,
124 sizeof (dump_bufaddr)) != sizeof (dump_bufaddr) ||
125 kvm_read(kvm_p, kvm_syms[1].n_value, (char *) &tnf_bufsize,
126 sizeof (tnf_bufsize)) != sizeof (tnf_bufsize)) {
127 (void) fprintf(stderr, gettext(
128 "kvm_read error in %s\n"), dumpfile);
129 exit(1);
130 }
131 if (dump_bufaddr == (uintptr_t)NULL || tnf_bufsize == 0) {
132 (void) fprintf(stderr, gettext(
133 "No trace data available in the kernel.\n"));
134 exit(1);
135 }
136 }
137
138 static void
139 live_kernel_init()
140
141 {
142 tifiocstate_t tstate;
143
144 if ((input_fd = open(TNFDEV, O_RDWR)) < 0) {
145 perror(TNFDEV);
146 exit(1);
147 }
148 if (ioctl(input_fd, TIFIOCGSTATE, &tstate) < 0) {
149 perror(gettext("Error getting trace system state"));
150 exit(1);
151 }
152 if (tstate.buffer_state != TIFIOCBUF_OK) {
153 (void) fprintf(stderr, gettext(
154 "No trace data available in the kernel.\n"));
155 exit(1);
156 }
157 tnf_bufsize = tstate.buffer_size;
158 }
159
160 static void
161 read_tnf_header(char *addr)
162
163 {
164 if (dumpfile != NULL) {
165 if (kvm_read(kvm_p, dump_bufaddr, addr, 512) != 512) {
166 (void) fprintf(stderr, gettext(
167 "Error reading tnf header from dump file.\n"));
168 exit(1);
169 }
170 } else {
171 if (ioctl(input_fd, TIFIOCGHEADER, addr) != 0) {
172 perror(gettext("Error reading tnf header from kernel"));
173 exit(1);
174 }
175 }
176 }
177
178 static int
179 read_tnf_block(tnf_block_header_t *addr, int block_num)
180
181 {
182 int offset;
183 tifiocgblock_t ioctl_arg;
184
185 if (dumpfile != NULL) {
186 offset = tnf_header->directory_size +
187 block_num * tnf_header->block_size;
188 if (kvm_read(kvm_p, dump_bufaddr + offset, (char *) addr,
189 tnf_header->block_size) != tnf_header->block_size) {
190 (void) fprintf(stderr, gettext(
191 "Error reading tnf block.\n"));
192 exit(1);
193 }
194 } else {
195 ioctl_arg.dst_addr = (char *) addr;
196 ioctl_arg.block_num = block_num;
197 if (ioctl(input_fd, TIFIOCGBLOCK, &ioctl_arg) < 0) {
198 if (errno == EBUSY)
199 return (EBUSY);
200 perror(gettext("Error reading tnf block"));
201 exit(1);
202 }
203 }
204 return (0);
205 }
206
207 static void
208 read_tnf_fwzone(tnf_ref32_t *dest, int start, int slots)
209
210 {
211 int offset;
212 int len;
213 tifiocgfw_t ioctl_arg;
214
215 if (dumpfile != NULL) {
216 /* LINTED assignment of 64-bit integer to 32-bit integer */
217 offset = tnf_header->block_size + start * sizeof (tnf_ref32_t);
218 /* LINTED assignment of 64-bit integer to 32-bit integer */
219 len = slots * sizeof (tnf_ref32_t);
220 if (kvm_read(kvm_p, dump_bufaddr + offset, (char *) dest,
221 len) != len) {
222 (void) fprintf(stderr, gettext(
223 "Error reading tnf forwarding zone.\n"));
224 exit(1);
225 }
226 } else {
227 /* LINTED pointer cast may result in improper alignment */
228 ioctl_arg.dst_addr = (long *) dest;
229 ioctl_arg.start = start;
230 ioctl_arg.slots = slots;
231 if (ioctl(input_fd, TIFIOCGFWZONE, &ioctl_arg) < 0) {
232 perror(gettext("Error reading tnf block"));
233 exit(1);
234 }
235 }
236 }
237
238 int
239 main(int argc, char *argv[])
240 {
241 const char *optstr = "d:n:";
242 const char *outfile;
243 char *local_buf;
244 int c;
245 tnf_uint32_t *magicp;
246 tnf_block_header_t *block_base, *blockp;
247 BLOCK_STATUS *block_stat, *bsp;
248 int block_num;
249 boolean_t any_unread, any_different, retry;
250 tnf_ref32_t *fwzone;
251 int fwzonesize;
252 int i;
253 int fwtries;
254 int block_count;
255
256 program_name = argv[0];
257 while ((c = getopt(argc, argv, optstr)) != EOF) {
258 switch (c) {
259 case 'd':
260 dumpfile = optarg;
261 break;
262 case 'n':
263 namelist = optarg;
264 break;
265 case '?':
266 usage(argv, gettext("unrecognized argument"));
267 }
268 }
269 if (optind != argc - 1) {
270 usage(argv, gettext("too many or too few arguments"));
271 } else {
272 outfile = argv[optind];
273 }
274 if ((dumpfile != NULL) ^ (namelist != NULL)) {
275 usage(argv, gettext("must specify both or neither of the "
276 "-d and -n options"));
277 }
278
279 output_fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0600);
280 if (output_fd < 0) {
281 perror(outfile);
282 exit(1);
283 }
284 if (dumpfile != NULL)
285 dumpfile_init();
286 else
287 live_kernel_init();
288
289 if ((local_buf = malloc(tnf_bufsize)) == NULL) {
290 (void) fprintf(stderr,
291 gettext("tnfxtract memory allocation failure\n"));
292 exit(1);
293 }
294
295 /* Read header, get block size, check for version mismatch */
296 read_tnf_header(local_buf);
297 /*LINTED pointer cast may result in improper alignment*/
298 magicp = (tnf_uint32_t *) local_buf;
299 /*LINTED pointer cast may result in improper alignment*/
300 tnf_header = (tnf_file_header_t *)(local_buf + sizeof (*magicp));
301 if (*magicp != TNF_MAGIC) {
302 (void) fprintf(stderr, gettext(
303 "Buffer is not in TNF format.\n"));
304 exit(1);
305 }
306 if (tnf_header->file_version != TNF_FILE_VERSION) {
307 (void) fprintf(stderr,
308 gettext("Version mismatch (tnfxtract: %d; buffer: %d)\n"),
309 TNF_FILE_VERSION, tnf_header->file_version);
310 exit(1);
311 }
312 writeout(local_buf, 0, tnf_header->block_size);
313 /* LINTED pointer cast may result in improper alignment */
314 block_base = (tnf_block_header_t *)
315 (local_buf + tnf_header->directory_size);
316 block_count = tnf_header->block_count -
317 tnf_header->directory_size / tnf_header->block_size;
318 fwzonesize = tnf_header->directory_size - tnf_header->block_size;
319
320 block_stat = (BLOCK_STATUS *)
321 calloc(block_count, sizeof (BLOCK_STATUS));
322 if (block_stat == NULL) {
323 (void) fprintf(stderr,
324 gettext("tnfxtract memory allocation failure\n"));
325 exit(1);
326 }
327
328 for (bsp = block_stat; bsp != block_stat + block_count; ++bsp)
329 bsp->ever_read = B_FALSE;
330 /*
331 * Make repeated passes until we've read every non-tag block.
332 */
333 do {
334 any_unread = B_FALSE;
335 bsp = block_stat;
336 block_num = 0;
337 blockp = block_base;
338 while (block_num != block_count) {
339 if (!bsp->ever_read) {
340 if (read_tnf_block(blockp, block_num) != 0)
341 any_unread = B_TRUE;
342 else {
343 bsp->ever_read = B_TRUE;
344 bsp->generation = blockp->generation;
345 bsp->bytes_valid = blockp->bytes_valid;
346 writeout((char *) blockp,
347 /* LINTED cast 64 to 32 bit */
348 (int)((char *) blockp - local_buf),
349 tnf_header->block_size);
350 }
351 }
352 ++bsp;
353 ++block_num;
354 /* LINTED pointer cast may result in improper alignment */
355 blockp = (tnf_block_header_t *)
356 ((char *) blockp + tnf_header->block_size);
357 }
358 } while (any_unread);
359
360 /*
361 * Then read tag blocks only, until we have two consecutive,
362 * consistent reads.
363 */
364 do {
365 any_different = B_FALSE;
366 bsp = block_stat;
367 block_num = 0;
368 blockp = block_base;
369 while (block_num != block_count) {
370 if (read_tnf_block(blockp, block_num) == 0 &&
371 blockp->generation == TNF_TAG_GENERATION_NUM &&
372 (bsp->generation != TNF_TAG_GENERATION_NUM ||
373 bsp->bytes_valid != blockp->bytes_valid)) {
374 bsp->generation = TNF_TAG_GENERATION_NUM;
375 bsp->bytes_valid = blockp->bytes_valid;
376 writeout((char *) blockp,
377 /* LINTED cast 64bit to 32 bit */
378 (int)((char *) blockp - local_buf),
379 tnf_header->block_size);
380 any_different = B_TRUE;
381 }
382 ++bsp;
383 ++block_num;
384 /* LINTED pointer cast may result in improper alignment */
385 blockp = (tnf_block_header_t *)
386 ((char *) blockp + tnf_header->block_size);
387 }
388 } while (any_different);
389
390 /*
391 * Then read the forwarding pointers. If any are -1:
392 * sleep briefly, then make another pass.
393 */
394 /*LINTED pointer cast may result in improper alignment*/
395 fwzone = (tnf_ref32_t *)(local_buf + tnf_header->block_size);
396
397 read_tnf_fwzone(fwzone, 0,
398 /* LINTED cast from 64-bit integer to 32-bit integer */
399 (int)(fwzonesize / sizeof (fwzone[0])));
400 fwtries = 0;
401 while (fwtries != MAXFWTRY) {
402 retry = B_FALSE;
403 for (i = 0; i != fwzonesize / sizeof (fwzone[0]); ++i) {
404 if (fwzone[i] == -1) {
405 read_tnf_fwzone(&fwzone[i], i, 1);
406 if (!retry) {
407 retry = B_TRUE;
408 ++fwtries;
409 }
410 }
411 }
412 if (!retry)
413 break;
414 sleep(2);
415 }
416 if (fwtries == MAXFWTRY) {
417 (void) fprintf(stderr, gettext(
418 "Warning: forwarding pointers may "
419 "be invalid.\n"));
420 }
421 writeout((char *) fwzone, tnf_header->block_size, fwzonesize);
422 return (0);
423 }