Remove building with NOCRYPTO option

[minix3.git] / minix / servers / vm / pagefaults.c

#define _SYSTEM 1

#include <minix/callnr.h>
#include <minix/com.h>
#include <minix/config.h>
#include <minix/const.h>
#include <minix/ds.h>
#include <minix/endpoint.h>
#include <minix/minlib.h>
#include <minix/type.h>
#include <minix/ipc.h>
#include <minix/sysutil.h>
#include <minix/syslib.h>
#include <minix/safecopies.h>
#include <minix/bitmap.h>
#include <minix/vfsif.h>

#include <machine/vmparam.h>

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <assert.h>

#include "glo.h"
#include "proto.h"
#include "util.h"
#include "region.h"

struct pf_state {
        endpoint_t ep;
        vir_bytes vaddr;
        u32_t err;
};

struct hm_state {
        endpoint_t caller;      /* KERNEL or process? if NONE, no callback */
        endpoint_t requestor;   /* on behalf of whom? */
        int transid;            /* VFS transaction id if valid */
        struct vmproc *vmp;     /* target address space */
        vir_bytes mem, len;     /* memory range */
        int wrflag;             /* must it be writable or not */
        int valid;              /* sanity check */
        int vfs_avail;          /* may vfs be called to satisfy this range? */
#define VALID   0xc0ff1
};

static void handle_memory_continue(struct vmproc *vmp, message *m,
        void *arg, void *statearg);
static int handle_memory_step(struct hm_state *hmstate, int retry);
static void handle_memory_final(struct hm_state *state, int result);

/*===========================================================================*
 *                              pf_errstr                               *
 *===========================================================================*/
char *pf_errstr(u32_t err)
{
        static char buf[100];

        snprintf(buf, sizeof(buf), "err 0x%lx ", (long)err);
        if(PFERR_NOPAGE(err)) strcat(buf, "nopage ");
        if(PFERR_PROT(err)) strcat(buf, "protection ");
        if(PFERR_WRITE(err)) strcat(buf, "write");
        if(PFERR_READ(err)) strcat(buf, "read");

        return buf;
}

static void pf_cont(struct vmproc *vmp, message *m, void *arg, void *statearg);

static void handle_memory_continue(struct vmproc *vmp, message *m, void *arg, void *statearg);

static void handle_pagefault(endpoint_t ep, vir_bytes addr, u32_t err, int retry)
{
        struct vmproc *vmp;
        int s, result;
        struct vir_region *region;
        vir_bytes offset;
        int p, wr = PFERR_WRITE(err);
        int io = 0;

        if(vm_isokendpt(ep, &p) != OK)
                panic("handle_pagefault: endpoint wrong: %d", ep);

        vmp = &vmproc[p];
        assert(vmp->vm_flags & VMF_INUSE);

        /* See if address is valid at all. */
        if(!(region = map_lookup(vmp, addr, NULL))) {
                if(PFERR_PROT(err))  {
                        printf("VM: pagefault: SIGSEGV %d protected addr 0x%lx; %s\n",
                                ep, addr, pf_errstr(err));
                } else {
                        assert(PFERR_NOPAGE(err));
                        printf("VM: pagefault: SIGSEGV %d bad addr 0x%lx; %s\n",
                                        ep, addr, pf_errstr(err));
                        sys_diagctl_stacktrace(ep);
                }
                if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
                if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }

        /* If process was writing, see if it's writable. */
        if(!(region->flags & VR_WRITABLE) && wr) {
                printf("VM: pagefault: SIGSEGV %d ro map 0x%lx %s\n",
                                ep, addr, pf_errstr(err));
                if((s=sys_kill(vmp->vm_endpoint, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
                if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }

        assert(addr >= region->vaddr);
        offset = addr - region->vaddr;

        /* Access is allowed; handle it. */
        if(retry) {
                result = map_pf(vmp, region, offset, wr, NULL, NULL, 0, &io);
                assert(result != SUSPEND);
        } else {
                struct pf_state state;
                state.ep = ep;
                state.vaddr = addr;
                state.err = err;
                result = map_pf(vmp, region, offset, wr, pf_cont,
                        &state, sizeof(state), &io);
        }
        if (io)
                vmp->vm_major_page_fault++;
        else
                vmp->vm_minor_page_fault++;

        if(result == SUSPEND) {
                return;
        }

        if(result != OK) {
                printf("VM: pagefault: SIGSEGV %d pagefault not handled\n", ep);
                if((s=sys_kill(ep, SIGSEGV)) != OK)
                        panic("sys_kill failed: %d", s);
                if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                        panic("do_pagefaults: sys_vmctl failed: %d", ep);
                return;
        }

        pt_clearmapcache();

        /* Pagefault is handled, so now reactivate the process. */
        if((s=sys_vmctl(ep, VMCTL_CLEAR_PAGEFAULT, 0 /*unused*/)) != OK)
                panic("do_pagefaults: sys_vmctl failed: %d", ep);
}


static void pf_cont(struct vmproc *vmp, message *m,
        void *arg, void *statearg)
{
        struct pf_state *state = statearg;
        int p;
        if(vm_isokendpt(state->ep, &p) != OK) return;   /* signal */
        handle_pagefault(state->ep, state->vaddr, state->err, 1);
}

static void handle_memory_continue(struct vmproc *vmp, message *m,
        void *arg, void *statearg)
{
        int r;
        struct hm_state *state = statearg;
        assert(state);
        assert(state->caller != NONE);
        assert(state->valid == VALID);

        if(m->VMV_RESULT != OK) {
                printf("VM: handle_memory_continue: vfs request failed\n");
                handle_memory_final(state, m->VMV_RESULT);
                return;
        }

        r = handle_memory_step(state, TRUE /*retry*/);

        assert(state->valid == VALID);

        if(r == SUSPEND) {
                return;
        }

        assert(state->valid == VALID);

        handle_memory_final(state, r);
}

static void handle_memory_final(struct hm_state *state, int result)
{
        int r, flag;

        assert(state);
        assert(state->valid == VALID);

        if(state->caller == KERNEL) {
                if((r=sys_vmctl(state->requestor, VMCTL_MEMREQ_REPLY, result)) != OK)
                        panic("handle_memory_continue: sys_vmctl failed: %d", r);
        } else if(state->caller != NONE) {
                /* Send a reply msg */
                message msg;
                memset(&msg, 0, sizeof(msg));
                msg.m_type = result;

                if(IS_VFS_FS_TRANSID(state->transid)) {
                        assert(state->caller == VFS_PROC_NR);
                        /* If a transaction ID was set, reset it */
                        msg.m_type = TRNS_ADD_ID(msg.m_type, state->transid);
                        flag = AMF_NOREPLY;
                } else
                        flag = 0;

                /*
                 * Use AMF_NOREPLY only if there was a transaction ID, which
                 * signifies that VFS issued the request asynchronously.
                 */
                if(asynsend3(state->caller, &msg, flag) != OK) {
                        panic("handle_memory_final: asynsend3 failed");
                }

                assert(state->valid == VALID);

                /* fail fast if anyone tries to access this state again */
                memset(state, 0, sizeof(*state));
        }
}

/*===========================================================================*
 *                              do_pagefaults                        *
 *===========================================================================*/
void do_pagefaults(message *m)
{
        handle_pagefault(m->m_source, m->VPF_ADDR, m->VPF_FLAGS, 0);
}

int handle_memory_once(struct vmproc *vmp, vir_bytes mem, vir_bytes len,
        int wrflag)
{
        int r;
        r = handle_memory_start(vmp, mem, len, wrflag, NONE, NONE, 0, 0);
        assert(r != SUSPEND);
        return r;
}

int handle_memory_start(struct vmproc *vmp, vir_bytes mem, vir_bytes len,
        int wrflag, endpoint_t caller, endpoint_t requestor, int transid,
        int vfs_avail)
{
        int r;
        struct hm_state state;
        vir_bytes o;

        if((o = mem % PAGE_SIZE)) {
                mem -= o;
                len += o;
        }

        len = roundup(len, PAGE_SIZE);

        state.vmp = vmp;
        state.mem = mem;
        state.len = len;
        state.wrflag = wrflag;
        state.requestor = requestor;
        state.caller = caller;
        state.transid = transid;
        state.valid = VALID;
        state.vfs_avail = vfs_avail;

        r = handle_memory_step(&state, FALSE /*retry*/);

        if(r == SUSPEND) {
                assert(caller != NONE);
                assert(vfs_avail);
        } else {
                handle_memory_final(&state, r);
        }

        return r;
}

/*===========================================================================*
 *                                 do_memory                                 *
 *===========================================================================*/
void do_memory(void)
{
        endpoint_t who, who_s, requestor;
        vir_bytes mem, mem_s;
        vir_bytes len;
        int wrflag;

        while(1) {
                int p, r = OK;
                struct vmproc *vmp;

                r = sys_vmctl_get_memreq(&who, &mem, &len, &wrflag, &who_s,
                        &mem_s, &requestor);

                switch(r) {
                case VMPTYPE_CHECK:
                {
                        int transid = 0;
                        int vfs_avail;

                        if(vm_isokendpt(who, &p) != OK)
                                panic("do_memory: bad endpoint: %d", who);
                        vmp = &vmproc[p];

                        assert(!IS_VFS_FS_TRANSID(transid));

                        /* is VFS blocked? */
                        if(requestor == VFS_PROC_NR) vfs_avail = 0;
                        else vfs_avail = 1;

                        handle_memory_start(vmp, mem, len, wrflag,
                                KERNEL, requestor, transid, vfs_avail);

                        break;
                }

                default:
                        return;
                }
        }
}

static int handle_memory_step(struct hm_state *hmstate, int retry)
{
        struct vir_region *region;
        vir_bytes offset, length, sublen;
        int r;

        /* Page-align memory and length. */
        assert(hmstate);
        assert(hmstate->valid == VALID);
        assert(!(hmstate->mem % VM_PAGE_SIZE));
        assert(!(hmstate->len % VM_PAGE_SIZE));

        while(hmstate->len > 0) {
                if(!(region = map_lookup(hmstate->vmp, hmstate->mem, NULL))) {
#if VERBOSE
                        map_printmap(hmstate->vmp);
                        printf("VM: do_memory: memory doesn't exist\n");
#endif
                        return EFAULT;
                } else if(!(region->flags & VR_WRITABLE) && hmstate->wrflag) {
#if VERBOSE
                        printf("VM: do_memory: write to unwritable map\n");
#endif
                        return EFAULT;
                }

                assert(region->vaddr <= hmstate->mem);
                assert(!(region->vaddr % VM_PAGE_SIZE));
                offset = hmstate->mem - region->vaddr;
                length = hmstate->len;
                if (offset + length > region->length)
                        length = region->length - offset;

                /*
                 * Handle one page at a time.  While it seems beneficial to
                 * handle multiple pages in one go, the opposite is true:
                 * map_handle_memory will handle one page at a time anyway, and
                 * if we give it the whole range multiple times, it will have
                 * to recheck pages it already handled.  In addition, in order
                 * to handle one-shot pages, we need to know whether we are
                 * retrying a single page, and that is not possible if this is
                 * hidden in map_handle_memory.
                 */
                while (length > 0) {
                        sublen = VM_PAGE_SIZE;

                        assert(sublen <= length);
                        assert(offset + sublen <= region->length);

                        /*
                         * Upon the second try for this range, do not allow
                         * calling into VFS again.  This prevents eternal loops
                         * in case the FS messes up, and allows one-shot pages
                         * to be mapped in on the second call.
                         */
                        if((region->def_memtype == &mem_type_mappedfile &&
                            (!hmstate->vfs_avail || retry)) ||
                            hmstate->caller == NONE) {
                                r = map_handle_memory(hmstate->vmp, region,
                                    offset, sublen, hmstate->wrflag, NULL,
                                    NULL, 0);
                                assert(r != SUSPEND);
                        } else {
                                r = map_handle_memory(hmstate->vmp, region,
                                    offset, sublen, hmstate->wrflag,
                                    handle_memory_continue, hmstate,
                                    sizeof(*hmstate));
                        }

                        if(r != OK) return r;

                        hmstate->len -= sublen;
                        hmstate->mem += sublen;

                        offset += sublen;
                        length -= sublen;
                        retry = FALSE;
                }
        }

        return OK;
}