drivers/infiniband/hw/hfi1/fault.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause
 /*
  * Copyright(c) 2018 Intel Corporation.
  */

 #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)) {
 		ret = -EFAULT;
 		goto free_data;
 	}

 	ret = debugfs_file_get(file->f_path.dentry);
 	if (unlikely(ret))
 		goto free_data;
 	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;
 		unsigned long bound = 1U << BITS_PER_BYTE;

 		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;
 		}
 		/* Check the inputs */
 		if (range_start >= bound || range_end >= bound)
 			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);
 free_data:
 	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))
 		goto free_data;
 	bit = find_first_bit(fault->opcodes, bitsize);
 	while (bit < bitsize) {
 		zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
 		if (zero - 1 != bit)
 			size += scnprintf(data + size,
 					 datalen - size - 1,
 					 "0x%lx-0x%lx,", bit, zero - 1);
 		else
 			size += scnprintf(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);
 free_data:
 	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;
 	struct dentry *fault_dir;

 	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);

 	fault_dir =
 		fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
 	if (IS_ERR(fault_dir)) {
 		kfree(ibd->fault);
 		ibd->fault = NULL;
 		return -ENOENT;
 	}
 	ibd->fault->dir = fault_dir;

 	debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
 			    &_fault_stats_file_ops);
 	debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
 	debugfs_create_bool("suppress_err", 0600, fault_dir,
 			    &ibd->fault->suppress_err);
 	debugfs_create_bool("opcode_mode", 0600, fault_dir,
 			    &ibd->fault->opcode);
 	debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
 			    &__fault_opcodes_fops);
 	debugfs_create_u64("skip_pkts", 0600, fault_dir,
 			   &ibd->fault->fault_skip);
 	debugfs_create_u64("skip_usec", 0600, fault_dir,
 			   &ibd->fault->fault_skip_usec);
 	debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);

 	return 0;
 }

 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;
 }
	// SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause
	/*
	* Copyright(c) 2018 Intel Corporation.
	*/

	#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)) {
	ret = -EFAULT;
	goto free_data;
	}

	ret = debugfs_file_get(file->f_path.dentry);
	if (unlikely(ret))
	goto free_data;
	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;
	unsigned long bound = 1U << BITS_PER_BYTE;

	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;
	}
	/* Check the inputs */
	if (range_start >= bound \|\| range_end >= bound)
	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);
	free_data:
	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))
	goto free_data;
	bit = find_first_bit(fault->opcodes, bitsize);
	while (bit < bitsize) {
	zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
	if (zero - 1 != bit)
	size += scnprintf(data + size,
	datalen - size - 1,
	"0x%lx-0x%lx,", bit, zero - 1);
	else
	size += scnprintf(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);
	free_data:
	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;
	struct dentry *fault_dir;

	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);

	fault_dir =
	fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
	if (IS_ERR(fault_dir)) {
	kfree(ibd->fault);
	ibd->fault = NULL;
	return -ENOENT;
	}
	ibd->fault->dir = fault_dir;

	debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
	&_fault_stats_file_ops);
	debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
	debugfs_create_bool("suppress_err", 0600, fault_dir,
	&ibd->fault->suppress_err);
	debugfs_create_bool("opcode_mode", 0600, fault_dir,
	&ibd->fault->opcode);
	debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
	&__fault_opcodes_fops);
	debugfs_create_u64("skip_pkts", 0600, fault_dir,
	&ibd->fault->fault_skip);
	debugfs_create_u64("skip_usec", 0600, fault_dir,
	&ibd->fault->fault_skip_usec);
	debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);

	return 0;
	}

	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;
	}