ocs_lnx.c

Go to the documentation of this file.

/**
 * Copyright (C) 2013-2015 Emulex
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.  The full GNU General
 * Public License can be found at <http://www.gnu.org/licenses/>.
 *
 * Written by: Chris Moore (chris.moore@emulex.com)
 *
 * Emulex
 * 3333 Susan Street
 * Costa Mesa, CA 92626
 */


#include "ocs.h"
#include "ocs_ini_template.h"

/* Copyright notice */
static const char ocs_copyright[] = "Copyright © 2013 Emulex. All rights reserved";

int logdest = 1;
int loglevel = 3;

extern ocs_scsi_ini_template_t ocs_iscsi_ini_template;

/**
 * @brief driver load entry point
 *
 * Called when driver is loaded, device class DRV_NAME is created, and
 * PCI devices are enumerated.
 *
 * @return returns 0 for success, a negative error code value for failure.
 */
static int __init ocs_init(void)
{
    int i;
    int ocs_count = 0;
    ocs_t *ocs;

    /* Initialize this back-end module */
    ocs_scsi_ini_driver_init(TRUE);

    /* Enumerate OCS devices and call new device (this will register callbacks with base driver) */
    for (i = 0; (ocs = ocs_get_instance(i));  i++) {
        if (ocs_scsi_ini_new_device(ocs) == 0) {
            ++ocs_count;
        }
    }

    if (ocs_count == 0) {
        ocs_scsi_ini_driver_exit(TRUE);
        printk(KERN_INFO "No valid devices found, %s not loaded\n", DRV_NAME);
        return -ENODEV;
    }

    printk(KERN_INFO "%s loaded\n", DRV_NAME);

    return 0;
}

/**
 * @brief driver unload entry point
 *
 * Called when driver is unloaded.   PCI devices are removed, and device class objects
 * removed.
 *
 * @return none
 */
static void __exit ocs_exit(void)
{
    int i;
    ocs_t *ocs;

    /* Enumerate OCS devices and call del device (this will delete callbacks with base driver) */
    for (i = 0; (ocs = ocs_get_instance(i)); i++) {
        ocs_scsi_ini_del_device(ocs);
    }
    ocs_scsi_ini_driver_exit(TRUE);

    printk(KERN_INFO "%s unloaded\n", DRV_NAME);
}

const char *ocs_display_name(void *os)
{
    ocs_t *ocs = os;
    ocs_assert(ocs, "[?]");

    return ocs->display_name;

}

static inline int get_current_tid(void)
{
    /* Code should be the same as in sys_gettid() */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
    return current->pid;
#else
    if (in_interrupt()) {
        /*
         * Unfortunately, task_pid_vnr() isn't IRQ-safe, so otherwise
         * it can oops. ToDo.
         */
        return current->pid;
    }
    return task_pid_vnr(current);
#endif
}

static const char *log_level_to_klog_level(int level)
{
    switch (level) {
        case LOG_CRIT:
            return KERN_CRIT;
        case LOG_ERR:
            return KERN_ERR;
        case LOG_WARN:
            return KERN_WARNING;
        case LOG_INFO:
        case LOG_TEST:
        case LOG_DEBUG:
            return KERN_INFO;
        default:
            return "";
    }
}

void _ocs_log(void *os, const char *func_name, int line, int level, const char *fmt, ...)
{
    va_list ap;
    char buf[256];
    char *p = buf;

    va_start(ap, fmt);

    if (logdest & 2) {
        struct timeval tv;

        do_gettimeofday(&tv);

        p += snprintf(p, sizeof(buf) - (p - buf), "%10ld.%06ld: ", tv.tv_sec, tv.tv_usec);
    }

    p += snprintf(p, sizeof(buf) - (p - buf), "[%d]: ", get_current_tid());

    p += snprintf(p, sizeof(buf) - (p - buf), "%s: ", DRV_NAME);
    p += snprintf(p, sizeof(buf) - (p - buf), "%s:", func_name);
    p += snprintf(p, sizeof(buf) - (p - buf), "%i:", line);
    p += snprintf(p, sizeof(buf) - (p - buf), "%s:", (os != NULL) ? ocs_display_name(os) : "");
    p += vsnprintf(p, sizeof(buf) - (p - buf), fmt, ap);

    va_end(ap);

    if (logdest & 1) {
        printk("%s%s", log_level_to_klog_level(level), buf);
    }

    if (logdest & 2) {
        ocs_ramlog_printf(os, "%s", buf);
    }
}

void
_ocs_assert(const char *cond, const char *filename, int linenum)
{
    const char *fn = strrchr(__FILE__, '/');

    ocs_log_err(NULL, "%s(%d) assertion (%s) failed\n", (fn ? fn + 1 : filename), linenum, cond);
    ocs_print_stack();
    ocs_save_ddump_all(OCS_DDUMP_FLAGS_WQES|OCS_DDUMP_FLAGS_CQES|OCS_DDUMP_FLAGS_MQES, -1, TRUE);
}
module_init(ocs_init);
module_exit(ocs_exit);

MODULE_VERSION(DRV_VERSION);
MODULE_LICENSE("GPL");