Subversion Repositories HelenOS

/*

 * Copyright (c) 2003 Josef Cejka

 * Copyright (c) 2005 Jakub Jermar

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - 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.

 * - The name of the author may not 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 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.

 */

/** @addtogroup genericconsole

 * @{

 */

/** @file

 */

#include <console/console.h>

#include <console/chardev.h>

#include <sysinfo/sysinfo.h>

#include <synch/waitq.h>

#include <synch/spinlock.h>

#include <arch/types.h>

#include <ddi/device.h>

#include <ddi/irq.h>

#include <ddi/ddi.h>

#include <ipc/irq.h>

#include <arch.h>

#include <func.h>

#include <print.h>

#include <atomic.h>

#define KLOG_SIZE PAGE_SIZE

#define KLOG_LATENCY 8

/** Kernel log cyclic buffer */

static char klog[KLOG_SIZE] __attribute__ ((aligned (PAGE_SIZE)));

/** Kernel log initialized */

static bool klog_inited = false;

/** First kernel log characters */

static index_t klog_start = 0;

/** Number of valid kernel log characters */

static size_t klog_len = 0;

/** Number of stored (not printed) kernel log characters */

static size_t klog_stored = 0;

/** Number of stored kernel log characters for uspace */

static size_t klog_uspace = 0;

/** Silence output */

bool silent = false;

/** Kernel log spinlock */

SPINLOCK_INITIALIZE(klog_lock);

/** Physical memory area used for klog buffer */

static parea_t klog_parea;

/*

 * For now, we use 0 as INR.

 * However, it is therefore desirable to have architecture specific

 * definition of KLOG_VIRT_INR in the future.

 */

#define KLOG_VIRT_INR   0

static irq_t klog_irq;

static chardev_operations_t null_stdout_ops = {

    .suspend = NULL,

    .resume = NULL,

    .write = NULL,

    .read = NULL

};

chardev_t null_stdout = {

    .name = "null",

    .op = &null_stdout_ops

};

/** Allways refuse IRQ ownership.

 *

 * This is not a real IRQ, so we always decline.

 *

 * @return Always returns IRQ_DECLINE.

 */

static irq_ownership_t klog_claim(irq_t *irq)

{

    return IRQ_DECLINE;

}

static void stdin_suspend(chardev_t *d)

{

}

static void stdin_resume(chardev_t *d)

{

}

static chardev_operations_t stdin_ops = {

    .suspend = stdin_suspend,

    .resume = stdin_resume,

};

/** Standard input character device */

static chardev_t _stdin;

chardev_t *stdin = NULL;

chardev_t *stdout = &null_stdout;

void console_init(void)

{

    chardev_initialize("stdin", &_stdin, &stdin_ops);

    stdin = &_stdin;

}

/** Initialize kernel logging facility

 *

 * The shared area contains kernel cyclic buffer. Userspace application may

 * be notified on new data with indication of position and size

 * of the data within the circular buffer.

 */

void klog_init(void)

{

    void *faddr = (void *) KA2PA(klog);

    ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);

    ASSERT(KLOG_SIZE % FRAME_SIZE == 0);

    devno_t devno = device_assign_devno();

    klog_parea.pbase = (uintptr_t) faddr;

    klog_parea.frames = SIZE2FRAMES(KLOG_SIZE);

    ddi_parea_register(&klog_parea);

    sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);

    sysinfo_set_item_val("klog.pages", NULL, SIZE2FRAMES(KLOG_SIZE));

    sysinfo_set_item_val("klog.devno", NULL, devno);

    sysinfo_set_item_val("klog.inr", NULL, KLOG_VIRT_INR);

    irq_initialize(&klog_irq);

    klog_irq.devno = devno;

    klog_irq.inr = KLOG_VIRT_INR;

    klog_irq.claim = klog_claim;

    irq_register(&klog_irq);

    spinlock_lock(&klog_lock);

    klog_inited = true;

    spinlock_unlock(&klog_lock);

}

void grab_console(void)

{

    silent = false;

    arch_grab_console();

}

void release_console(void)

{

    silent = true;

    arch_release_console();

}

/** Get character from character device. Do not echo character.

 *

 * @param chardev Character device.

 *

 * @return Character read.

 */

uint8_t _getc(chardev_t *chardev)

{

    uint8_t ch;

    ipl_t ipl;

    if (atomic_get(&haltstate)) {

        /* If we are here, we are hopefully on the processor, that

         * issued the 'halt' command, so proceed to read the character

         * directly from input

         */

        if (chardev->op->read)

            return chardev->op->read(chardev);

        /* no other way of interacting with user, halt */

        if (CPU)

            printf("cpu%u: ", CPU->id);

        else

            printf("cpu: ");

        printf("halted (no kconsole)\n");

        cpu_halt();

    }

    waitq_sleep(&chardev->wq);

    ipl = interrupts_disable();

    spinlock_lock(&chardev->lock);

    ch = chardev->buffer[(chardev->index - chardev->counter) % CHARDEV_BUFLEN];

    chardev->counter--;

    spinlock_unlock(&chardev->lock);

    interrupts_restore(ipl);

    chardev->op->resume(chardev);

    return ch;

}

/** Get string from character device.

 *

 * Read characters from character device until first occurrence

 * of newline character.

 *

 * @param chardev Character device.

 * @param buf Buffer where to store string terminated by '\0'.

 * @param buflen Size of the buffer.

 *

 * @return Number of characters read.

 */

count_t gets(chardev_t *chardev, char *buf, size_t buflen)

{

    index_t index = 0;

    char ch;

    while (index < buflen) {

        ch = _getc(chardev);

        if (ch == '\b') {

            if (index > 0) {

                index--;

                /* Space backspace, space */

                putchar('\b');

                putchar(' ');

                putchar('\b');

            }

            continue;

        }

        putchar(ch);

        if (ch == '\n') { /* end of string => write 0, return */

            buf[index] = '\0';

            return (count_t) index;

        }

        buf[index++] = ch;

    }

    return (count_t) index;

}

/** Get character from device & echo it to screen */

uint8_t getc(chardev_t *chardev)

{

    uint8_t ch;

    ch = _getc(chardev);

    putchar(ch);

    return ch;

}

void klog_update(void)

{

    spinlock_lock(&klog_lock);

    if ((klog_inited) && (klog_irq.notif_cfg.notify) && (klog_uspace > 0)) {

        ipc_irq_send_msg_3(&klog_irq, klog_start, klog_len, klog_uspace);

        klog_uspace = 0;

    }

    spinlock_unlock(&klog_lock);

}

void putchar(char c)

{

    spinlock_lock(&klog_lock);

    if ((klog_stored > 0) && (stdout->op->write)) {

        /* Print charaters stored in kernel log */

        index_t i;

        for (i = klog_len - klog_stored; i < klog_len; i++)

            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE], silent);

        klog_stored = 0;

    }

    /* Store character in the cyclic kernel log */

    klog[(klog_start + klog_len) % KLOG_SIZE] = c;

    if (klog_len < KLOG_SIZE)

        klog_len++;

    else

        klog_start = (klog_start + 1) % KLOG_SIZE;

    if (stdout->op->write)

        stdout->op->write(stdout, c, silent);

    else {

        /* The character is just in the kernel log */

        if (klog_stored < klog_len)

            klog_stored++;

    }

    /* The character is stored for uspace */

    if (klog_uspace < klog_len)

        klog_uspace++;

    /* Check notify uspace to update */

    bool update;

    if ((klog_uspace > KLOG_LATENCY) || (c == '\n'))

        update = true;

    else

        update = false;

    spinlock_unlock(&klog_lock);

    if (update)

        klog_update();

}

/** @}

 */