Date: Tue, 21 Jun 2005 19:40:23 GMT From: Peter Wemm <peter@FreeBSD.org> To: Perforce Change Reviews <perforce@freebsd.org> Subject: PERFORCE change 78774 for review Message-ID: <200506211940.j5LJeNi8063222@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=78774 Change 78774 by peter@peter_daintree on 2005/06/21 19:40:04 Switch dumps over to doing sparse ELF dumps, taken from ia64 with as few tweaks as possible. Hence the first/next glue to walk walk the phys_avail[] array. Affected files ... .. //depot/projects/hammer/sys/amd64/amd64/dump_machdep.c#9 edit .. //depot/projects/hammer/sys/sys/kerneldump.h#3 edit Differences ... ==== //depot/projects/hammer/sys/amd64/amd64/dump_machdep.c#9 (text+ko) ==== @@ -1,40 +1,31 @@ /*- - * Copyright (c) 2002 Poul-Henning Kamp - * Copyright (c) 2002 Networks Associates Technology, Inc. + * Copyright (c) 2002 Marcel Moolenaar * All rights reserved. * - * This software was developed for the FreeBSD Project by Poul-Henning Kamp - * and NAI Labs, the Security Research Division of Network Associates, Inc. - * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the - * DARPA CHATS research program. - * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: + * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. The names of the authors may not be used to endorse or promote - * products derived from this software without specific prior written - * permission. * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include <sys/cdefs.h> -__FBSDID("$FreeBSD: src/sys/amd64/amd64/dump_machdep.c,v 1.9 2003/07/25 21:15:44 obrien Exp $"); +__FBSDID("$FreeBSD: src/sys/ia64/ia64/dump_machdep.c,v 1.12 2005/01/06 22:18:22 imp Exp $"); #include <sys/param.h> #include <sys/systm.h> @@ -44,92 +35,307 @@ #include <sys/kerneldump.h> #include <vm/vm.h> #include <vm/pmap.h> +#include <machine/elf.h> #include <machine/md_var.h> CTASSERT(sizeof(struct kerneldumpheader) == 512); +/* + * Don't touch the first SIZEOF_METADATA bytes on the dump device. This + * is to protect us from metadata and to protect metadata from us. + */ +#define SIZEOF_METADATA (64*1024) + +#define MD_ALIGN(x) (((off_t)(x) + PAGE_MASK) & ~PAGE_MASK) +#define DEV_ALIGN(x) (((off_t)(x) + (DEV_BSIZE-1)) & ~(DEV_BSIZE-1)) + +struct md_pa { + vm_paddr_t md_start; + vm_paddr_t md_end; +}; + +typedef int callback_t(struct md_pa *, int, void *); + static struct kerneldumpheader kdh; +static off_t dumplo, fileofs; + +/* Handle buffered writes. */ +static char buffer[DEV_BSIZE]; +static size_t fragsz; + +static struct md_pa * +md_pa_first(void) +{ + struct md_pa *mdp; -void -dumpsys(struct dumperinfo *di) + mdp = (struct md_pa *)&phys_avail[0]; + if (mdp->md_start == 0 && mdp->md_end == 0) + mdp = NULL; + return (mdp); +} + +static struct md_pa * +md_pa_next(struct md_pa *mdp) { - off_t dumplo; - vm_offset_t a, addr; - u_int count, left, u; - void *va; - int i, mb; - int c; + + mdp++; + if (mdp->md_start == 0 && mdp->md_end == 0) + mdp = NULL; + return (mdp); +} - printf("Dumping %ld MB\n", Maxmem / (1024*1024 / PAGE_SIZE)); +/* XXX should be MI */ +static void +mkdumpheader(struct kerneldumpheader *kdh, uint32_t archver, uint64_t dumplen, + uint32_t blksz) +{ - /* Fill in the kernel dump header */ - strcpy(kdh.magic, KERNELDUMPMAGIC); - strcpy(kdh.architecture, "amd64"); - kdh.version = htod32(KERNELDUMPVERSION); - kdh.architectureversion = htod32(KERNELDUMP_I386_VERSION); - kdh.dumplength = htod64(Maxmem * (off_t)PAGE_SIZE); - kdh.dumptime = htod64(time_second); - kdh.blocksize = htod32(di->blocksize); - strncpy(kdh.hostname, hostname, sizeof kdh.hostname); - strncpy(kdh.versionstring, version, sizeof kdh.versionstring); + bzero(kdh, sizeof(*kdh)); + strncpy(kdh->magic, KERNELDUMPMAGIC, sizeof(kdh->magic)); + strncpy(kdh->architecture, MACHINE_ARCH, sizeof(kdh->architecture)); + kdh->version = htod32(KERNELDUMPVERSION); + kdh->architectureversion = htod32(archver); + kdh->dumplength = htod64(dumplen); + kdh->dumptime = htod64(time_second); + kdh->blocksize = htod32(blksz); + strncpy(kdh->hostname, hostname, sizeof(kdh->hostname)); + strncpy(kdh->versionstring, version, sizeof(kdh->versionstring)); if (panicstr != NULL) - strncpy(kdh.panicstring, panicstr, sizeof kdh.panicstring); - kdh.parity = kerneldump_parity(&kdh); + strncpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring)); + kdh->parity = kerneldump_parity(kdh); +} + +static int +buf_write(struct dumperinfo *di, char *ptr, size_t sz) +{ + size_t len; + int error; - /* - * Check if we will have enough room to save the coredump. - * The partition size needed is the sum of: - * Memory to save + header + trailer + Room to leave untouched - * at partition head. (an arbitrary amount). - */ - if (di->mediasize < - Maxmem * (off_t)PAGE_SIZE + sizeof kdh * 2 + 64*1024) { - printf("\nDump failed. Partition too small.\n"); - return; + while (sz) { + len = DEV_BSIZE - fragsz; + if (len > sz) + len = sz; + bcopy(ptr, buffer + fragsz, len); + fragsz += len; + ptr += len; + sz -= len; + if (fragsz == DEV_BSIZE) { + error = di->dumper(di->priv, buffer, 0, dumplo, + DEV_BSIZE); + if (error) + return error; + dumplo += DEV_BSIZE; + fragsz = 0; + } } - dumplo = di->mediaoffset + di->mediasize - Maxmem * (off_t)PAGE_SIZE; - dumplo -= sizeof kdh * 2; - i = di->dumper(di->priv, &kdh, 0, dumplo, sizeof kdh); - if (i) - printf("\nDump failed writing header (%d)\n", i); - dumplo += sizeof kdh; - i = 0; - addr = 0; - va = 0; - mb = 0; - for (count = 0; count < Maxmem;) { - left = Maxmem - count; - if (left > MAXDUMPPGS) - left = MAXDUMPPGS; - for (u = 0; u < left; u++) { - a = addr + u * PAGE_SIZE; - if (!is_physical_memory(a)) - a = 0; - va = pmap_kenter_temporary(trunc_page(a), u); + + return (0); +} + +static int +buf_flush(struct dumperinfo *di) +{ + int error; + + if (fragsz == 0) + return (0); + + error = di->dumper(di->priv, buffer, 0, dumplo, DEV_BSIZE); + dumplo += DEV_BSIZE; + return (error); +} + +static int +cb_dumpdata(struct md_pa *mdp, int seqnr, void *arg) +{ + struct dumperinfo *di = (struct dumperinfo*)arg; + vm_offset_t pa; + uint64_t pgs; + size_t counter, sz; + int c, error, twiddle; + + error = 0; /* catch case in which chunk size is 0 */ + counter = 0; /* Update twiddle every 16MB */ + twiddle = 0; + pgs = (mdp->md_end - mdp->md_start) / PAGE_SIZE; + pa = mdp->md_start; + + printf(" chunk %d: %ld pages ", seqnr, (long)pgs); + + while (pgs) { + sz = (pgs > (DFLTPHYS >> PAGE_SHIFT)) + ? DFLTPHYS : pgs << PAGE_SHIFT; + counter += sz; + if (counter >> 24) { + printf("%c\b", "|/-\\"[twiddle++ & 3]); + counter &= (1<<24) - 1; } - i = count / (16*1024*1024 / PAGE_SIZE); - if (i != mb) { - printf(" %d", count / (1024 * 1024 / PAGE_SIZE)); - mb = i; - } - i = di->dumper(di->priv, va, 0, dumplo, left * PAGE_SIZE); - if (i) + error = di->dumper(di->priv, (void*)pa, 0, dumplo, sz); + if (error) break; - count += left; - dumplo += left * PAGE_SIZE; - addr += left * PAGE_SIZE; - if ((c = cncheckc()) == 0x03) { - printf("\nDump aborted.\n"); - return; - } else if (c != -1) - printf("[CTRL-C to abort] "); + dumplo += sz; + pgs -= sz >> PAGE_SHIFT; + pa += sz; + + /* Check for user abort. */ + c = cncheckc(); + if (c == 0x03) + return (ECANCELED); + if (c != -1) + printf("(CTRL-C to abort) "); + } + printf("... %s\n", (error) ? "fail" : "ok"); + return (error); +} + +static int +cb_dumphdr(struct md_pa *mdp, int seqnr, void *arg) +{ + struct dumperinfo *di = (struct dumperinfo*)arg; + Elf64_Phdr phdr; + uint64_t size; + int error; + + size = mdp->md_end - mdp->md_start; + bzero(&phdr, sizeof(phdr)); + phdr.p_type = PT_LOAD; + phdr.p_flags = PF_R; /* XXX */ + phdr.p_offset = fileofs; + phdr.p_vaddr = mdp->md_start; + phdr.p_paddr = mdp->md_start; + phdr.p_filesz = size; + phdr.p_memsz = size; + phdr.p_align = PAGE_SIZE; + + error = buf_write(di, (char*)&phdr, sizeof(phdr)); + fileofs += phdr.p_filesz; + return (error); +} + +static int +cb_size(struct md_pa *mdp, int seqnr, void *arg) +{ + uint64_t *sz = (uint64_t*)arg; + + *sz += (uint64_t)(mdp->md_end - mdp->md_start); + return (0); +} + +static int +foreach_chunk(callback_t cb, void *arg) +{ + struct md_pa *mdp; + int error, seqnr; + + seqnr = 0; + mdp = md_pa_first(); + while (mdp != NULL) { + error = (*cb)(mdp, seqnr++, arg); + if (error) + return (-error); + mdp = md_pa_next(mdp); + } + return (seqnr); +} + +void +dumpsys(struct dumperinfo *di) +{ + Elf64_Ehdr ehdr; + uint64_t dumpsize; + off_t hdrgap; + size_t hdrsz; + int error; + + bzero(&ehdr, sizeof(ehdr)); + ehdr.e_ident[EI_MAG0] = ELFMAG0; + ehdr.e_ident[EI_MAG1] = ELFMAG1; + ehdr.e_ident[EI_MAG2] = ELFMAG2; + ehdr.e_ident[EI_MAG3] = ELFMAG3; + ehdr.e_ident[EI_CLASS] = ELFCLASS64; +#if BYTE_ORDER == LITTLE_ENDIAN + ehdr.e_ident[EI_DATA] = ELFDATA2LSB; +#else + ehdr.e_ident[EI_DATA] = ELFDATA2MSB; +#endif + ehdr.e_ident[EI_VERSION] = EV_CURRENT; + ehdr.e_ident[EI_OSABI] = ELFOSABI_STANDALONE; /* XXX big picture? */ + ehdr.e_type = ET_CORE; + ehdr.e_machine = EM_X86_64; + ehdr.e_phoff = sizeof(ehdr); + ehdr.e_flags = 0; + ehdr.e_ehsize = sizeof(ehdr); + ehdr.e_phentsize = sizeof(Elf64_Phdr); + ehdr.e_shentsize = sizeof(Elf64_Shdr); + + /* Calculate dump size. */ + dumpsize = 0L; + ehdr.e_phnum = foreach_chunk(cb_size, &dumpsize); + hdrsz = ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize; + fileofs = MD_ALIGN(hdrsz); + dumpsize += fileofs; + hdrgap = fileofs - DEV_ALIGN(hdrsz); + + /* Determine dump offset on device. */ + if (di->mediasize < SIZEOF_METADATA + dumpsize + sizeof(kdh) * 2) { + error = ENOSPC; + goto fail; } - if (i) - printf("\nDump failed writing data (%d)\n", i); - i = di->dumper(di->priv, &kdh, 0, dumplo, sizeof kdh); - if (i) - printf("\nDump failed writing trailer (%d)\n", i); - di->dumper(di->priv, NULL, 0, 0, 0); /* tell them we are done */ + dumplo = di->mediaoffset + di->mediasize - dumpsize; + dumplo -= sizeof(kdh) * 2; + + mkdumpheader(&kdh, KERNELDUMP_IA64_VERSION, dumpsize, di->blocksize); + + printf("Dumping %llu MB (%d chunks)\n", (long long)dumpsize >> 20, + ehdr.e_phnum); + + /* Dump leader */ + error = di->dumper(di->priv, &kdh, 0, dumplo, sizeof(kdh)); + if (error) + goto fail; + dumplo += sizeof(kdh); + + /* Dump ELF header */ + error = buf_write(di, (char*)&ehdr, sizeof(ehdr)); + if (error) + goto fail; + + /* Dump program headers */ + error = foreach_chunk(cb_dumphdr, di); + if (error < 0) + goto fail; + buf_flush(di); + + /* + * All headers are written using blocked I/O, so we know the + * current offset is (still) block aligned. Skip the alignement + * in the file to have the segment contents aligned at page + * boundary. We cannot use MD_ALIGN on dumplo, because we don't + * care and may very well be unaligned within the dump device. + */ + dumplo += hdrgap; + + /* Dump memory chunks (updates dumplo) */ + error = foreach_chunk(cb_dumpdata, di); + if (error < 0) + goto fail; + + /* Dump trailer */ + error = di->dumper(di->priv, &kdh, 0, dumplo, sizeof(kdh)); + if (error) + goto fail; + + /* Signal completion, signoff and exit stage left. */ + di->dumper(di->priv, NULL, 0, 0, 0); printf("\nDump complete\n"); return; + + fail: + if (error < 0) + error = -error; + + if (error == ECANCELED) + printf("\nDump aborted\n"); + else + printf("\n** DUMP FAILED (ERROR %d) **\n", error); } ==== //depot/projects/hammer/sys/sys/kerneldump.h#3 (text+ko) ==== @@ -69,6 +69,7 @@ #define KERNELDUMP_I386_VERSION 1 #define KERNELDUMP_IA64_VERSION 1 #define KERNELDUMP_SPARC64_VERSION 1 +#define KERNELDUMP_AMD64_VERSION 2 uint64_t dumplength; /* excl headers */ uint64_t dumptime; uint32_t blocksize;
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200506211940.j5LJeNi8063222>