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