/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This file is more or less the same as the Solaris IBTL debug
 * implementation. The debug functions and conf variables are
 * similar. One significant change is :
 *      sol_ofs_supress_above_l2
 * This has to be set to 0, in /etc/system to enable debug prints
 * above level 2.
 */
#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ib/clients/of/sol_ofs/sol_ofs_common.h>

#define SOL_OFS_PRINT_BUF_LEN           4096
#define SOL_OFS_DEBUG_BUF_SIZE          0x10000
#define SOL_OFS_DEBUG_EXTRA_SIZE        8
#define SOL_OFS_LOG_L5                  5
#define SOL_OFS_LOG_L4                  4
#define SOL_OFS_LOG_L3                  3
#define SOL_OFS_LOG_L2                  2
#define SOL_OFS_LOG_L1                  1
#define SOL_OFS_LOG_L0                  0

static kmutex_t sol_ofs_debug_mutex;
static char     sol_ofs_print_buf[SOL_OFS_PRINT_BUF_LEN];
static char     *sol_ofs_debug_sptr = NULL;
static char     *sol_ofs_debug_eptr = NULL;

char    *sol_ofs_debug_buf = NULL;
int     sol_ofs_clear_debug_buf_flag = 0;
int     sol_ofs_debug_buf_size = SOL_OFS_DEBUG_BUF_SIZE;
int     sol_ofs_suppress_dprintf = 0;
int     sol_ofs_buffer_dprintf = 1;
int     sol_ofs_supress_above_l2 = 1;

int     sol_ucma_errlevel = 2;          /* sol_ucma driver */
int     sol_uverbs_errlevel = 2;        /* sol_uverbs driver */
int     sol_umad_errlevel = 2;          /* sol_umad driver */

int     sol_rdmacm_errlevel = 2;        /* rdmacm part of sol_ofs */
int     sol_kverbs_errlevel = 2;        /* kverbs part of sol_ofs */
/* sol_ofs module (except rdmacm and kverbs) */
int     sol_ofs_module_errlevel = 2;

/* Global error levels for all OF related modules */
int     sol_of_errlevel = 2;

static void
sol_ofs_clear_dbg_buf()
{
        ASSERT(MUTEX_HELD(&sol_ofs_debug_mutex));
        if (sol_ofs_debug_buf) {
                sol_ofs_debug_sptr = sol_ofs_debug_buf;
                sol_ofs_debug_eptr = sol_ofs_debug_buf +
                    sol_ofs_debug_buf_size - SOL_OFS_DEBUG_EXTRA_SIZE;
                bzero(sol_ofs_debug_sptr, sol_ofs_debug_buf_size);
        }
}

/*
 * sol_ofs_dprintf_init() and sol_ofs_dprintf_fini() must be called
 * from the _init of the sol_ofs module.
 */
void
sol_ofs_dprintf_init()
{
        char    *dbg_buf;

        mutex_init(&sol_ofs_debug_mutex, NULL, MUTEX_DRIVER, NULL);

        if (sol_ofs_debug_buf_size < SOL_OFS_DEBUG_EXTRA_SIZE) {
#ifdef DEBUG
                cmn_err(CE_NOTE, "sol_ofs:\t debug buf size 0x%x too small, "
                    "setting to 0x%x", sol_ofs_debug_buf_size,
                    SOL_OFS_DEBUG_BUF_SIZE);
#endif
                sol_ofs_debug_buf_size = SOL_OFS_DEBUG_BUF_SIZE;
        }

        dbg_buf = kmem_zalloc(sol_ofs_debug_buf_size, KM_SLEEP);
        mutex_enter(&sol_ofs_debug_mutex);
        sol_ofs_debug_buf = dbg_buf;
        sol_ofs_clear_dbg_buf();
        mutex_exit(&sol_ofs_debug_mutex);
}

void
sol_ofs_dprintf_fini()
{
        char    *dbg_buf;

        mutex_enter(&sol_ofs_debug_mutex);
        dbg_buf = sol_ofs_debug_buf;
        sol_ofs_debug_buf = NULL;
        mutex_exit(&sol_ofs_debug_mutex);

        kmem_free(dbg_buf, sol_ofs_debug_buf_size);
        mutex_destroy(&sol_ofs_debug_mutex);
}

static void
sol_ofs_dprintf_vlog(char *name, uint_t level, char *fmt, va_list ap)
{
        char    *label = (name == NULL) ? "sol_ofs_ulp" : name;
        char    *msg_ptr;
        size_t  len;

        mutex_enter(&sol_ofs_debug_mutex);
        /* if not using logging scheme; quit */
        if (sol_ofs_suppress_dprintf || (sol_ofs_debug_buf == NULL)) {
                mutex_exit(&sol_ofs_debug_mutex);
                return;
        }
        /* if level doesn't match, we are done */
        if (level > SOL_OFS_LOG_L5) {
                mutex_exit(&sol_ofs_debug_mutex);
                return;
        }

        /* If user requests to clear debug buffer, go ahead */
        if (sol_ofs_clear_debug_buf_flag) {
                sol_ofs_clear_dbg_buf();
                sol_ofs_clear_debug_buf_flag = 0;
        }

        /* Skip printing to buffer, if too small */
        if (sol_ofs_debug_buf_size <= 0) {
                sol_ofs_buffer_dprintf = 0;
        }

        /* Put label and debug info into buffer */
        len = snprintf((char *)sol_ofs_print_buf, SOL_OFS_DRV_NAME_LEN,
            "%s:\t", label);
        msg_ptr = (char *)sol_ofs_print_buf + len;
        len += vsnprintf(msg_ptr, SOL_OFS_PRINT_BUF_LEN - len - 2, fmt, ap);
        len = min(len, SOL_OFS_PRINT_BUF_LEN - 2);
        ASSERT(len == strlen(sol_ofs_print_buf));
        sol_ofs_print_buf[len++] = '\n';
        sol_ofs_print_buf[len] = '\0';

        /* Stuff into debug buffer */
        if (sol_ofs_buffer_dprintf) {
                /*
                 * overwrite >>>> that might be over the end of the
                 * buffer.
                 */
                *sol_ofs_debug_sptr = '\0';

                if (sol_ofs_debug_sptr + len > sol_ofs_debug_eptr) {
                        size_t left;

                        left = sol_ofs_debug_eptr - sol_ofs_debug_sptr;
                        bcopy((caddr_t)sol_ofs_print_buf,
                            (caddr_t)sol_ofs_debug_sptr, left);
                        bcopy((caddr_t)sol_ofs_print_buf + left,
                            (caddr_t)sol_ofs_debug_buf, len - left);
                        sol_ofs_debug_sptr = sol_ofs_debug_buf + len - left;
                } else {
                        bcopy((caddr_t)sol_ofs_print_buf,
                            (caddr_t)sol_ofs_debug_sptr, len);
                        sol_ofs_debug_sptr += len;
                }
        }

        /*
         * L5-L2 message may go to the sol_ofs_debug_buf
         * L1 messages will go to the log buf in non-debug kernels and
         * to console and log buf in debug kernels
         * L0 messages are warnings and will go to console and log buf
         */
        switch (level) {
        case SOL_OFS_LOG_L5:
        case SOL_OFS_LOG_L4:
        case SOL_OFS_LOG_L3:
        case SOL_OFS_LOG_L2:
                if (!sol_ofs_buffer_dprintf) {
                        cmn_err(CE_CONT, "^%s", sol_ofs_print_buf);
                }
                break;
        case SOL_OFS_LOG_L1 :
#ifdef  DEBUG
                cmn_err(CE_CONT, "%s", sol_ofs_print_buf);
#else
                if (!sol_ofs_buffer_dprintf) {
                        cmn_err(CE_CONT, "^%s", sol_ofs_print_buf);
                }
#endif
                break;
        case SOL_OFS_LOG_L0 :
                /* Strip the "\n" added earlier */
                if (sol_ofs_print_buf[len - 1] == '\n') {
                        sol_ofs_print_buf[len - 1] = '\0';
                }
                if (msg_ptr[len - 1] == '\n') {
                        msg_ptr[len - 1] = '\0';
                }
                cmn_err(CE_WARN, sol_ofs_print_buf);
                break;
        }

        mutex_exit(&sol_ofs_debug_mutex);
}

/* Check individual error levels */
#define SOL_OFS_CHECK_ERR_LEVEL(level)                  \
        if (!(uint_t)strncmp(name, "sol_ucma", 8)) {    \
                if (sol_ucma_errlevel < level)          \
                        return;                         \
        } else if (!(uint_t)strncmp(name, "sol_rdmacm", 10)) {  \
                if (sol_rdmacm_errlevel < level)        \
                        return;                         \
        } else if (!(uint_t)strncmp(name, "sol_uverbs", 10)) {  \
                if (sol_uverbs_errlevel < level)        \
                        return;                         \
        } else if (!(uint_t)strncmp(name, "sol_umad", 8)) {     \
                if (sol_umad_errlevel < level)          \
                        return;                         \
        } else if (!(uint_t)strncmp(name, "sol_ofs_mod", 12)) { \
                if (sol_ofs_module_errlevel < level)    \
                        return;                         \
        } else if (strncmp(name, "sol_kverbs", 10) == 0) {      \
                if (sol_kverbs_errlevel < level)                \
                        return;                         \
        } else if (sol_of_errlevel < level)             \
                return;

void
sol_ofs_dprintf_l5(char *name, char *fmt, ...)
{
        va_list ap;

        if (sol_ofs_supress_above_l2)
                return;
        SOL_OFS_CHECK_ERR_LEVEL(SOL_OFS_LOG_L5);

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L5, fmt, ap);
        va_end(ap);
}

void
sol_ofs_dprintf_l4(char *name, char *fmt, ...)
{
        va_list ap;

        if (sol_ofs_supress_above_l2)
                return;
        SOL_OFS_CHECK_ERR_LEVEL(SOL_OFS_LOG_L4);

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L4, fmt, ap);
        va_end(ap);
}

void
sol_ofs_dprintf_l3(char *name, char *fmt, ...)
{
        va_list ap;

        if (sol_ofs_supress_above_l2)
                return;
        SOL_OFS_CHECK_ERR_LEVEL(SOL_OFS_LOG_L3);

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L3, fmt, ap);
        va_end(ap);
}

void
sol_ofs_dprintf_l2(char *name, char *fmt, ...)
{
        va_list ap;

        SOL_OFS_CHECK_ERR_LEVEL(SOL_OFS_LOG_L2);

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L2, fmt, ap);
        va_end(ap);
}

void
sol_ofs_dprintf_l1(char *name, char *fmt, ...)
{
        va_list ap;

        SOL_OFS_CHECK_ERR_LEVEL(SOL_OFS_LOG_L1);

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L1, fmt, ap);
        va_end(ap);
}

void
sol_ofs_dprintf_l0(char *name, char *fmt, ...)
{
        va_list ap;

        if (sol_of_errlevel < SOL_OFS_LOG_L0)
                return;

        va_start(ap, fmt);
        sol_ofs_dprintf_vlog(name, SOL_OFS_LOG_L1, fmt, ap);
        va_end(ap);
}