drivers/infiniband/hw/hfi1/fault.c

   1 /*
   2  * Copyright(c) 2018 Intel Corporation.
   3  *
   4  * This file is provided under a dual BSD/GPLv2 license.  When using or
   5  * redistributing this file, you may do so under either license.
   6  *
   7  * GPL LICENSE SUMMARY
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of version 2 of the GNU General Public License as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * BSD LICENSE
  19  *
  20  * Redistribution and use in source and binary forms, with or without
  21  * modification, are permitted provided that the following conditions
  22  * are met:
  23  *
  24  *  - Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  *  - Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in
  28  *    the documentation and/or other materials provided with the
  29  *    distribution.
  30  *  - Neither the name of Intel Corporation nor the names of its
  31  *    contributors may be used to endorse or promote products derived
  32  *    from this software without specific prior written permission.
  33  *
  34  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  35  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  36  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  37  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  38  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  39  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  40  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  41  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  42  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  43  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  44  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  45  *
  46  */
  47 #include <linux/debugfs.h>
  48 #include <linux/seq_file.h>
  49 #include <linux/kernel.h>
  50 #include <linux/module.h>
  51 #include <linux/types.h>
  52 #include <linux/bitmap.h>
  53
  54 #include "debugfs.h"
  55 #include "fault.h"
  56 #include "trace.h"
  57
  58 #define HFI1_FAULT_DIR_TX   BIT(0)
  59 #define HFI1_FAULT_DIR_RX   BIT(1)
  60 #define HFI1_FAULT_DIR_TXRX (HFI1_FAULT_DIR_TX | HFI1_FAULT_DIR_RX)
  61
  62 static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
  63 {
  64         struct hfi1_opcode_stats_perctx *opstats;
  65
  66         if (*pos >= ARRAY_SIZE(opstats->stats))
  67                 return NULL;
  68         return pos;
  69 }
  70
  71 static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
  72 {
  73         struct hfi1_opcode_stats_perctx *opstats;
  74
  75         ++*pos;
  76         if (*pos >= ARRAY_SIZE(opstats->stats))
  77                 return NULL;
  78         return pos;
  79 }
  80
  81 static void _fault_stats_seq_stop(struct seq_file *s, void *v)
  82 {
  83 }
  84
  85 static int _fault_stats_seq_show(struct seq_file *s, void *v)
  86 {
  87         loff_t *spos = v;
  88         loff_t i = *spos, j;
  89         u64 n_packets = 0, n_bytes = 0;
  90         struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
  91         struct hfi1_devdata *dd = dd_from_dev(ibd);
  92         struct hfi1_ctxtdata *rcd;
  93
  94         for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
  95                 rcd = hfi1_rcd_get_by_index(dd, j);
  96                 if (rcd) {
  97                         n_packets += rcd->opstats->stats[i].n_packets;
  98                         n_bytes += rcd->opstats->stats[i].n_bytes;
  99                 }
 100                 hfi1_rcd_put(rcd);
 101         }
 102         for_each_possible_cpu(j) {
 103                 struct hfi1_opcode_stats_perctx *sp =
 104                         per_cpu_ptr(dd->tx_opstats, j);
 105
 106                 n_packets += sp->stats[i].n_packets;
 107                 n_bytes += sp->stats[i].n_bytes;
 108         }
 109         if (!n_packets && !n_bytes)
 110                 return SEQ_SKIP;
 111         if (!ibd->fault->n_rxfaults[i] && !ibd->fault->n_txfaults[i])
 112                 return SEQ_SKIP;
 113         seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
 114                    (unsigned long long)n_packets,
 115                    (unsigned long long)n_bytes,
 116                    (unsigned long long)ibd->fault->n_rxfaults[i],
 117                    (unsigned long long)ibd->fault->n_txfaults[i]);
 118         return 0;
 119 }
 120
 121 DEBUGFS_SEQ_FILE_OPS(fault_stats);
 122 DEBUGFS_SEQ_FILE_OPEN(fault_stats);
 123 DEBUGFS_FILE_OPS(fault_stats);
 124
 125 static int fault_opcodes_open(struct inode *inode, struct file *file)
 126 {
 127         file->private_data = inode->i_private;
 128         return nonseekable_open(inode, file);
 129 }
 130
 131 static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
 132                                    size_t len, loff_t *pos)
 133 {
 134         ssize_t ret = 0;
 135         /* 1280 = 256 opcodes * 4 chars/opcode + 255 commas + NULL */
 136         size_t copy, datalen = 1280;
 137         char *data, *token, *ptr, *end;
 138         struct fault *fault = file->private_data;
 139
 140         data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
 141         if (!data)
 142                 return -ENOMEM;
 143         copy = min(len, datalen - 1);
 144         if (copy_from_user(data, buf, copy))
 145                 return -EFAULT;
 146
 147         ret = debugfs_file_get(file->f_path.dentry);
 148         if (unlikely(ret))
 149                 return ret;
 150         ptr = data;
 151         token = ptr;
 152         for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
 153                 char *dash;
 154                 unsigned long range_start, range_end, i;
 155                 bool remove = false;
 156                 unsigned long bound = 1U << BITS_PER_BYTE;
 157
 158                 end = strchr(ptr, ',');
 159                 if (end)
 160                         *end = '\0';
 161                 if (token[0] == '-') {
 162                         remove = true;
 163                         token++;
 164                 }
 165                 dash = strchr(token, '-');
 166                 if (dash)
 167                         *dash = '\0';
 168                 if (kstrtoul(token, 0, &range_start))
 169                         break;
 170                 if (dash) {
 171                         token = dash + 1;
 172                         if (kstrtoul(token, 0, &range_end))
 173                                 break;
 174                 } else {
 175                         range_end = range_start;
 176                 }
 177                 if (range_start == range_end && range_start == -1UL) {
 178                         bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
 179                                     BITS_PER_BYTE);
 180                         break;
 181                 }
 182                 /* Check the inputs */
 183                 if (range_start >= bound || range_end >= bound)
 184                         break;
 185
 186                 for (i = range_start; i <= range_end; i++) {
 187                         if (remove)
 188                                 clear_bit(i, fault->opcodes);
 189                         else
 190                                 set_bit(i, fault->opcodes);
 191                 }
 192                 if (!end)
 193                         break;
 194         }
 195         ret = len;
 196
 197         debugfs_file_put(file->f_path.dentry);
 198         kfree(data);
 199         return ret;
 200 }
 201
 202 static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
 203                                   size_t len, loff_t *pos)
 204 {
 205         ssize_t ret = 0;
 206         char *data;
 207         size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
 208         unsigned long bit = 0, zero = 0;
 209         struct fault *fault = file->private_data;
 210         size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
 211
 212         data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
 213         if (!data)
 214                 return -ENOMEM;
 215         ret = debugfs_file_get(file->f_path.dentry);
 216         if (unlikely(ret))
 217                 return ret;
 218         bit = find_first_bit(fault->opcodes, bitsize);
 219         while (bit < bitsize) {
 220                 zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
 221                 if (zero - 1 != bit)
 222                         size += snprintf(data + size,
 223                                          datalen - size - 1,
 224                                          "0x%lx-0x%lx,", bit, zero - 1);
 225                 else
 226                         size += snprintf(data + size,
 227                                          datalen - size - 1, "0x%lx,",
 228                                          bit);
 229                 bit = find_next_bit(fault->opcodes, bitsize, zero);
 230         }
 231         debugfs_file_put(file->f_path.dentry);
 232         data[size - 1] = '\n';
 233         data[size] = '\0';
 234         ret = simple_read_from_buffer(buf, len, pos, data, size);
 235         kfree(data);
 236         return ret;
 237 }
 238
 239 static const struct file_operations __fault_opcodes_fops = {
 240         .owner = THIS_MODULE,
 241         .open = fault_opcodes_open,
 242         .read = fault_opcodes_read,
 243         .write = fault_opcodes_write,
 244         .llseek = no_llseek
 245 };
 246
 247 void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
 248 {
 249         if (ibd->fault)
 250                 debugfs_remove_recursive(ibd->fault->dir);
 251         kfree(ibd->fault);
 252         ibd->fault = NULL;
 253 }
 254
 255 int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
 256 {
 257         struct dentry *parent = ibd->hfi1_ibdev_dbg;
 258         struct dentry *fault_dir;
 259
 260         ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
 261         if (!ibd->fault)
 262                 return -ENOMEM;
 263
 264         ibd->fault->attr.interval = 1;
 265         ibd->fault->attr.require_end = ULONG_MAX;
 266         ibd->fault->attr.stacktrace_depth = 32;
 267         ibd->fault->attr.dname = NULL;
 268         ibd->fault->attr.verbose = 0;
 269         ibd->fault->enable = false;
 270         ibd->fault->opcode = false;
 271         ibd->fault->fault_skip = 0;
 272         ibd->fault->skip = 0;
 273         ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
 274         ibd->fault->suppress_err = false;
 275         bitmap_zero(ibd->fault->opcodes,
 276                     sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
 277
 278         fault_dir =
 279                 fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
 280         if (IS_ERR(fault_dir)) {
 281                 kfree(ibd->fault);
 282                 ibd->fault = NULL;
 283                 return -ENOENT;
 284         }
 285         ibd->fault->dir = fault_dir;
 286
 287         debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
 288                             &_fault_stats_file_ops);
 289         debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
 290         debugfs_create_bool("suppress_err", 0600, fault_dir,
 291                             &ibd->fault->suppress_err);
 292         debugfs_create_bool("opcode_mode", 0600, fault_dir,
 293                             &ibd->fault->opcode);
 294         debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
 295                             &__fault_opcodes_fops);
 296         debugfs_create_u64("skip_pkts", 0600, fault_dir,
 297                            &ibd->fault->fault_skip);
 298         debugfs_create_u64("skip_usec", 0600, fault_dir,
 299                            &ibd->fault->fault_skip_usec);
 300         debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);
 301
 302         return 0;
 303 }
 304
 305 bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
 306 {
 307         if (ibd->fault)
 308                 return ibd->fault->suppress_err;
 309         return false;
 310 }
 311
 312 static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
 313                                 u8 direction)
 314 {
 315         bool ret = false;
 316
 317         if (!ibd->fault || !ibd->fault->enable)
 318                 return false;
 319         if (!(ibd->fault->direction & direction))
 320                 return false;
 321         if (ibd->fault->opcode) {
 322                 if (bitmap_empty(ibd->fault->opcodes,
 323                                  (sizeof(ibd->fault->opcodes) *
 324                                   BITS_PER_BYTE)))
 325                         return false;
 326                 if (!(test_bit(opcode, ibd->fault->opcodes)))
 327                         return false;
 328         }
 329         if (ibd->fault->fault_skip_usec &&
 330             time_before(jiffies, ibd->fault->skip_usec))
 331                 return false;
 332         if (ibd->fault->fault_skip && ibd->fault->skip) {
 333                 ibd->fault->skip--;
 334                 return false;
 335         }
 336         ret = should_fail(&ibd->fault->attr, 1);
 337         if (ret) {
 338                 ibd->fault->skip = ibd->fault->fault_skip;
 339                 ibd->fault->skip_usec = jiffies +
 340                         usecs_to_jiffies(ibd->fault->fault_skip_usec);
 341         }
 342         return ret;
 343 }
 344
 345 bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
 346 {
 347         struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
 348
 349         if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
 350                 trace_hfi1_fault_opcode(qp, opcode);
 351                 ibd->fault->n_txfaults[opcode]++;
 352                 return true;
 353         }
 354         return false;
 355 }
 356
 357 bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
 358 {
 359         struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
 360
 361         if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
 362                 trace_hfi1_fault_packet(packet);
 363                 ibd->fault->n_rxfaults[packet->opcode]++;
 364                 return true;
 365         }
 366         return false;
 367 }