hw/hfi1/fault.c

0001 // SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause
0002 /*
0003  * Copyright(c) 2018 Intel Corporation.
0004  */
0005
0006 #include <linux/debugfs.h>
0007 #include <linux/seq_file.h>
0008 #include <linux/kernel.h>
0009 #include <linux/types.h>
0010 #include <linux/bitmap.h>
0011
0012 #include "debugfs.h"
0013 #include "fault.h"
0014 #include "trace.h"
0015
0016 #define HFI1_FAULT_DIR_TX   BIT(0)
0017 #define HFI1_FAULT_DIR_RX   BIT(1)
0018 #define HFI1_FAULT_DIR_TXRX (HFI1_FAULT_DIR_TX | HFI1_FAULT_DIR_RX)
0019
0020 static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
0021 {
0022     struct hfi1_opcode_stats_perctx *opstats;
0023
0024     if (*pos >= ARRAY_SIZE(opstats->stats))
0025         return NULL;
0026     return pos;
0027 }
0028
0029 static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
0030 {
0031     struct hfi1_opcode_stats_perctx *opstats;
0032
0033     ++*pos;
0034     if (*pos >= ARRAY_SIZE(opstats->stats))
0035         return NULL;
0036     return pos;
0037 }
0038
0039 static void _fault_stats_seq_stop(struct seq_file *s, void *v)
0040 {
0041 }
0042
0043 static int _fault_stats_seq_show(struct seq_file *s, void *v)
0044 {
0045     loff_t *spos = v;
0046     loff_t i = *spos, j;
0047     u64 n_packets = 0, n_bytes = 0;
0048     struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
0049     struct hfi1_devdata *dd = dd_from_dev(ibd);
0050     struct hfi1_ctxtdata *rcd;
0051
0052     for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
0053         rcd = hfi1_rcd_get_by_index(dd, j);
0054         if (rcd) {
0055             n_packets += rcd->opstats->stats[i].n_packets;
0056             n_bytes += rcd->opstats->stats[i].n_bytes;
0057         }
0058         hfi1_rcd_put(rcd);
0059     }
0060     for_each_possible_cpu(j) {
0061         struct hfi1_opcode_stats_perctx *sp =
0062             per_cpu_ptr(dd->tx_opstats, j);
0063
0064         n_packets += sp->stats[i].n_packets;
0065         n_bytes += sp->stats[i].n_bytes;
0066     }
0067     if (!n_packets && !n_bytes)
0068         return SEQ_SKIP;
0069     if (!ibd->fault->n_rxfaults[i] && !ibd->fault->n_txfaults[i])
0070         return SEQ_SKIP;
0071     seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
0072            (unsigned long long)n_packets,
0073            (unsigned long long)n_bytes,
0074            (unsigned long long)ibd->fault->n_rxfaults[i],
0075            (unsigned long long)ibd->fault->n_txfaults[i]);
0076     return 0;
0077 }
0078
0079 DEBUGFS_SEQ_FILE_OPS(fault_stats);
0080 DEBUGFS_SEQ_FILE_OPEN(fault_stats);
0081 DEBUGFS_FILE_OPS(fault_stats);
0082
0083 static int fault_opcodes_open(struct inode *inode, struct file *file)
0084 {
0085     file->private_data = inode->i_private;
0086     return nonseekable_open(inode, file);
0087 }
0088
0089 static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
0090                    size_t len, loff_t *pos)
0091 {
0092     ssize_t ret = 0;
0093     /* 1280 = 256 opcodes * 4 chars/opcode + 255 commas + NULL */
0094     size_t copy, datalen = 1280;
0095     char *data, *token, *ptr, *end;
0096     struct fault *fault = file->private_data;
0097
0098     data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
0099     if (!data)
0100         return -ENOMEM;
0101     copy = min(len, datalen - 1);
0102     if (copy_from_user(data, buf, copy)) {
0103         ret = -EFAULT;
0104         goto free_data;
0105     }
0106
0107     ret = debugfs_file_get(file->f_path.dentry);
0108     if (unlikely(ret))
0109         goto free_data;
0110     ptr = data;
0111     token = ptr;
0112     for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
0113         char *dash;
0114         unsigned long range_start, range_end, i;
0115         bool remove = false;
0116         unsigned long bound = 1U << BITS_PER_BYTE;
0117
0118         end = strchr(ptr, ',');
0119         if (end)
0120             *end = '\0';
0121         if (token[0] == '-') {
0122             remove = true;
0123             token++;
0124         }
0125         dash = strchr(token, '-');
0126         if (dash)
0127             *dash = '\0';
0128         if (kstrtoul(token, 0, &range_start))
0129             break;
0130         if (dash) {
0131             token = dash + 1;
0132             if (kstrtoul(token, 0, &range_end))
0133                 break;
0134         } else {
0135             range_end = range_start;
0136         }
0137         if (range_start == range_end && range_start == -1UL) {
0138             bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
0139                     BITS_PER_BYTE);
0140             break;
0141         }
0142         /* Check the inputs */
0143         if (range_start >= bound || range_end >= bound)
0144             break;
0145
0146         for (i = range_start; i <= range_end; i++) {
0147             if (remove)
0148                 clear_bit(i, fault->opcodes);
0149             else
0150                 set_bit(i, fault->opcodes);
0151         }
0152         if (!end)
0153             break;
0154     }
0155     ret = len;
0156
0157     debugfs_file_put(file->f_path.dentry);
0158 free_data:
0159     kfree(data);
0160     return ret;
0161 }
0162
0163 static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
0164                   size_t len, loff_t *pos)
0165 {
0166     ssize_t ret = 0;
0167     char *data;
0168     size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
0169     unsigned long bit = 0, zero = 0;
0170     struct fault *fault = file->private_data;
0171     size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
0172
0173     data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
0174     if (!data)
0175         return -ENOMEM;
0176     ret = debugfs_file_get(file->f_path.dentry);
0177     if (unlikely(ret))
0178         goto free_data;
0179     bit = find_first_bit(fault->opcodes, bitsize);
0180     while (bit < bitsize) {
0181         zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
0182         if (zero - 1 != bit)
0183             size += scnprintf(data + size,
0184                      datalen - size - 1,
0185                      "0x%lx-0x%lx,", bit, zero - 1);
0186         else
0187             size += scnprintf(data + size,
0188                      datalen - size - 1, "0x%lx,",
0189                      bit);
0190         bit = find_next_bit(fault->opcodes, bitsize, zero);
0191     }
0192     debugfs_file_put(file->f_path.dentry);
0193     data[size - 1] = '\n';
0194     data[size] = '\0';
0195     ret = simple_read_from_buffer(buf, len, pos, data, size);
0196 free_data:
0197     kfree(data);
0198     return ret;
0199 }
0200
0201 static const struct file_operations __fault_opcodes_fops = {
0202     .owner = THIS_MODULE,
0203     .open = fault_opcodes_open,
0204     .read = fault_opcodes_read,
0205     .write = fault_opcodes_write,
0206     .llseek = no_llseek
0207 };
0208
0209 void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
0210 {
0211     if (ibd->fault)
0212         debugfs_remove_recursive(ibd->fault->dir);
0213     kfree(ibd->fault);
0214     ibd->fault = NULL;
0215 }
0216
0217 int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
0218 {
0219     struct dentry *parent = ibd->hfi1_ibdev_dbg;
0220     struct dentry *fault_dir;
0221
0222     ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
0223     if (!ibd->fault)
0224         return -ENOMEM;
0225
0226     ibd->fault->attr.interval = 1;
0227     ibd->fault->attr.require_end = ULONG_MAX;
0228     ibd->fault->attr.stacktrace_depth = 32;
0229     ibd->fault->attr.dname = NULL;
0230     ibd->fault->attr.verbose = 0;
0231     ibd->fault->enable = false;
0232     ibd->fault->opcode = false;
0233     ibd->fault->fault_skip = 0;
0234     ibd->fault->skip = 0;
0235     ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
0236     ibd->fault->suppress_err = false;
0237     bitmap_zero(ibd->fault->opcodes,
0238             sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
0239
0240     fault_dir =
0241         fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
0242     if (IS_ERR(fault_dir)) {
0243         kfree(ibd->fault);
0244         ibd->fault = NULL;
0245         return -ENOENT;
0246     }
0247     ibd->fault->dir = fault_dir;
0248
0249     debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
0250                 &_fault_stats_file_ops);
0251     debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
0252     debugfs_create_bool("suppress_err", 0600, fault_dir,
0253                 &ibd->fault->suppress_err);
0254     debugfs_create_bool("opcode_mode", 0600, fault_dir,
0255                 &ibd->fault->opcode);
0256     debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
0257                 &__fault_opcodes_fops);
0258     debugfs_create_u64("skip_pkts", 0600, fault_dir,
0259                &ibd->fault->fault_skip);
0260     debugfs_create_u64("skip_usec", 0600, fault_dir,
0261                &ibd->fault->fault_skip_usec);
0262     debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);
0263
0264     return 0;
0265 }
0266
0267 bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
0268 {
0269     if (ibd->fault)
0270         return ibd->fault->suppress_err;
0271     return false;
0272 }
0273
0274 static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
0275                 u8 direction)
0276 {
0277     bool ret = false;
0278
0279     if (!ibd->fault || !ibd->fault->enable)
0280         return false;
0281     if (!(ibd->fault->direction & direction))
0282         return false;
0283     if (ibd->fault->opcode) {
0284         if (bitmap_empty(ibd->fault->opcodes,
0285                  (sizeof(ibd->fault->opcodes) *
0286                   BITS_PER_BYTE)))
0287             return false;
0288         if (!(test_bit(opcode, ibd->fault->opcodes)))
0289             return false;
0290     }
0291     if (ibd->fault->fault_skip_usec &&
0292         time_before(jiffies, ibd->fault->skip_usec))
0293         return false;
0294     if (ibd->fault->fault_skip && ibd->fault->skip) {
0295         ibd->fault->skip--;
0296         return false;
0297     }
0298     ret = should_fail(&ibd->fault->attr, 1);
0299     if (ret) {
0300         ibd->fault->skip = ibd->fault->fault_skip;
0301         ibd->fault->skip_usec = jiffies +
0302             usecs_to_jiffies(ibd->fault->fault_skip_usec);
0303     }
0304     return ret;
0305 }
0306
0307 bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
0308 {
0309     struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
0310
0311     if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
0312         trace_hfi1_fault_opcode(qp, opcode);
0313         ibd->fault->n_txfaults[opcode]++;
0314         return true;
0315     }
0316     return false;
0317 }
0318
0319 bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
0320 {
0321     struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
0322
0323     if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
0324         trace_hfi1_fault_packet(packet);
0325         ibd->fault->n_rxfaults[packet->opcode]++;
0326         return true;
0327     }
0328     return false;
0329 }