xref: /openbmc/linux/drivers/infiniband/hw/hfi1/fault.c (revision 75eeaed4)
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 
_fault_stats_seq_start(struct seq_file * s,loff_t * pos)20 static 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 
_fault_stats_seq_next(struct seq_file * s,void * v,loff_t * pos)29 static 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 
_fault_stats_seq_stop(struct seq_file * s,void * v)39 static void _fault_stats_seq_stop(struct seq_file *s, void *v)
40 {
41 }
42 
_fault_stats_seq_show(struct seq_file * s,void * v)43 static 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 
79 DEBUGFS_SEQ_FILE_OPS(fault_stats);
80 DEBUGFS_SEQ_FILE_OPEN(fault_stats);
81 DEBUGFS_FILE_OPS(fault_stats);
82 
fault_opcodes_open(struct inode * inode,struct file * file)83 static 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 
fault_opcodes_write(struct file * file,const char __user * buf,size_t len,loff_t * pos)89 static 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 	ret = debugfs_file_get(file->f_path.dentry);
108 	if (unlikely(ret))
109 		goto free_data;
110 	ptr = data;
111 	token = ptr;
112 	for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
113 		char *dash;
114 		unsigned long range_start, range_end, i;
115 		bool remove = false;
116 		unsigned long bound = 1U << BITS_PER_BYTE;
117 
118 		end = strchr(ptr, ',');
119 		if (end)
120 			*end = '\0';
121 		if (token[0] == '-') {
122 			remove = true;
123 			token++;
124 		}
125 		dash = strchr(token, '-');
126 		if (dash)
127 			*dash = '\0';
128 		if (kstrtoul(token, 0, &range_start))
129 			break;
130 		if (dash) {
131 			token = dash + 1;
132 			if (kstrtoul(token, 0, &range_end))
133 				break;
134 		} else {
135 			range_end = range_start;
136 		}
137 		if (range_start == range_end && range_start == -1UL) {
138 			bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
139 				    BITS_PER_BYTE);
140 			break;
141 		}
142 		/* Check the inputs */
143 		if (range_start >= bound || range_end >= bound)
144 			break;
145 
146 		for (i = range_start; i <= range_end; i++) {
147 			if (remove)
148 				clear_bit(i, fault->opcodes);
149 			else
150 				set_bit(i, fault->opcodes);
151 		}
152 		if (!end)
153 			break;
154 	}
155 	ret = len;
156 
157 	debugfs_file_put(file->f_path.dentry);
158 free_data:
159 	kfree(data);
160 	return ret;
161 }
162 
fault_opcodes_read(struct file * file,char __user * buf,size_t len,loff_t * pos)163 static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
164 				  size_t len, loff_t *pos)
165 {
166 	ssize_t ret = 0;
167 	char *data;
168 	size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
169 	unsigned long bit = 0, zero = 0;
170 	struct fault *fault = file->private_data;
171 	size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
172 
173 	data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
174 	if (!data)
175 		return -ENOMEM;
176 	ret = debugfs_file_get(file->f_path.dentry);
177 	if (unlikely(ret))
178 		goto free_data;
179 	bit = find_first_bit(fault->opcodes, bitsize);
180 	while (bit < bitsize) {
181 		zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
182 		if (zero - 1 != bit)
183 			size += scnprintf(data + size,
184 					 datalen - size - 1,
185 					 "0x%lx-0x%lx,", bit, zero - 1);
186 		else
187 			size += scnprintf(data + size,
188 					 datalen - size - 1, "0x%lx,",
189 					 bit);
190 		bit = find_next_bit(fault->opcodes, bitsize, zero);
191 	}
192 	debugfs_file_put(file->f_path.dentry);
193 	data[size - 1] = '\n';
194 	data[size] = '\0';
195 	ret = simple_read_from_buffer(buf, len, pos, data, size);
196 free_data:
197 	kfree(data);
198 	return ret;
199 }
200 
201 static const struct file_operations __fault_opcodes_fops = {
202 	.owner = THIS_MODULE,
203 	.open = fault_opcodes_open,
204 	.read = fault_opcodes_read,
205 	.write = fault_opcodes_write,
206 	.llseek = no_llseek
207 };
208 
hfi1_fault_exit_debugfs(struct hfi1_ibdev * ibd)209 void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
210 {
211 	if (ibd->fault)
212 		debugfs_remove_recursive(ibd->fault->dir);
213 	kfree(ibd->fault);
214 	ibd->fault = NULL;
215 }
216 
hfi1_fault_init_debugfs(struct hfi1_ibdev * ibd)217 int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
218 {
219 	struct dentry *parent = ibd->hfi1_ibdev_dbg;
220 	struct dentry *fault_dir;
221 
222 	ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
223 	if (!ibd->fault)
224 		return -ENOMEM;
225 
226 	ibd->fault->attr.interval = 1;
227 	ibd->fault->attr.require_end = ULONG_MAX;
228 	ibd->fault->attr.stacktrace_depth = 32;
229 	ibd->fault->attr.dname = NULL;
230 	ibd->fault->attr.verbose = 0;
231 	ibd->fault->enable = false;
232 	ibd->fault->opcode = false;
233 	ibd->fault->fault_skip = 0;
234 	ibd->fault->skip = 0;
235 	ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
236 	ibd->fault->suppress_err = false;
237 	bitmap_zero(ibd->fault->opcodes,
238 		    sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
239 
240 	fault_dir =
241 		fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
242 	if (IS_ERR(fault_dir)) {
243 		kfree(ibd->fault);
244 		ibd->fault = NULL;
245 		return -ENOENT;
246 	}
247 	ibd->fault->dir = fault_dir;
248 
249 	debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
250 			    &_fault_stats_file_ops);
251 	debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
252 	debugfs_create_bool("suppress_err", 0600, fault_dir,
253 			    &ibd->fault->suppress_err);
254 	debugfs_create_bool("opcode_mode", 0600, fault_dir,
255 			    &ibd->fault->opcode);
256 	debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
257 			    &__fault_opcodes_fops);
258 	debugfs_create_u64("skip_pkts", 0600, fault_dir,
259 			   &ibd->fault->fault_skip);
260 	debugfs_create_u64("skip_usec", 0600, fault_dir,
261 			   &ibd->fault->fault_skip_usec);
262 	debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);
263 
264 	return 0;
265 }
266 
hfi1_dbg_fault_suppress_err(struct hfi1_ibdev * ibd)267 bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
268 {
269 	if (ibd->fault)
270 		return ibd->fault->suppress_err;
271 	return false;
272 }
273 
__hfi1_should_fault(struct hfi1_ibdev * ibd,u32 opcode,u8 direction)274 static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
275 				u8 direction)
276 {
277 	bool ret = false;
278 
279 	if (!ibd->fault || !ibd->fault->enable)
280 		return false;
281 	if (!(ibd->fault->direction & direction))
282 		return false;
283 	if (ibd->fault->opcode) {
284 		if (bitmap_empty(ibd->fault->opcodes,
285 				 (sizeof(ibd->fault->opcodes) *
286 				  BITS_PER_BYTE)))
287 			return false;
288 		if (!(test_bit(opcode, ibd->fault->opcodes)))
289 			return false;
290 	}
291 	if (ibd->fault->fault_skip_usec &&
292 	    time_before(jiffies, ibd->fault->skip_usec))
293 		return false;
294 	if (ibd->fault->fault_skip && ibd->fault->skip) {
295 		ibd->fault->skip--;
296 		return false;
297 	}
298 	ret = should_fail(&ibd->fault->attr, 1);
299 	if (ret) {
300 		ibd->fault->skip = ibd->fault->fault_skip;
301 		ibd->fault->skip_usec = jiffies +
302 			usecs_to_jiffies(ibd->fault->fault_skip_usec);
303 	}
304 	return ret;
305 }
306 
hfi1_dbg_should_fault_tx(struct rvt_qp * qp,u32 opcode)307 bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
308 {
309 	struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
310 
311 	if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
312 		trace_hfi1_fault_opcode(qp, opcode);
313 		ibd->fault->n_txfaults[opcode]++;
314 		return true;
315 	}
316 	return false;
317 }
318 
hfi1_dbg_should_fault_rx(struct hfi1_packet * packet)319 bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
320 {
321 	struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
322 
323 	if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
324 		trace_hfi1_fault_packet(packet);
325 		ibd->fault->n_rxfaults[packet->opcode]++;
326 		return true;
327 	}
328 	return false;
329 }
330