drivers/net/ethernet/intel/fm10k/fm10k_debugfs.c

   1 /* Intel(R) Ethernet Switch Host Interface Driver
   2  * Copyright(c) 2013 - 2016 Intel Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * The full GNU General Public License is included in this distribution in
  14  * the file called "COPYING".
  15  *
  16  * Contact Information:
  17  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  18  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  19  */
  20
  21 #include "fm10k.h"
  22
  23 #include <linux/debugfs.h>
  24 #include <linux/seq_file.h>
  25
  26 static struct dentry *dbg_root;
  27
  28 /* Descriptor Seq Functions */
  29
  30 static void *fm10k_dbg_desc_seq_start(struct seq_file *s, loff_t *pos)
  31 {
  32         struct fm10k_ring *ring = s->private;
  33
  34         return (*pos < ring->count) ? pos : NULL;
  35 }
  36
  37 static void *fm10k_dbg_desc_seq_next(struct seq_file *s,
  38                                      void __always_unused *v,
  39                                      loff_t *pos)
  40 {
  41         struct fm10k_ring *ring = s->private;
  42
  43         return (++(*pos) < ring->count) ? pos : NULL;
  44 }
  45
  46 static void fm10k_dbg_desc_seq_stop(struct seq_file __always_unused *s,
  47                                     void __always_unused *v)
  48 {
  49         /* Do nothing. */
  50 }
  51
  52 static void fm10k_dbg_desc_break(struct seq_file *s, int i)
  53 {
  54         while (i--)
  55                 seq_putc(s, '-');
  56
  57         seq_putc(s, '\n');
  58 }
  59
  60 static int fm10k_dbg_tx_desc_seq_show(struct seq_file *s, void *v)
  61 {
  62         struct fm10k_ring *ring = s->private;
  63         int i = *(loff_t *)v;
  64         static const char tx_desc_hdr[] =
  65                 "DES BUFFER_ADDRESS     LENGTH VLAN   MSS    HDRLEN FLAGS\n";
  66
  67         /* Generate header */
  68         if (!i) {
  69                 seq_printf(s, tx_desc_hdr);
  70                 fm10k_dbg_desc_break(s, sizeof(tx_desc_hdr) - 1);
  71         }
  72
  73         /* Validate descriptor allocation */
  74         if (!ring->desc) {
  75                 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
  76         } else {
  77                 struct fm10k_tx_desc *txd = FM10K_TX_DESC(ring, i);
  78
  79                 seq_printf(s, "%03X %#018llx %#06x %#06x %#06x %#06x %#04x\n",
  80                            i, txd->buffer_addr, txd->buflen, txd->vlan,
  81                            txd->mss, txd->hdrlen, txd->flags);
  82         }
  83
  84         return 0;
  85 }
  86
  87 static int fm10k_dbg_rx_desc_seq_show(struct seq_file *s, void *v)
  88 {
  89         struct fm10k_ring *ring = s->private;
  90         int i = *(loff_t *)v;
  91         static const char rx_desc_hdr[] =
  92         "DES DATA       RSS        STATERR    LENGTH VLAN   DGLORT SGLORT TIMESTAMP\n";
  93
  94         /* Generate header */
  95         if (!i) {
  96                 seq_printf(s, rx_desc_hdr);
  97                 fm10k_dbg_desc_break(s, sizeof(rx_desc_hdr) - 1);
  98         }
  99
 100         /* Validate descriptor allocation */
 101         if (!ring->desc) {
 102                 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
 103         } else {
 104                 union fm10k_rx_desc *rxd = FM10K_RX_DESC(ring, i);
 105
 106                 seq_printf(s,
 107                            "%03X %#010x %#010x %#010x %#06x %#06x %#06x %#06x %#018llx\n",
 108                            i, rxd->d.data, rxd->d.rss, rxd->d.staterr,
 109                            rxd->w.length, rxd->w.vlan, rxd->w.dglort,
 110                            rxd->w.sglort, rxd->q.timestamp);
 111         }
 112
 113         return 0;
 114 }
 115
 116 static const struct seq_operations fm10k_dbg_tx_desc_seq_ops = {
 117         .start = fm10k_dbg_desc_seq_start,
 118         .next  = fm10k_dbg_desc_seq_next,
 119         .stop  = fm10k_dbg_desc_seq_stop,
 120         .show  = fm10k_dbg_tx_desc_seq_show,
 121 };
 122
 123 static const struct seq_operations fm10k_dbg_rx_desc_seq_ops = {
 124         .start = fm10k_dbg_desc_seq_start,
 125         .next  = fm10k_dbg_desc_seq_next,
 126         .stop  = fm10k_dbg_desc_seq_stop,
 127         .show  = fm10k_dbg_rx_desc_seq_show,
 128 };
 129
 130 static int fm10k_dbg_desc_open(struct inode *inode, struct file *filep)
 131 {
 132         struct fm10k_ring *ring = inode->i_private;
 133         struct fm10k_q_vector *q_vector = ring->q_vector;
 134         const struct seq_operations *desc_seq_ops;
 135         int err;
 136
 137         if (ring < q_vector->rx.ring)
 138                 desc_seq_ops = &fm10k_dbg_tx_desc_seq_ops;
 139         else
 140                 desc_seq_ops = &fm10k_dbg_rx_desc_seq_ops;
 141
 142         err = seq_open(filep, desc_seq_ops);
 143         if (err)
 144                 return err;
 145
 146         ((struct seq_file *)filep->private_data)->private = ring;
 147
 148         return 0;
 149 }
 150
 151 static const struct file_operations fm10k_dbg_desc_fops = {
 152         .owner   = THIS_MODULE,
 153         .open    = fm10k_dbg_desc_open,
 154         .read    = seq_read,
 155         .llseek  = seq_lseek,
 156         .release = seq_release,
 157 };
 158
 159 /**
 160  * fm10k_dbg_q_vector_init - setup debugfs for the q_vectors
 161  * @q_vector: q_vector to allocate directories for
 162  *
 163  * A folder is created for each q_vector found. In each q_vector
 164  * folder, a debugfs file is created for each tx and rx ring
 165  * allocated to the q_vector.
 166  **/
 167 void fm10k_dbg_q_vector_init(struct fm10k_q_vector *q_vector)
 168 {
 169         struct fm10k_intfc *interface = q_vector->interface;
 170         char name[16];
 171         int i;
 172
 173         if (!interface->dbg_intfc)
 174                 return;
 175
 176         /* Generate a folder for each q_vector */
 177         snprintf(name, sizeof(name), "q_vector.%03d", q_vector->v_idx);
 178
 179         q_vector->dbg_q_vector = debugfs_create_dir(name, interface->dbg_intfc);
 180         if (!q_vector->dbg_q_vector)
 181                 return;
 182
 183         /* Generate a file for each rx ring in the q_vector */
 184         for (i = 0; i < q_vector->tx.count; i++) {
 185                 struct fm10k_ring *ring = &q_vector->tx.ring[i];
 186
 187                 snprintf(name, sizeof(name), "tx_ring.%03d", ring->queue_index);
 188
 189                 debugfs_create_file(name, 0600,
 190                                     q_vector->dbg_q_vector, ring,
 191                                     &fm10k_dbg_desc_fops);
 192         }
 193
 194         /* Generate a file for each rx ring in the q_vector */
 195         for (i = 0; i < q_vector->rx.count; i++) {
 196                 struct fm10k_ring *ring = &q_vector->rx.ring[i];
 197
 198                 snprintf(name, sizeof(name), "rx_ring.%03d", ring->queue_index);
 199
 200                 debugfs_create_file(name, 0600,
 201                                     q_vector->dbg_q_vector, ring,
 202                                     &fm10k_dbg_desc_fops);
 203         }
 204 }
 205
 206 /**
 207  * fm10k_dbg_free_q_vector_dir - setup debugfs for the q_vectors
 208  * @q_vector: q_vector to allocate directories for
 209  **/
 210 void fm10k_dbg_q_vector_exit(struct fm10k_q_vector *q_vector)
 211 {
 212         struct fm10k_intfc *interface = q_vector->interface;
 213
 214         if (interface->dbg_intfc)
 215                 debugfs_remove_recursive(q_vector->dbg_q_vector);
 216         q_vector->dbg_q_vector = NULL;
 217 }
 218
 219 /**
 220  * fm10k_dbg_intfc_init - setup the debugfs directory for the intferface
 221  * @interface: the interface that is starting up
 222  **/
 223
 224 void fm10k_dbg_intfc_init(struct fm10k_intfc *interface)
 225 {
 226         const char *name = pci_name(interface->pdev);
 227
 228         if (dbg_root)
 229                 interface->dbg_intfc = debugfs_create_dir(name, dbg_root);
 230 }
 231
 232 /**
 233  * fm10k_dbg_intfc_exit - clean out the interface's debugfs entries
 234  * @interface: the interface that is stopping
 235  **/
 236 void fm10k_dbg_intfc_exit(struct fm10k_intfc *interface)
 237 {
 238         if (dbg_root)
 239                 debugfs_remove_recursive(interface->dbg_intfc);
 240         interface->dbg_intfc = NULL;
 241 }
 242
 243 /**
 244  * fm10k_dbg_init - start up debugfs for the driver
 245  **/
 246 void fm10k_dbg_init(void)
 247 {
 248         dbg_root = debugfs_create_dir(fm10k_driver_name, NULL);
 249 }
 250
 251 /**
 252  * fm10k_dbg_exit - clean out the driver's debugfs entries
 253  **/
 254 void fm10k_dbg_exit(void)
 255 {
 256         debugfs_remove_recursive(dbg_root);
 257         dbg_root = NULL;
 258 }