IB/hfi1: Rework fault injection machinery

The packet fault injection code present in the HFI1 driver had some
issues which not only fragment the code but also created user
confusion. Furthermore, it suffered from the following issues:

  1. The fault_packet method only worked for received packets. This
     meant that the only fault injection mode available for sent
     packets is fault_opcode, which did not allow for random packet
     drops on all egressing packets.
  2. The mask available for the fault_opcode mode did not really work
     due to the fact that the opcode values are not bits in a bitmask but
     rather sequential integer values. Creating a opcode/mask pair that
     would successfully capture a set of packets was nearly impossible.
  3. The code was fragmented and used too many debugfs entries to
     operate and control. This was confusing to users.
  4. It did not allow filtering fault injection on a per direction basis -
     egress vs. ingress.

In order to improve or fix the above issues, the following changes have
been made:

   1. The fault injection methods have been combined into a single fault
      injection facility. As such, the fault injection has been plugged
      into both the send and receive code paths. Regardless of method used
      the fault injection will operate on both egress and ingress packets.
   2. The type of fault injection - by packet or by opcode - is now controlled
      by changing the boolean value of the file "opcode_mode". When the value
      is set to True, fault injection is done by opcode. Otherwise, by
      packet.
   2. The masking ability has been removed in favor of a bitmap that holds
      opcodes of interest (one bit per opcode, a total of 256 bits). This
      works in tandem with the "opcode_mode" value. When the value of
      "opcode_mode" is False, this bitmap is ignored. When the value is
      True, the bitmap lists all opcodes to be considered for fault injection.
      By default, the bitmap is empty. When the user wants to filter by opcode,
      the user sets the corresponding bit in the bitmap by echo'ing the bit
      position into the 'opcodes' file. This gets around the issue that the set
      of opcodes does not lend itself to effective masks and allow for extremely
      fine-grained filtering by opcode.
   4. fault_packet and fault_opcode methods have been combined. Hence, there
      is only one debugfs directory controlling the entire operation of the
      fault injection machinery. This reduces the number of debugfs entries
      and provides a more unified user experience.
   5. A new control files - "direction" - is provided to allow the user to
      control the direction of packets, which are subject to fault injection.
   6. A new control file - "skip_usec" - is added that would allow the user
      to specify a "timeout" during which no fault injection will occur.

In addition, the following bug fixes have been applied:

   1. The fault injection code has been split into its own header and source
      files. This was done to better organize the code and support conditional
      compilation without littering the code with #ifdef's.
   2. The method by which the TX PIO packets were being marked for drop
      conflicted with the way send contexts were being setup. As a result,
      the send context was repeatedly being reset.
   3. The fault injection only makes sense when the user can control it
      through the debugfs entries. However, a kernel configuration can
      enable fault injection but keep fault injection debugfs entries
      disabled. Therefore, it makes sense that the HFI fault injection
      code depends on both.
   4. Error suppression did not take into account the method by which PIO
      packets were being dropped. Therefore, even with error suppression
      turned on, errors would still be displayed to the screen. A larger
      enough packet drop percentage would case the kernel to crash because
      the driver would be stuck printing errors.

Reviewed-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Reviewed-by: Don Hiatt <don.hiatt@intel.com>
Reviewed-by: Mike Marciniszyn <mike.marciniszyn@intel.com>
Signed-off-by: Mitko Haralanov <mitko.haralanov@intel.com>
Signed-off-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>

10 files changed, 577 insertions, 358 deletions

diff --git a/drivers/infiniband/hw/hfi1/Makefile b/drivers/infiniband/hw/hfi1/Makefile
index ce4010bad982..f451ba912f47 100644
--- a/drivers/infiniband/hw/hfi1/Makefile
+++ b/drivers/infiniband/hw/hfi1/Makefile
@@ -14,7 +14,15 @@ hfi1-y := affinity.o chip.o device.o driver.o efivar.o \
         qp.o qsfp.o rc.o ruc.o sdma.o sysfs.o trace.o \
         uc.o ud.o user_exp_rcv.o user_pages.o user_sdma.o verbs.o \
         verbs_txreq.o vnic_main.o vnic_sdma.o
-hfi1-$(CONFIG_DEBUG_FS) += debugfs.o
+
+ifdef CONFIG_DEBUG_FS
+hfi1-y += debugfs.o
+ifdef CONFIG_FAULT_INJECTION
+ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
+hfi1-y += fault.o
+endif
+endif
+endif
 
 CFLAGS_trace.o = -I$(src)
 ifdef MVERSION
diff --git a/drivers/infiniband/hw/hfi1/chip.c b/drivers/infiniband/hw/hfi1/chip.c
index 4cd422ff92f8..582cf7eb779f 100644
--- a/drivers/infiniband/hw/hfi1/chip.c
+++ b/drivers/infiniband/hw/hfi1/chip.c
@@ -1,5 +1,5 @@
 /*
- * Copyright(c) 2015 - 2017 Intel Corporation.
+ * Copyright(c) 2015 - 2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -65,6 +65,7 @@
 #include "aspm.h"
 #include "affinity.h"
 #include "debugfs.h"
+#include "fault.h"
 
 #define NUM_IB_PORTS 1
 
diff --git a/drivers/infiniband/hw/hfi1/debugfs.c b/drivers/infiniband/hw/hfi1/debugfs.c
index 5343960610fe..9f992ae36c89 100644
--- a/drivers/infiniband/hw/hfi1/debugfs.c
+++ b/drivers/infiniband/hw/hfi1/debugfs.c
@@ -60,15 +60,13 @@
 #include "device.h"
 #include "qp.h"
 #include "sdma.h"
+#include "fault.h"
 
 static struct dentry *hfi1_dbg_root;
 
 /* wrappers to enforce srcu in seq file */
-static ssize_t hfi1_seq_read(
-        struct file *file,
-        char __user *buf,
-        size_t size,
-        loff_t *ppos)
+ssize_t hfi1_seq_read(struct file *file, char __user *buf, size_t size,
+                      loff_t *ppos)
 {
         struct dentry *d = file->f_path.dentry;
         ssize_t r;
@@ -81,10 +79,7 @@ static ssize_t hfi1_seq_read(
         return r;
 }
 
-static loff_t hfi1_seq_lseek(
-        struct file *file,
-        loff_t offset,
-        int whence)
+loff_t hfi1_seq_lseek(struct file *file, loff_t offset, int whence)
 {
         struct dentry *d = file->f_path.dentry;
         loff_t r;
@@ -100,48 +95,6 @@ static loff_t hfi1_seq_lseek(
 #define private2dd(file) (file_inode(file)->i_private)
 #define private2ppd(file) (file_inode(file)->i_private)
 
-#define DEBUGFS_SEQ_FILE_OPS(name) \
-static const struct seq_operations _##name##_seq_ops = { \
-        .start = _##name##_seq_start, \
-        .next  = _##name##_seq_next, \
-        .stop  = _##name##_seq_stop, \
-        .show  = _##name##_seq_show \
-}
-
-#define DEBUGFS_SEQ_FILE_OPEN(name) \
-static int _##name##_open(struct inode *inode, struct file *s) \
-{ \
-        struct seq_file *seq; \
-        int ret; \
-        ret =  seq_open(s, &_##name##_seq_ops); \
-        if (ret) \
-                return ret; \
-        seq = s->private_data; \
-        seq->private = inode->i_private; \
-        return 0; \
-}
-
-#define DEBUGFS_FILE_OPS(name) \
-static const struct file_operations _##name##_file_ops = { \
-        .owner   = THIS_MODULE, \
-        .open    = _##name##_open, \
-        .read    = hfi1_seq_read, \
-        .llseek  = hfi1_seq_lseek, \
-        .release = seq_release \
-}
-
-#define DEBUGFS_FILE_CREATE(name, parent, data, ops, mode)      \
-do { \
-        struct dentry *ent; \
-        ent = debugfs_create_file(name, mode, parent, \
-                data, ops); \
-        if (!ent) \
-                pr_warn("create of %s failed\n", name); \
-} while (0)
-
-#define DEBUGFS_SEQ_FILE_CREATE(name, parent, data) \
-        DEBUGFS_FILE_CREATE(#name, parent, data, &_##name##_file_ops, S_IRUGO)
-
 static void *_opcode_stats_seq_start(struct seq_file *s, loff_t *pos)
 {
         struct hfi1_opcode_stats_perctx *opstats;
@@ -1160,236 +1113,6 @@ DEBUGFS_SEQ_FILE_OPS(sdma_cpu_list);
 DEBUGFS_SEQ_FILE_OPEN(sdma_cpu_list)
 DEBUGFS_FILE_OPS(sdma_cpu_list);
 
-#ifdef CONFIG_FAULT_INJECTION
-static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
-{
-        struct hfi1_opcode_stats_perctx *opstats;
-
-        if (*pos >= ARRAY_SIZE(opstats->stats))
-                return NULL;
-        return pos;
-}
-
-static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
-{
-        struct hfi1_opcode_stats_perctx *opstats;
-
-        ++*pos;
-        if (*pos >= ARRAY_SIZE(opstats->stats))
-                return NULL;
-        return pos;
-}
-
-static void _fault_stats_seq_stop(struct seq_file *s, void *v)
-{
-}
-
-static int _fault_stats_seq_show(struct seq_file *s, void *v)
-{
-        loff_t *spos = v;
-        loff_t i = *spos, j;
-        u64 n_packets = 0, n_bytes = 0;
-        struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
-        struct hfi1_devdata *dd = dd_from_dev(ibd);
-        struct hfi1_ctxtdata *rcd;
-
-        for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
-                rcd = hfi1_rcd_get_by_index(dd, j);
-                if (rcd) {
-                        n_packets += rcd->opstats->stats[i].n_packets;
-                        n_bytes += rcd->opstats->stats[i].n_bytes;
-                }
-                hfi1_rcd_put(rcd);
-        }
-        for_each_possible_cpu(j) {
-                struct hfi1_opcode_stats_perctx *sp =
-                        per_cpu_ptr(dd->tx_opstats, j);
-
-                n_packets += sp->stats[i].n_packets;
-                n_bytes += sp->stats[i].n_bytes;
-        }
-        if (!n_packets && !n_bytes)
-                return SEQ_SKIP;
-        if (!ibd->fault_opcode->n_rxfaults[i] &&
-            !ibd->fault_opcode->n_txfaults[i])
-                return SEQ_SKIP;
-        seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
-                   (unsigned long long)n_packets,
-                   (unsigned long long)n_bytes,
-                   (unsigned long long)ibd->fault_opcode->n_rxfaults[i],
-                   (unsigned long long)ibd->fault_opcode->n_txfaults[i]);
-        return 0;
-}
-
-DEBUGFS_SEQ_FILE_OPS(fault_stats);
-DEBUGFS_SEQ_FILE_OPEN(fault_stats);
-DEBUGFS_FILE_OPS(fault_stats);
-
-static void fault_exit_opcode_debugfs(struct hfi1_ibdev *ibd)
-{
-        if (ibd->fault_opcode)
-                debugfs_remove_recursive(ibd->fault_opcode->dir);
-        kfree(ibd->fault_opcode);
-        ibd->fault_opcode = NULL;
-}
-
-static int fault_init_opcode_debugfs(struct hfi1_ibdev *ibd)
-{
-        struct dentry *parent = ibd->hfi1_ibdev_dbg;
-
-        ibd->fault_opcode = kzalloc(sizeof(*ibd->fault_opcode), GFP_KERNEL);
-        if (!ibd->fault_opcode)
-                return -ENOMEM;
-
-        ibd->fault_opcode->attr.interval = 1;
-        ibd->fault_opcode->attr.require_end = ULONG_MAX;
-        ibd->fault_opcode->attr.stacktrace_depth = 32;
-        ibd->fault_opcode->attr.dname = NULL;
-        ibd->fault_opcode->attr.verbose = 0;
-        ibd->fault_opcode->fault_by_opcode = false;
-        ibd->fault_opcode->opcode = 0;
-        ibd->fault_opcode->mask = 0xff;
-
-        ibd->fault_opcode->dir =
-                fault_create_debugfs_attr("fault_opcode",
-                                          parent,
-                                          &ibd->fault_opcode->attr);
-        if (IS_ERR(ibd->fault_opcode->dir)) {
-                kfree(ibd->fault_opcode);
-                ibd->fault_opcode = NULL;
-                return -ENOENT;
-        }
-
-        DEBUGFS_SEQ_FILE_CREATE(fault_stats, ibd->fault_opcode->dir, ibd);
-        if (!debugfs_create_bool("fault_by_opcode", 0600,
-                                 ibd->fault_opcode->dir,
-                                 &ibd->fault_opcode->fault_by_opcode))
-                goto fail;
-        if (!debugfs_create_x8("opcode", 0600, ibd->fault_opcode->dir,
-                               &ibd->fault_opcode->opcode))
-                goto fail;
-        if (!debugfs_create_x8("mask", 0600, ibd->fault_opcode->dir,
-                               &ibd->fault_opcode->mask))
-                goto fail;
-
-        return 0;
-fail:
-        fault_exit_opcode_debugfs(ibd);
-        return -ENOMEM;
-}
-
-static void fault_exit_packet_debugfs(struct hfi1_ibdev *ibd)
-{
-        if (ibd->fault_packet)
-                debugfs_remove_recursive(ibd->fault_packet->dir);
-        kfree(ibd->fault_packet);
-        ibd->fault_packet = NULL;
-}
-
-static int fault_init_packet_debugfs(struct hfi1_ibdev *ibd)
-{
-        struct dentry *parent = ibd->hfi1_ibdev_dbg;
-
-        ibd->fault_packet = kzalloc(sizeof(*ibd->fault_packet), GFP_KERNEL);
-        if (!ibd->fault_packet)
-                return -ENOMEM;
-
-        ibd->fault_packet->attr.interval = 1;
-        ibd->fault_packet->attr.require_end = ULONG_MAX;
-        ibd->fault_packet->attr.stacktrace_depth = 32;
-        ibd->fault_packet->attr.dname = NULL;
-        ibd->fault_packet->attr.verbose = 0;
-        ibd->fault_packet->fault_by_packet = false;
-
-        ibd->fault_packet->dir =
-                fault_create_debugfs_attr("fault_packet",
-                                          parent,
-                                          &ibd->fault_opcode->attr);
-        if (IS_ERR(ibd->fault_packet->dir)) {
-                kfree(ibd->fault_packet);
-                ibd->fault_packet = NULL;
-                return -ENOENT;
-        }
-
-        if (!debugfs_create_bool("fault_by_packet", 0600,
-                                 ibd->fault_packet->dir,
-                                 &ibd->fault_packet->fault_by_packet))
-                goto fail;
-        if (!debugfs_create_u64("fault_stats", 0400,
-                                ibd->fault_packet->dir,
-                                &ibd->fault_packet->n_faults))
-                goto fail;
-
-        return 0;
-fail:
-        fault_exit_packet_debugfs(ibd);
-        return -ENOMEM;
-}
-
-static void fault_exit_debugfs(struct hfi1_ibdev *ibd)
-{
-        fault_exit_opcode_debugfs(ibd);
-        fault_exit_packet_debugfs(ibd);
-}
-
-static int fault_init_debugfs(struct hfi1_ibdev *ibd)
-{
-        int ret = 0;
-
-        ret = fault_init_opcode_debugfs(ibd);
-        if (ret)
-                return ret;
-
-        ret = fault_init_packet_debugfs(ibd);
-        if (ret)
-                fault_exit_opcode_debugfs(ibd);
-
-        return ret;
-}
-
-bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
-{
-        return ibd->fault_suppress_err;
-}
-
-bool hfi1_dbg_fault_opcode(struct rvt_qp *qp, u32 opcode, bool rx)
-{
-        bool ret = false;
-        struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
-
-        if (!ibd->fault_opcode || !ibd->fault_opcode->fault_by_opcode)
-                return false;
-        if (ibd->fault_opcode->opcode != (opcode & ibd->fault_opcode->mask))
-                return false;
-        ret = should_fail(&ibd->fault_opcode->attr, 1);
-        if (ret) {
-                trace_hfi1_fault_opcode(qp, opcode);
-                if (rx)
-                        ibd->fault_opcode->n_rxfaults[opcode]++;
-                else
-                        ibd->fault_opcode->n_txfaults[opcode]++;
-        }
-        return ret;
-}
-
-bool hfi1_dbg_fault_packet(struct hfi1_packet *packet)
-{
-        struct rvt_dev_info *rdi = &packet->rcd->ppd->dd->verbs_dev.rdi;
-        struct hfi1_ibdev *ibd = dev_from_rdi(rdi);
-        bool ret = false;
-
-        if (!ibd->fault_packet || !ibd->fault_packet->fault_by_packet)
-                return false;
-
-        ret = should_fail(&ibd->fault_packet->attr, 1);
-        if (ret) {
-                ++ibd->fault_packet->n_faults;
-                trace_hfi1_fault_packet(packet);
-        }
-        return ret;
-}
-#endif
-
 void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd)
 {
         char name[sizeof("port0counters") + 1];
@@ -1442,21 +1165,14 @@ void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd)
                                             S_IRUGO : S_IRUGO | S_IWUSR);
                 }
 
-#ifdef CONFIG_FAULT_INJECTION
-        debugfs_create_bool("fault_suppress_err", 0600,
-                            ibd->hfi1_ibdev_dbg,
-                            &ibd->fault_suppress_err);
-        fault_init_debugfs(ibd);
-#endif
+        hfi1_fault_init_debugfs(ibd);
 }
 
 void hfi1_dbg_ibdev_exit(struct hfi1_ibdev *ibd)
 {
         if (!hfi1_dbg_root)
                 goto out;
-#ifdef CONFIG_FAULT_INJECTION
-        fault_exit_debugfs(ibd);
-#endif
+        hfi1_fault_exit_debugfs(ibd);
         debugfs_remove(ibd->hfi1_ibdev_link);
         debugfs_remove_recursive(ibd->hfi1_ibdev_dbg);
 out:
diff --git a/drivers/infiniband/hw/hfi1/debugfs.h b/drivers/infiniband/hw/hfi1/debugfs.h
index 38c38a98156d..1c91461b108f 100644
--- a/drivers/infiniband/hw/hfi1/debugfs.h
+++ b/drivers/infiniband/hw/hfi1/debugfs.h
@@ -1,7 +1,7 @@
 #ifndef _HFI1_DEBUGFS_H
 #define _HFI1_DEBUGFS_H
 /*
- * Copyright(c) 2015, 2016 Intel Corporation.
+ * Copyright(c) 2015, 2016, 2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -48,51 +48,59 @@
  */
 
 struct hfi1_ibdev;
-#ifdef CONFIG_DEBUG_FS
-void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd);
-void hfi1_dbg_ibdev_exit(struct hfi1_ibdev *ibd);
-void hfi1_dbg_init(void);
-void hfi1_dbg_exit(void);
 
-#ifdef CONFIG_FAULT_INJECTION
-#include <linux/fault-inject.h>
-struct fault_opcode {
-        struct fault_attr attr;
-        struct dentry *dir;
-        bool fault_by_opcode;
-        u64 n_rxfaults[256];
-        u64 n_txfaults[256];
-        u8 opcode;
-        u8 mask;
-};
-
-struct fault_packet {
-        struct fault_attr attr;
-        struct dentry *dir;
-        bool fault_by_packet;
-        u64 n_faults;
-};
-
-bool hfi1_dbg_fault_opcode(struct rvt_qp *qp, u32 opcode, bool rx);
-bool hfi1_dbg_fault_packet(struct hfi1_packet *packet);
-bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd);
-#else
-static inline bool hfi1_dbg_fault_packet(struct hfi1_packet *packet)
-{
-        return false;
+#define DEBUGFS_FILE_CREATE(name, parent, data, ops, mode)      \
+do { \
+        struct dentry *ent; \
+        const char *__name = name; \
+        ent = debugfs_create_file(__name, mode, parent, \
+                data, ops); \
+        if (!ent) \
+                pr_warn("create of %s failed\n", __name); \
+} while (0)
+
+#define DEBUGFS_SEQ_FILE_OPS(name) \
+static const struct seq_operations _##name##_seq_ops = { \
+        .start = _##name##_seq_start, \
+        .next  = _##name##_seq_next, \
+        .stop  = _##name##_seq_stop, \
+        .show  = _##name##_seq_show \
 }
 
-static inline bool hfi1_dbg_fault_opcode(struct rvt_qp *qp,
-                                         u32 opcode, bool rx)
-{
-        return false;
+#define DEBUGFS_SEQ_FILE_OPEN(name) \
+static int _##name##_open(struct inode *inode, struct file *s) \
+{ \
+        struct seq_file *seq; \
+        int ret; \
+        ret =  seq_open(s, &_##name##_seq_ops); \
+        if (ret) \
+                return ret; \
+        seq = s->private_data; \
+        seq->private = inode->i_private; \
+        return 0; \
 }
 
-static inline bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
-{
-        return false;
+#define DEBUGFS_FILE_OPS(name) \
+static const struct file_operations _##name##_file_ops = { \
+        .owner   = THIS_MODULE, \
+        .open    = _##name##_open, \
+        .read    = hfi1_seq_read, \
+        .llseek  = hfi1_seq_lseek, \
+        .release = seq_release \
 }
-#endif
+
+#define DEBUGFS_SEQ_FILE_CREATE(name, parent, data) \
+        DEBUGFS_FILE_CREATE(#name, parent, data, &_##name##_file_ops, 0444)
+
+ssize_t hfi1_seq_read(struct file *file, char __user *buf, size_t size,
+                      loff_t *ppos);
+loff_t hfi1_seq_lseek(struct file *file, loff_t offset, int whence);
+
+#ifdef CONFIG_DEBUG_FS
+void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd);
+void hfi1_dbg_ibdev_exit(struct hfi1_ibdev *ibd);
+void hfi1_dbg_init(void);
+void hfi1_dbg_exit(void);
 
 #else
 static inline void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd)
@@ -111,13 +119,12 @@ static inline void hfi1_dbg_exit(void)
 {
 }
 
-static inline bool hfi1_dbg_fault_packet(struct hfi1_packet *packet)
+static inline bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
 {
         return false;
 }
 
-static inline bool hfi1_dbg_fault_opcode(struct rvt_qp *qp,
-                                         u32 opcode, bool rx)
+static inline bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
 {
         return false;
 }
diff --git a/drivers/infiniband/hw/hfi1/driver.c b/drivers/infiniband/hw/hfi1/driver.c
index bd837a048bf4..e5a57ebd8da4 100644
--- a/drivers/infiniband/hw/hfi1/driver.c
+++ b/drivers/infiniband/hw/hfi1/driver.c
@@ -1,5 +1,5 @@
 /*
- * Copyright(c) 2015-2017 Intel Corporation.
+ * Copyright(c) 2015-2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -61,6 +61,7 @@
 #include "sdma.h"
 #include "debugfs.h"
 #include "vnic.h"
+#include "fault.h"
 
 #undef pr_fmt
 #define pr_fmt(fmt) DRIVER_NAME ": " fmt
@@ -1565,10 +1566,10 @@ void handle_eflags(struct hfi1_packet *packet)
  */
 int process_receive_ib(struct hfi1_packet *packet)
 {
-        if (unlikely(hfi1_dbg_fault_packet(packet)))
+        if (hfi1_setup_9B_packet(packet))
                 return RHF_RCV_CONTINUE;
 
-        if (hfi1_setup_9B_packet(packet))
+        if (unlikely(hfi1_dbg_should_fault_rx(packet)))
                 return RHF_RCV_CONTINUE;
 
         trace_hfi1_rcvhdr(packet);
@@ -1642,7 +1643,8 @@ int process_receive_error(struct hfi1_packet *packet)
         /* KHdrHCRCErr -- KDETH packet with a bad HCRC */
         if (unlikely(
                  hfi1_dbg_fault_suppress_err(&packet->rcd->dd->verbs_dev) &&
-                 rhf_rcv_type_err(packet->rhf) == 3))
+                 (rhf_rcv_type_err(packet->rhf) == RHF_RCV_TYPE_ERROR ||
+                  packet->rhf & RHF_DC_ERR)))
                 return RHF_RCV_CONTINUE;
 
         hfi1_setup_ib_header(packet);
@@ -1657,10 +1659,10 @@ int process_receive_error(struct hfi1_packet *packet)
 
 int kdeth_process_expected(struct hfi1_packet *packet)
 {
-        if (unlikely(hfi1_dbg_fault_packet(packet)))
+        hfi1_setup_9B_packet(packet);
+        if (unlikely(hfi1_dbg_should_fault_rx(packet)))
                 return RHF_RCV_CONTINUE;
 
-        hfi1_setup_ib_header(packet);
         if (unlikely(rhf_err_flags(packet->rhf)))
                 handle_eflags(packet);
 
@@ -1671,11 +1673,11 @@ int kdeth_process_expected(struct hfi1_packet *packet)
 
 int kdeth_process_eager(struct hfi1_packet *packet)
 {
-        hfi1_setup_ib_header(packet);
+        hfi1_setup_9B_packet(packet);
+        if (unlikely(hfi1_dbg_should_fault_rx(packet)))
+                return RHF_RCV_CONTINUE;
         if (unlikely(rhf_err_flags(packet->rhf)))
                 handle_eflags(packet);
-        if (unlikely(hfi1_dbg_fault_packet(packet)))
-                return RHF_RCV_CONTINUE;
 
         dd_dev_err(packet->rcd->dd,
                    "Unhandled eager packet received. Dropping.\n");
diff --git a/drivers/infiniband/hw/hfi1/fault.c b/drivers/infiniband/hw/hfi1/fault.c
new file mode 100644
index 000000000000..e2290f32c8d9
--- /dev/null
+++ b/drivers/infiniband/hw/hfi1/fault.c
@@ -0,0 +1,375 @@
+/*
+ * Copyright(c) 2018 Intel Corporation.
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  - Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  - Neither the name of Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/bitmap.h>
+
+#include "debugfs.h"
+#include "fault.h"
+#include "trace.h"
+
+#define HFI1_FAULT_DIR_TX   BIT(0)
+#define HFI1_FAULT_DIR_RX   BIT(1)
+#define HFI1_FAULT_DIR_TXRX (HFI1_FAULT_DIR_TX | HFI1_FAULT_DIR_RX)
+
+static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
+{
+        struct hfi1_opcode_stats_perctx *opstats;
+
+        if (*pos >= ARRAY_SIZE(opstats->stats))
+                return NULL;
+        return pos;
+}
+
+static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
+{
+        struct hfi1_opcode_stats_perctx *opstats;
+
+        ++*pos;
+        if (*pos >= ARRAY_SIZE(opstats->stats))
+                return NULL;
+        return pos;
+}
+
+static void _fault_stats_seq_stop(struct seq_file *s, void *v)
+{
+}
+
+static int _fault_stats_seq_show(struct seq_file *s, void *v)
+{
+        loff_t *spos = v;
+        loff_t i = *spos, j;
+        u64 n_packets = 0, n_bytes = 0;
+        struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
+        struct hfi1_devdata *dd = dd_from_dev(ibd);
+        struct hfi1_ctxtdata *rcd;
+
+        for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
+                rcd = hfi1_rcd_get_by_index(dd, j);
+                if (rcd) {
+                        n_packets += rcd->opstats->stats[i].n_packets;
+                        n_bytes += rcd->opstats->stats[i].n_bytes;
+                }
+                hfi1_rcd_put(rcd);
+        }
+        for_each_possible_cpu(j) {
+                struct hfi1_opcode_stats_perctx *sp =
+                        per_cpu_ptr(dd->tx_opstats, j);
+
+                n_packets += sp->stats[i].n_packets;
+                n_bytes += sp->stats[i].n_bytes;
+        }
+        if (!n_packets && !n_bytes)
+                return SEQ_SKIP;
+        if (!ibd->fault->n_rxfaults[i] && !ibd->fault->n_txfaults[i])
+                return SEQ_SKIP;
+        seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
+                   (unsigned long long)n_packets,
+                   (unsigned long long)n_bytes,
+                   (unsigned long long)ibd->fault->n_rxfaults[i],
+                   (unsigned long long)ibd->fault->n_txfaults[i]);
+        return 0;
+}
+
+DEBUGFS_SEQ_FILE_OPS(fault_stats);
+DEBUGFS_SEQ_FILE_OPEN(fault_stats);
+DEBUGFS_FILE_OPS(fault_stats);
+
+static int fault_opcodes_open(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
+                                   size_t len, loff_t *pos)
+{
+        ssize_t ret = 0;
+        /* 1280 = 256 opcodes * 4 chars/opcode + 255 commas + NULL */
+        size_t copy, datalen = 1280;
+        char *data, *token, *ptr, *end;
+        struct fault *fault = file->private_data;
+
+        data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        copy = min(len, datalen - 1);
+        if (copy_from_user(data, buf, copy))
+                return -EFAULT;
+
+        ret = debugfs_file_get(file->f_path.dentry);
+        if (unlikely(ret))
+                return ret;
+        ptr = data;
+        token = ptr;
+        for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
+                char *dash;
+                unsigned long range_start, range_end, i;
+                bool remove = false;
+
+                end = strchr(ptr, ',');
+                if (end)
+                        *end = '\0';
+                if (token[0] == '-') {
+                        remove = true;
+                        token++;
+                }
+                dash = strchr(token, '-');
+                if (dash)
+                        *dash = '\0';
+                if (kstrtoul(token, 0, &range_start))
+                        break;
+                if (dash) {
+                        token = dash + 1;
+                        if (kstrtoul(token, 0, &range_end))
+                                break;
+                } else {
+                        range_end = range_start;
+                }
+                if (range_start == range_end && range_start == -1UL) {
+                        bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
+                                    BITS_PER_BYTE);
+                        break;
+                }
+                for (i = range_start; i <= range_end; i++) {
+                        if (remove)
+                                clear_bit(i, fault->opcodes);
+                        else
+                                set_bit(i, fault->opcodes);
+                }
+                if (!end)
+                        break;
+        }
+        ret = len;
+
+        debugfs_file_put(file->f_path.dentry);
+        kfree(data);
+        return ret;
+}
+
+static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
+                                  size_t len, loff_t *pos)
+{
+        ssize_t ret = 0;
+        char *data;
+        size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
+        unsigned long bit = 0, zero = 0;
+        struct fault *fault = file->private_data;
+        size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
+
+        data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        ret = debugfs_file_get(file->f_path.dentry);
+        if (unlikely(ret))
+                return ret;
+        bit = find_first_bit(fault->opcodes, bitsize);
+        while (bit < bitsize) {
+                zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
+                if (zero - 1 != bit)
+                        size += snprintf(data + size,
+                                         datalen - size - 1,
+                                         "0x%lx-0x%lx,", bit, zero - 1);
+                else
+                        size += snprintf(data + size,
+                                         datalen - size - 1, "0x%lx,",
+                                         bit);
+                bit = find_next_bit(fault->opcodes, bitsize, zero);
+        }
+        debugfs_file_put(file->f_path.dentry);
+        data[size - 1] = '\n';
+        data[size] = '\0';
+        ret = simple_read_from_buffer(buf, len, pos, data, size);
+        kfree(data);
+        return ret;
+}
+
+static const struct file_operations __fault_opcodes_fops = {
+        .owner = THIS_MODULE,
+        .open = fault_opcodes_open,
+        .read = fault_opcodes_read,
+        .write = fault_opcodes_write,
+        .llseek = no_llseek
+};
+
+void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
+{
+        if (ibd->fault)
+                debugfs_remove_recursive(ibd->fault->dir);
+        kfree(ibd->fault);
+        ibd->fault = NULL;
+}
+
+int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
+{
+        struct dentry *parent = ibd->hfi1_ibdev_dbg;
+
+        ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
+        if (!ibd->fault)
+                return -ENOMEM;
+
+        ibd->fault->attr.interval = 1;
+        ibd->fault->attr.require_end = ULONG_MAX;
+        ibd->fault->attr.stacktrace_depth = 32;
+        ibd->fault->attr.dname = NULL;
+        ibd->fault->attr.verbose = 0;
+        ibd->fault->enable = false;
+        ibd->fault->opcode = false;
+        ibd->fault->fault_skip = 0;
+        ibd->fault->skip = 0;
+        ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
+        ibd->fault->suppress_err = false;
+        bitmap_zero(ibd->fault->opcodes,
+                    sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
+
+        ibd->fault->dir =
+                fault_create_debugfs_attr("fault", parent,
+                                          &ibd->fault->attr);
+        if (IS_ERR(ibd->fault->dir)) {
+                kfree(ibd->fault);
+                ibd->fault = NULL;
+                return -ENOENT;
+        }
+
+        DEBUGFS_SEQ_FILE_CREATE(fault_stats, ibd->fault->dir, ibd);
+        if (!debugfs_create_bool("enable", 0600, ibd->fault->dir,
+                                 &ibd->fault->enable))
+                goto fail;
+        if (!debugfs_create_bool("suppress_err", 0600,
+                                 ibd->fault->dir,
+                                 &ibd->fault->suppress_err))
+                goto fail;
+        if (!debugfs_create_bool("opcode_mode", 0600, ibd->fault->dir,
+                                 &ibd->fault->opcode))
+                goto fail;
+        if (!debugfs_create_file("opcodes", 0600, ibd->fault->dir,
+                                 ibd->fault, &__fault_opcodes_fops))
+                goto fail;
+        if (!debugfs_create_u64("skip_pkts", 0600,
+                                ibd->fault->dir,
+                                &ibd->fault->fault_skip))
+                goto fail;
+        if (!debugfs_create_u64("skip_usec", 0600,
+                                ibd->fault->dir,
+                                &ibd->fault->fault_skip_usec))
+                goto fail;
+        if (!debugfs_create_u8("direction", 0600, ibd->fault->dir,
+                               &ibd->fault->direction))
+                goto fail;
+
+        return 0;
+fail:
+        hfi1_fault_exit_debugfs(ibd);
+        return -ENOMEM;
+}
+
+bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
+{
+        if (ibd->fault)
+                return ibd->fault->suppress_err;
+        return false;
+}
+
+static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
+                                u8 direction)
+{
+        bool ret = false;
+
+        if (!ibd->fault || !ibd->fault->enable)
+                return false;
+        if (!(ibd->fault->direction & direction))
+                return false;
+        if (ibd->fault->opcode) {
+                if (bitmap_empty(ibd->fault->opcodes,
+                                 (sizeof(ibd->fault->opcodes) *
+                                  BITS_PER_BYTE)))
+                        return false;
+                if (!(test_bit(opcode, ibd->fault->opcodes)))
+                        return false;
+        }
+        if (ibd->fault->fault_skip_usec &&
+            time_before(jiffies, ibd->fault->skip_usec))
+                return false;
+        if (ibd->fault->fault_skip && ibd->fault->skip) {
+                ibd->fault->skip--;
+                return false;
+        }
+        ret = should_fail(&ibd->fault->attr, 1);
+        if (ret) {
+                ibd->fault->skip = ibd->fault->fault_skip;
+                ibd->fault->skip_usec = jiffies +
+                        usecs_to_jiffies(ibd->fault->fault_skip_usec);
+        }
+        return ret;
+}
+
+bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
+{
+        struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
+
+        if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
+                trace_hfi1_fault_opcode(qp, opcode);
+                ibd->fault->n_txfaults[opcode]++;
+                return true;
+        }
+        return false;
+}
+
+bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
+{
+        struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
+
+        if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
+                trace_hfi1_fault_packet(packet);
+                ibd->fault->n_rxfaults[packet->opcode]++;
+                return true;
+        }
+        return false;
+}
diff --git a/drivers/infiniband/hw/hfi1/fault.h b/drivers/infiniband/hw/hfi1/fault.h
new file mode 100644
index 000000000000..a83382700a7c
--- /dev/null
+++ b/drivers/infiniband/hw/hfi1/fault.h
@@ -0,0 +1,109 @@
+#ifndef _HFI1_FAULT_H
+#define _HFI1_FAULT_H
+/*
+ * Copyright(c) 2018 Intel Corporation.
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  - Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *  - Neither the name of Intel Corporation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <linux/fault-inject.h>
+#include <linux/dcache.h>
+#include <linux/bitops.h>
+#include <linux/kernel.h>
+#include <rdma/rdma_vt.h>
+
+#include "hfi.h"
+
+struct hfi1_ibdev;
+
+#if defined(CONFIG_FAULT_INJECTION) && defined(CONFIG_FAULT_INJECTION_DEBUG_FS)
+struct fault {
+        struct fault_attr attr;
+        struct dentry *dir;
+        u64 n_rxfaults[(1U << BITS_PER_BYTE)];
+        u64 n_txfaults[(1U << BITS_PER_BYTE)];
+        u64 fault_skip;
+        u64 skip;
+        u64 fault_skip_usec;
+        unsigned long skip_usec;
+        unsigned long opcodes[(1U << BITS_PER_BYTE) / BITS_PER_LONG];
+        bool enable;
+        bool suppress_err;
+        bool opcode;
+        u8 direction;
+};
+
+int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd);
+bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode);
+bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet);
+bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd);
+void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd);
+
+#else
+
+static inline int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
+{
+        return 0;
+}
+
+static inline bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
+{
+        return false;
+}
+
+static inline bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp,
+                                            u32 opcode)
+{
+        return false;
+}
+
+static inline bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
+{
+        return false;
+}
+
+static inline void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
+{
+}
+#endif
+#endif /* _HFI1_FAULT_H */
diff --git a/drivers/infiniband/hw/hfi1/hfi.h b/drivers/infiniband/hw/hfi1/hfi.h
index 9c97c180c35e..9cd758ce7764 100644
--- a/drivers/infiniband/hw/hfi1/hfi.h
+++ b/drivers/infiniband/hw/hfi1/hfi.h
@@ -1,7 +1,7 @@
 #ifndef _HFI1_KERNEL_H
 #define _HFI1_KERNEL_H
 /*
- * Copyright(c) 2015-2017 Intel Corporation.
+ * Copyright(c) 2015-2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -2049,7 +2049,9 @@ static inline u64 hfi1_pkt_default_send_ctxt_mask(struct hfi1_devdata *dd,
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_TOO_LONG_BYPASS_PACKETS_SMASK
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_TOO_LONG_IB_PACKETS_SMASK
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_BAD_PKT_LEN_SMASK
+#ifndef CONFIG_FAULT_INJECTION
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_PBC_TEST_SMASK
+#endif
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_TOO_SMALL_BYPASS_PACKETS_SMASK
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_TOO_SMALL_IB_PACKETS_SMASK
         | SEND_CTXT_CHECK_ENABLE_DISALLOW_RAW_IPV6_SMASK
@@ -2062,7 +2064,11 @@ static inline u64 hfi1_pkt_default_send_ctxt_mask(struct hfi1_devdata *dd,
         | SEND_CTXT_CHECK_ENABLE_CHECK_ENABLE_SMASK;
 
         if (ctxt_type == SC_USER)
-                base_sc_integrity |= HFI1_PKT_USER_SC_INTEGRITY;
+                base_sc_integrity |=
+#ifndef CONFIG_FAULT_INJECTION
+                        SEND_CTXT_CHECK_ENABLE_DISALLOW_PBC_TEST_SMASK |
+#endif
+                        HFI1_PKT_USER_SC_INTEGRITY;
         else
                 base_sc_integrity |= HFI1_PKT_KERNEL_SC_INTEGRITY;
 
diff --git a/drivers/infiniband/hw/hfi1/verbs.c b/drivers/infiniband/hw/hfi1/verbs.c
index c8cf4d4984d3..9554e912af98 100644
--- a/drivers/infiniband/hw/hfi1/verbs.c
+++ b/drivers/infiniband/hw/hfi1/verbs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright(c) 2015 - 2017 Intel Corporation.
+ * Copyright(c) 2015 - 2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -63,6 +63,7 @@
 #include "verbs_txreq.h"
 #include "debugfs.h"
 #include "vnic.h"
+#include "fault.h"
 
 static unsigned int hfi1_lkey_table_size = 16;
 module_param_named(lkey_table_size, hfi1_lkey_table_size, uint,
@@ -624,10 +625,6 @@ static inline void hfi1_handle_packet(struct hfi1_packet *packet,
                 if (hfi1_do_pkey_check(packet))
                         goto unlock_drop;
 
-                if (unlikely(hfi1_dbg_fault_opcode(packet->qp, packet->opcode,
-                                                   true)))
-                        goto unlock_drop;
-
                 spin_lock_irqsave(&packet->qp->r_lock, flags);
                 packet_handler = qp_ok(packet);
                 if (likely(packet_handler))
@@ -934,8 +931,7 @@ int hfi1_verbs_send_dma(struct rvt_qp *qp, struct hfi1_pkt_state *ps,
                         else
                                 pbc |= (ib_is_sc5(sc5) << PBC_DC_INFO_SHIFT);
 
-                        if (unlikely(hfi1_dbg_fault_opcode(qp, ps->opcode,
-                                                           false)))
+                        if (unlikely(hfi1_dbg_should_fault_tx(qp, ps->opcode)))
                                 pbc = hfi1_fault_tx(qp, ps->opcode, pbc);
                         pbc = create_pbc(ppd,
                                          pbc,
@@ -1088,7 +1084,8 @@ int hfi1_verbs_send_pio(struct rvt_qp *qp, struct hfi1_pkt_state *ps,
                         pbc |= PBC_PACKET_BYPASS | PBC_INSERT_BYPASS_ICRC;
                 else
                         pbc |= (ib_is_sc5(sc5) << PBC_DC_INFO_SHIFT);
-                if (unlikely(hfi1_dbg_fault_opcode(qp, ps->opcode, false)))
+
+                if (unlikely(hfi1_dbg_should_fault_tx(qp, ps->opcode)))
                         pbc = hfi1_fault_tx(qp, ps->opcode, pbc);
                 pbc = create_pbc(ppd, pbc, qp->srate_mbps, vl, plen);
         }
diff --git a/drivers/infiniband/hw/hfi1/verbs.h b/drivers/infiniband/hw/hfi1/verbs.h
index 2d787b8346ca..081ca52e6621 100644
--- a/drivers/infiniband/hw/hfi1/verbs.h
+++ b/drivers/infiniband/hw/hfi1/verbs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright(c) 2015 - 2017 Intel Corporation.
+ * Copyright(c) 2015 - 2018 Intel Corporation.
  *
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
@@ -227,9 +227,7 @@ struct hfi1_ibdev {
         /* per HFI symlinks to above */
         struct dentry *hfi1_ibdev_link;
 #ifdef CONFIG_FAULT_INJECTION
-        struct fault_opcode *fault_opcode;
-        struct fault_packet *fault_packet;
-        bool fault_suppress_err;
+        struct fault *fault;
 #endif
 #endif
 };