/*      $NetBSD: stubs.c,v 1.27 2020/07/03 15:31:25 skrll Exp $ */

/*
 * Copyright (c) 1994-1998 Mark Brinicombe.
 * Copyright (c) 1994 Brini.
 * All rights reserved.
 *
 * This code is derived from software written for Brini by Mark Brinicombe
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Mark Brinicombe
 *      for the NetBSD Project.
 * 4. The name of the company nor the name of the author may be used to
 *    endorse or promote products derived from this software without specific
 *    prior written permission.
 *
 * 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 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.
 *
 * Routines that are temporary or do not have a home yet.
 *
 * Created      : 17/09/94
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: stubs.c,v 1.27 2020/07/03 15:31:25 skrll Exp $");

#include <sys/param.h>

#include <sys/conf.h>
#include <sys/core.h>
#include <sys/errno.h>
#include <sys/kcore.h>
#include <sys/msgbuf.h>
#include <sys/proc.h>
#include <sys/systm.h>

#include <uvm/uvm_extern.h>

#include <machine/cpu.h>
#include <machine/intr.h>
#include <machine/bootconfig.h>
#include <machine/pcb.h>

#include <arm/arm32/machdep.h>
#include <arm/kcore.h>

extern dev_t dumpdev;

int     cpu_dump(void);
int     cpu_dumpsize(void);
u_long  cpu_dump_mempagecnt(void);

/*
 * These variables are needed by /sbin/savecore
 */
uint32_t dumpmag = 0x8fca0101;  /* magic number */
int     dumpsize = 0;           /* pages */
long    dumplo = 0;             /* blocks */

struct pcb dumppcb;

/*
 * This is called by main to set dumplo and dumpsize.
 * Dumps always skip the first PAGE_SIZE of disk space
 * in case there might be a disk label stored there.
 * If there is extra space, put dump at the end to
 * reduce the chance that swapping trashes it.
 */

void
cpu_dumpconf(void)
{
        int nblks, dumpblks;    /* size of dump area */

        if (dumpdev == NODEV)
                return;
        nblks = bdev_size(dumpdev);
        if (nblks <= ctod(1))
                return;

        dumpblks = cpu_dumpsize();
        if (dumpblks < 0)
                goto bad;
        dumpblks += ctod(cpu_dump_mempagecnt());

        /* If dump won't fit (incl. room for possible label), punt. */
        if (dumpblks > (nblks - ctod(1)))
                goto bad;

        /* Put dump at end of partition */
        dumplo = nblks - dumpblks;

        /* dumpsize is in page units, and doesn't include headers. */
        dumpsize = cpu_dump_mempagecnt();
        return;

 bad:
        dumpsize = 0;
}

/*
 * cpu_dump: dump the machine-dependent kernel core dump headers.
 */
int
cpu_dump(void)
{
        int (*dump)(dev_t, daddr_t, void *, size_t);
        char bf[dbtob(1)];
        kcore_seg_t *segp;
        cpu_kcore_hdr_t *cpuhdrp;
        phys_ram_seg_t *memsegp;
        const struct bdevsw *bdev;
        int i;

        bdev = bdevsw_lookup(dumpdev);
        if (bdev == NULL)
                return ENXIO;
        dump = bdev->d_dump;

        memset(bf, 0, sizeof bf);
        segp = (kcore_seg_t *)bf;
        cpuhdrp = (cpu_kcore_hdr_t *)&bf[ALIGN(sizeof(*segp))];
        memsegp = (phys_ram_seg_t *)&bf[ ALIGN(sizeof(*segp)) +
            ALIGN(sizeof(*cpuhdrp))];

        /*
         * Generate a segment header.
         */
        CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
        segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));

        /*
         * Add the machine-dependent header info.
         */
        cpuhdrp->version = 1;
        cpuhdrp->PAKernelL1Table = pmap_kernel_L1_addr();
        cpuhdrp->UserL1TableSize = 0;
        cpuhdrp->nmemsegs = bootconfig.dramblocks;
        cpuhdrp->omemsegs = ALIGN(sizeof(*cpuhdrp));

        /*
         * Fill in the memory segment descriptors.
         */
        for (i = 0; i < bootconfig.dramblocks; i++) {
                memsegp[i].start = bootconfig.dram[i].address;
                memsegp[i].size = bootconfig.dram[i].pages * PAGE_SIZE;
        }

        return dump(dumpdev, dumplo, bf, dbtob(1));
}

/*
 * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
 */
int
cpu_dumpsize(void)
{
        int size;

        size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t)) +
            ALIGN( bootconfig.dramblocks * sizeof(phys_ram_seg_t));
        if (roundup(size, dbtob(1)) != dbtob(1))
                return -1;

        return 1;
}


/*
 * cpu_dump_mempagecnt: calculate the size of RAM (in pages) to be dumped.
 */
u_long
cpu_dump_mempagecnt(void)
{
        u_long i, n;

        n = 0;
        for (i = 0; i < bootconfig.dramblocks; i++) {
                n += bootconfig.dram[i].pages;
        }

        return n;
}

/* This should be moved to machdep.c */

extern vaddr_t memhook;         /* XXX */

/*
 * Doadump comes here after turning off memory management and
 * getting on the dump stack, either when called above, or by
 * the auto-restart code.
 */
void dodumpsys(void);

void
dodumpsys(void)
{
        const struct bdevsw *bdev;
        daddr_t blkno;
        int psize;
        int error;
        int addr;
        int block;
        int len;
        vaddr_t dumpspace;

        /* flush everything out of caches */
        cpu_dcache_wbinv_all();

        if (dumpdev == NODEV)
                return;
        if (dumpsize == 0) {
                cpu_dumpconf();
        }
        if (dumplo <= 0 || dumpsize == 0) {
                printf("\ndump to dev %u,%u not possible\n",
                    major(dumpdev), minor(dumpdev));
                delay(5000000);
                return;
        }
        printf("\ndumping to dev %u,%u offset %ld\n",
            major(dumpdev), minor(dumpdev), dumplo);


        bdev = bdevsw_lookup(dumpdev);
        if (bdev == NULL || bdev->d_psize == NULL)
                return;
        psize = bdev_size(dumpdev);
        printf("dump ");
        if (psize == -1) {
                printf("area unavailable\n");
                return;
        }

        if ((error = cpu_dump()) != 0)
                goto err;

        blkno = dumplo + cpu_dumpsize();
        dumpspace = memhook;
        error = 0;
        len = 0;

        for (block = 0; block < bootconfig.dramblocks && error == 0; ++block) {
                addr = bootconfig.dram[block].address;
                for (;addr < (bootconfig.dram[block].address
                    + (bootconfig.dram[block].pages * PAGE_SIZE));
                     addr += PAGE_SIZE) {
                        if ((len % (1024*1024)) == 0)
                                printf("%d ", len / (1024*1024));

                        pmap_kenter_pa(dumpspace, addr, VM_PROT_READ, 0);
                        pmap_update(pmap_kernel());
                        error = (*bdev->d_dump)(dumpdev,
                            blkno, (void *) dumpspace, PAGE_SIZE);

                        if (error)
                                goto err;
                        blkno += btodb(PAGE_SIZE);
                        len += PAGE_SIZE;
                }
        }
err:
        switch (error) {
        case ENXIO:
                printf("device bad\n");
                break;

        case EFAULT:
                printf("device not ready\n");
                break;

        case EINVAL:
                printf("area improper\n");
                break;

        case EIO:
                printf("i/o error\n");
                break;

        case EINTR:
                printf("aborted from console\n");
                break;

        case 0:
                printf("succeeded\n");
                break;

        default:
                printf("error %d\n", error);
                break;
        }
        printf("\n\n");
        delay(5000000);
}

/* End of stubs.c */