/*      $OpenBSD: uvm_unix.c,v 1.73 2024/01/17 22:22:25 kurt Exp $      */
/*      $NetBSD: uvm_unix.c,v 1.18 2000/09/13 15:00:25 thorpej Exp $    */

/*
 * Copyright (c) 1997 Charles D. Cranor and Washington University.
 * Copyright (c) 1991, 1993 The Regents of the University of California.  
 * Copyright (c) 1988 University of Utah.
 *
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * the Systems Programming Group of the University of Utah Computer
 * Science Department.
 *
 * 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. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 * from: Utah $Hdr: vm_unix.c 1.1 89/11/07$
 *      @(#)vm_unix.c   8.1 (Berkeley) 6/11/93
 * from: Id: uvm_unix.c,v 1.1.2.2 1997/08/25 18:52:30 chuck Exp
 */

/*
 * uvm_unix.c: traditional sbrk/grow interface to vm.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/resourcevar.h>
#include <sys/vnode.h>

#include <sys/mount.h>
#include <sys/syscallargs.h>

#include <uvm/uvm.h>

/*
 * sys_obreak: set break
 */

int
sys_obreak(struct proc *p, void *v, register_t *retval)
{
        struct sys_obreak_args /* {
                syscallarg(char *) nsize;
        } */ *uap = v;
        struct vmspace *vm = p->p_vmspace;
        vaddr_t new, old, base;
        int error;

        base = (vaddr_t)vm->vm_daddr;
        new = round_page((vaddr_t)SCARG(uap, nsize));
        if (new < base || (new - base) > lim_cur(RLIMIT_DATA))
                return (ENOMEM);

        old = round_page(base + ptoa(vm->vm_dsize));

        if (new == old)
                return (0);

        /* grow or shrink? */
        if (new > old) {
                error = uvm_map(&vm->vm_map, &old, new - old, NULL,
                    UVM_UNKNOWN_OFFSET, 0,
                    UVM_MAPFLAG(PROT_READ | PROT_WRITE,
                    PROT_READ | PROT_WRITE | PROT_EXEC, MAP_INHERIT_COPY,
                    MADV_NORMAL, UVM_FLAG_FIXED|UVM_FLAG_COPYONW));
                if (error) {
                        uprintf("sbrk: grow %ld failed, error = %d\n",
                            new - old, error);
                        return (ENOMEM);
                }
                vm->vm_dsize += atop(new - old);
        } else {
                uvm_unmap(&vm->vm_map, new, old);
                vm->vm_dsize -= atop(old - new);
        }

        return (0);
}

/*
 * uvm_grow: enlarge the "stack segment" to include sp.
 */
void
uvm_grow(struct proc *p, vaddr_t sp)
{
        struct vmspace *vm = p->p_vmspace;
        vm_map_t map = &vm->vm_map;
        int si;

        /* For user defined stacks (from sendsig). */
        if (sp < (vaddr_t)vm->vm_maxsaddr)
                return;
#ifdef MACHINE_STACK_GROWS_UP
        if (sp >= (vaddr_t)vm->vm_minsaddr)
                return;
#endif

        vm_map_lock(map);

        /* For common case of already allocated (from trap). */
#ifdef MACHINE_STACK_GROWS_UP
        if (sp < (vaddr_t)vm->vm_maxsaddr + ptoa(vm->vm_ssize))
#else
        if (sp >= (vaddr_t)vm->vm_minsaddr - ptoa(vm->vm_ssize))
#endif
                goto out;

        /* Really need to check vs limit and increment stack size if ok. */
#ifdef MACHINE_STACK_GROWS_UP
        si = atop(sp - (vaddr_t)vm->vm_maxsaddr) - vm->vm_ssize + 1;
#else
        si = atop((vaddr_t)vm->vm_minsaddr - sp) - vm->vm_ssize;
#endif
        if (vm->vm_ssize + si <= atop(lim_cur(RLIMIT_STACK)))
                vm->vm_ssize += si;
out:
        vm_map_unlock(map);
}

#ifndef SMALL_KERNEL

#define WALK_CHUNK      32
/*
 * Not all the pages in an amap may be present.  When dumping core,
 * we don't want to force all the pages to be present: it's a waste
 * of time and memory when we already know what they contain (zeros)
 * and the ELF format at least can adequately represent them as a
 * segment with memory size larger than its file size.
 *
 * So, we walk the amap with calls to amap_lookups() and scan the
 * resulting pointers to find ranges of zero or more present pages
 * followed by at least one absent page or the end of the amap.
 * When then pass that range to the walk callback with 'start'
 * pointing to the start of the present range, 'realend' pointing
 * to the first absent page (or the end of the entry), and 'end'
 * pointing to the page past the last absent page (or the end of
 * the entry).
 *
 * Note that if the first page of the amap is empty then the callback
 * must be invoked with 'start' == 'realend' so it can present that
 * first range of absent pages.
 */
int
uvm_coredump_walk_amap(struct vm_map_entry *entry, int *nsegmentp,
    uvm_coredump_walk_cb *walk, void *cookie)
{
        struct vm_anon *anons[WALK_CHUNK];
        vaddr_t pos, start, realend, end, entry_end;
        vm_prot_t prot;
        int nsegment, absent, npages, i, error;

        prot = entry->protection;
        nsegment = *nsegmentp;
        start = entry->start;
        entry_end = MIN(entry->end, VM_MAXUSER_ADDRESS);

        absent = 0;
        for (pos = start; pos < entry_end; pos += npages << PAGE_SHIFT) {
                npages = (entry_end - pos) >> PAGE_SHIFT;
                if (npages > WALK_CHUNK)
                        npages = WALK_CHUNK;
                amap_lookups(&entry->aref, pos - entry->start, anons, npages);
                for (i = 0; i < npages; i++) {
                        if ((anons[i] == NULL) == absent)
                                continue;
                        if (!absent) {
                                /* going from present to absent: set realend */
                                realend = pos + (i << PAGE_SHIFT);
                                absent = 1;
                                continue;
                        }

                        /* going from absent to present: invoke callback */
                        end = pos + (i << PAGE_SHIFT);
                        if (start != end) {
                                error = (*walk)(start, realend, end, prot,
                                    0, nsegment, cookie);
                                if (error)
                                        return error;
                                nsegment++;
                        }
                        start = realend = end;
                        absent = 0;
                }
        }

        if (!absent)
                realend = entry_end;
        error = (*walk)(start, realend, entry_end, prot, 0, nsegment, cookie);
        *nsegmentp = nsegment + 1;
        return error;
}

/*
 * Common logic for whether a map entry should be included in a coredump
 */
static inline int
uvm_should_coredump(struct proc *p, struct vm_map_entry *entry)
{
        if (!(entry->protection & PROT_WRITE) &&
            entry->aref.ar_amap == NULL &&
            entry->start != p->p_p->ps_sigcode &&
            entry->start != p->p_p->ps_timekeep)
                return 0;

        /*
         * Skip ranges marked as unreadable, as uiomove(UIO_USERSPACE)
         * will fail on them.  Maybe this really should be a test of
         * entry->max_protection, but doing
         *      uvm_map_extract(UVM_EXTRACT_FIXPROT)
         * on each such page would suck.
         */
        if (!(entry->protection & PROT_READ) &&
            entry->start != p->p_p->ps_sigcode)
                return 0;

        /* Skip ranges excluded from coredumps. */
        if (UVM_ET_ISCONCEAL(entry))
                return 0;

        /* Don't dump mmaped devices. */
        if (entry->object.uvm_obj != NULL &&
            UVM_OBJ_IS_DEVICE(entry->object.uvm_obj))
                return 0;

        if (entry->start >= VM_MAXUSER_ADDRESS)
                return 0;

        return 1;
}


/* do nothing callback for uvm_coredump_walk_amap() */
static int
noop(vaddr_t start, vaddr_t realend, vaddr_t end, vm_prot_t prot,
    int isvnode, int nsegment, void *cookie)
{
        return 0;
}

/*
 * Walk the VA space for a process to identify what to write to
 * a coredump.  First the number of contiguous ranges is counted,
 * then the 'setup' callback is invoked to prepare for actually
 * recording the ranges, then the VA is walked again, invoking
 * the 'walk' callback for each range.  The number of ranges walked
 * is guaranteed to match the count seen by the 'setup' callback.
 */

int
uvm_coredump_walkmap(struct proc *p, uvm_coredump_setup_cb *setup,
    uvm_coredump_walk_cb *walk, void *cookie)
{
        struct vmspace *vm = p->p_vmspace;
        struct vm_map *map = &vm->vm_map;
        struct vm_map_entry *entry;
        vaddr_t end;
        int refed_amaps = 0;
        int nsegment, error, isvnode;

        /*
         * Walk the map once to count the segments.  If an amap is
         * referenced more than once than take *another* reference
         * and treat the amap as exactly one segment instead of
         * checking page presence inside it.  On the second pass
         * we'll recognize which amaps we did that for by the ref
         * count being >1...and decrement it then.
         */
        nsegment = 0;
        RBT_FOREACH(entry, uvm_map_addr, &map->addr) {
                /* should never happen for a user process */
                if (UVM_ET_ISSUBMAP(entry)) {
                        panic("%s: user process with submap?", __func__);
                }

                if (! uvm_should_coredump(p, entry))
                        continue;

                if (entry->aref.ar_amap != NULL) {
                        if (entry->aref.ar_amap->am_ref == 1) {
                                uvm_coredump_walk_amap(entry, &nsegment,
                                    &noop, cookie);
                                continue;
                        }

                        /*
                         * Multiple refs currently, so take another and
                         * treat it as a single segment
                         */
                        entry->aref.ar_amap->am_ref++;
                        refed_amaps++;
                }

                nsegment++;
        }

        /*
         * Okay, we have a count in nsegment.  Prepare to
         * walk it again, then invoke the setup callback. 
         */
        entry = RBT_MIN(uvm_map_addr, &map->addr);
        error = (*setup)(nsegment, cookie);
        if (error)
                goto cleanup;

        /*
         * Setup went okay, so do the second walk, invoking the walk
         * callback on the counted segments and cleaning up references
         * as we go.
         */
        nsegment = 0;
        for (; entry != NULL; entry = RBT_NEXT(uvm_map_addr, entry)) {
                if (! uvm_should_coredump(p, entry))
                        continue;

                if (entry->aref.ar_amap != NULL &&
                    entry->aref.ar_amap->am_ref == 1) {
                        error = uvm_coredump_walk_amap(entry, &nsegment,
                            walk, cookie);
                        if (error)
                                break;
                        continue;
                }

                end = entry->end;
                if (end > VM_MAXUSER_ADDRESS)
                        end = VM_MAXUSER_ADDRESS;

                isvnode = (entry->object.uvm_obj != NULL &&
                    UVM_OBJ_IS_VNODE(entry->object.uvm_obj));
                error = (*walk)(entry->start, end, end, entry->protection,
                    isvnode, nsegment, cookie);
                if (error)
                        break;
                nsegment++;

                if (entry->aref.ar_amap != NULL &&
                    entry->aref.ar_amap->am_ref > 1) {
                        /* multiple refs, so we need to drop one */
                        entry->aref.ar_amap->am_ref--;
                        refed_amaps--;
                }
        }

        if (error) {
cleanup:
                /* clean up the extra references from where we left off */
                if (refed_amaps > 0) {
                        for (; entry != NULL;
                            entry = RBT_NEXT(uvm_map_addr, entry)) {
                                if (entry->aref.ar_amap == NULL ||
                                    entry->aref.ar_amap->am_ref == 1)
                                        continue;
                                if (! uvm_should_coredump(p, entry))
                                        continue;
                                entry->aref.ar_amap->am_ref--;
                                if (refed_amaps-- == 0)
                                        break;
                        }
                }
        }

        return error;
}

#endif  /* !SMALL_KERNEL */