xref: /freebsd/sys/ddb/db_textdump.c (revision 4a5216a6dc0c3ce4cf5f2d3ee8af0c3ff3402c4f)
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: write a series of text files to the dump
29  * partition for later recovery, including captured DDB output, kernel
30  * configuration, message buffer, and panic message.  This allows for a more
31  * compact representation of critical debugging information than traditional
32  * binary dumps, as well as allowing dump information to be used without
33  * 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 ustar file format so that we can write data
50  * incrementally as a stream without reference to previous files.
51  *
52  * TODO
53  * ----
54  *
55  * - Allow subsytems to register to submit files for inclusion in the text
56  *   dump in a generic way.
57  */
58 
59 #include <sys/cdefs.h>
60 __FBSDID("$FreeBSD$");
61 
62 #include "opt_config.h"
63 
64 #include <sys/param.h>
65 #include <sys/conf.h>
66 #include <sys/kernel.h>
67 #include <sys/kerneldump.h>
68 #include <sys/msgbuf.h>
69 #include <sys/sysctl.h>
70 #include <sys/systm.h>
71 #include <sys/vimage.h>
72 
73 #include <ddb/ddb.h>
74 #include <ddb/db_lex.h>
75 
76 static 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  */
91 struct 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  */
115 CTASSERT(sizeof(struct kerneldumpheader) == TEXTDUMP_BLOCKSIZE);
116 CTASSERT(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  */
122 int	textdump_pending;
123 SYSCTL_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
146 static int textdump_do_config = 1;
147 SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_config, CTLFLAG_RW,
148     &textdump_do_config, 0, "Dump kernel configuration in textdump");
149 #endif
150 
151 static int textdump_do_ddb = 1;
152 SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_ddb, CTLFLAG_RW,
153     &textdump_do_ddb, 0, "Dump DDB captured output in textdump");
154 
155 static int textdump_do_msgbuf = 1;
156 SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_msgbuf, CTLFLAG_RW,
157     &textdump_do_msgbuf, 0, "Dump kernel message buffer in textdump");
158 
159 static int textdump_do_panic = 1;
160 SYSCTL_INT(_debug_ddb_textdump, OID_AUTO, do_panic, CTLFLAG_RW,
161     &textdump_do_panic, 0, "Dump kernel panic message in textdump");
162 
163 static int textdump_do_version = 1;
164 SYSCTL_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  */
170 static off_t textdump_offset;		/* Offset of next sequential write. */
171 static int textdump_error;		/* Carried write error, if any. */
172 
173 /*
174  * Statically allocate space to prepare block-sized headers and data.
175  */
176 char textdump_block_buffer[TEXTDUMP_BLOCKSIZE];
177 static struct kerneldumpheader kdh;
178 
179 /*
180  * Calculate and fill in the checksum for a ustar header.
181  */
182 static void
183 ustar_checksum(struct ustar_header *uhp)
184 {
185 	u_int sum;
186 	int i;
187 
188 	for (i = 0; i < sizeof(uhp->uh_sum); i++)
189 		uhp->uh_sum[i] = ' ';
190 	sum = 0;
191 	for (i = 0; i < sizeof(*uhp); i++)
192 		sum += ((u_char *)uhp)[i];
193 	snprintf(uhp->uh_sum, sizeof(uhp->uh_sum), "%6o", sum);
194 }
195 
196 /*
197  * Each file in the tarball has a block-sized header with its name and other,
198  * largely hard-coded, properties.
199  */
200 void
201 textdump_mkustar(char *block_buffer, const char *filename, u_int size)
202 {
203 	struct ustar_header *uhp;
204 
205 	uhp = (struct ustar_header *)block_buffer;
206 	bzero(uhp, sizeof(*uhp));
207 	strlcpy(uhp->uh_filename, filename, sizeof(uhp->uh_filename));
208 	strlcpy(uhp->uh_mode, TAR_MODE, sizeof(uhp->uh_mode));
209 	snprintf(uhp->uh_size, sizeof(uhp->uh_size), "%o", size);
210 	strlcpy(uhp->uh_tar_owner, TAR_UID, sizeof(uhp->uh_tar_owner));
211 	strlcpy(uhp->uh_tar_group, TAR_GID, sizeof(uhp->uh_tar_group));
212 	strlcpy(uhp->uh_owner, TAR_USER, sizeof(uhp->uh_owner));
213 	strlcpy(uhp->uh_group, TAR_GROUP, sizeof(uhp->uh_group));
214 	snprintf(uhp->uh_mtime, sizeof(uhp->uh_mtime), "%lo",
215 	    (unsigned long)time_second);
216 	uhp->uh_type = 0;
217 	strlcpy(uhp->uh_ustar, TAR_USTAR, sizeof(uhp->uh_ustar));
218 	ustar_checksum(uhp);
219 }
220 
221 /*
222  * textdump_writeblock() writes TEXTDUMP_BLOCKSIZE-sized blocks of data to
223  * the space between di->mediaoffset and di->mediaoffset + di->mediasize.  It
224  * accepts an offset relative to di->mediaoffset.  If we're carrying any
225  * error from previous I/O, return that error and don't continue to try to
226  * write.  Most writers ignore the error and forge ahead on the basis that
227  * there's not much you can do.
228  */
229 static int
230 textdump_writeblock(struct dumperinfo *di, off_t offset, char *buffer)
231 {
232 
233 	if (textdump_error)
234 		return (textdump_error);
235 	if (offset + TEXTDUMP_BLOCKSIZE > di->mediasize)
236 		return (EIO);
237 	if (offset < SIZEOF_METADATA)
238 		return (ENOSPC);
239 	textdump_error = dump_write(di, buffer, 0, offset + di->mediaoffset,
240 	    TEXTDUMP_BLOCKSIZE);
241 	return (textdump_error);
242 }
243 
244 /*
245  * Interfaces to save and restore the dump offset, so that printers can go
246  * back to rewrite a header if required, while avoiding their knowing about
247  * the global layout of the blocks.
248  *
249  * If we ever want to support writing textdumps to tape or other
250  * stream-oriented target, we'll need to remove this.
251  */
252 void
253 textdump_saveoff(off_t *offsetp)
254 {
255 
256 	*offsetp = textdump_offset;
257 }
258 
259 void
260 textdump_restoreoff(off_t offset)
261 {
262 
263 	textdump_offset = offset;
264 }
265 
266 /*
267  * Interface to write the "next block" relative to the current offset; since
268  * we write backwards from the end of the partition, we subtract, but there's
269  * no reason for the caller to know this.
270  */
271 int
272 textdump_writenextblock(struct dumperinfo *di, char *buffer)
273 {
274 	int error;
275 
276 	error = textdump_writeblock(di, textdump_offset, buffer);
277 	textdump_offset -= TEXTDUMP_BLOCKSIZE;
278 	return (error);
279 }
280 
281 #ifdef INCLUDE_CONFIG_FILE
282 extern char kernconfstring[];
283 
284 /*
285  * Dump kernel configuration.
286  */
287 static void
288 textdump_dump_config(struct dumperinfo *di)
289 {
290 	u_int count, fullblocks, len;
291 
292 	len = strlen(kernconfstring);
293 	textdump_mkustar(textdump_block_buffer, TAR_CONFIG_FILENAME, len);
294 	(void)textdump_writenextblock(di, textdump_block_buffer);
295 
296 	/*
297 	 * Write out all full blocks directly from the string, and handle any
298 	 * left-over bits by copying it to out to the local buffer and
299 	 * zero-padding it.
300 	 */
301 	fullblocks = len / TEXTDUMP_BLOCKSIZE;
302 	for (count = 0; count < fullblocks; count++)
303 		(void)textdump_writenextblock(di, kernconfstring + count *
304 		    TEXTDUMP_BLOCKSIZE);
305 	if (len % TEXTDUMP_BLOCKSIZE != 0) {
306 		bzero(textdump_block_buffer, TEXTDUMP_BLOCKSIZE);
307 		bcopy(kernconfstring + count * TEXTDUMP_BLOCKSIZE,
308 		    textdump_block_buffer, len % TEXTDUMP_BLOCKSIZE);
309 		(void)textdump_writenextblock(di, textdump_block_buffer);
310 	}
311 }
312 #endif /* INCLUDE_CONFIG_FILE */
313 
314 /*
315  * Dump kernel message buffer.
316  */
317 static void
318 textdump_dump_msgbuf(struct dumperinfo *di)
319 {
320 	off_t end_offset, tarhdr_offset;
321 	u_int i, len, offset, seq, total_len;
322 	char buf[16];
323 
324 	/*
325 	 * Write out a dummy tar header to advance the offset; we'll rewrite
326 	 * it later once we know the true size.
327 	 */
328 	textdump_saveoff(&tarhdr_offset);
329 	textdump_mkustar(textdump_block_buffer, TAR_MSGBUF_FILENAME, 0);
330 	(void)textdump_writenextblock(di, textdump_block_buffer);
331 
332 	/*
333 	 * Copy out the data in small chunks, but don't copy nuls that may be
334 	 * present if the message buffer has not yet completely filled at
335 	 * least once.
336 	 */
337 	total_len = 0;
338 	offset = 0;
339         msgbuf_peekbytes(msgbufp, NULL, 0, &seq);
340         while ((len = msgbuf_peekbytes(msgbufp, buf, sizeof(buf), &seq)) > 0) {
341 		for (i = 0; i < len; i++) {
342 			if (buf[i] == '\0')
343 				continue;
344 			textdump_block_buffer[offset] = buf[i];
345 			offset++;
346 			if (offset != sizeof(textdump_block_buffer))
347 				continue;
348 			(void)textdump_writenextblock(di,
349 			    textdump_block_buffer);
350 			total_len += offset;
351 			offset = 0;
352 		}
353         }
354 	total_len += offset;	/* Without the zero-padding. */
355 	if (offset != 0) {
356 		bzero(textdump_block_buffer + offset,
357 		    sizeof(textdump_block_buffer) - offset);
358 		(void)textdump_writenextblock(di, textdump_block_buffer);
359 	}
360 
361 	/*
362 	 * Rewrite tar header to reflect how much was actually written.
363 	 */
364 	textdump_saveoff(&end_offset);
365 	textdump_restoreoff(tarhdr_offset);
366 	textdump_mkustar(textdump_block_buffer, TAR_MSGBUF_FILENAME,
367 	    total_len);
368 	(void)textdump_writenextblock(di, textdump_block_buffer);
369 	textdump_restoreoff(end_offset);
370 }
371 
372 static void
373 textdump_dump_panic(struct dumperinfo *di)
374 {
375 	u_int len;
376 
377 	/*
378 	 * Write out tar header -- we store up to one block of panic message.
379 	 */
380 	len = min(strlen(panicstr), TEXTDUMP_BLOCKSIZE);
381 	textdump_mkustar(textdump_block_buffer, TAR_PANIC_FILENAME, len);
382 	(void)textdump_writenextblock(di, textdump_block_buffer);
383 
384 	/*
385 	 * Zero-pad the panic string and write out block.
386 	 */
387 	bzero(textdump_block_buffer, sizeof(textdump_block_buffer));
388 	bcopy(panicstr, textdump_block_buffer, len);
389 	(void)textdump_writenextblock(di, textdump_block_buffer);
390 }
391 
392 static void
393 textdump_dump_version(struct dumperinfo *di)
394 {
395 	u_int len;
396 
397 	/*
398 	 * Write out tar header -- at most one block of version information.
399 	 */
400 	len = min(strlen(version), TEXTDUMP_BLOCKSIZE);
401 	textdump_mkustar(textdump_block_buffer, TAR_VERSION_FILENAME, len);
402 	(void)textdump_writenextblock(di, textdump_block_buffer);
403 
404 	/*
405 	 * Zero pad the version string and write out block.
406 	 */
407 	bzero(textdump_block_buffer, sizeof(textdump_block_buffer));
408 	bcopy(version, textdump_block_buffer, len);
409 	(void)textdump_writenextblock(di, textdump_block_buffer);
410 }
411 
412 /*
413  * Commit text dump to disk.
414  */
415 void
416 textdump_dumpsys(struct dumperinfo *di)
417 {
418 	off_t dumplen, trailer_offset;
419 
420 	if (di->blocksize != TEXTDUMP_BLOCKSIZE) {
421 		printf("Dump partition block size (%ju) not textdump "
422 		    "block size (%ju)", (uintmax_t)di->blocksize,
423 		    (uintmax_t)TEXTDUMP_BLOCKSIZE);
424 		return;
425 	}
426 
427 	/*
428 	 * We don't know a priori how large the dump will be, but we do know
429 	 * that we need to reserve space for metadata and that we need two
430 	 * dump headers.  Also leave room for one ustar header and one block
431 	 * of data.
432 	 */
433 	if (di->mediasize < SIZEOF_METADATA + 2 * sizeof(kdh)) {
434 		printf("Insufficient space on dump partition.\n");
435 		return;
436 	}
437 	textdump_error = 0;
438 
439 	/*
440 	 * Position the start of the dump so that we'll write the kernel dump
441 	 * trailer immediately before the end of the partition, and then work
442 	 * our way back.  We will rewrite this header later to reflect the
443 	 * true size if things go well.
444 	 */
445 	textdump_offset = di->mediasize - sizeof(kdh);
446 	textdump_saveoff(&trailer_offset);
447 	mkdumpheader(&kdh, TEXTDUMPMAGIC, KERNELDUMP_TEXT_VERSION, 0, TEXTDUMP_BLOCKSIZE);
448 	(void)textdump_writenextblock(di, (char *)&kdh);
449 
450 	/*
451 	 * Write a series of files in ustar format.
452 	 */
453 	if (textdump_do_ddb)
454 		db_capture_dump(di);
455 #ifdef INCLUDE_CONFIG_FILE
456 	if (textdump_do_config)
457 		textdump_dump_config(di);
458 #endif
459 	if (textdump_do_msgbuf)
460 		textdump_dump_msgbuf(di);
461 	if (textdump_do_panic && panicstr != NULL)
462 		textdump_dump_panic(di);
463 	if (textdump_do_version)
464 		textdump_dump_version(di);
465 
466 	/*
467 	 * Now that we know the true size, we can write out the header, then
468 	 * seek back to the end and rewrite the trailer with the correct
469 	 * size.
470 	 */
471 	dumplen = trailer_offset - (textdump_offset + TEXTDUMP_BLOCKSIZE);
472 	mkdumpheader(&kdh, TEXTDUMPMAGIC, KERNELDUMP_TEXT_VERSION, dumplen,
473 	    TEXTDUMP_BLOCKSIZE);
474 	(void)textdump_writenextblock(di, (char *)&kdh);
475 	textdump_restoreoff(trailer_offset);
476 	(void)textdump_writenextblock(di, (char *)&kdh);
477 
478 	/*
479 	 * Terminate the dump, report any errors, and clear the pending flag.
480 	 */
481 	if (textdump_error == 0)
482 		(void)dump_write(di, NULL, 0, 0, 0);
483 	if (textdump_error == ENOSPC)
484 		printf("Insufficient space on dump partition\n");
485 	else if (textdump_error != 0)
486 		printf("Error %d writing dump\n", textdump_error);
487 	else
488 		printf("Textdump complete.\n");
489 	textdump_pending = 0;
490 }
491 
492 /*-
493  * DDB(4) command to manage textdumps:
494  *
495  * textdump set        - request a textdump
496  * textdump status     - print DDB output textdump status
497  * textdump unset      - clear textdump request
498  */
499 static void
500 db_textdump_usage(void)
501 {
502 
503 	db_printf("textdump [unset|set|status]\n");
504 }
505 
506 void
507 db_textdump_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
508     char *modif)
509 {
510 	int t;
511 
512 	t = db_read_token();
513 	if (t != tIDENT) {
514 		db_textdump_usage();
515 		return;
516 	}
517 	if (db_read_token() != tEOL) {
518 		db_textdump_usage();
519 		return;
520 	}
521 	if (strcmp(db_tok_string, "set") == 0) {
522 		textdump_pending = 1;
523 		db_printf("textdump set\n");
524 	} else if (strcmp(db_tok_string, "status") == 0) {
525 		if (textdump_pending)
526 			db_printf("textdump is set\n");
527 		else
528 			db_printf("textdump is not set\n");
529 	} else if (strcmp(db_tok_string, "unset") == 0) {
530 		textdump_pending = 0;
531 		db_printf("textdump unset\n");
532 	} else
533 		db_textdump_usage();
534 }
535