drivers/scsi/fnic/fnic_trace.c

   1 /*
   2  * Copyright 2012 Cisco Systems, Inc.  All rights reserved.
   3  *
   4  * This program is free software; you may redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   9  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  10  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  11  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  12  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  13  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  14  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  15  * SOFTWARE.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/mempool.h>
  20 #include <linux/errno.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/kallsyms.h>
  23 #include <linux/time.h>
  24 #include <linux/vmalloc.h>
  25 #include "fnic_io.h"
  26 #include "fnic.h"
  27
  28 unsigned int trace_max_pages;
  29 static int fnic_max_trace_entries;
  30
  31 static unsigned long fnic_trace_buf_p;
  32 static DEFINE_SPINLOCK(fnic_trace_lock);
  33
  34 static fnic_trace_dbg_t fnic_trace_entries;
  35 int fnic_tracing_enabled = 1;
  36
  37 /* static char *fnic_fc_ctlr_trace_buf_p; */
  38
  39 static int fc_trace_max_entries;
  40 static unsigned long fnic_fc_ctlr_trace_buf_p;
  41 static fnic_trace_dbg_t fc_trace_entries;
  42 int fnic_fc_tracing_enabled = 1;
  43 int fnic_fc_trace_cleared = 1;
  44 static DEFINE_SPINLOCK(fnic_fc_trace_lock);
  45
  46
  47 /*
  48  * fnic_trace_get_buf - Give buffer pointer to user to fill up trace information
  49  *
  50  * Description:
  51  * This routine gets next available trace buffer entry location @wr_idx
  52  * from allocated trace buffer pages and give that memory location
  53  * to user to store the trace information.
  54  *
  55  * Return Value:
  56  * This routine returns pointer to next available trace entry
  57  * @fnic_buf_head for user to fill trace information.
  58  */
  59 fnic_trace_data_t *fnic_trace_get_buf(void)
  60 {
  61         unsigned long fnic_buf_head;
  62         unsigned long flags;
  63
  64         spin_lock_irqsave(&fnic_trace_lock, flags);
  65
  66         /*
  67          * Get next available memory location for writing trace information
  68          * at @wr_idx and increment @wr_idx
  69          */
  70         fnic_buf_head =
  71                 fnic_trace_entries.page_offset[fnic_trace_entries.wr_idx];
  72         fnic_trace_entries.wr_idx++;
  73
  74         /*
  75          * Verify if trace buffer is full then change wd_idx to
  76          * start from zero
  77          */
  78         if (fnic_trace_entries.wr_idx >= fnic_max_trace_entries)
  79                 fnic_trace_entries.wr_idx = 0;
  80
  81         /*
  82          * Verify if write index @wr_idx and read index @rd_idx are same then
  83          * increment @rd_idx to move to next entry in trace buffer
  84          */
  85         if (fnic_trace_entries.wr_idx == fnic_trace_entries.rd_idx) {
  86                 fnic_trace_entries.rd_idx++;
  87                 if (fnic_trace_entries.rd_idx >= fnic_max_trace_entries)
  88                         fnic_trace_entries.rd_idx = 0;
  89         }
  90         spin_unlock_irqrestore(&fnic_trace_lock, flags);
  91         return (fnic_trace_data_t *)fnic_buf_head;
  92 }
  93
  94 /*
  95  * fnic_get_trace_data - Copy trace buffer to a memory file
  96  * @fnic_dbgfs_t: pointer to debugfs trace buffer
  97  *
  98  * Description:
  99  * This routine gathers the fnic trace debugfs data from the fnic_trace_data_t
 100  * buffer and dumps it to fnic_dbgfs_t. It will start at the rd_idx entry in
 101  * the log and process the log until the end of the buffer. Then it will gather
 102  * from the beginning of the log and process until the current entry @wr_idx.
 103  *
 104  * Return Value:
 105  * This routine returns the amount of bytes that were dumped into fnic_dbgfs_t
 106  */
 107 int fnic_get_trace_data(fnic_dbgfs_t *fnic_dbgfs_prt)
 108 {
 109         int rd_idx;
 110         int wr_idx;
 111         int len = 0;
 112         unsigned long flags;
 113         char str[KSYM_SYMBOL_LEN];
 114         struct timespec val;
 115         fnic_trace_data_t *tbp;
 116
 117         spin_lock_irqsave(&fnic_trace_lock, flags);
 118         rd_idx = fnic_trace_entries.rd_idx;
 119         wr_idx = fnic_trace_entries.wr_idx;
 120         if (wr_idx < rd_idx) {
 121                 while (1) {
 122                         /* Start from read index @rd_idx */
 123                         tbp = (fnic_trace_data_t *)
 124                                   fnic_trace_entries.page_offset[rd_idx];
 125                         if (!tbp) {
 126                                 spin_unlock_irqrestore(&fnic_trace_lock, flags);
 127                                 return 0;
 128                         }
 129                         /* Convert function pointer to function name */
 130                         if (sizeof(unsigned long) < 8) {
 131                                 sprint_symbol(str, tbp->fnaddr.low);
 132                                 jiffies_to_timespec(tbp->timestamp.low, &val);
 133                         } else {
 134                                 sprint_symbol(str, tbp->fnaddr.val);
 135                                 jiffies_to_timespec(tbp->timestamp.val, &val);
 136                         }
 137                         /*
 138                          * Dump trace buffer entry to memory file
 139                          * and increment read index @rd_idx
 140                          */
 141                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 142                                   (trace_max_pages * PAGE_SIZE * 3) - len,
 143                                   "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
 144                                   "%16llx %16llx %16llx\n", val.tv_sec,
 145                                   val.tv_nsec, str, tbp->host_no, tbp->tag,
 146                                   tbp->data[0], tbp->data[1], tbp->data[2],
 147                                   tbp->data[3], tbp->data[4]);
 148                         rd_idx++;
 149                         /*
 150                          * If rd_idx is reached to maximum trace entries
 151                          * then move rd_idx to zero
 152                          */
 153                         if (rd_idx > (fnic_max_trace_entries-1))
 154                                 rd_idx = 0;
 155                         /*
 156                          * Continure dumpping trace buffer entries into
 157                          * memory file till rd_idx reaches write index
 158                          */
 159                         if (rd_idx == wr_idx)
 160                                 break;
 161                 }
 162         } else if (wr_idx > rd_idx) {
 163                 while (1) {
 164                         /* Start from read index @rd_idx */
 165                         tbp = (fnic_trace_data_t *)
 166                                   fnic_trace_entries.page_offset[rd_idx];
 167                         if (!tbp) {
 168                                 spin_unlock_irqrestore(&fnic_trace_lock, flags);
 169                                 return 0;
 170                         }
 171                         /* Convert function pointer to function name */
 172                         if (sizeof(unsigned long) < 8) {
 173                                 sprint_symbol(str, tbp->fnaddr.low);
 174                                 jiffies_to_timespec(tbp->timestamp.low, &val);
 175                         } else {
 176                                 sprint_symbol(str, tbp->fnaddr.val);
 177                                 jiffies_to_timespec(tbp->timestamp.val, &val);
 178                         }
 179                         /*
 180                          * Dump trace buffer entry to memory file
 181                          * and increment read index @rd_idx
 182                          */
 183                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 184                                   (trace_max_pages * PAGE_SIZE * 3) - len,
 185                                   "%16lu.%16lu %-50s %8x %8x %16llx %16llx "
 186                                   "%16llx %16llx %16llx\n", val.tv_sec,
 187                                   val.tv_nsec, str, tbp->host_no, tbp->tag,
 188                                   tbp->data[0], tbp->data[1], tbp->data[2],
 189                                   tbp->data[3], tbp->data[4]);
 190                         rd_idx++;
 191                         /*
 192                          * Continue dumpping trace buffer entries into
 193                          * memory file till rd_idx reaches write index
 194                          */
 195                         if (rd_idx == wr_idx)
 196                                 break;
 197                 }
 198         }
 199         spin_unlock_irqrestore(&fnic_trace_lock, flags);
 200         return len;
 201 }
 202
 203 /*
 204  * fnic_get_stats_data - Copy fnic stats buffer to a memory file
 205  * @fnic_dbgfs_t: pointer to debugfs fnic stats buffer
 206  *
 207  * Description:
 208  * This routine gathers the fnic stats debugfs data from the fnic_stats struct
 209  * and dumps it to stats_debug_info.
 210  *
 211  * Return Value:
 212  * This routine returns the amount of bytes that were dumped into
 213  * stats_debug_info
 214  */
 215 int fnic_get_stats_data(struct stats_debug_info *debug,
 216                         struct fnic_stats *stats)
 217 {
 218         int len = 0;
 219         int buf_size = debug->buf_size;
 220         struct timespec val1, val2;
 221
 222         len = snprintf(debug->debug_buffer + len, buf_size - len,
 223                   "------------------------------------------\n"
 224                   "\t\tIO Statistics\n"
 225                   "------------------------------------------\n");
 226         len += snprintf(debug->debug_buffer + len, buf_size - len,
 227                   "Number of Active IOs: %lld\nMaximum Active IOs: %lld\n"
 228                   "Number of IOs: %lld\nNumber of IO Completions: %lld\n"
 229                   "Number of IO Failures: %lld\nNumber of IO NOT Found: %lld\n"
 230                   "Number of Memory alloc Failures: %lld\n"
 231                   "Number of IOREQ Null: %lld\n"
 232                   "Number of SCSI cmd pointer Null: %lld\n",
 233                   (u64)atomic64_read(&stats->io_stats.active_ios),
 234                   (u64)atomic64_read(&stats->io_stats.max_active_ios),
 235                   (u64)atomic64_read(&stats->io_stats.num_ios),
 236                   (u64)atomic64_read(&stats->io_stats.io_completions),
 237                   (u64)atomic64_read(&stats->io_stats.io_failures),
 238                   (u64)atomic64_read(&stats->io_stats.io_not_found),
 239                   (u64)atomic64_read(&stats->io_stats.alloc_failures),
 240                   (u64)atomic64_read(&stats->io_stats.ioreq_null),
 241                   (u64)atomic64_read(&stats->io_stats.sc_null));
 242
 243         len += snprintf(debug->debug_buffer + len, buf_size - len,
 244                   "\n------------------------------------------\n"
 245                   "\t\tAbort Statistics\n"
 246                   "------------------------------------------\n");
 247         len += snprintf(debug->debug_buffer + len, buf_size - len,
 248                   "Number of Aborts: %lld\n"
 249                   "Number of Abort Failures: %lld\n"
 250                   "Number of Abort Driver Timeouts: %lld\n"
 251                   "Number of Abort FW Timeouts: %lld\n"
 252                   "Number of Abort IO NOT Found: %lld\n",
 253                   (u64)atomic64_read(&stats->abts_stats.aborts),
 254                   (u64)atomic64_read(&stats->abts_stats.abort_failures),
 255                   (u64)atomic64_read(&stats->abts_stats.abort_drv_timeouts),
 256                   (u64)atomic64_read(&stats->abts_stats.abort_fw_timeouts),
 257                   (u64)atomic64_read(&stats->abts_stats.abort_io_not_found));
 258
 259         len += snprintf(debug->debug_buffer + len, buf_size - len,
 260                   "\n------------------------------------------\n"
 261                   "\t\tTerminate Statistics\n"
 262                   "------------------------------------------\n");
 263         len += snprintf(debug->debug_buffer + len, buf_size - len,
 264                   "Number of Terminates: %lld\n"
 265                   "Maximum Terminates: %lld\n"
 266                   "Number of Terminate Driver Timeouts: %lld\n"
 267                   "Number of Terminate FW Timeouts: %lld\n"
 268                   "Number of Terminate IO NOT Found: %lld\n"
 269                   "Number of Terminate Failures: %lld\n",
 270                   (u64)atomic64_read(&stats->term_stats.terminates),
 271                   (u64)atomic64_read(&stats->term_stats.max_terminates),
 272                   (u64)atomic64_read(&stats->term_stats.terminate_drv_timeouts),
 273                   (u64)atomic64_read(&stats->term_stats.terminate_fw_timeouts),
 274                   (u64)atomic64_read(&stats->term_stats.terminate_io_not_found),
 275                   (u64)atomic64_read(&stats->term_stats.terminate_failures));
 276
 277         len += snprintf(debug->debug_buffer + len, buf_size - len,
 278                   "\n------------------------------------------\n"
 279                   "\t\tReset Statistics\n"
 280                   "------------------------------------------\n");
 281
 282         len += snprintf(debug->debug_buffer + len, buf_size - len,
 283                   "Number of Device Resets: %lld\n"
 284                   "Number of Device Reset Failures: %lld\n"
 285                   "Number of Device Reset Aborts: %lld\n"
 286                   "Number of Device Reset Timeouts: %lld\n"
 287                   "Number of Device Reset Terminates: %lld\n"
 288                   "Number of FW Resets: %lld\n"
 289                   "Number of FW Reset Completions: %lld\n"
 290                   "Number of FW Reset Failures: %lld\n"
 291                   "Number of Fnic Reset: %lld\n"
 292                   "Number of Fnic Reset Completions: %lld\n"
 293                   "Number of Fnic Reset Failures: %lld\n",
 294                   (u64)atomic64_read(&stats->reset_stats.device_resets),
 295                   (u64)atomic64_read(&stats->reset_stats.device_reset_failures),
 296                   (u64)atomic64_read(&stats->reset_stats.device_reset_aborts),
 297                   (u64)atomic64_read(&stats->reset_stats.device_reset_timeouts),
 298                   (u64)atomic64_read(
 299                           &stats->reset_stats.device_reset_terminates),
 300                   (u64)atomic64_read(&stats->reset_stats.fw_resets),
 301                   (u64)atomic64_read(&stats->reset_stats.fw_reset_completions),
 302                   (u64)atomic64_read(&stats->reset_stats.fw_reset_failures),
 303                   (u64)atomic64_read(&stats->reset_stats.fnic_resets),
 304                   (u64)atomic64_read(
 305                           &stats->reset_stats.fnic_reset_completions),
 306                   (u64)atomic64_read(&stats->reset_stats.fnic_reset_failures));
 307
 308         len += snprintf(debug->debug_buffer + len, buf_size - len,
 309                   "\n------------------------------------------\n"
 310                   "\t\tFirmware Statistics\n"
 311                   "------------------------------------------\n");
 312
 313         len += snprintf(debug->debug_buffer + len, buf_size - len,
 314                   "Number of Active FW Requests %lld\n"
 315                   "Maximum FW Requests: %lld\n"
 316                   "Number of FW out of resources: %lld\n"
 317                   "Number of FW IO errors: %lld\n",
 318                   (u64)atomic64_read(&stats->fw_stats.active_fw_reqs),
 319                   (u64)atomic64_read(&stats->fw_stats.max_fw_reqs),
 320                   (u64)atomic64_read(&stats->fw_stats.fw_out_of_resources),
 321                   (u64)atomic64_read(&stats->fw_stats.io_fw_errs));
 322
 323         len += snprintf(debug->debug_buffer + len, buf_size - len,
 324                   "\n------------------------------------------\n"
 325                   "\t\tVlan Discovery Statistics\n"
 326                   "------------------------------------------\n");
 327
 328         len += snprintf(debug->debug_buffer + len, buf_size - len,
 329                   "Number of Vlan Discovery Requests Sent %lld\n"
 330                   "Vlan Response Received with no FCF VLAN ID: %lld\n"
 331                   "No solicitations recvd after vlan set, expiry count: %lld\n"
 332                   "Flogi rejects count: %lld\n",
 333                   (u64)atomic64_read(&stats->vlan_stats.vlan_disc_reqs),
 334                   (u64)atomic64_read(&stats->vlan_stats.resp_withno_vlanID),
 335                   (u64)atomic64_read(&stats->vlan_stats.sol_expiry_count),
 336                   (u64)atomic64_read(&stats->vlan_stats.flogi_rejects));
 337
 338         len += snprintf(debug->debug_buffer + len, buf_size - len,
 339                   "\n------------------------------------------\n"
 340                   "\t\tOther Important Statistics\n"
 341                   "------------------------------------------\n");
 342
 343         jiffies_to_timespec(stats->misc_stats.last_isr_time, &val1);
 344         jiffies_to_timespec(stats->misc_stats.last_ack_time, &val2);
 345
 346         len += snprintf(debug->debug_buffer + len, buf_size - len,
 347                   "Last ISR time: %llu (%8lu.%8lu)\n"
 348                   "Last ACK time: %llu (%8lu.%8lu)\n"
 349                   "Number of ISRs: %lld\n"
 350                   "Maximum CQ Entries: %lld\n"
 351                   "Number of ACK index out of range: %lld\n"
 352                   "Number of data count mismatch: %lld\n"
 353                   "Number of FCPIO Timeouts: %lld\n"
 354                   "Number of FCPIO Aborted: %lld\n"
 355                   "Number of SGL Invalid: %lld\n"
 356                   "Number of Copy WQ Alloc Failures for ABTs: %lld\n"
 357                   "Number of Copy WQ Alloc Failures for Device Reset: %lld\n"
 358                   "Number of Copy WQ Alloc Failures for IOs: %lld\n"
 359                   "Number of no icmnd itmf Completions: %lld\n"
 360                   "Number of QUEUE Fulls: %lld\n"
 361                   "Number of rport not ready: %lld\n"
 362                   "Number of receive frame errors: %lld\n",
 363                   (u64)stats->misc_stats.last_isr_time,
 364                   val1.tv_sec, val1.tv_nsec,
 365                   (u64)stats->misc_stats.last_ack_time,
 366                   val2.tv_sec, val2.tv_nsec,
 367                   (u64)atomic64_read(&stats->misc_stats.isr_count),
 368                   (u64)atomic64_read(&stats->misc_stats.max_cq_entries),
 369                   (u64)atomic64_read(&stats->misc_stats.ack_index_out_of_range),
 370                   (u64)atomic64_read(&stats->misc_stats.data_count_mismatch),
 371                   (u64)atomic64_read(&stats->misc_stats.fcpio_timeout),
 372                   (u64)atomic64_read(&stats->misc_stats.fcpio_aborted),
 373                   (u64)atomic64_read(&stats->misc_stats.sgl_invalid),
 374                   (u64)atomic64_read(
 375                           &stats->misc_stats.abts_cpwq_alloc_failures),
 376                   (u64)atomic64_read(
 377                           &stats->misc_stats.devrst_cpwq_alloc_failures),
 378                   (u64)atomic64_read(&stats->misc_stats.io_cpwq_alloc_failures),
 379                   (u64)atomic64_read(&stats->misc_stats.no_icmnd_itmf_cmpls),
 380                   (u64)atomic64_read(&stats->misc_stats.queue_fulls),
 381                   (u64)atomic64_read(&stats->misc_stats.rport_not_ready),
 382                   (u64)atomic64_read(&stats->misc_stats.frame_errors));
 383
 384         return len;
 385
 386 }
 387
 388 /*
 389  * fnic_trace_buf_init - Initialize fnic trace buffer logging facility
 390  *
 391  * Description:
 392  * Initialize trace buffer data structure by allocating required memory and
 393  * setting page_offset information for every trace entry by adding trace entry
 394  * length to previous page_offset value.
 395  */
 396 int fnic_trace_buf_init(void)
 397 {
 398         unsigned long fnic_buf_head;
 399         int i;
 400         int err = 0;
 401
 402         trace_max_pages = fnic_trace_max_pages;
 403         fnic_max_trace_entries = (trace_max_pages * PAGE_SIZE)/
 404                                           FNIC_ENTRY_SIZE_BYTES;
 405
 406         fnic_trace_buf_p = (unsigned long)vmalloc((trace_max_pages * PAGE_SIZE));
 407         if (!fnic_trace_buf_p) {
 408                 printk(KERN_ERR PFX "Failed to allocate memory "
 409                                   "for fnic_trace_buf_p\n");
 410                 err = -ENOMEM;
 411                 goto err_fnic_trace_buf_init;
 412         }
 413         memset((void *)fnic_trace_buf_p, 0, (trace_max_pages * PAGE_SIZE));
 414
 415         fnic_trace_entries.page_offset = vmalloc(fnic_max_trace_entries *
 416                                                   sizeof(unsigned long));
 417         if (!fnic_trace_entries.page_offset) {
 418                 printk(KERN_ERR PFX "Failed to allocate memory for"
 419                                   " page_offset\n");
 420                 if (fnic_trace_buf_p) {
 421                         vfree((void *)fnic_trace_buf_p);
 422                         fnic_trace_buf_p = 0;
 423                 }
 424                 err = -ENOMEM;
 425                 goto err_fnic_trace_buf_init;
 426         }
 427         memset((void *)fnic_trace_entries.page_offset, 0,
 428                   (fnic_max_trace_entries * sizeof(unsigned long)));
 429         fnic_trace_entries.wr_idx = fnic_trace_entries.rd_idx = 0;
 430         fnic_buf_head = fnic_trace_buf_p;
 431
 432         /*
 433          * Set page_offset field of fnic_trace_entries struct by
 434          * calculating memory location for every trace entry using
 435          * length of each trace entry
 436          */
 437         for (i = 0; i < fnic_max_trace_entries; i++) {
 438                 fnic_trace_entries.page_offset[i] = fnic_buf_head;
 439                 fnic_buf_head += FNIC_ENTRY_SIZE_BYTES;
 440         }
 441         err = fnic_trace_debugfs_init();
 442         if (err < 0) {
 443                 pr_err("fnic: Failed to initialize debugfs for tracing\n");
 444                 goto err_fnic_trace_debugfs_init;
 445         }
 446         pr_info("fnic: Successfully Initialized Trace Buffer\n");
 447         return err;
 448 err_fnic_trace_debugfs_init:
 449         fnic_trace_free();
 450 err_fnic_trace_buf_init:
 451         return err;
 452 }
 453
 454 /*
 455  * fnic_trace_free - Free memory of fnic trace data structures.
 456  */
 457 void fnic_trace_free(void)
 458 {
 459         fnic_tracing_enabled = 0;
 460         fnic_trace_debugfs_terminate();
 461         if (fnic_trace_entries.page_offset) {
 462                 vfree((void *)fnic_trace_entries.page_offset);
 463                 fnic_trace_entries.page_offset = NULL;
 464         }
 465         if (fnic_trace_buf_p) {
 466                 vfree((void *)fnic_trace_buf_p);
 467                 fnic_trace_buf_p = 0;
 468         }
 469         printk(KERN_INFO PFX "Successfully Freed Trace Buffer\n");
 470 }
 471
 472 /*
 473  * fnic_fc_ctlr_trace_buf_init -
 474  * Initialize trace buffer to log fnic control frames
 475  * Description:
 476  * Initialize trace buffer data structure by allocating
 477  * required memory for trace data as well as for Indexes.
 478  * Frame size is 256 bytes and
 479  * memory is allocated for 1024 entries of 256 bytes.
 480  * Page_offset(Index) is set to the address of trace entry
 481  * and page_offset is initialized by adding frame size
 482  * to the previous page_offset entry.
 483  */
 484
 485 int fnic_fc_trace_init(void)
 486 {
 487         unsigned long fc_trace_buf_head;
 488         int err = 0;
 489         int i;
 490
 491         fc_trace_max_entries = (fnic_fc_trace_max_pages * PAGE_SIZE)/
 492                                 FC_TRC_SIZE_BYTES;
 493         fnic_fc_ctlr_trace_buf_p = (unsigned long)vmalloc(
 494                                         fnic_fc_trace_max_pages * PAGE_SIZE);
 495         if (!fnic_fc_ctlr_trace_buf_p) {
 496                 pr_err("fnic: Failed to allocate memory for "
 497                        "FC Control Trace Buf\n");
 498                 err = -ENOMEM;
 499                 goto err_fnic_fc_ctlr_trace_buf_init;
 500         }
 501
 502         memset((void *)fnic_fc_ctlr_trace_buf_p, 0,
 503                         fnic_fc_trace_max_pages * PAGE_SIZE);
 504
 505         /* Allocate memory for page offset */
 506         fc_trace_entries.page_offset = vmalloc(fc_trace_max_entries *
 507                                                 sizeof(unsigned long));
 508         if (!fc_trace_entries.page_offset) {
 509                 pr_err("fnic:Failed to allocate memory for page_offset\n");
 510                 if (fnic_fc_ctlr_trace_buf_p) {
 511                         pr_err("fnic: Freeing FC Control Trace Buf\n");
 512                         vfree((void *)fnic_fc_ctlr_trace_buf_p);
 513                         fnic_fc_ctlr_trace_buf_p = 0;
 514                 }
 515                 err = -ENOMEM;
 516                 goto err_fnic_fc_ctlr_trace_buf_init;
 517         }
 518         memset((void *)fc_trace_entries.page_offset, 0,
 519                (fc_trace_max_entries * sizeof(unsigned long)));
 520
 521         fc_trace_entries.rd_idx = fc_trace_entries.wr_idx = 0;
 522         fc_trace_buf_head = fnic_fc_ctlr_trace_buf_p;
 523
 524         /*
 525         * Set up fc_trace_entries.page_offset field with memory location
 526         * for every trace entry
 527         */
 528         for (i = 0; i < fc_trace_max_entries; i++) {
 529                 fc_trace_entries.page_offset[i] = fc_trace_buf_head;
 530                 fc_trace_buf_head += FC_TRC_SIZE_BYTES;
 531         }
 532         err = fnic_fc_trace_debugfs_init();
 533         if (err < 0) {
 534                 pr_err("fnic: Failed to initialize FC_CTLR tracing.\n");
 535                 goto err_fnic_fc_ctlr_trace_debugfs_init;
 536         }
 537         pr_info("fnic: Successfully Initialized FC_CTLR Trace Buffer\n");
 538         return err;
 539
 540 err_fnic_fc_ctlr_trace_debugfs_init:
 541         fnic_fc_trace_free();
 542 err_fnic_fc_ctlr_trace_buf_init:
 543         return err;
 544 }
 545
 546 /*
 547  * Fnic_fc_ctlr_trace_free - Free memory of fnic_fc_ctlr trace data structures.
 548  */
 549 void fnic_fc_trace_free(void)
 550 {
 551         fnic_fc_tracing_enabled = 0;
 552         fnic_fc_trace_debugfs_terminate();
 553         if (fc_trace_entries.page_offset) {
 554                 vfree((void *)fc_trace_entries.page_offset);
 555                 fc_trace_entries.page_offset = NULL;
 556         }
 557         if (fnic_fc_ctlr_trace_buf_p) {
 558                 vfree((void *)fnic_fc_ctlr_trace_buf_p);
 559                 fnic_fc_ctlr_trace_buf_p = 0;
 560         }
 561         pr_info("fnic:Successfully FC_CTLR Freed Trace Buffer\n");
 562 }
 563
 564 /*
 565  * fnic_fc_ctlr_set_trace_data:
 566  *       Maintain rd & wr idx accordingly and set data
 567  * Passed parameters:
 568  *       host_no: host number accociated with fnic
 569  *       frame_type: send_frame, rece_frame or link event
 570  *       fc_frame: pointer to fc_frame
 571  *       frame_len: Length of the fc_frame
 572  * Description:
 573  *   This routine will get next available wr_idx and
 574  *   copy all passed trace data to the buffer pointed by wr_idx
 575  *   and increment wr_idx. It will also make sure that we dont
 576  *   overwrite the entry which we are reading and also
 577  *   wrap around if we reach the maximum entries.
 578  * Returned Value:
 579  *   It will return 0 for success or -1 for failure
 580  */
 581 int fnic_fc_trace_set_data(u32 host_no, u8 frame_type,
 582                                 char *frame, u32 fc_trc_frame_len)
 583 {
 584         unsigned long flags;
 585         struct fc_trace_hdr *fc_buf;
 586         unsigned long eth_fcoe_hdr_len;
 587         char *fc_trace;
 588
 589         if (fnic_fc_tracing_enabled == 0)
 590                 return 0;
 591
 592         spin_lock_irqsave(&fnic_fc_trace_lock, flags);
 593
 594         if (fnic_fc_trace_cleared == 1) {
 595                 fc_trace_entries.rd_idx = fc_trace_entries.wr_idx = 0;
 596                 pr_info("fnic: Resetting the read idx\n");
 597                 memset((void *)fnic_fc_ctlr_trace_buf_p, 0,
 598                                 fnic_fc_trace_max_pages * PAGE_SIZE);
 599                 fnic_fc_trace_cleared = 0;
 600         }
 601
 602         fc_buf = (struct fc_trace_hdr *)
 603                 fc_trace_entries.page_offset[fc_trace_entries.wr_idx];
 604
 605         fc_trace_entries.wr_idx++;
 606
 607         if (fc_trace_entries.wr_idx >= fc_trace_max_entries)
 608                 fc_trace_entries.wr_idx = 0;
 609
 610         if (fc_trace_entries.wr_idx == fc_trace_entries.rd_idx) {
 611                 fc_trace_entries.rd_idx++;
 612                 if (fc_trace_entries.rd_idx >= fc_trace_max_entries)
 613                         fc_trace_entries.rd_idx = 0;
 614         }
 615
 616         fc_buf->time_stamp = CURRENT_TIME;
 617         fc_buf->host_no = host_no;
 618         fc_buf->frame_type = frame_type;
 619
 620         fc_trace = (char *)FC_TRACE_ADDRESS(fc_buf);
 621
 622         /* During the receive path, we do not have eth hdr as well as fcoe hdr
 623          * at trace entry point so we will stuff 0xff just to make it generic.
 624          */
 625         if (frame_type == FNIC_FC_RECV) {
 626                 eth_fcoe_hdr_len = sizeof(struct ethhdr) +
 627                                         sizeof(struct fcoe_hdr);
 628                 memset((char *)fc_trace, 0xff, eth_fcoe_hdr_len);
 629                 /* Copy the rest of data frame */
 630                 memcpy((char *)(fc_trace + eth_fcoe_hdr_len), (void *)frame,
 631                 min_t(u8, fc_trc_frame_len,
 632                         (u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE
 633                                                 - eth_fcoe_hdr_len)));
 634         } else {
 635                 memcpy((char *)fc_trace, (void *)frame,
 636                 min_t(u8, fc_trc_frame_len,
 637                         (u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)));
 638         }
 639
 640         /* Store the actual received length */
 641         fc_buf->frame_len = fc_trc_frame_len;
 642
 643         spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
 644         return 0;
 645 }
 646
 647 /*
 648  * fnic_fc_ctlr_get_trace_data: Copy trace buffer to a memory file
 649  * Passed parameter:
 650  *       @fnic_dbgfs_t: pointer to debugfs trace buffer
 651  *       rdata_flag: 1 => Unformated file
 652  *                   0 => formated file
 653  * Description:
 654  *       This routine will copy the trace data to memory file with
 655  *       proper formatting and also copy to another memory
 656  *       file without formatting for further procesing.
 657  * Retrun Value:
 658  *       Number of bytes that were dumped into fnic_dbgfs_t
 659  */
 660
 661 int fnic_fc_trace_get_data(fnic_dbgfs_t *fnic_dbgfs_prt, u8 rdata_flag)
 662 {
 663         int rd_idx, wr_idx;
 664         unsigned long flags;
 665         int len = 0, j;
 666         struct fc_trace_hdr *tdata;
 667         char *fc_trace;
 668
 669         spin_lock_irqsave(&fnic_fc_trace_lock, flags);
 670         if (fc_trace_entries.wr_idx == fc_trace_entries.rd_idx) {
 671                 spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
 672                 pr_info("fnic: Buffer is empty\n");
 673                 return 0;
 674         }
 675         rd_idx = fc_trace_entries.rd_idx;
 676         wr_idx = fc_trace_entries.wr_idx;
 677         if (rdata_flag == 0) {
 678                 len += snprintf(fnic_dbgfs_prt->buffer + len,
 679                         (fnic_fc_trace_max_pages * PAGE_SIZE * 3) - len,
 680                         "Time Stamp (UTC)\t\t"
 681                         "Host No:   F Type:  len:     FCoE_FRAME:\n");
 682         }
 683
 684         while (rd_idx != wr_idx) {
 685                 tdata = (struct fc_trace_hdr *)
 686                         fc_trace_entries.page_offset[rd_idx];
 687                 if (!tdata) {
 688                         pr_info("fnic: Rd data is NULL\n");
 689                         spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
 690                         return 0;
 691                 }
 692                 if (rdata_flag == 0) {
 693                         copy_and_format_trace_data(tdata,
 694                                 fnic_dbgfs_prt, &len, rdata_flag);
 695                 } else {
 696                         fc_trace = (char *)tdata;
 697                         for (j = 0; j < FC_TRC_SIZE_BYTES; j++) {
 698                                 len += snprintf(fnic_dbgfs_prt->buffer + len,
 699                                 (fnic_fc_trace_max_pages * PAGE_SIZE * 3)
 700                                 - len, "%02x", fc_trace[j] & 0xff);
 701                         } /* for loop */
 702                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 703                                 (fnic_fc_trace_max_pages * PAGE_SIZE * 3) - len,
 704                                 "\n");
 705                 }
 706                 rd_idx++;
 707                 if (rd_idx > (fc_trace_max_entries - 1))
 708                         rd_idx = 0;
 709         }
 710
 711         spin_unlock_irqrestore(&fnic_fc_trace_lock, flags);
 712         return len;
 713 }
 714
 715 /*
 716  * copy_and_format_trace_data: Copy formatted data to char * buffer
 717  * Passed Parameter:
 718  *      @fc_trace_hdr_t: pointer to trace data
 719  *      @fnic_dbgfs_t: pointer to debugfs trace buffer
 720  *      @orig_len: pointer to len
 721  *      rdata_flag: 0 => Formated file, 1 => Unformated file
 722  * Description:
 723  *      This routine will format and copy the passed trace data
 724  *      for formated file or unformated file accordingly.
 725  */
 726
 727 void copy_and_format_trace_data(struct fc_trace_hdr *tdata,
 728                                 fnic_dbgfs_t *fnic_dbgfs_prt, int *orig_len,
 729                                 u8 rdata_flag)
 730 {
 731         struct tm tm;
 732         int j, i = 1, len;
 733         char *fc_trace, *fmt;
 734         int ethhdr_len = sizeof(struct ethhdr) - 1;
 735         int fcoehdr_len = sizeof(struct fcoe_hdr);
 736         int fchdr_len = sizeof(struct fc_frame_header);
 737         int max_size = fnic_fc_trace_max_pages * PAGE_SIZE * 3;
 738
 739         tdata->frame_type = tdata->frame_type & 0x7F;
 740
 741         len = *orig_len;
 742
 743         time_to_tm(tdata->time_stamp.tv_sec, 0, &tm);
 744
 745         fmt = "%02d:%02d:%04ld %02d:%02d:%02d.%09lu ns%8x       %c%8x\t";
 746         len += snprintf(fnic_dbgfs_prt->buffer + len,
 747                 max_size - len,
 748                 fmt,
 749                 tm.tm_mon + 1, tm.tm_mday, tm.tm_year + 1900,
 750                 tm.tm_hour, tm.tm_min, tm.tm_sec,
 751                 tdata->time_stamp.tv_nsec, tdata->host_no,
 752                 tdata->frame_type, tdata->frame_len);
 753
 754         fc_trace = (char *)FC_TRACE_ADDRESS(tdata);
 755
 756         for (j = 0; j < min_t(u8, tdata->frame_len,
 757                 (u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)); j++) {
 758                 if (tdata->frame_type == FNIC_FC_LE) {
 759                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 760                                 max_size - len, "%c", fc_trace[j]);
 761                 } else {
 762                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 763                                 max_size - len, "%02x", fc_trace[j] & 0xff);
 764                         len += snprintf(fnic_dbgfs_prt->buffer + len,
 765                                 max_size - len, " ");
 766                         if (j == ethhdr_len ||
 767                                 j == ethhdr_len + fcoehdr_len ||
 768                                 j == ethhdr_len + fcoehdr_len + fchdr_len ||
 769                                 (i > 3 && j%fchdr_len == 0)) {
 770                                 len += snprintf(fnic_dbgfs_prt->buffer
 771                                         + len, max_size - len,
 772                                         "\n\t\t\t\t\t\t\t\t");
 773                                 i++;
 774                         }
 775                 } /* end of else*/
 776         } /* End of for loop*/
 777         len += snprintf(fnic_dbgfs_prt->buffer + len,
 778                 max_size - len, "\n");
 779         *orig_len = len;
 780 }