sys/ia64/ia64/dump_machdep.c

   1 /*-
   2  * Copyright (c) 2002 Marcel Moolenaar
   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  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_watchdog.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/conf.h>
  35 #include <sys/cons.h>
  36 #include <sys/kernel.h>
  37 #include <sys/kerneldump.h>
  38 #ifdef SW_WATCHDOG
  39 #include <sys/watchdog.h>
  40 #endif
  41 #include <vm/vm.h>
  42 #include <vm/pmap.h>
  43 #include <machine/bootinfo.h>
  44 #include <machine/efi.h>
  45 #include <machine/elf.h>
  46 #include <machine/md_var.h>
  47
  48 CTASSERT(sizeof(struct kerneldumpheader) == 512);
  49
  50 /*
  51  * Don't touch the first SIZEOF_METADATA bytes on the dump device. This
  52  * is to protect us from metadata and to protect metadata from us.
  53  */
  54 #define SIZEOF_METADATA         (64*1024)
  55
  56 #define MD_ALIGN(x)     (((off_t)(x) + EFI_PAGE_MASK) & ~EFI_PAGE_MASK)
  57 #define DEV_ALIGN(x)    (((off_t)(x) + (DEV_BSIZE-1)) & ~(DEV_BSIZE-1))
  58
  59 typedef int callback_t(struct efi_md*, int, void*);
  60
  61 static struct kerneldumpheader kdh;
  62 static off_t dumplo, fileofs;
  63
  64 /* Handle buffered writes. */
  65 static char buffer[DEV_BSIZE];
  66 static size_t fragsz;
  67
  68 static int
  69 buf_write(struct dumperinfo *di, char *ptr, size_t sz)
  70 {
  71         size_t len;
  72         int error;
  73
  74         while (sz) {
  75                 len = DEV_BSIZE - fragsz;
  76                 if (len > sz)
  77                         len = sz;
  78                 bcopy(ptr, buffer + fragsz, len);
  79                 fragsz += len;
  80                 ptr += len;
  81                 sz -= len;
  82                 if (fragsz == DEV_BSIZE) {
  83                         error = dump_write(di, buffer, 0, dumplo,
  84                             DEV_BSIZE);
  85                         if (error)
  86                                 return error;
  87                         dumplo += DEV_BSIZE;
  88                         fragsz = 0;
  89                 }
  90         }
  91
  92         return (0);
  93 }
  94
  95 static int
  96 buf_flush(struct dumperinfo *di)
  97 {
  98         int error;
  99
 100         if (fragsz == 0)
 101                 return (0);
 102
 103         error = dump_write(di, buffer, 0, dumplo, DEV_BSIZE);
 104         dumplo += DEV_BSIZE;
 105         fragsz = 0;
 106         return (error);
 107 }
 108
 109 static int
 110 cb_dumpdata(struct efi_md *mdp, int seqnr, void *arg)
 111 {
 112         struct dumperinfo *di = (struct dumperinfo*)arg;
 113         vm_offset_t pa;
 114         uint64_t pgs;
 115         size_t counter, sz;
 116         int c, error, twiddle;
 117
 118         error = 0;      /* catch case in which mdp->md_pages is 0 */
 119         counter = 0;    /* Update twiddle every 16MB */
 120         twiddle = 0;
 121         pgs = mdp->md_pages;
 122         pa = IA64_PHYS_TO_RR7(mdp->md_phys);
 123
 124         printf("  chunk %d: %ld pages ", seqnr, (long)pgs);
 125
 126         while (pgs) {
 127                 sz = (pgs > (DFLTPHYS >> EFI_PAGE_SHIFT))
 128                     ? DFLTPHYS : pgs << EFI_PAGE_SHIFT;
 129                 counter += sz;
 130                 if (counter >> 24) {
 131                         printf("%c\b", "|/-\\"[twiddle++ & 3]);
 132                         counter &= (1<<24) - 1;
 133                 }
 134 #ifdef SW_WATCHDOG
 135                 wdog_kern_pat(WD_LASTVAL);
 136 #endif
 137                 error = dump_write(di, (void*)pa, 0, dumplo, sz);
 138                 if (error)
 139                         break;
 140                 dumplo += sz;
 141                 pgs -= sz >> EFI_PAGE_SHIFT;
 142                 pa += sz;
 143
 144                 /* Check for user abort. */
 145                 c = cncheckc();
 146                 if (c == 0x03)
 147                         return (ECANCELED);
 148                 if (c != -1)
 149                         printf("(CTRL-C to abort)  ");
 150         }
 151         printf("... %s\n", (error) ? "fail" : "ok");
 152         return (error);
 153 }
 154
 155 static int
 156 cb_dumphdr(struct efi_md *mdp, int seqnr, void *arg)
 157 {
 158         struct dumperinfo *di = (struct dumperinfo*)arg;
 159         Elf64_Phdr phdr;
 160         int error;
 161
 162         bzero(&phdr, sizeof(phdr));
 163         phdr.p_type = PT_LOAD;
 164         phdr.p_flags = PF_R;                    /* XXX */
 165         phdr.p_offset = fileofs;
 166         phdr.p_vaddr = (uintptr_t)mdp->md_virt; /* XXX probably bogus. */
 167         phdr.p_paddr = mdp->md_phys;
 168         phdr.p_filesz = mdp->md_pages << EFI_PAGE_SHIFT;
 169         phdr.p_memsz = mdp->md_pages << EFI_PAGE_SHIFT;
 170         phdr.p_align = EFI_PAGE_SIZE;
 171
 172         error = buf_write(di, (char*)&phdr, sizeof(phdr));
 173         fileofs += phdr.p_filesz;
 174         return (error);
 175 }
 176
 177 static int
 178 cb_size(struct efi_md *mdp, int seqnr, void *arg)
 179 {
 180         uint64_t *sz = (uint64_t*)arg;
 181
 182         *sz += (uint64_t)mdp->md_pages << EFI_PAGE_SHIFT;
 183         return (0);
 184 }
 185
 186 static int
 187 foreach_chunk(callback_t cb, void *arg)
 188 {
 189         struct efi_md *mdp;
 190         int error, seqnr;
 191
 192         seqnr = 0;
 193         mdp = efi_md_first();
 194         while (mdp != NULL) {
 195                 if (mdp->md_type == EFI_MD_TYPE_FREE ||
 196                     mdp->md_type == EFI_MD_TYPE_DATA ||
 197                     mdp->md_type == EFI_MD_TYPE_CODE ||
 198                     mdp->md_type == EFI_MD_TYPE_BS_DATA ||
 199                     mdp->md_type == EFI_MD_TYPE_BS_CODE) {
 200                         error = (*cb)(mdp, seqnr++, arg);
 201                         if (error)
 202                                 return (-error);
 203                 }
 204                 mdp = efi_md_next(mdp);
 205         }
 206         return (seqnr);
 207 }
 208
 209 void
 210 dumpsys(struct dumperinfo *di)
 211 {
 212         Elf64_Ehdr ehdr;
 213         uint64_t dumpsize;
 214         off_t hdrgap;
 215         size_t hdrsz;
 216         int error;
 217
 218         bzero(&ehdr, sizeof(ehdr));
 219         ehdr.e_ident[EI_MAG0] = ELFMAG0;
 220         ehdr.e_ident[EI_MAG1] = ELFMAG1;
 221         ehdr.e_ident[EI_MAG2] = ELFMAG2;
 222         ehdr.e_ident[EI_MAG3] = ELFMAG3;
 223         ehdr.e_ident[EI_CLASS] = ELFCLASS64;
 224 #if BYTE_ORDER == LITTLE_ENDIAN
 225         ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
 226 #else
 227         ehdr.e_ident[EI_DATA] = ELFDATA2MSB;
 228 #endif
 229         ehdr.e_ident[EI_VERSION] = EV_CURRENT;
 230         ehdr.e_ident[EI_OSABI] = ELFOSABI_STANDALONE;   /* XXX big picture? */
 231         ehdr.e_type = ET_CORE;
 232         ehdr.e_machine = EM_IA_64;
 233         ehdr.e_entry = ia64_tpa((uintptr_t)bootinfo);
 234         ehdr.e_phoff = sizeof(ehdr);
 235         ehdr.e_flags = EF_IA_64_ABSOLUTE;               /* XXX misuse? */
 236         ehdr.e_ehsize = sizeof(ehdr);
 237         ehdr.e_phentsize = sizeof(Elf64_Phdr);
 238         ehdr.e_shentsize = sizeof(Elf64_Shdr);
 239
 240         /* Calculate dump size. */
 241         dumpsize = 0L;
 242         ehdr.e_phnum = foreach_chunk(cb_size, &dumpsize);
 243         hdrsz = ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize;
 244         fileofs = MD_ALIGN(hdrsz);
 245         dumpsize += fileofs;
 246         hdrgap = fileofs - DEV_ALIGN(hdrsz);
 247
 248         /* Determine dump offset on device. */
 249         if (di->mediasize < SIZEOF_METADATA + dumpsize + sizeof(kdh) * 2) {
 250                 error = ENOSPC;
 251                 goto fail;
 252         }
 253         dumplo = di->mediaoffset + di->mediasize - dumpsize;
 254         dumplo -= sizeof(kdh) * 2;
 255
 256         mkdumpheader(&kdh, KERNELDUMPMAGIC, KERNELDUMP_IA64_VERSION, dumpsize, di->blocksize);
 257
 258         printf("Dumping %llu MB (%d chunks)\n", (long long)dumpsize >> 20,
 259             ehdr.e_phnum);
 260
 261         /* Dump leader */
 262         error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
 263         if (error)
 264                 goto fail;
 265         dumplo += sizeof(kdh);
 266
 267         /* Dump ELF header */
 268         error = buf_write(di, (char*)&ehdr, sizeof(ehdr));
 269         if (error)
 270                 goto fail;
 271
 272         /* Dump program headers */
 273         error = foreach_chunk(cb_dumphdr, di);
 274         if (error < 0)
 275                 goto fail;
 276         buf_flush(di);
 277
 278         /*
 279          * All headers are written using blocked I/O, so we know the
 280          * current offset is (still) block aligned. Skip the alignement
 281          * in the file to have the segment contents aligned at page
 282          * boundary. We cannot use MD_ALIGN on dumplo, because we don't
 283          * care and may very well be unaligned within the dump device.
 284          */
 285         dumplo += hdrgap;
 286
 287         /* Dump memory chunks (updates dumplo) */
 288         error = foreach_chunk(cb_dumpdata, di);
 289         if (error < 0)
 290                 goto fail;
 291
 292         /* Dump trailer */
 293         error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
 294         if (error)
 295                 goto fail;
 296
 297         /* Signal completion, signoff and exit stage left. */
 298         dump_write(di, NULL, 0, 0, 0);
 299         printf("\nDump complete\n");
 300         return;
 301
 302  fail:
 303         if (error < 0)
 304                 error = -error;
 305
 306         if (error == ECANCELED)
 307                 printf("\nDump aborted\n");
 308         else
 309                 printf("\n** DUMP FAILED (ERROR %d) **\n", error);
 310 }