Subversion Repositories c0or1k

/*

 * Common exception handling code

 *

 * Copyright (C) 2008 - 2010 B Labs Ltd.

 * Written by Bahadir Balban

 */

#include <l4/generic/scheduler.h>

#include <l4/generic/thread.h>

#include <l4/api/thread.h>

#include <l4/generic/space.h>

#include <l4/generic/tcb.h>

#include <l4/generic/platform.h>

#include <l4/generic/debug.h>

#include <l4/lib/printk.h>

#include <l4/api/ipc.h>

#include <l4/api/kip.h>

#include <l4/api/errno.h>

#include INC_ARCH(exception.h)

#include INC_GLUE(memlayout.h)

#include INC_GLUE(memory.h)

#include INC_GLUE(mapping.h)

#include INC_GLUE(message.h)

#include INC_GLUE(ipc.h)

#include INC_SUBARCH(mm.h)

void abort_die(void)

{

        disable_irqs();

        print_early("Unhandled kernel abort.\n");

        print_early("Kernel panic.\n");

        print_early("Halting system...\n");

        while (1)

                ;

}

struct ipc_state {

        u32 mr[MR_TOTAL];

        unsigned int flags;

};

void ipc_save_state(struct ipc_state *state)

{

        unsigned int *mr0_current = KTCB_REF_MR0(current);

        BUG_ON(!mr0_current);

        /* Save primary message registers */

        for (int i = 0; i < MR_TOTAL; i++)

                state->mr[i] = mr0_current[i];

        /* Save ipc flags */

        state->flags = tcb_get_ipc_flags(current);

}

void ipc_restore_state(struct ipc_state *state)

{

        unsigned int *mr0_current = KTCB_REF_MR0(current);

        BUG_ON(!mr0_current);

        /* Restore primary message registers */

        for (int i = 0; i < MR_TOTAL; i++)

                mr0_current[i] = state->mr[i];

        /* Restore ipc flags */

        tcb_set_ipc_flags(current, state->flags);

}

/* Send data fault ipc to the faulty task's pager */

int __attribute__((optimize("O0")))

fault_ipc_to_pager(u32 faulty_pc, u32 fsr, u32 far, u32 ipc_tag)

{

        int err;

        /* mr[0] has the fault tag. The rest is the fault structure */

        u32 mr[MR_TOTAL] = {

                [MR_TAG] = ipc_tag,

                [MR_SENDER] = current->tid

        };

        fault_kdata_t *fault = (fault_kdata_t *)&mr[MR_UNUSED_START];

        /* Fill in fault information to pass over during ipc */

        fault->faulty_pc = faulty_pc;

        fault->fsr = fsr;

        fault->far = far;

        /*

         * Write pte of the abort address,

         * which is different on pabt/dabt

         */

        if (is_prefetch_abort(fsr))

                fault->pte = virt_to_pte(faulty_pc);

        else

                fault->pte = virt_to_pte(far);

        /*

         * System calls save arguments (and message registers)

         * on the kernel stack. They are then referenced from

         * the caller's ktcb. Here, we forge a fault structure

         * as if an ipc syscall has occured. Then the reference

         * to the fault structure is set in the ktcb such that

         * it lies on the mr0 offset when referred as the syscall

         * context.

         */

        /*

         * Assign fault such that it overlaps

         * as the MR0 reference in ktcb.

         */

        current->syscall_regs = (syscall_context_t *)

                                ((unsigned long)&mr[0] -

                                 offsetof(syscall_context_t, r3));

        /* Set current flags to short ipc */

        tcb_set_ipc_flags(current, IPC_FLAGS_SHORT);

        /* Detect if a pager is self-faulting */

        if (current->tid == current->pagerid) {

                printk("Pager (%d) faulted on itself. "

                       "FSR: 0x%x, FAR: 0x%x, PC: 0x%x pte: 0x%x CPU%d Exiting.\n",

                       current->tid, fault->fsr, fault->far,

                       fault->faulty_pc, fault->pte, smp_get_cpuid());

                thread_destroy(current);

        }

        /* Send ipc to the task's pager */

        if ((err = ipc_sendrecv(current->pagerid,

                                current->pagerid, 0)) < 0) {

                        BUG_ON(current->nlocks);

                /* Return on interrupt */

                if (err == -EINTR) {

                        printk("Thread (%d) page-faulted "

                               "and got interrupted by its pager.\n",

                               current->tid);

                        return err;

                } else { /* Suspend on any other error */

                        printk("Thread (%d) faulted in kernel "

                               "and an error occured during "

                               "page-fault ipc. err=%d. "

                               "Suspending task.\n",

                               current->tid, err);

                        current->flags |= TASK_SUSPENDING;

                        sched_suspend_sync();

                }

        }

        return 0;

}

/*

 * When a task calls the kernel and the supplied user buffer is

 * not mapped, the kernel generates a page fault to the task's

 * pager so that the pager can make the decision on mapping the

 * buffer. Remember that if a task maps its own user buffer to

 * itself this way, the kernel can access it, since it shares

 * that task's page table.

 */

int pager_pagein_request(unsigned long addr, unsigned long size,

                         unsigned int flags)

{

        int err;

        u32 abort = 0;

        unsigned long npages = __pfn(align_up(size, PAGE_SIZE));

        struct ipc_state ipc_state;

        set_abort_type(abort, ABORT_TYPE_DATA);

        /* Save current ipc state */

        ipc_save_state(&ipc_state);

        /* For every page to be used by the

         * kernel send a page-in request */

        for (int i = 0; i < npages; i++)

                if ((err = fault_ipc_to_pager(0, abort,

                                              addr + (i * PAGE_SIZE),

                                              L4_IPC_TAG_PFAULT)) < 0)

                        return err;

        /* Restore ipc state */

        ipc_restore_state(&ipc_state);

        return 0;

}

/*

 * @r0: The address where the program counter was during the fault.

 * @r1: Contains the fault status register

 * @r2: Contains the fault address register

 */

void data_abort_handler(u32 faulted_pc, u32 dfsr, u32 dfar, u32 spsr)

{

        int ret;

        system_account_dabort();

        /* Indicate abort type on dfsr */

        set_abort_type(dfsr, ABORT_TYPE_DATA);

        dbg_abort("Data abort PC:0x%x, FAR: 0x%x, FSR: 0x%x, CPU%d\n",

                  faulted_pc, dfar, dfsr, smp_get_cpuid());

        /*

         * Check abort type and tell

         * if it's an irrecoverable fault

         */

        if ((ret = check_abort_type(faulted_pc, dfsr, dfar, spsr)) < 0)

                goto die; /* Die if irrecoverable */

        else if (ret == ABORT_HANDLED)

                return;

        /* Notify the pager */

        fault_ipc_to_pager(faulted_pc, dfsr, dfar, L4_IPC_TAG_PFAULT);

        /*

         * FIXME:

         * Check return value of pager, and also make a record of

         * the fault that has occured. We ought to expect progress

         * from the pager. If the same fault is occuring a number

         * of times consecutively, we might want to kill the pager.

         */

        /* See if current task has various flags set by its pager */

        if (current->flags & TASK_SUSPENDING) {

                BUG_ON(current->nlocks);

                sched_suspend_sync();

        }

        return;

die:

        dprintk("FAR:", dfar);

        dprintk("PC:", faulted_pc);

        abort_die();

}

void prefetch_abort_handler(u32 faulted_pc, u32 ifsr, u32 ifar, u32 spsr)

{

        int ret;

        system_account_pabort();

        /* Indicate abort type on dfsr */

        set_abort_type(ifsr, ABORT_TYPE_PREFETCH);

        dbg_abort("Prefetch abort PC:0x%x, FAR: 0x%x, FSR: 0x%x, CPU%d\n",

                  faulted_pc, ifar, ifsr, smp_get_cpuid());

        /*

         * Check abort type and tell

         * if it's an irrecoverable fault

         */

        if ((ret = check_abort_type(0, ifsr, ifar, spsr)) < 0)

                goto die; /* Die if irrecoverable */

        else if (ret == ABORT_HANDLED)

                return; /* Return if handled internally */

        /* Notify the pager */

        fault_ipc_to_pager(faulted_pc, ifsr, ifar, L4_IPC_TAG_PFAULT);

        /*

         * FIXME:

         * Check return value of pager, and also make a record of

         * the fault that has occured. We ought to expect progress

         * from the pager. If the same fault is occuring a number

         * of times consecutively, we might want to kill the pager.

         */

        /* See if current task has various flags set by its pager */

        if (current->flags & TASK_SUSPENDING) {

                BUG_ON(current->nlocks);

                sched_suspend_sync();

        }

        return;

die:

        dprintk("FAR:", ifar);

        abort_die();

}

void undefined_instr_handler(u32 undefined_address, u32 spsr, u32 lr)

{

        dbg_abort("Undefined instruction. PC:0x%x", undefined_address);

        system_account_undef_abort();

        fault_ipc_to_pager(undefined_address, 0, undefined_address,

                           L4_IPC_TAG_UNDEF_FAULT);

        if (!is_user_mode(spsr)) {

                dprintk("Undefined instruction occured in "

                        "non-user mode. addr=", undefined_address);

                goto die;

        }

        /* See if current task has various flags set by its pager */

        if (current->flags & TASK_SUSPENDING) {

                BUG_ON(current->nlocks);

                sched_suspend_sync();

        }

        return;

die:

        abort_die();

}

extern int current_irq_nest_count;

/*

 * This is called right where the nest count is increased

 * in case the nesting is beyond the predefined max limit.

 * It is another matter whether this limit is enough to

 * guarantee the kernel stack is not overflown.

 *

 * FIXME: Take measures to recover. (E.g. disable irqs etc)

 *

 * Note that this is called in irq context, and it *also*

 * thrashes the designated irq stack which is only 12 bytes.

 *

 * It really is assumed the system has come to a halt when

 * this happens.

 */

void irq_overnest_error(void)

{

        printk("Irqs nested beyond limit. Current count: %d",

                current_irq_nest_count);

        print_early("System halted...\n");

        while(1)

                ;

}