sys/arm/arm/minidump_machdep.c

   1 /*-
   2  * Copyright (c) 2008 Semihalf, Grzegorz Bernacki
   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  * from: FreeBSD: src/sys/i386/i386/minidump_machdep.c,v 1.6 2008/08/17 23:27:27
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  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 #include <sys/msgbuf.h>
  39 #include <vm/vm.h>
  40 #include <vm/pmap.h>
  41 #include <machine/pmap.h>
  42 #include <machine/atomic.h>
  43 #include <machine/elf.h>
  44 #include <machine/md_var.h>
  45 #include <machine/vmparam.h>
  46 #include <machine/minidump.h>
  47 #include <machine/cpufunc.h>
  48
  49 CTASSERT(sizeof(struct kerneldumpheader) == 512);
  50
  51 /*
  52  * Don't touch the first SIZEOF_METADATA bytes on the dump device. This
  53  * is to protect us from metadata and to protect metadata from us.
  54  */
  55 #define SIZEOF_METADATA         (64*1024)
  56
  57 uint32_t *vm_page_dump;
  58 int vm_page_dump_size;
  59
  60 static struct kerneldumpheader kdh;
  61 static off_t dumplo;
  62
  63 /* Handle chunked writes. */
  64 static size_t fragsz, offset;
  65 static void *dump_va;
  66 static uint64_t counter, progress;
  67
  68 CTASSERT(sizeof(*vm_page_dump) == 4);
  69
  70 static int
  71 is_dumpable(vm_paddr_t pa)
  72 {
  73         int i;
  74
  75         for (i = 0; dump_avail[i] != 0 || dump_avail[i + 1] != 0; i += 2) {
  76                 if (pa >= dump_avail[i] && pa < dump_avail[i + 1])
  77                         return (1);
  78         }
  79         return (0);
  80 }
  81
  82 #define PG2MB(pgs) (((pgs) + (1 << 8) - 1) >> 8)
  83
  84 static int
  85 blk_flush(struct dumperinfo *di)
  86 {
  87         int error;
  88
  89         if (fragsz == 0)
  90                 return (0);
  91
  92         error = dump_write(di, (char*)dump_va + offset, 0, dumplo, fragsz - offset);
  93         dumplo += (fragsz - offset);
  94         fragsz = 0;
  95         offset = 0;
  96         return (error);
  97 }
  98
  99 static int
 100 blk_write(struct dumperinfo *di, char *ptr, vm_paddr_t pa, size_t sz)
 101 {
 102         size_t len;
 103         int error, i, c;
 104         u_int maxdumpsz;
 105
 106         maxdumpsz = di->maxiosize;
 107
 108         if (maxdumpsz == 0)     /* seatbelt */
 109                 maxdumpsz = PAGE_SIZE;
 110
 111         error = 0;
 112
 113         if (ptr != NULL && pa != 0) {
 114                 printf("cant have both va and pa!\n");
 115                 return (EINVAL);
 116         }
 117
 118         if (ptr != NULL) {
 119                 /* If we're doing a virtual dump, flush any pre-existing pa pages */
 120                 error = blk_flush(di);
 121                 if (error)
 122                         return (error);
 123         }
 124
 125         while (sz) {
 126                 if (fragsz == 0) {
 127                         offset = pa & PAGE_MASK;
 128                         fragsz += offset;
 129                 }
 130                 len = maxdumpsz - fragsz;
 131                 if (len > sz)
 132                         len = sz;
 133                 counter += len;
 134                 progress -= len;
 135
 136                 if (counter >> 22) {
 137                         printf(" %lld", PG2MB(progress >> PAGE_SHIFT));
 138                         counter &= (1<<22) - 1;
 139                 }
 140
 141                 if (ptr) {
 142                         error = dump_write(di, ptr, 0, dumplo, len);
 143                         if (error)
 144                                 return (error);
 145                         dumplo += len;
 146                         ptr += len;
 147                         sz -= len;
 148                 } else {
 149                         for (i = 0; i < len; i += PAGE_SIZE)
 150                                 dump_va = pmap_kenter_temp(pa + i,
 151                                     (i + fragsz) >> PAGE_SHIFT);
 152                         fragsz += len;
 153                         pa += len;
 154                         sz -= len;
 155                         if (fragsz == maxdumpsz) {
 156                                 error = blk_flush(di);
 157                                 if (error)
 158                                         return (error);
 159                         }
 160                 }
 161
 162                 /* Check for user abort. */
 163                 c = cncheckc();
 164                 if (c == 0x03)
 165                         return (ECANCELED);
 166                 if (c != -1)
 167                         printf(" (CTRL-C to abort) ");
 168         }
 169
 170         return (0);
 171 }
 172
 173 static int
 174 blk_write_cont(struct dumperinfo *di, vm_paddr_t pa, size_t sz)
 175 {
 176         int error;
 177
 178         error = blk_write(di, 0, pa, sz);
 179         if (error)
 180                 return (error);
 181
 182         error = blk_flush(di);
 183         if (error)
 184                 return (error);
 185
 186         return (0);
 187 }
 188
 189 /* A fake page table page, to avoid having to handle both 4K and 2M pages */
 190 static pt_entry_t fakept[NPTEPG];
 191
 192 void
 193 minidumpsys(struct dumperinfo *di)
 194 {
 195         struct minidumphdr mdhdr;
 196         uint64_t dumpsize;
 197         uint32_t ptesize;
 198         uint32_t bits;
 199         uint32_t pa, prev_pa = 0, count = 0;
 200         vm_offset_t va;
 201         pd_entry_t *pdp;
 202         pt_entry_t *pt, *ptp;
 203         int i, k, bit, error;
 204         char *addr;
 205
 206         /* Flush cache */
 207         cpu_idcache_wbinv_all();
 208         cpu_l2cache_wbinv_all();
 209
 210         counter = 0;
 211         /* Walk page table pages, set bits in vm_page_dump */
 212         ptesize = 0;
 213         for (va = KERNBASE; va < kernel_vm_end; va += NBPDR) {
 214                 /*
 215                  * We always write a page, even if it is zero. Each
 216                  * page written corresponds to 2MB of space
 217                  */
 218                 ptesize += L2_TABLE_SIZE_REAL;
 219                 pmap_get_pde_pte(pmap_kernel(), va, &pdp, &ptp);
 220                 if (pmap_pde_v(pdp) && pmap_pde_section(pdp)) {
 221                         /* This is a section mapping 1M page. */
 222                         pa = (*pdp & L1_S_ADDR_MASK) | (va & ~L1_S_ADDR_MASK);
 223                         for (k = 0; k < (L1_S_SIZE / PAGE_SIZE); k++) {
 224                                 if (is_dumpable(pa))
 225                                         dump_add_page(pa);
 226                                 pa += PAGE_SIZE;
 227                         }
 228                         continue;
 229                 }
 230                 if (pmap_pde_v(pdp) && pmap_pde_page(pdp)) {
 231                         /* Set bit for each valid page in this 1MB block */
 232                         addr = pmap_kenter_temp(*pdp & L1_C_ADDR_MASK, 0);
 233                         pt = (pt_entry_t*)(addr +
 234                             (((uint32_t)*pdp  & L1_C_ADDR_MASK) & PAGE_MASK));
 235                         for (k = 0; k < 256; k++) {
 236                                 if ((pt[k] & L2_TYPE_MASK) == L2_TYPE_L) {
 237                                         pa = (pt[k] & L2_L_FRAME) |
 238                                             (va & L2_L_OFFSET);
 239                                         for (i = 0; i < 16; i++) {
 240                                                 if (is_dumpable(pa))
 241                                                         dump_add_page(pa);
 242                                                 k++;
 243                                                 pa += PAGE_SIZE;
 244                                         }
 245                                 } else if ((pt[k] & L2_TYPE_MASK) == L2_TYPE_S) {
 246                                         pa = (pt[k] & L2_S_FRAME) |
 247                                             (va & L2_S_OFFSET);
 248                                         if (is_dumpable(pa))
 249                                                 dump_add_page(pa);
 250                                 }
 251                         }
 252                 } else {
 253                         /* Nothing, we're going to dump a null page */
 254                 }
 255         }
 256
 257         /* Calculate dump size. */
 258         dumpsize = ptesize;
 259         dumpsize += round_page(msgbufp->msg_size);
 260         dumpsize += round_page(vm_page_dump_size);
 261
 262         for (i = 0; i < vm_page_dump_size / sizeof(*vm_page_dump); i++) {
 263                 bits = vm_page_dump[i];
 264                 while (bits) {
 265                         bit = ffs(bits) - 1;
 266                         pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) +
 267                             bit) * PAGE_SIZE;
 268                         /* Clear out undumpable pages now if needed */
 269                         if (is_dumpable(pa))
 270                                 dumpsize += PAGE_SIZE;
 271                         else
 272                                 dump_drop_page(pa);
 273                         bits &= ~(1ul << bit);
 274                 }
 275         }
 276
 277         dumpsize += PAGE_SIZE;
 278
 279         /* Determine dump offset on device. */
 280         if (di->mediasize < SIZEOF_METADATA + dumpsize + sizeof(kdh) * 2) {
 281                 error = ENOSPC;
 282                 goto fail;
 283         }
 284
 285         dumplo = di->mediaoffset + di->mediasize - dumpsize;
 286         dumplo -= sizeof(kdh) * 2;
 287         progress = dumpsize;
 288
 289         /* Initialize mdhdr */
 290         bzero(&mdhdr, sizeof(mdhdr));
 291         strcpy(mdhdr.magic, MINIDUMP_MAGIC);
 292         mdhdr.version = MINIDUMP_VERSION;
 293         mdhdr.msgbufsize = msgbufp->msg_size;
 294         mdhdr.bitmapsize = vm_page_dump_size;
 295         mdhdr.ptesize = ptesize;
 296         mdhdr.kernbase = KERNBASE;
 297
 298         mkdumpheader(&kdh, KERNELDUMPMAGIC, KERNELDUMP_ARM_VERSION, dumpsize,
 299             di->blocksize);
 300
 301         printf("Physical memory: %u MB\n", ptoa((uintmax_t)physmem) / 1048576);
 302         printf("Dumping %llu MB:", (long long)dumpsize >> 20);
 303
 304         /* Dump leader */
 305         error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
 306         if (error)
 307                 goto fail;
 308         dumplo += sizeof(kdh);
 309
 310         /* Dump my header */
 311         bzero(&fakept, sizeof(fakept));
 312         bcopy(&mdhdr, &fakept, sizeof(mdhdr));
 313         error = blk_write(di, (char *)&fakept, 0, PAGE_SIZE);
 314         if (error)
 315                 goto fail;
 316
 317         /* Dump msgbuf up front */
 318         error = blk_write(di, (char *)msgbufp->msg_ptr, 0, round_page(msgbufp->msg_size));
 319         if (error)
 320                 goto fail;
 321
 322         /* Dump bitmap */
 323         error = blk_write(di, (char *)vm_page_dump, 0,
 324             round_page(vm_page_dump_size));
 325         if (error)
 326                 goto fail;
 327
 328         /* Dump kernel page table pages */
 329         for (va = KERNBASE; va < kernel_vm_end; va += NBPDR) {
 330                 /* We always write a page, even if it is zero */
 331                 pmap_get_pde_pte(pmap_kernel(), va, &pdp, &ptp);
 332
 333                 if (pmap_pde_v(pdp) && pmap_pde_section(pdp))  {
 334                         if (count) {
 335                                 error = blk_write_cont(di, prev_pa,
 336                                     count * L2_TABLE_SIZE_REAL);
 337                                 if (error)
 338                                         goto fail;
 339                                 count = 0;
 340                                 prev_pa = 0;
 341                         }
 342                         /* This is a single 2M block. Generate a fake PTP */
 343                         pa = (*pdp & L1_S_ADDR_MASK) | (va & ~L1_S_ADDR_MASK);
 344                         for (k = 0; k < (L1_S_SIZE / PAGE_SIZE); k++) {
 345                                 fakept[k] = L2_S_PROTO | (pa + (k * PAGE_SIZE)) |
 346                                     L2_S_PROT(PTE_KERNEL,
 347                                     VM_PROT_READ | VM_PROT_WRITE);
 348                         }
 349                         error = blk_write(di, (char *)&fakept, 0,
 350                             L2_TABLE_SIZE_REAL);
 351                         if (error)
 352                                 goto fail;
 353                         /* Flush, in case we reuse fakept in the same block */
 354                         error = blk_flush(di);
 355                         if (error)
 356                                 goto fail;
 357                         continue;
 358                 }
 359                 if (pmap_pde_v(pdp) && pmap_pde_page(pdp)) {
 360                         pa = *pdp & L1_C_ADDR_MASK;
 361                         if (!count) {
 362                                 prev_pa = pa;
 363                                 count++;
 364                         }
 365                         else {
 366                                 if (pa == (prev_pa + count * L2_TABLE_SIZE_REAL))
 367                                         count++;
 368                                 else {
 369                                         error = blk_write_cont(di, prev_pa,
 370                                             count * L2_TABLE_SIZE_REAL);
 371                                         if (error)
 372                                                 goto fail;
 373                                         count = 1;
 374                                         prev_pa = pa;
 375                                 }
 376                         }
 377                 } else {
 378                         if (count) {
 379                                 error = blk_write_cont(di, prev_pa,
 380                                     count * L2_TABLE_SIZE_REAL);
 381                                 if (error)
 382                                         goto fail;
 383                                 count = 0;
 384                                 prev_pa = 0;
 385                         }
 386                         bzero(fakept, sizeof(fakept));
 387                         error = blk_write(di, (char *)&fakept, 0,
 388                             L2_TABLE_SIZE_REAL);
 389                         if (error)
 390                                 goto fail;
 391                         /* Flush, in case we reuse fakept in the same block */
 392                         error = blk_flush(di);
 393                         if (error)
 394                                 goto fail;
 395                 }
 396         }
 397
 398         if (count) {
 399                 error = blk_write_cont(di, prev_pa, count * L2_TABLE_SIZE_REAL);
 400                 if (error)
 401                         goto fail;
 402                 count = 0;
 403                 prev_pa = 0;
 404         }
 405
 406         /* Dump memory chunks */
 407         for (i = 0; i < vm_page_dump_size / sizeof(*vm_page_dump); i++) {
 408                 bits = vm_page_dump[i];
 409                 while (bits) {
 410                         bit = ffs(bits) - 1;
 411                         pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) +
 412                             bit) * PAGE_SIZE;
 413                         if (!count) {
 414                                 prev_pa = pa;
 415                                 count++;
 416                         } else {
 417                                 if (pa == (prev_pa + count * PAGE_SIZE))
 418                                         count++;
 419                                 else {
 420                                         error = blk_write_cont(di, prev_pa,
 421                                             count * PAGE_SIZE);
 422                                         if (error)
 423                                                 goto fail;
 424                                         count = 1;
 425                                         prev_pa = pa;
 426                                 }
 427                         }
 428                         bits &= ~(1ul << bit);
 429                 }
 430         }
 431         if (count) {
 432                 error = blk_write_cont(di, prev_pa, count * PAGE_SIZE);
 433                 if (error)
 434                         goto fail;
 435                 count = 0;
 436                 prev_pa = 0;
 437         }
 438
 439         /* Dump trailer */
 440         error = dump_write(di, &kdh, 0, dumplo, sizeof(kdh));
 441         if (error)
 442                 goto fail;
 443         dumplo += sizeof(kdh);
 444
 445         /* Signal completion, signoff and exit stage left. */
 446         dump_write(di, NULL, 0, 0, 0);
 447         printf("\nDump complete\n");
 448         return;
 449
 450 fail:
 451         if (error < 0)
 452                 error = -error;
 453
 454         if (error == ECANCELED)
 455                 printf("\nDump aborted\n");
 456         else if (error == ENOSPC)
 457                 printf("\nDump failed. Partition too small.\n");
 458         else
 459                 printf("\n** DUMP FAILED (ERROR %d) **\n", error);
 460 }
 461
 462 void
 463 dump_add_page(vm_paddr_t pa)
 464 {
 465         int idx, bit;
 466
 467         pa >>= PAGE_SHIFT;
 468         idx = pa >> 5;          /* 2^5 = 32 */
 469         bit = pa & 31;
 470         atomic_set_int(&vm_page_dump[idx], 1ul << bit);
 471 }
 472
 473 void
 474 dump_drop_page(vm_paddr_t pa)
 475 {
 476         int idx, bit;
 477
 478         pa >>= PAGE_SHIFT;
 479         idx = pa >> 5;          /* 2^5 = 32 */
 480         bit = pa & 31;
 481         atomic_clear_int(&vm_page_dump[idx], 1ul << bit);
 482 }