drivers/infiniband/hw/qib/qib_debugfs.c

   1 #ifdef CONFIG_DEBUG_FS
   2 /*
   3  * Copyright (c) 2013 Intel Corporation.  All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33 #include <linux/debugfs.h>
  34 #include <linux/seq_file.h>
  35 #include <linux/kernel.h>
  36 #include <linux/export.h>
  37
  38 #include "qib.h"
  39 #include "qib_verbs.h"
  40 #include "qib_debugfs.h"
  41
  42 static struct dentry *qib_dbg_root;
  43
  44 #define DEBUGFS_FILE(name) \
  45 static const struct seq_operations _##name##_seq_ops = { \
  46         .start = _##name##_seq_start, \
  47         .next  = _##name##_seq_next, \
  48         .stop  = _##name##_seq_stop, \
  49         .show  = _##name##_seq_show \
  50 }; \
  51 static int _##name##_open(struct inode *inode, struct file *s) \
  52 { \
  53         struct seq_file *seq; \
  54         int ret; \
  55         ret =  seq_open(s, &_##name##_seq_ops); \
  56         if (ret) \
  57                 return ret; \
  58         seq = s->private_data; \
  59         seq->private = inode->i_private; \
  60         return 0; \
  61 } \
  62 static const struct file_operations _##name##_file_ops = { \
  63         .owner   = THIS_MODULE, \
  64         .open    = _##name##_open, \
  65         .read    = seq_read, \
  66         .llseek  = seq_lseek, \
  67         .release = seq_release \
  68 };
  69
  70 #define DEBUGFS_FILE_CREATE(name) \
  71 do { \
  72         struct dentry *ent; \
  73         ent = debugfs_create_file(#name , 0400, ibd->qib_ibdev_dbg, \
  74                 ibd, &_##name##_file_ops); \
  75         if (!ent) \
  76                 pr_warn("create of " #name " failed\n"); \
  77 } while (0)
  78
  79 static void *_opcode_stats_seq_start(struct seq_file *s, loff_t *pos)
  80 {
  81         struct qib_opcode_stats_perctx *opstats;
  82
  83         if (*pos >= ARRAY_SIZE(opstats->stats))
  84                 return NULL;
  85         return pos;
  86 }
  87
  88 static void *_opcode_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
  89 {
  90         struct qib_opcode_stats_perctx *opstats;
  91
  92         ++*pos;
  93         if (*pos >= ARRAY_SIZE(opstats->stats))
  94                 return NULL;
  95         return pos;
  96 }
  97
  98
  99 static void _opcode_stats_seq_stop(struct seq_file *s, void *v)
 100 {
 101         /* nothing allocated */
 102 }
 103
 104 static int _opcode_stats_seq_show(struct seq_file *s, void *v)
 105 {
 106         loff_t *spos = v;
 107         loff_t i = *spos, j;
 108         u64 n_packets = 0, n_bytes = 0;
 109         struct qib_ibdev *ibd = (struct qib_ibdev *)s->private;
 110         struct qib_devdata *dd = dd_from_dev(ibd);
 111
 112         for (j = 0; j < dd->first_user_ctxt; j++) {
 113                 if (!dd->rcd[j])
 114                         continue;
 115                 n_packets += dd->rcd[j]->opstats->stats[i].n_packets;
 116                 n_bytes += dd->rcd[j]->opstats->stats[i].n_bytes;
 117         }
 118         if (!n_packets && !n_bytes)
 119                 return SEQ_SKIP;
 120         seq_printf(s, "%02llx %llu/%llu\n", i,
 121                 (unsigned long long) n_packets,
 122                 (unsigned long long) n_bytes);
 123
 124         return 0;
 125 }
 126
 127 DEBUGFS_FILE(opcode_stats)
 128
 129 static void *_ctx_stats_seq_start(struct seq_file *s, loff_t *pos)
 130 {
 131         struct qib_ibdev *ibd = (struct qib_ibdev *)s->private;
 132         struct qib_devdata *dd = dd_from_dev(ibd);
 133
 134         if (!*pos)
 135                 return SEQ_START_TOKEN;
 136         if (*pos >= dd->first_user_ctxt)
 137                 return NULL;
 138         return pos;
 139 }
 140
 141 static void *_ctx_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
 142 {
 143         struct qib_ibdev *ibd = (struct qib_ibdev *)s->private;
 144         struct qib_devdata *dd = dd_from_dev(ibd);
 145
 146         if (v == SEQ_START_TOKEN)
 147                 return pos;
 148
 149         ++*pos;
 150         if (*pos >= dd->first_user_ctxt)
 151                 return NULL;
 152         return pos;
 153 }
 154
 155 static void _ctx_stats_seq_stop(struct seq_file *s, void *v)
 156 {
 157         /* nothing allocated */
 158 }
 159
 160 static int _ctx_stats_seq_show(struct seq_file *s, void *v)
 161 {
 162         loff_t *spos;
 163         loff_t i, j;
 164         u64 n_packets = 0;
 165         struct qib_ibdev *ibd = (struct qib_ibdev *)s->private;
 166         struct qib_devdata *dd = dd_from_dev(ibd);
 167
 168         if (v == SEQ_START_TOKEN) {
 169                 seq_puts(s, "Ctx:npkts\n");
 170                 return 0;
 171         }
 172
 173         spos = v;
 174         i = *spos;
 175
 176         if (!dd->rcd[i])
 177                 return SEQ_SKIP;
 178
 179         for (j = 0; j < ARRAY_SIZE(dd->rcd[i]->opstats->stats); j++)
 180                 n_packets += dd->rcd[i]->opstats->stats[j].n_packets;
 181
 182         if (!n_packets)
 183                 return SEQ_SKIP;
 184
 185         seq_printf(s, "  %llu:%llu\n", i, n_packets);
 186         return 0;
 187 }
 188
 189 DEBUGFS_FILE(ctx_stats)
 190
 191 static void *_qp_stats_seq_start(struct seq_file *s, loff_t *pos)
 192 {
 193         struct qib_qp_iter *iter;
 194         loff_t n = *pos;
 195
 196         rcu_read_lock();
 197         iter = qib_qp_iter_init(s->private);
 198         if (!iter)
 199                 return NULL;
 200
 201         while (n--) {
 202                 if (qib_qp_iter_next(iter)) {
 203                         kfree(iter);
 204                         return NULL;
 205                 }
 206         }
 207
 208         return iter;
 209 }
 210
 211 static void *_qp_stats_seq_next(struct seq_file *s, void *iter_ptr,
 212                                    loff_t *pos)
 213 {
 214         struct qib_qp_iter *iter = iter_ptr;
 215
 216         (*pos)++;
 217
 218         if (qib_qp_iter_next(iter)) {
 219                 kfree(iter);
 220                 return NULL;
 221         }
 222
 223         return iter;
 224 }
 225
 226 static void _qp_stats_seq_stop(struct seq_file *s, void *iter_ptr)
 227 {
 228         rcu_read_unlock();
 229 }
 230
 231 static int _qp_stats_seq_show(struct seq_file *s, void *iter_ptr)
 232 {
 233         struct qib_qp_iter *iter = iter_ptr;
 234
 235         if (!iter)
 236                 return 0;
 237
 238         qib_qp_iter_print(s, iter);
 239
 240         return 0;
 241 }
 242
 243 DEBUGFS_FILE(qp_stats)
 244
 245 void qib_dbg_ibdev_init(struct qib_ibdev *ibd)
 246 {
 247         char name[10];
 248
 249         snprintf(name, sizeof(name), "qib%d", dd_from_dev(ibd)->unit);
 250         ibd->qib_ibdev_dbg = debugfs_create_dir(name, qib_dbg_root);
 251         if (!ibd->qib_ibdev_dbg) {
 252                 pr_warn("create of %s failed\n", name);
 253                 return;
 254         }
 255         DEBUGFS_FILE_CREATE(opcode_stats);
 256         DEBUGFS_FILE_CREATE(ctx_stats);
 257         DEBUGFS_FILE_CREATE(qp_stats);
 258         return;
 259 }
 260
 261 void qib_dbg_ibdev_exit(struct qib_ibdev *ibd)
 262 {
 263         if (!qib_dbg_root)
 264                 goto out;
 265         debugfs_remove_recursive(ibd->qib_ibdev_dbg);
 266 out:
 267         ibd->qib_ibdev_dbg = NULL;
 268 }
 269
 270 void qib_dbg_init(void)
 271 {
 272         qib_dbg_root = debugfs_create_dir(QIB_DRV_NAME, NULL);
 273         if (!qib_dbg_root)
 274                 pr_warn("init of debugfs failed\n");
 275 }
 276
 277 void qib_dbg_exit(void)
 278 {
 279         debugfs_remove_recursive(qib_dbg_root);
 280         qib_dbg_root = NULL;
 281 }
 282
 283 #endif
 284