xref: /openbmc/linux/drivers/infiniband/hw/hfi1/fault.c (revision 22d55f02)
1 /*
2  * Copyright(c) 2018 Intel Corporation.
3  *
4  * This file is provided under a dual BSD/GPLv2 license.  When using or
5  * redistributing this file, you may do so under either license.
6  *
7  * GPL LICENSE SUMMARY
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of version 2 of the GNU General Public License as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * BSD LICENSE
19  *
20  * Redistribution and use in source and binary forms, with or without
21  * modification, are permitted provided that the following conditions
22  * are met:
23  *
24  *  - Redistributions of source code must retain the above copyright
25  *    notice, this list of conditions and the following disclaimer.
26  *  - Redistributions in binary form must reproduce the above copyright
27  *    notice, this list of conditions and the following disclaimer in
28  *    the documentation and/or other materials provided with the
29  *    distribution.
30  *  - Neither the name of Intel Corporation nor the names of its
31  *    contributors may be used to endorse or promote products derived
32  *    from this software without specific prior written permission.
33  *
34  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45  *
46  */
47 #include <linux/debugfs.h>
48 #include <linux/seq_file.h>
49 #include <linux/kernel.h>
50 #include <linux/module.h>
51 #include <linux/types.h>
52 #include <linux/bitmap.h>
53 
54 #include "debugfs.h"
55 #include "fault.h"
56 #include "trace.h"
57 
58 #define HFI1_FAULT_DIR_TX   BIT(0)
59 #define HFI1_FAULT_DIR_RX   BIT(1)
60 #define HFI1_FAULT_DIR_TXRX (HFI1_FAULT_DIR_TX | HFI1_FAULT_DIR_RX)
61 
62 static void *_fault_stats_seq_start(struct seq_file *s, loff_t *pos)
63 {
64 	struct hfi1_opcode_stats_perctx *opstats;
65 
66 	if (*pos >= ARRAY_SIZE(opstats->stats))
67 		return NULL;
68 	return pos;
69 }
70 
71 static void *_fault_stats_seq_next(struct seq_file *s, void *v, loff_t *pos)
72 {
73 	struct hfi1_opcode_stats_perctx *opstats;
74 
75 	++*pos;
76 	if (*pos >= ARRAY_SIZE(opstats->stats))
77 		return NULL;
78 	return pos;
79 }
80 
81 static void _fault_stats_seq_stop(struct seq_file *s, void *v)
82 {
83 }
84 
85 static int _fault_stats_seq_show(struct seq_file *s, void *v)
86 {
87 	loff_t *spos = v;
88 	loff_t i = *spos, j;
89 	u64 n_packets = 0, n_bytes = 0;
90 	struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private;
91 	struct hfi1_devdata *dd = dd_from_dev(ibd);
92 	struct hfi1_ctxtdata *rcd;
93 
94 	for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) {
95 		rcd = hfi1_rcd_get_by_index(dd, j);
96 		if (rcd) {
97 			n_packets += rcd->opstats->stats[i].n_packets;
98 			n_bytes += rcd->opstats->stats[i].n_bytes;
99 		}
100 		hfi1_rcd_put(rcd);
101 	}
102 	for_each_possible_cpu(j) {
103 		struct hfi1_opcode_stats_perctx *sp =
104 			per_cpu_ptr(dd->tx_opstats, j);
105 
106 		n_packets += sp->stats[i].n_packets;
107 		n_bytes += sp->stats[i].n_bytes;
108 	}
109 	if (!n_packets && !n_bytes)
110 		return SEQ_SKIP;
111 	if (!ibd->fault->n_rxfaults[i] && !ibd->fault->n_txfaults[i])
112 		return SEQ_SKIP;
113 	seq_printf(s, "%02llx %llu/%llu (faults rx:%llu faults: tx:%llu)\n", i,
114 		   (unsigned long long)n_packets,
115 		   (unsigned long long)n_bytes,
116 		   (unsigned long long)ibd->fault->n_rxfaults[i],
117 		   (unsigned long long)ibd->fault->n_txfaults[i]);
118 	return 0;
119 }
120 
121 DEBUGFS_SEQ_FILE_OPS(fault_stats);
122 DEBUGFS_SEQ_FILE_OPEN(fault_stats);
123 DEBUGFS_FILE_OPS(fault_stats);
124 
125 static int fault_opcodes_open(struct inode *inode, struct file *file)
126 {
127 	file->private_data = inode->i_private;
128 	return nonseekable_open(inode, file);
129 }
130 
131 static ssize_t fault_opcodes_write(struct file *file, const char __user *buf,
132 				   size_t len, loff_t *pos)
133 {
134 	ssize_t ret = 0;
135 	/* 1280 = 256 opcodes * 4 chars/opcode + 255 commas + NULL */
136 	size_t copy, datalen = 1280;
137 	char *data, *token, *ptr, *end;
138 	struct fault *fault = file->private_data;
139 
140 	data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
141 	if (!data)
142 		return -ENOMEM;
143 	copy = min(len, datalen - 1);
144 	if (copy_from_user(data, buf, copy))
145 		return -EFAULT;
146 
147 	ret = debugfs_file_get(file->f_path.dentry);
148 	if (unlikely(ret))
149 		return ret;
150 	ptr = data;
151 	token = ptr;
152 	for (ptr = data; *ptr; ptr = end + 1, token = ptr) {
153 		char *dash;
154 		unsigned long range_start, range_end, i;
155 		bool remove = false;
156 		unsigned long bound = 1U << BITS_PER_BYTE;
157 
158 		end = strchr(ptr, ',');
159 		if (end)
160 			*end = '\0';
161 		if (token[0] == '-') {
162 			remove = true;
163 			token++;
164 		}
165 		dash = strchr(token, '-');
166 		if (dash)
167 			*dash = '\0';
168 		if (kstrtoul(token, 0, &range_start))
169 			break;
170 		if (dash) {
171 			token = dash + 1;
172 			if (kstrtoul(token, 0, &range_end))
173 				break;
174 		} else {
175 			range_end = range_start;
176 		}
177 		if (range_start == range_end && range_start == -1UL) {
178 			bitmap_zero(fault->opcodes, sizeof(fault->opcodes) *
179 				    BITS_PER_BYTE);
180 			break;
181 		}
182 		/* Check the inputs */
183 		if (range_start >= bound || range_end >= bound)
184 			break;
185 
186 		for (i = range_start; i <= range_end; i++) {
187 			if (remove)
188 				clear_bit(i, fault->opcodes);
189 			else
190 				set_bit(i, fault->opcodes);
191 		}
192 		if (!end)
193 			break;
194 	}
195 	ret = len;
196 
197 	debugfs_file_put(file->f_path.dentry);
198 	kfree(data);
199 	return ret;
200 }
201 
202 static ssize_t fault_opcodes_read(struct file *file, char __user *buf,
203 				  size_t len, loff_t *pos)
204 {
205 	ssize_t ret = 0;
206 	char *data;
207 	size_t datalen = 1280, size = 0; /* see fault_opcodes_write() */
208 	unsigned long bit = 0, zero = 0;
209 	struct fault *fault = file->private_data;
210 	size_t bitsize = sizeof(fault->opcodes) * BITS_PER_BYTE;
211 
212 	data = kcalloc(datalen, sizeof(*data), GFP_KERNEL);
213 	if (!data)
214 		return -ENOMEM;
215 	ret = debugfs_file_get(file->f_path.dentry);
216 	if (unlikely(ret))
217 		return ret;
218 	bit = find_first_bit(fault->opcodes, bitsize);
219 	while (bit < bitsize) {
220 		zero = find_next_zero_bit(fault->opcodes, bitsize, bit);
221 		if (zero - 1 != bit)
222 			size += snprintf(data + size,
223 					 datalen - size - 1,
224 					 "0x%lx-0x%lx,", bit, zero - 1);
225 		else
226 			size += snprintf(data + size,
227 					 datalen - size - 1, "0x%lx,",
228 					 bit);
229 		bit = find_next_bit(fault->opcodes, bitsize, zero);
230 	}
231 	debugfs_file_put(file->f_path.dentry);
232 	data[size - 1] = '\n';
233 	data[size] = '\0';
234 	ret = simple_read_from_buffer(buf, len, pos, data, size);
235 	kfree(data);
236 	return ret;
237 }
238 
239 static const struct file_operations __fault_opcodes_fops = {
240 	.owner = THIS_MODULE,
241 	.open = fault_opcodes_open,
242 	.read = fault_opcodes_read,
243 	.write = fault_opcodes_write,
244 	.llseek = no_llseek
245 };
246 
247 void hfi1_fault_exit_debugfs(struct hfi1_ibdev *ibd)
248 {
249 	if (ibd->fault)
250 		debugfs_remove_recursive(ibd->fault->dir);
251 	kfree(ibd->fault);
252 	ibd->fault = NULL;
253 }
254 
255 int hfi1_fault_init_debugfs(struct hfi1_ibdev *ibd)
256 {
257 	struct dentry *parent = ibd->hfi1_ibdev_dbg;
258 	struct dentry *fault_dir;
259 
260 	ibd->fault = kzalloc(sizeof(*ibd->fault), GFP_KERNEL);
261 	if (!ibd->fault)
262 		return -ENOMEM;
263 
264 	ibd->fault->attr.interval = 1;
265 	ibd->fault->attr.require_end = ULONG_MAX;
266 	ibd->fault->attr.stacktrace_depth = 32;
267 	ibd->fault->attr.dname = NULL;
268 	ibd->fault->attr.verbose = 0;
269 	ibd->fault->enable = false;
270 	ibd->fault->opcode = false;
271 	ibd->fault->fault_skip = 0;
272 	ibd->fault->skip = 0;
273 	ibd->fault->direction = HFI1_FAULT_DIR_TXRX;
274 	ibd->fault->suppress_err = false;
275 	bitmap_zero(ibd->fault->opcodes,
276 		    sizeof(ibd->fault->opcodes) * BITS_PER_BYTE);
277 
278 	fault_dir =
279 		fault_create_debugfs_attr("fault", parent, &ibd->fault->attr);
280 	if (IS_ERR(fault_dir)) {
281 		kfree(ibd->fault);
282 		ibd->fault = NULL;
283 		return -ENOENT;
284 	}
285 	ibd->fault->dir = fault_dir;
286 
287 	debugfs_create_file("fault_stats", 0444, fault_dir, ibd,
288 			    &_fault_stats_file_ops);
289 	debugfs_create_bool("enable", 0600, fault_dir, &ibd->fault->enable);
290 	debugfs_create_bool("suppress_err", 0600, fault_dir,
291 			    &ibd->fault->suppress_err);
292 	debugfs_create_bool("opcode_mode", 0600, fault_dir,
293 			    &ibd->fault->opcode);
294 	debugfs_create_file("opcodes", 0600, fault_dir, ibd->fault,
295 			    &__fault_opcodes_fops);
296 	debugfs_create_u64("skip_pkts", 0600, fault_dir,
297 			   &ibd->fault->fault_skip);
298 	debugfs_create_u64("skip_usec", 0600, fault_dir,
299 			   &ibd->fault->fault_skip_usec);
300 	debugfs_create_u8("direction", 0600, fault_dir, &ibd->fault->direction);
301 
302 	return 0;
303 }
304 
305 bool hfi1_dbg_fault_suppress_err(struct hfi1_ibdev *ibd)
306 {
307 	if (ibd->fault)
308 		return ibd->fault->suppress_err;
309 	return false;
310 }
311 
312 static bool __hfi1_should_fault(struct hfi1_ibdev *ibd, u32 opcode,
313 				u8 direction)
314 {
315 	bool ret = false;
316 
317 	if (!ibd->fault || !ibd->fault->enable)
318 		return false;
319 	if (!(ibd->fault->direction & direction))
320 		return false;
321 	if (ibd->fault->opcode) {
322 		if (bitmap_empty(ibd->fault->opcodes,
323 				 (sizeof(ibd->fault->opcodes) *
324 				  BITS_PER_BYTE)))
325 			return false;
326 		if (!(test_bit(opcode, ibd->fault->opcodes)))
327 			return false;
328 	}
329 	if (ibd->fault->fault_skip_usec &&
330 	    time_before(jiffies, ibd->fault->skip_usec))
331 		return false;
332 	if (ibd->fault->fault_skip && ibd->fault->skip) {
333 		ibd->fault->skip--;
334 		return false;
335 	}
336 	ret = should_fail(&ibd->fault->attr, 1);
337 	if (ret) {
338 		ibd->fault->skip = ibd->fault->fault_skip;
339 		ibd->fault->skip_usec = jiffies +
340 			usecs_to_jiffies(ibd->fault->fault_skip_usec);
341 	}
342 	return ret;
343 }
344 
345 bool hfi1_dbg_should_fault_tx(struct rvt_qp *qp, u32 opcode)
346 {
347 	struct hfi1_ibdev *ibd = to_idev(qp->ibqp.device);
348 
349 	if (__hfi1_should_fault(ibd, opcode, HFI1_FAULT_DIR_TX)) {
350 		trace_hfi1_fault_opcode(qp, opcode);
351 		ibd->fault->n_txfaults[opcode]++;
352 		return true;
353 	}
354 	return false;
355 }
356 
357 bool hfi1_dbg_should_fault_rx(struct hfi1_packet *packet)
358 {
359 	struct hfi1_ibdev *ibd = &packet->rcd->dd->verbs_dev;
360 
361 	if (__hfi1_should_fault(ibd, packet->opcode, HFI1_FAULT_DIR_RX)) {
362 		trace_hfi1_fault_packet(packet);
363 		ibd->fault->n_rxfaults[packet->opcode]++;
364 		return true;
365 	}
366 	return false;
367 }
368