cpufreq: cpufreq-cpu0: remove dependency on THERMAL and REGULATOR

[linux/fpc-iii.git] / drivers / scsi / fnic / fnic_trace.c

/*
 * Copyright 2012 Cisco Systems, Inc.  All rights reserved.
 *
 * This program is free software; you may redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/module.h>
#include <linux/mempool.h>
#include <linux/errno.h>
#include <linux/spinlock.h>
#include <linux/kallsyms.h>
#include "fnic_io.h"
#include "fnic.h"

unsigned int trace_max_pages;
static int fnic_max_trace_entries;

static unsigned long fnic_trace_buf_p;
static DEFINE_SPINLOCK(fnic_trace_lock);

static fnic_trace_dbg_t fnic_trace_entries;
int fnic_tracing_enabled = 1;

/*
 * fnic_trace_get_buf - Give buffer pointer to user to fill up trace information
 *
 * Description:
 * This routine gets next available trace buffer entry location @wr_idx
 * from allocated trace buffer pages and give that memory location
 * to user to store the trace information.
 *
 * Return Value:
 * This routine returns pointer to next available trace entry
 * @fnic_buf_head for user to fill trace information.
 */
fnic_trace_data_t *fnic_trace_get_buf(void)
{
        unsigned long fnic_buf_head;
        unsigned long flags;

        spin_lock_irqsave(&fnic_trace_lock, flags);

        /*
         * Get next available memory location for writing trace information
         * at @wr_idx and increment @wr_idx
         */
        fnic_buf_head =
                fnic_trace_entries.page_offset[fnic_trace_entries.wr_idx];
        fnic_trace_entries.wr_idx++;

        /*
         * Verify if trace buffer is full then change wd_idx to
         * start from zero
         */
        if (fnic_trace_entries.wr_idx >= fnic_max_trace_entries)
                fnic_trace_entries.wr_idx = 0;

        /*
         * Verify if write index @wr_idx and read index @rd_idx are same then
         * increment @rd_idx to move to next entry in trace buffer
         */
        if (fnic_trace_entries.wr_idx == fnic_trace_entries.rd_idx) {
                fnic_trace_entries.rd_idx++;
                if (fnic_trace_entries.rd_idx >= fnic_max_trace_entries)
                        fnic_trace_entries.rd_idx = 0;
        }
        spin_unlock_irqrestore(&fnic_trace_lock, flags);
        return (fnic_trace_data_t *)fnic_buf_head;
}

/*
 * fnic_get_trace_data - Copy trace buffer to a memory file
 * @fnic_dbgfs_t: pointer to debugfs trace buffer
 *
 * Description:
 * This routine gathers the fnic trace debugfs data from the fnic_trace_data_t
 * buffer and dumps it to fnic_dbgfs_t. It will start at the rd_idx entry in
 * the log and process the log until the end of the buffer. Then it will gather
 * from the beginning of the log and process until the current entry @wr_idx.
 *
 * Return Value:
 * This routine returns the amount of bytes that were dumped into fnic_dbgfs_t
 */
int fnic_get_trace_data(fnic_dbgfs_t *fnic_dbgfs_prt)
{
        int rd_idx;
        int wr_idx;
        int len = 0;
        unsigned long flags;
        char str[KSYM_SYMBOL_LEN];
        struct timespec val;
        fnic_trace_data_t *tbp;

        spin_lock_irqsave(&fnic_trace_lock, flags);
        rd_idx = fnic_trace_entries.rd_idx;
        wr_idx = fnic_trace_entries.wr_idx;
        if (wr_idx < rd_idx) {
                while (1) {
                        /* Start from read index @rd_idx */
                        tbp = (fnic_trace_data_t *)
                                  fnic_trace_entries.page_offset[rd_idx];
                        if (!tbp) {
                                spin_unlock_irqrestore(&fnic_trace_lock, flags);
                                return 0;
                        }
                        /* Convert function pointer to function name */
                        if (sizeof(unsigned long) < 8) {
                                sprint_symbol(str, tbp->fnaddr.low);
                                jiffies_to_timespec(tbp->timestamp.low, &val);
                        } else {
                                sprint_symbol(str, tbp->fnaddr.val);
                                jiffies_to_timespec(tbp->timestamp.val, &val);
                        }
                        /*
                         * Dump trace buffer entry to memory file
                         * and increment read index @rd_idx
                         */
                        len += snprintf(fnic_dbgfs_prt->buffer + len,
                                  (trace_max_pages * PAGE_SIZE * 3) - len,
                                  "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
                                  "%16llx %16llx %16llx\n", val.tv_sec,
                                  val.tv_nsec, str, tbp->host_no, tbp->tag,
                                  tbp->data[0], tbp->data[1], tbp->data[2],
                                  tbp->data[3], tbp->data[4]);
                        rd_idx++;
                        /*
                         * If rd_idx is reached to maximum trace entries
                         * then move rd_idx to zero
                         */
                        if (rd_idx > (fnic_max_trace_entries-1))
                                rd_idx = 0;
                        /*
                         * Continure dumpping trace buffer entries into
                         * memory file till rd_idx reaches write index
                         */
                        if (rd_idx == wr_idx)
                                break;
                }
        } else if (wr_idx > rd_idx) {
                while (1) {
                        /* Start from read index @rd_idx */
                        tbp = (fnic_trace_data_t *)
                                  fnic_trace_entries.page_offset[rd_idx];
                        if (!tbp) {
                                spin_unlock_irqrestore(&fnic_trace_lock, flags);
                                return 0;
                        }
                        /* Convert function pointer to function name */
                        if (sizeof(unsigned long) < 8) {
                                sprint_symbol(str, tbp->fnaddr.low);
                                jiffies_to_timespec(tbp->timestamp.low, &val);
                        } else {
                                sprint_symbol(str, tbp->fnaddr.val);
                                jiffies_to_timespec(tbp->timestamp.val, &val);
                        }
                        /*
                         * Dump trace buffer entry to memory file
                         * and increment read index @rd_idx
                         */
                        len += snprintf(fnic_dbgfs_prt->buffer + len,
                                  (trace_max_pages * PAGE_SIZE * 3) - len,
                                  "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
                                  "%16llx %16llx %16llx\n", val.tv_sec,
                                  val.tv_nsec, str, tbp->host_no, tbp->tag,
                                  tbp->data[0], tbp->data[1], tbp->data[2],
                                  tbp->data[3], tbp->data[4]);
                        rd_idx++;
                        /*
                         * Continue dumpping trace buffer entries into
                         * memory file till rd_idx reaches write index
                         */
                        if (rd_idx == wr_idx)
                                break;
                }
        }
        spin_unlock_irqrestore(&fnic_trace_lock, flags);
        return len;
}

/*
 * fnic_get_stats_data - Copy fnic stats buffer to a memory file
 * @fnic_dbgfs_t: pointer to debugfs fnic stats buffer
 *
 * Description:
 * This routine gathers the fnic stats debugfs data from the fnic_stats struct
 * and dumps it to stats_debug_info.
 *
 * Return Value:
 * This routine returns the amount of bytes that were dumped into
 * stats_debug_info
 */
int fnic_get_stats_data(struct stats_debug_info *debug,
                        struct fnic_stats *stats)
{
        int len = 0;
        int buf_size = debug->buf_size;
        struct timespec val1, val2;

        len = snprintf(debug->debug_buffer + len, buf_size - len,
                  "------------------------------------------\n"
                  "\t\tIO Statistics\n"
                  "------------------------------------------\n");
        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Active IOs: %lld\nMaximum Active IOs: %lld\n"
                  "Number of IOs: %lld\nNumber of IO Completions: %lld\n"
                  "Number of IO Failures: %lld\nNumber of IO NOT Found: %lld\n"
                  "Number of Memory alloc Failures: %lld\n"
                  "Number of IOREQ Null: %lld\n"
                  "Number of SCSI cmd pointer Null: %lld\n",
                  (u64)atomic64_read(&stats->io_stats.active_ios),
                  (u64)atomic64_read(&stats->io_stats.max_active_ios),
                  (u64)atomic64_read(&stats->io_stats.num_ios),
                  (u64)atomic64_read(&stats->io_stats.io_completions),
                  (u64)atomic64_read(&stats->io_stats.io_failures),
                  (u64)atomic64_read(&stats->io_stats.io_not_found),
                  (u64)atomic64_read(&stats->io_stats.alloc_failures),
                  (u64)atomic64_read(&stats->io_stats.ioreq_null),
                  (u64)atomic64_read(&stats->io_stats.sc_null));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tAbort Statistics\n"
                  "------------------------------------------\n");
        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Aborts: %lld\n"
                  "Number of Abort Failures: %lld\n"
                  "Number of Abort Driver Timeouts: %lld\n"
                  "Number of Abort FW Timeouts: %lld\n"
                  "Number of Abort IO NOT Found: %lld\n",
                  (u64)atomic64_read(&stats->abts_stats.aborts),
                  (u64)atomic64_read(&stats->abts_stats.abort_failures),
                  (u64)atomic64_read(&stats->abts_stats.abort_drv_timeouts),
                  (u64)atomic64_read(&stats->abts_stats.abort_fw_timeouts),
                  (u64)atomic64_read(&stats->abts_stats.abort_io_not_found));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tTerminate Statistics\n"
                  "------------------------------------------\n");
        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Terminates: %lld\n"
                  "Maximum Terminates: %lld\n"
                  "Number of Terminate Driver Timeouts: %lld\n"
                  "Number of Terminate FW Timeouts: %lld\n"
                  "Number of Terminate IO NOT Found: %lld\n"
                  "Number of Terminate Failures: %lld\n",
                  (u64)atomic64_read(&stats->term_stats.terminates),
                  (u64)atomic64_read(&stats->term_stats.max_terminates),
                  (u64)atomic64_read(&stats->term_stats.terminate_drv_timeouts),
                  (u64)atomic64_read(&stats->term_stats.terminate_fw_timeouts),
                  (u64)atomic64_read(&stats->term_stats.terminate_io_not_found),
                  (u64)atomic64_read(&stats->term_stats.terminate_failures));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tReset Statistics\n"
                  "------------------------------------------\n");

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Device Resets: %lld\n"
                  "Number of Device Reset Failures: %lld\n"
                  "Number of Device Reset Aborts: %lld\n"
                  "Number of Device Reset Timeouts: %lld\n"
                  "Number of Device Reset Terminates: %lld\n"
                  "Number of FW Resets: %lld\n"
                  "Number of FW Reset Completions: %lld\n"
                  "Number of FW Reset Failures: %lld\n"
                  "Number of Fnic Reset: %lld\n"
                  "Number of Fnic Reset Completions: %lld\n"
                  "Number of Fnic Reset Failures: %lld\n",
                  (u64)atomic64_read(&stats->reset_stats.device_resets),
                  (u64)atomic64_read(&stats->reset_stats.device_reset_failures),
                  (u64)atomic64_read(&stats->reset_stats.device_reset_aborts),
                  (u64)atomic64_read(&stats->reset_stats.device_reset_timeouts),
                  (u64)atomic64_read(
                          &stats->reset_stats.device_reset_terminates),
                  (u64)atomic64_read(&stats->reset_stats.fw_resets),
                  (u64)atomic64_read(&stats->reset_stats.fw_reset_completions),
                  (u64)atomic64_read(&stats->reset_stats.fw_reset_failures),
                  (u64)atomic64_read(&stats->reset_stats.fnic_resets),
                  (u64)atomic64_read(
                          &stats->reset_stats.fnic_reset_completions),
                  (u64)atomic64_read(&stats->reset_stats.fnic_reset_failures));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tFirmware Statistics\n"
                  "------------------------------------------\n");

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Active FW Requests %lld\n"
                  "Maximum FW Requests: %lld\n"
                  "Number of FW out of resources: %lld\n"
                  "Number of FW IO errors: %lld\n",
                  (u64)atomic64_read(&stats->fw_stats.active_fw_reqs),
                  (u64)atomic64_read(&stats->fw_stats.max_fw_reqs),
                  (u64)atomic64_read(&stats->fw_stats.fw_out_of_resources),
                  (u64)atomic64_read(&stats->fw_stats.io_fw_errs));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tVlan Discovery Statistics\n"
                  "------------------------------------------\n");

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Number of Vlan Discovery Requests Sent %lld\n"
                  "Vlan Response Received with no FCF VLAN ID: %lld\n"
                  "No solicitations recvd after vlan set, expiry count: %lld\n"
                  "Flogi rejects count: %lld\n",
                  (u64)atomic64_read(&stats->vlan_stats.vlan_disc_reqs),
                  (u64)atomic64_read(&stats->vlan_stats.resp_withno_vlanID),
                  (u64)atomic64_read(&stats->vlan_stats.sol_expiry_count),
                  (u64)atomic64_read(&stats->vlan_stats.flogi_rejects));

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "\n------------------------------------------\n"
                  "\t\tOther Important Statistics\n"
                  "------------------------------------------\n");

        jiffies_to_timespec(stats->misc_stats.last_isr_time, &val1);
        jiffies_to_timespec(stats->misc_stats.last_ack_time, &val2);

        len += snprintf(debug->debug_buffer + len, buf_size - len,
                  "Last ISR time: %llu (%8lu.%8lu)\n"
                  "Last ACK time: %llu (%8lu.%8lu)\n"
                  "Number of ISRs: %lld\n"
                  "Maximum CQ Entries: %lld\n"
                  "Number of ACK index out of range: %lld\n"
                  "Number of data count mismatch: %lld\n"
                  "Number of FCPIO Timeouts: %lld\n"
                  "Number of FCPIO Aborted: %lld\n"
                  "Number of SGL Invalid: %lld\n"
                  "Number of Copy WQ Alloc Failures for ABTs: %lld\n"
                  "Number of Copy WQ Alloc Failures for Device Reset: %lld\n"
                  "Number of Copy WQ Alloc Failures for IOs: %lld\n"
                  "Number of no icmnd itmf Completions: %lld\n"
                  "Number of QUEUE Fulls: %lld\n"
                  "Number of rport not ready: %lld\n"
                  "Number of receive frame errors: %lld\n",
                  (u64)stats->misc_stats.last_isr_time,
                  val1.tv_sec, val1.tv_nsec,
                  (u64)stats->misc_stats.last_ack_time,
                  val2.tv_sec, val2.tv_nsec,
                  (u64)atomic64_read(&stats->misc_stats.isr_count),
                  (u64)atomic64_read(&stats->misc_stats.max_cq_entries),
                  (u64)atomic64_read(&stats->misc_stats.ack_index_out_of_range),
                  (u64)atomic64_read(&stats->misc_stats.data_count_mismatch),
                  (u64)atomic64_read(&stats->misc_stats.fcpio_timeout),
                  (u64)atomic64_read(&stats->misc_stats.fcpio_aborted),
                  (u64)atomic64_read(&stats->misc_stats.sgl_invalid),
                  (u64)atomic64_read(
                          &stats->misc_stats.abts_cpwq_alloc_failures),
                  (u64)atomic64_read(
                          &stats->misc_stats.devrst_cpwq_alloc_failures),
                  (u64)atomic64_read(&stats->misc_stats.io_cpwq_alloc_failures),
                  (u64)atomic64_read(&stats->misc_stats.no_icmnd_itmf_cmpls),
                  (u64)atomic64_read(&stats->misc_stats.queue_fulls),
                  (u64)atomic64_read(&stats->misc_stats.rport_not_ready),
                  (u64)atomic64_read(&stats->misc_stats.frame_errors));

        return len;

}

/*
 * fnic_trace_buf_init - Initialize fnic trace buffer logging facility
 *
 * Description:
 * Initialize trace buffer data structure by allocating required memory and
 * setting page_offset information for every trace entry by adding trace entry
 * length to previous page_offset value.
 */
int fnic_trace_buf_init(void)
{
        unsigned long fnic_buf_head;
        int i;
        int err = 0;

        trace_max_pages = fnic_trace_max_pages;
        fnic_max_trace_entries = (trace_max_pages * PAGE_SIZE)/
                                          FNIC_ENTRY_SIZE_BYTES;

        fnic_trace_buf_p = (unsigned long)vmalloc((trace_max_pages * PAGE_SIZE));
        if (!fnic_trace_buf_p) {
                printk(KERN_ERR PFX "Failed to allocate memory "
                                  "for fnic_trace_buf_p\n");
                err = -ENOMEM;
                goto err_fnic_trace_buf_init;
        }
        memset((void *)fnic_trace_buf_p, 0, (trace_max_pages * PAGE_SIZE));

        fnic_trace_entries.page_offset = vmalloc(fnic_max_trace_entries *
                                                  sizeof(unsigned long));
        if (!fnic_trace_entries.page_offset) {
                printk(KERN_ERR PFX "Failed to allocate memory for"
                                  " page_offset\n");
                if (fnic_trace_buf_p) {
                        vfree((void *)fnic_trace_buf_p);
                        fnic_trace_buf_p = 0;
                }
                err = -ENOMEM;
                goto err_fnic_trace_buf_init;
        }
        memset((void *)fnic_trace_entries.page_offset, 0,
                  (fnic_max_trace_entries * sizeof(unsigned long)));
        fnic_trace_entries.wr_idx = fnic_trace_entries.rd_idx = 0;
        fnic_buf_head = fnic_trace_buf_p;

        /*
         * Set page_offset field of fnic_trace_entries struct by
         * calculating memory location for every trace entry using
         * length of each trace entry
         */
        for (i = 0; i < fnic_max_trace_entries; i++) {
                fnic_trace_entries.page_offset[i] = fnic_buf_head;
                fnic_buf_head += FNIC_ENTRY_SIZE_BYTES;
        }
        err = fnic_trace_debugfs_init();
        if (err < 0) {
                printk(KERN_ERR PFX "Failed to initialize debugfs for tracing\n");
                goto err_fnic_trace_debugfs_init;
        }
        printk(KERN_INFO PFX "Successfully Initialized Trace Buffer\n");
        return err;
err_fnic_trace_debugfs_init:
        fnic_trace_free();
err_fnic_trace_buf_init:
        return err;
}

/*
 * fnic_trace_free - Free memory of fnic trace data structures.
 */
void fnic_trace_free(void)
{
        fnic_tracing_enabled = 0;
        fnic_trace_debugfs_terminate();
        if (fnic_trace_entries.page_offset) {
                vfree((void *)fnic_trace_entries.page_offset);
                fnic_trace_entries.page_offset = NULL;
        }
        if (fnic_trace_buf_p) {
                vfree((void *)fnic_trace_buf_p);
                fnic_trace_buf_p = 0;
        }
        printk(KERN_INFO PFX "Successfully Freed Trace Buffer\n");
}