db_textdump.c revision 174921
1/*-
2 * Copyright (c) 2007 Robert N. M. Watson
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27/*-
28 * Kernel text-dump support: allow a series of text files to be written to
29 * the dump partition for later recovery, including captured DDB output, the
30 * kernel configuration, message buffer, panic message, etc.  This allows for
31 * a more compact representation of critical debugging information than
32 * traditional binary dumps, as well as allowing dump information to be used
33 * without access to kernel symbols, source code, etc.
34 *
35 * Storage Layout
36 * --------------
37 *
38 * Crash dumps are aligned to the end of the dump or swap partition in order
39 * to minimize the chances of swap duing fsck eating into the dump.  However,
40 * unlike a memory dump, we don't know the size of the textdump a priori, so
41 * can't just write it out sequentially in order from a known starting point
42 * calculated with respect to the end of the partition.  In order to address
43 * this, we actually write out the textdump in reverse block order, allowing
44 * us to directly align it to the end of the partition and then write out the
45 * dump header and trailer before and after it once done.  savecore(8) must
46 * know to reverse the order of the blocks in order to produce a readable
47 * file.
48 *
49 * Data is written out in the 'tar' file format, as it provides the facility
50 * to write data incrementally as a stream without reference to previous
51 * files.
52 *
53 * TODO
54 * ----
55 *
56 * - Allow subsytems to register to submit files for inclusion in the text
57 *   dump in a generic way.
58 */
59
60#include <sys/cdefs.h>
61__FBSDID("$FreeBSD: head/sys/ddb/db_textdump.c 174921 2007-12-26 11:32:33Z rwatson $");
62
63#include "opt_config.h"
64
65#include <sys/param.h>
66#include <sys/conf.h>
67#include <sys/kernel.h>
68#include <sys/kerneldump.h>
69#include <sys/msgbuf.h>
70#include <sys/sysctl.h>
71#include <sys/systm.h>
72
73#include <ddb/ddb.h>
74#include <ddb/db_lex.h>
75
76static SYSCTL_NODE(_debug_ddb, OID_AUTO, textdump, CTLFLAG_RW, 0,
77    "DDB textdump options");
78
79/*
80 * Don't touch the first SIZEOF_METADATA bytes on the dump device.  This is
81 * to protect us from metadata and metadata from us.
82 */
83#define	SIZEOF_METADATA		(64*1024)
84
85/*
86 * Data is written out as a series of files in the ustar tar format.  ustar
87 * is a simple streamed format consiting of a series of files prefixed with
88 * headers, and all padded to 512-byte block boundaries, which maps
89 * conveniently to our requirements.
90 */
91struct ustar_header {
92	char	uh_filename[100];
93	char	uh_mode[8];
94	char	uh_tar_owner[8];
95	char	uh_tar_group[8];
96	char	uh_size[12];
97	char	uh_mtime[12];
98	char	uh_sum[8];
99	char	uh_type;
100	char	uh_linkfile[100];
101	char	uh_ustar[6];
102	char	uh_version[2];
103	char	uh_owner[32];
104	char	uh_group[32];
105	char	uh_major[8];
106	char	uh_minor[8];
107	char	uh_filenameprefix[155];
108	char	uh_zeropad[12];
109} __packed;
110
111/*
112 * Various size assertions -- pretty much everything must be one block in
113 * size.
114 */
115CTASSERT(sizeof(struct kerneldumpheader) == TEXTDUMP_BLOCKSIZE);
116CTASSERT(sizeof(struct ustar_header) == TEXTDUMP_BLOCKSIZE);
117
118/*
119 * Is a textdump scheduled?  If so, the shutdown code will invoke our dumpsys
120 * routine instead of the machine-dependent kernel dump routine.
121 */
122int	textdump_pending;
123SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, pending, CTLFLAG_RW,
124    &textdump_pending, 0,
125    "Perform textdump instead of regular kernel dump.");
126
127/*
128 * Various constants for tar headers and contents.
129 */
130#define	TAR_USER	"root"
131#define	TAR_GROUP	"wheel"
132#define	TAR_UID		"0"
133#define	TAR_GID		"0"
134#define	TAR_MODE	"0600"
135#define	TAR_USTAR	"ustar"
136
137#define	TAR_CONFIG_FILENAME	"config.txt"	/* Kernel configuration. */
138#define	TAR_MSGBUF_FILENAME	"msgbuf.txt"	/* Kernel messsage buffer. */
139#define	TAR_PANIC_FILENAME	"panic.txt"	/* Panic message. */
140#define	TAR_VERSION_FILENAME	"version.txt"	/* Kernel version. */
141
142/*
143 * Configure which files will be dumped.
144 */
145#ifdef INCLUDE_CONFIG_FILE
146static int textdump_do_config = 1;
147SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_config, CTLFLAG_RW,
148    &textdump_do_config, 0, "Dump kernel configuration in textdump");
149#endif
150
151static int textdump_do_ddb = 1;
152SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_ddb, CTLFLAG_RW,
153    &textdump_do_ddb, 0, "Dump DDB captured output in textdump");
154
155static int textdump_do_msgbuf = 1;
156SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_msgbuf, CTLFLAG_RW,
157    &textdump_do_msgbuf, 0, "Dump kernel message buffer in textdump");
158
159static int textdump_do_panic = 1;
160SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_panic, CTLFLAG_RW,
161    &textdump_do_panic, 0, "Dump kernel panic message in textdump");
162
163static int textdump_do_version = 1;
164SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_version, CTLFLAG_RW,
165    &textdump_do_version, 0, "Dump kernel version string in textdump");
166
167/*
168 * State related to incremental writing of blocks to disk.
169 */
170static off_t textdump_offset;		/* Offset of next sequential write. */
171static int textdump_error;		/* Carried write error, if any. */
172
173/*
174 * Statically allocate space to prepare block-sized headers and data.
175 */
176char textdump_block_buffer[TEXTDUMP_BLOCKSIZE];
177static struct kerneldumpheader kdh;
178
179/*
180 * Text dumps are prefixed with a normal kernel dump header but with a
181 * different magic number to allow them to be uniquely identified.
182 */
183static void
184mkdumpheader(struct kerneldumpheader *kdh, uint32_t archver,
185    uint64_t dumplen, uint32_t blksz)
186{
187
188	bzero(kdh, sizeof(*kdh));
189	strncpy(kdh->magic, TEXTDUMPMAGIC, sizeof(kdh->magic));
190	strncpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture));
191	kdh->version = htod32(KERNELDUMPVERSION);
192	kdh->architectureversion = htod32(archver);
193	kdh->dumplength = htod64(dumplen);
194	kdh->dumptime = htod64(time_second);
195	kdh->blocksize = htod32(blksz);
196	strncpy(kdh->hostname, hostname, sizeof(kdh->hostname));
197	strncpy(kdh->versionstring, version, sizeof(kdh->versionstring));
198	if (panicstr != NULL)
199		strncpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring));
200	kdh->parity = kerneldump_parity(kdh);
201}
202
203/*
204 * Calculate and fill in the checksum for a tar header.
205 */
206static void
207ustar_checksum(struct ustar_header *uhp)
208{
209	u_int sum;
210	int i;
211
212	for (i = 0; i < sizeof(uhp->uh_sum); i++)
213		uhp->uh_sum[i] = ' ';
214	sum = 0;
215	for (i = 0; i < sizeof(*uhp); i++)
216		sum += ((u_char *)uhp)[i];
217	snprintf(uhp->uh_sum, sizeof(uhp->uh_sum), "%6o", sum);
218}
219
220/*
221 * Each file in the tarball has a block-sized header with its name and other,
222 * largely hard-coded, properties.
223 */
224void
225textdump_mkustar(char *block_buffer, const char *filename, u_int size)
226{
227	struct ustar_header *uhp;
228
229	uhp = (struct ustar_header *)block_buffer;
230	bzero(uhp, sizeof(*uhp));
231	strlcpy(uhp->uh_filename, filename, sizeof(uhp->uh_filename));
232	strlcpy(uhp->uh_mode, TAR_MODE, sizeof(uhp->uh_mode));
233	snprintf(uhp->uh_size, sizeof(uhp->uh_size), "%o", size);
234	strlcpy(uhp->uh_tar_owner, TAR_UID, sizeof(uhp->uh_tar_owner));
235	strlcpy(uhp->uh_tar_group, TAR_GID, sizeof(uhp->uh_tar_group));
236	strlcpy(uhp->uh_owner, TAR_USER, sizeof(uhp->uh_owner));
237	strlcpy(uhp->uh_group, TAR_GROUP, sizeof(uhp->uh_group));
238	snprintf(uhp->uh_mtime, sizeof(uhp->uh_mtime), "%lo",
239	    (unsigned long)time_second);
240	uhp->uh_type = 0;
241	strlcpy(uhp->uh_ustar, TAR_USTAR, sizeof(uhp->uh_ustar));
242	ustar_checksum(uhp);
243}
244
245/*
246 * textdump_writeblock() writes TEXTDUMP_BLOCKSIZE-sized blocks of data to
247 * the space between di->mediaoffset and di->mediaoffset + di->mediasize.  It
248 * accepts an offset relative to di->mediaoffset.  If we're carrying any
249 * error from previous I/O, return that error and don't continue to try to
250 * write.  Most writers ignore the error and forge ahead on the basis that
251 * there's not much you can do.
252 */
253static int
254textdump_writeblock(struct dumperinfo *di, off_t offset, char *buffer)
255{
256
257	if (textdump_error)
258		return (textdump_error);
259	if (offset + TEXTDUMP_BLOCKSIZE > di->mediasize)
260		return (EIO);
261	if (offset < SIZEOF_METADATA)
262		return (ENOSPC);
263	textdump_error = di->dumper(di->priv, buffer, 0, offset +
264	    di->mediaoffset, TEXTDUMP_BLOCKSIZE);
265	return (textdump_error);
266}
267
268/*
269 * Interfaces to save and restore the dump offset, so that printers can go
270 * back to rewrite a header if required, while avoiding their knowing about
271 * the global layout of the blocks.
272 */
273void
274textdump_saveoff(off_t *offsetp)
275{
276
277	*offsetp = textdump_offset;
278}
279
280void
281textdump_restoreoff(off_t offset)
282{
283
284	textdump_offset = offset;
285}
286
287/*
288 * Interface to write the "next block" relative to the current offset; since
289 * we write backwards from the end of the partition, we subtract, but there's
290 * no reason for the caller to know this.
291 */
292int
293textdump_writenextblock(struct dumperinfo *di, char *buffer)
294{
295	int error;
296
297	error = textdump_writeblock(di, textdump_offset, buffer);
298	textdump_offset -= TEXTDUMP_BLOCKSIZE;
299	return (error);
300}
301
302#ifdef INCLUDE_CONFIG_FILE
303extern char kernconfstring[];
304
305/*
306 * Dump kernel configuration.
307 */
308static void
309textdump_dump_config(struct dumperinfo *di)
310{
311	u_int count, fullblocks, len;
312
313	len = strlen(kernconfstring);
314	textdump_mkustar(textdump_block_buffer, TAR_CONFIG_FILENAME, len);
315	(void)textdump_writenextblock(di, textdump_block_buffer);
316
317	/*
318	 * Write out all full blocks directly from the string, and handle any
319	 * left-over bits by copying it to out to the local buffer and
320	 * zero-padding it.
321	 */
322	fullblocks = len / TEXTDUMP_BLOCKSIZE;
323	for (count = 0; count < fullblocks; count++)
324		(void)textdump_writenextblock(di, kernconfstring + count *
325		    TEXTDUMP_BLOCKSIZE);
326	if (len % TEXTDUMP_BLOCKSIZE != 0) {
327		bzero(textdump_block_buffer, TEXTDUMP_BLOCKSIZE);
328		bcopy(kernconfstring + count * TEXTDUMP_BLOCKSIZE,
329		    textdump_block_buffer, len % TEXTDUMP_BLOCKSIZE);
330		(void)textdump_writenextblock(di, textdump_block_buffer);
331	}
332}
333#endif /* INCLUDE_CONFIG_FILE */
334
335/*
336 * Dump kernel message buffer.
337 */
338static void
339textdump_dump_msgbuf(struct dumperinfo *di)
340{
341	off_t end_offset, tarhdr_offset;
342	u_int i, len, offset, seq, total_len;
343	char buf[16];
344
345	/*
346	 * Write out a dummy tar header to advance the offset; we'll rewrite
347	 * it later once we know the true size.
348	 */
349	textdump_saveoff(&tarhdr_offset);
350	textdump_mkustar(textdump_block_buffer, TAR_MSGBUF_FILENAME, 0);
351	(void)textdump_writenextblock(di, textdump_block_buffer);
352
353	/*
354	 * Copy out the data in small chunks, but don't copy nuls that may be
355	 * present if the message buffer has not yet completely filled at
356	 * least once.
357	 */
358	total_len = 0;
359	offset = 0;
360        msgbuf_peekbytes(msgbufp, NULL, 0, &seq);
361        while ((len = msgbuf_peekbytes(msgbufp, buf, sizeof(buf), &seq)) > 0) {
362		for (i = 0; i < len; i++) {
363			if (buf[i] == '\0')
364				continue;
365			textdump_block_buffer[offset] = buf[i];
366			offset++;
367			if (offset != sizeof(textdump_block_buffer))
368				continue;
369			(void)textdump_writenextblock(di,
370			    textdump_block_buffer);
371			total_len += offset;
372			offset = 0;
373		}
374        }
375	total_len += offset;	/* Without the zero-padding. */
376	if (offset != 0) {
377		bzero(textdump_block_buffer + offset,
378		    sizeof(textdump_block_buffer) - offset);
379		(void)textdump_writenextblock(di, textdump_block_buffer);
380	}
381
382	/*
383	 * Rewrite tar header to reflect how much was actually written.
384	 */
385	textdump_saveoff(&end_offset);
386	textdump_restoreoff(tarhdr_offset);
387	textdump_mkustar(textdump_block_buffer, TAR_MSGBUF_FILENAME,
388	    total_len);
389	(void)textdump_writenextblock(di, textdump_block_buffer);
390	textdump_restoreoff(end_offset);
391}
392
393static void
394textdump_dump_panic(struct dumperinfo *di)
395{
396	u_int len;
397
398	/*
399	 * Write out tar header -- we store up to one block of panic message.
400	 */
401	len = min(strlen(panicstr), TEXTDUMP_BLOCKSIZE);
402	textdump_mkustar(textdump_block_buffer, TAR_PANIC_FILENAME, len);
403	(void)textdump_writenextblock(di, textdump_block_buffer);
404
405	/*
406	 * Zero-pad the panic string and write out block.
407	 */
408	bzero(textdump_block_buffer, sizeof(textdump_block_buffer));
409	bcopy(panicstr, textdump_block_buffer, len);
410	(void)textdump_writenextblock(di, textdump_block_buffer);
411}
412
413static void
414textdump_dump_version(struct dumperinfo *di)
415{
416	u_int len;
417
418	/*
419	 * Write out tar header -- at most one block of version information.
420	 */
421	len = min(strlen(version), TEXTDUMP_BLOCKSIZE);
422	textdump_mkustar(textdump_block_buffer, TAR_VERSION_FILENAME, len);
423	(void)textdump_writenextblock(di, textdump_block_buffer);
424
425	/*
426	 * Zero pad the version string and write out block.
427	 */
428	bzero(textdump_block_buffer, sizeof(textdump_block_buffer));
429	bcopy(version, textdump_block_buffer, len);
430	(void)textdump_writenextblock(di, textdump_block_buffer);
431}
432
433/*
434 * Commit text dump to disk.
435 */
436void
437textdump_dumpsys(struct dumperinfo *di)
438{
439	off_t dumplen, trailer_offset;
440
441	if (di->blocksize != TEXTDUMP_BLOCKSIZE) {
442		printf("Dump partition block size (%ju) not textdump "
443		    "block size (%ju)", (uintmax_t)di->blocksize,
444		    (uintmax_t)TEXTDUMP_BLOCKSIZE);
445		return;
446	}
447
448	/*
449	 * We don't know a priori how large the dump will be, but we do know
450	 * that we need to reserve space for metadata and that we need two
451	 * dump headers.  Also leave room for one ustar header and one block
452	 * of data.
453	 */
454	if (di->mediasize < SIZEOF_METADATA + 2 * sizeof(kdh)) {
455		printf("Insufficient space on dump partition.\n");
456		return;
457	}
458	textdump_error = 0;
459
460	/*
461	 * Position the start of the dump so that we'll write the kernel dump
462	 * trailer immediately before the end of the partition, and then work
463	 * our way back.  We will rewrite this header later to reflect the
464	 * true size if things go well.
465	 */
466	textdump_offset = di->mediasize - sizeof(kdh);
467	textdump_saveoff(&trailer_offset);
468	mkdumpheader(&kdh, KERNELDUMP_TEXT_VERSION, 0, TEXTDUMP_BLOCKSIZE);
469	(void)textdump_writenextblock(di, (char *)&kdh);
470
471	/*
472	 * Write a series of files in ustar format.
473	 */
474	if (textdump_do_ddb)
475		db_capture_dump(di);
476#ifdef INCLUDE_CONFIG_FILE
477	if (textdump_do_config)
478		textdump_dump_config(di);
479#endif
480	if (textdump_do_msgbuf)
481		textdump_dump_msgbuf(di);
482	if (textdump_do_panic && panicstr != NULL)
483		textdump_dump_panic(di);
484	if (textdump_do_version)
485		textdump_dump_version(di);
486
487	/*
488	 * Now that we know the true size, we can write out the header, then
489	 * seek back to the end and rewrite the trailer with the correct
490	 * size.
491	 */
492	dumplen = trailer_offset - (textdump_offset + TEXTDUMP_BLOCKSIZE);
493	mkdumpheader(&kdh, KERNELDUMP_TEXT_VERSION, dumplen,
494	    TEXTDUMP_BLOCKSIZE);
495	(void)textdump_writenextblock(di, (char *)&kdh);
496	textdump_restoreoff(trailer_offset);
497	(void)textdump_writenextblock(di, (char *)&kdh);
498
499	/*
500	 * Terminate the dump, report any errors, and clear the pending flag.
501	 */
502	if (textdump_error == 0)
503		(void)di->dumper(di->priv, NULL, 0, 0, 0);
504	if (textdump_error == ENOSPC)
505		printf("Insufficient space on dump partition\n");
506	else if (textdump_error != 0)
507		printf("Error %d writing dump\n", textdump_error);
508	else
509		printf("Textdump complete.\n");
510	textdump_pending = 0;
511}
512
513/*-
514 * DDB(4) command to manage textdumps:
515 *
516 * textdump set        - request a textdump
517 * textdump status     - print DDB output textdump status
518 * textdump unset      - clear textdump request
519 */
520static void
521db_textdump_usage(void)
522{
523
524	db_printf("textdump [unset|set|status]\n");
525}
526
527void
528db_textdump_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
529    char *modif)
530{
531	int t;
532
533	t = db_read_token();
534	if (t != tIDENT) {
535		db_textdump_usage();
536		return;
537	}
538	if (db_read_token() != tEOL) {
539		db_textdump_usage();
540		return;
541	}
542	if (strcmp(db_tok_string, "set") == 0) {
543		textdump_pending = 1;
544		db_printf("textdump set\n");
545	} else if (strcmp(db_tok_string, "status") == 0) {
546		if (textdump_pending)
547			db_printf("textdump is set\n");
548		else
549			db_printf("textdump is not set\n");
550	} else if (strcmp(db_tok_string, "unset") == 0) {
551		textdump_pending = 0;
552		db_printf("textdump unset\n");
553	} else
554		db_textdump_usage();
555}
556