source: mainline/kernel/generic/src/log/log.c@ fc0de8c

/*
 * Copyright (c) 2013 Martin Sucha
 * 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 kernel_generic
 * @{
 */
/** @file
 */

#include <sysinfo/sysinfo.h>
#include <synch/spinlock.h>
#include <typedefs.h>
#include <ddi/irq.h>
#include <ddi/ddi.h>
#include <ipc/event.h>
#include <ipc/irq.h>
#include <arch.h>
#include <panic.h>
#include <putchar.h>
#include <atomic.h>
#include <syscall/copy.h>
#include <errno.h>
#include <str.h>
#include <print.h>
#include <printf/printf_core.h>
#include <stdarg.h>
#include <log.h>
#include <console/console.h>
#include <abi/log.h>
#include <stdlib.h>

#define LOG_PAGES    8
#define LOG_LENGTH   (LOG_PAGES * PAGE_SIZE)
#define LOG_ENTRY_HEADER_LENGTH (sizeof(size_t) + sizeof(uint32_t))

/** Cyclic buffer holding the data for kernel log */
uint8_t log_buffer[LOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));

/** Kernel log initialized */
static atomic_bool log_inited = false;

/** Position in the cyclic buffer where the first log entry starts */
size_t log_start = 0;

/** Sum of length of all log entries currently stored in the cyclic buffer */
size_t log_used = 0;

/** Log spinlock */
SPINLOCK_STATIC_INITIALIZE_NAME(log_lock, "log_lock");

/** Overall count of logged messages, which may overflow as needed */
static uint32_t log_counter = 0;

/** Starting position of the entry currently being written to the log */
static size_t log_current_start = 0;

/** Length (including header) of the entry currently being written to the log */
static size_t log_current_len = 0;

/** Start of the next entry to be handed to uspace starting from log_start */
static size_t next_for_uspace = 0;

static void log_update(void *);

/** Initialize kernel logging facility
 *
 */
void log_init(void)
{
        event_set_unmask_callback(EVENT_KLOG, log_update);
        atomic_store(&log_inited, true);
}

static size_t log_copy_from(uint8_t *data, size_t pos, size_t len)
{
        for (size_t i = 0; i < len; i++, pos = (pos + 1) % LOG_LENGTH) {
                data[i] = log_buffer[pos];
        }
        return pos;
}

static size_t log_copy_to(const uint8_t *data, size_t pos, size_t len)
{
        for (size_t i = 0; i < len; i++, pos = (pos + 1) % LOG_LENGTH) {
                log_buffer[pos] = data[i];
        }
        return pos;
}

/** Append data to the currently open log entry.
 *
 * This function requires that the log_lock is acquired by the caller.
 */
static void log_append(const uint8_t *data, size_t len)
{
        /* Cap the length so that the entry entirely fits into the buffer */
        if (len > LOG_LENGTH - log_current_len) {
                len = LOG_LENGTH - log_current_len;
        }

        if (len == 0)
                return;

        size_t log_free = LOG_LENGTH - log_used - log_current_len;

        /* Discard older entries to make space, if necessary */
        while (len > log_free) {
                size_t entry_len;
                log_copy_from((uint8_t *) &entry_len, log_start, sizeof(size_t));
                log_start = (log_start + entry_len) % LOG_LENGTH;
                log_used -= entry_len;
                log_free += entry_len;
                next_for_uspace -= entry_len;
        }

        size_t pos = (log_current_start + log_current_len) % LOG_LENGTH;
        log_copy_to(data, pos, len);
        log_current_len += len;
}

/** Begin writing an entry to the log.
 *
 * This acquires the log and output buffer locks, so only calls to log_* functions should
 * be used until calling log_end.
 */
void log_begin(log_facility_t fac, log_level_t level)
{
        spinlock_lock(&log_lock);
        spinlock_lock(&kio_lock);

        log_current_start = (log_start + log_used) % LOG_LENGTH;
        log_current_len = 0;

        /* Write header of the log entry, the length will be written in log_end() */
        log_append((uint8_t *) &log_current_len, sizeof(size_t));
        log_append((uint8_t *) &log_counter, sizeof(uint32_t));
        uint32_t fac32 = fac;
        uint32_t lvl32 = level;
        log_append((uint8_t *) &fac32, sizeof(uint32_t));
        log_append((uint8_t *) &lvl32, sizeof(uint32_t));

        log_counter++;
}

/** Finish writing an entry to the log.
 *
 * This releases the log and output buffer locks.
 */
void log_end(void)
{
        /* Set the length in the header to correct value */
        log_copy_to((uint8_t *) &log_current_len, log_current_start, sizeof(size_t));
        log_used += log_current_len;

        kio_push_char('\n');
        spinlock_unlock(&kio_lock);
        spinlock_unlock(&log_lock);

        /* This has to be called after we released the locks above */
        kio_flush();
        kio_update(NULL);
        log_update(NULL);
}

static void log_update(void *event)
{
        if (!atomic_load(&log_inited))
                return;

        spinlock_lock(&log_lock);
        if (next_for_uspace < log_used)
                event_notify_0(EVENT_KLOG, true);
        spinlock_unlock(&log_lock);
}

static int log_printf_str_write(const char *str, size_t size, void *data)
{
        size_t offset = 0;
        size_t chars = 0;

        while (offset < size) {
                kio_push_char(str_decode(str, &offset, size));
                chars++;
        }

        log_append((const uint8_t *)str, size);

        return chars;
}

static int log_printf_wstr_write(const wchar_t *wstr, size_t size, void *data)
{
        char buffer[16];
        size_t offset = 0;
        size_t chars = 0;

        for (offset = 0; offset < size; offset += sizeof(wchar_t), chars++) {
                kio_push_char(wstr[chars]);

                size_t buffer_offset = 0;
                errno_t rc = chr_encode(wstr[chars], buffer, &buffer_offset, 16);
                if (rc != EOK) {
                        return EOF;
                }

                log_append((const uint8_t *)buffer, buffer_offset);
        }

        return chars;
}

/** Append a message to the currently being written entry.
 *
 * Requires that an entry has been started using log_begin()
 */
int log_vprintf(const char *fmt, va_list args)
{
        int ret;

        printf_spec_t ps = {
                log_printf_str_write,
                log_printf_wstr_write,
                NULL
        };

        ret = printf_core(fmt, &ps, args);

        return ret;
}

/** Append a message to the currently being written entry.
 *
 * Requires that an entry has been started using log_begin()
 */
int log_printf(const char *fmt, ...)
{
        int ret;
        va_list args;

        va_start(args, fmt);
        ret = log_vprintf(fmt, args);
        va_end(args);

        return ret;
}

/** Log a message to the kernel log.
 *
 * This atomically appends a log entry.
 * The resulting message should not contain a trailing newline, as the log
 * entries are explicitly delimited when stored in the log.
 */
int log(log_facility_t fac, log_level_t level, const char *fmt, ...)
{
        int ret;
        va_list args;

        log_begin(fac, level);

        va_start(args, fmt);
        ret = log_vprintf(fmt, args);
        va_end(args);

        log_end();

        return ret;
}

/** Control of the log from uspace
 *
 */
sys_errno_t sys_klog(sysarg_t operation, uspace_addr_t buf, size_t size,
    sysarg_t level, uspace_ptr_size_t uspace_nread)
{
        char *data;
        errno_t rc;

        if (size > PAGE_SIZE)
                return (sys_errno_t) ELIMIT;

        switch (operation) {
        case KLOG_WRITE:
                data = (char *) malloc(size + 1);
                if (!data)
                        return (sys_errno_t) ENOMEM;

                rc = copy_from_uspace(data, buf, size);
                if (rc) {
                        free(data);
                        return (sys_errno_t) rc;
                }
                data[size] = 0;

                if (level >= LVL_LIMIT)
                        level = LVL_NOTE;

                log(LF_USPACE, level, "%s", data);

                free(data);
                return EOK;
        case KLOG_READ:
                data = (char *) malloc(size);
                if (!data)
                        return (sys_errno_t) ENOMEM;

                size_t entry_len = 0;
                size_t copied = 0;

                rc = EOK;

                spinlock_lock(&log_lock);

                while (next_for_uspace < log_used) {
                        size_t pos = (log_start + next_for_uspace) % LOG_LENGTH;
                        log_copy_from((uint8_t *) &entry_len, pos, sizeof(size_t));

                        if (entry_len > PAGE_SIZE) {
                                /*
                                 * Since we limit data transfer
                                 * to uspace to a maximum of PAGE_SIZE
                                 * bytes, skip any entries larger
                                 * than this limit to prevent
                                 * userspace being stuck trying to
                                 * read them.
                                 */
                                next_for_uspace += entry_len;
                                continue;
                        }

                        if (size < copied + entry_len) {
                                if (copied == 0)
                                        rc = EOVERFLOW;
                                break;
                        }

                        log_copy_from((uint8_t *) (data + copied), pos, entry_len);
                        copied += entry_len;
                        next_for_uspace += entry_len;
                }

                spinlock_unlock(&log_lock);

                if (rc != EOK) {
                        free(data);
                        return (sys_errno_t) rc;
                }

                rc = copy_to_uspace(buf, data, size);

                free(data);

                if (rc != EOK)
                        return (sys_errno_t) rc;

                return copy_to_uspace(uspace_nread, &copied, sizeof(copied));
                return EOK;
        default:
                return (sys_errno_t) ENOTSUP;
        }
}

/** @}
 */