fault.c

  1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
  2/*
  3 * Copyright(c) 2018 Intel Corporation.
  4 */
  5
  6#include <linux/debugfs.h>
  7#include <linux/seq_file.h>
  8#include <linux/kernel.h>
  9#include <linux/types.h>
 10#include <linux/bitmap.h>
 11
 12#include "debugfs.h"
 13#include "fault.h"
 14#include "trace.h"
 15
 16#define HFI1_FAULT_DIR_TX   BIT(0)
 17#define HFI1_FAULT_DIR_RX   BIT(1)
 18#define HFI1_FAULT_DIR_TXRX (HFI1_FAULT_DIR_TX | HFI1_FAULT_DIR_RX)
 19
 20static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
 21{
 22	struct hfi1_opcode_stats_perctx *opstats;
 23
 24	if (*pos >= ARRAY_SIZE(opstats->stats))
 25		return NULL;
 26	return pos;
 27}
 28
 29static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
 30{
 31	struct hfi1_opcode_stats_perctx *opstats;
 32
 33	++*pos;
 34	if (*pos >= ARRAY_SIZE(opstats->stats))
 35		return NULL;
 36	return pos;
 37}
 38
 39static void _fault_stats_seq_stop(struct seq_file *s, void *v)
 40{
 41}
 42
 43static int _fault_stats_seq_show(struct seq_file *s, void *v)
 44{
 45	loff_t *spos = v;
 46	loff_t i = *spos, j;
 47	u64 n_packets = 0, n_bytes = 0;
 48	struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
 49	struct hfi1_devdata *dd = dd_from_dev(ibd);
 50	struct hfi1_ctxtdata *rcd;
 51
 52	for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
 53		rcd = hfi1_rcd_get_by_index(dd, j);
 54		if (rcd) {
 55			n_packets += rcd->opstats->stats[i].n_packets;
 56			n_bytes += rcd->opstats->stats[i].n_bytes;
 57		}
 58		hfi1_rcd_put(rcd);
 59	}
 60	for_each_possible_cpu(j) {
 61		struct hfi1_opcode_stats_perctx *sp =
 62			per_cpu_ptr(dd->tx_opstats, j);
 63
 64		n_packets += sp->stats[i].n_packets;
 65		n_bytes += sp->stats[i].n_bytes;
 66	}
 67	if (!n_packets && !n_bytes)
 68		return SEQ_SKIP;
 69	if (!ibd->fault->n_rxfaults[i] && !ibd->fault->n_txfaults[i])
 70		return SEQ_SKIP;
 71	seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
 72		   (unsigned long long)n_packets,
 73		   (unsigned long long)n_bytes,
 74		   (unsigned long long)ibd->fault->n_rxfaults[i],
 75		   (unsigned long long)ibd->fault->n_txfaults[i]);
 76	return 0;
 77}
 78
 79DEBUGFS_SEQ_FILE_OPS(fault_stats);
 80DEBUGFS_SEQ_FILE_OPEN(fault_stats);
 81DEBUGFS_FILE_OPS(fault_stats);
 82
 83static int fault_opcodes_open(struct inode *inode, struct file *file)
 84{
 85	file->private_data = inode->i_private;
 86	return nonseekable_open(inode, file);
 87}
 88
 89static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
 90				   size_t len, loff_t *pos)
 91{
 92	ssize_t ret = 0;
 93	/* 1280 = 256 opcodes * 4 chars/opcode + 255 commas + NULL */
 94	size_t copy, datalen = 1280;
 95	char *data, *token, *ptr, *end;
 96	struct fault *fault = file->private_data;
 97
 98	data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
 99	if (!data)
100		return -ENOMEM;
101	copy = min(len, datalen - 1);
102	if (copy_from_user(data, buf, copy)) {
103		ret = -EFAULT;
104		goto free_data;
105	}
106
107	ptr = data;
108	token = ptr;
109	for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
110		char *dash;
111		unsigned long range_start, range_end, i;
112		bool remove = false;
113		unsigned long bound = 1U << BITS_PER_BYTE;
114
115		end = strchr(ptr, ',');
116		if (end)
117			*end = '\0';
118		if (token[0] == '-') {
119			remove = true;
120			token++;
121		}
122		dash = strchr(token, '-');
123		if (dash)
124			*dash = '\0';
125		if (kstrtoul(token, 0, &range_start))
126			break;
127		if (dash) {
128			token = dash + 1;
129			if (kstrtoul(token, 0, &range_end))
130				break;
131		} else {
132			range_end = range_start;
133		}
134		if (range_start == range_end && range_start == -1UL) {
135			bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
136				    BITS_PER_BYTE);
137			break;
138		}
139		/* Check the inputs */
140		if (range_start >= bound || range_end >= bound)
141			break;
142
143		for (i = range_start; i <= range_end; i++) {
144			if (remove)
145				clear_bit(i, fault->opcodes);
146			else
147				set_bit(i, fault->opcodes);
148		}
149		if (!end)
150			break;
151	}
152	ret = len;
153
154free_data:
155	kfree(data);
156	return ret;
157}
158
159static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
160				  size_t len, loff_t *pos)
161{
162	ssize_t ret = 0;
163	char *data;
164	size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
165	unsigned long bit = 0, zero = 0;
166	struct fault *fault = file->private_data;
167	size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
168
169	data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
170	if (!data)
171		return -ENOMEM;
172	bit = find_first_bit(fault->opcodes, bitsize);
173	while (bit < bitsize) {
174		zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
175		if (zero - 1 != bit)
176			size += scnprintf(data + size,
177					 datalen - size - 1,
178					 "0x%lx-0x%lx,", bit, zero - 1);
179		else
180			size += scnprintf(data + size,
181					 datalen - size - 1, "0x%lx,",
182					 bit);
183		bit = find_next_bit(fault->opcodes, bitsize, zero);
184	}
185	data[size - 1] = '\n';
186	data[size] = '\0';
187	ret = simple_read_from_buffer(buf, len, pos, data, size);
188	kfree(data);
189	return ret;
190}
191
192static const struct file_operations __fault_opcodes_fops = {
193	.owner = THIS_MODULE,
194	.open = fault_opcodes_open,
195	.read = fault_opcodes_read,
196	.write = fault_opcodes_write,
197};
198
199void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
200{
201	if (ibd->fault)
202		debugfs_remove_recursive(ibd->fault->dir);
203	kfree(ibd->fault);
204	ibd->fault = NULL;
205}
206
207int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
208{
209	struct dentry *parent = ibd->hfi1_ibdev_dbg;
210	struct dentry *fault_dir;
211
212	ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
213	if (!ibd->fault)
214		return -ENOMEM;
215
216	ibd->fault->attr.interval = 1;
217	ibd->fault->attr.require_end = ULONG_MAX;
218	ibd->fault->attr.stacktrace_depth = 32;
219	ibd->fault->attr.dname = NULL;
220	ibd->fault->attr.verbose = 0;
221	ibd->fault->enable = false;
222	ibd->fault->opcode = false;
223	ibd->fault->fault_skip = 0;
224	ibd->fault->skip = 0;
225	ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
226	ibd->fault->suppress_err = false;
227	bitmap_zero(ibd->fault->opcodes,
228		    sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
229
230	fault_dir =
231		fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
232	if (IS_ERR(fault_dir)) {
233		kfree(ibd->fault);
234		ibd->fault = NULL;
235		return -ENOENT;
236	}
237	ibd->fault->dir = fault_dir;
238
239	debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
240			    &_fault_stats_file_ops);
241	debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
242	debugfs_create_bool("suppress_err", 0600, fault_dir,
243			    &ibd->fault->suppress_err);
244	debugfs_create_bool("opcode_mode", 0600, fault_dir,
245			    &ibd->fault->opcode);
246	debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
247			    &__fault_opcodes_fops);
248	debugfs_create_u64("skip_pkts", 0600, fault_dir,
249			   &ibd->fault->fault_skip);
250	debugfs_create_u64("skip_usec", 0600, fault_dir,
251			   &ibd->fault->fault_skip_usec);
252	debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);
253
254	return 0;
255}
256
257bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
258{
259	if (ibd->fault)
260		return ibd->fault->suppress_err;
261	return false;
262}
263
264static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
265				u8 direction)
266{
267	bool ret = false;
268
269	if (!ibd->fault || !ibd->fault->enable)
270		return false;
271	if (!(ibd->fault->direction & direction))
272		return false;
273	if (ibd->fault->opcode) {
274		if (bitmap_empty(ibd->fault->opcodes,
275				 (sizeof(ibd->fault->opcodes) *
276				  BITS_PER_BYTE)))
277			return false;
278		if (!(test_bit(opcode, ibd->fault->opcodes)))
279			return false;
280	}
281	if (ibd->fault->fault_skip_usec &&
282	    time_before(jiffies, ibd->fault->skip_usec))
283		return false;
284	if (ibd->fault->fault_skip && ibd->fault->skip) {
285		ibd->fault->skip--;
286		return false;
287	}
288	ret = should_fail(&ibd->fault->attr, 1);
289	if (ret) {
290		ibd->fault->skip = ibd->fault->fault_skip;
291		ibd->fault->skip_usec = jiffies +
292			usecs_to_jiffies(ibd->fault->fault_skip_usec);
293	}
294	return ret;
295}
296
297bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
298{
299	struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
300
301	if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
302		trace_hfi1_fault_opcode(qp, opcode);
303		ibd->fault->n_txfaults[opcode]++;
304		return true;
305	}
306	return false;
307}
308
309bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
310{
311	struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
312
313	if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
314		trace_hfi1_fault_packet(packet);
315		ibd->fault->n_rxfaults[packet->opcode]++;
316		return true;
317	}
318	return false;
319}