1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2021 Intel Corporation. All rights rsvd. */
3
4 #include <linux/module.h>
5 #include <linux/kernel.h>
6 #include <linux/highmem.h>
7 #include <linux/mm.h>
8 #include <linux/slab.h>
9 #include <linux/delay.h>
10 #include <linux/smp.h>
11 #include <uapi/linux/idxd.h>
12 #include <linux/idxd.h>
13 #include <linux/dmaengine.h>
14 #include "../../dma/idxd/idxd.h"
15 #include <linux/debugfs.h>
16 #include <crypto/internal/acompress.h>
17 #include "iaa_crypto.h"
18 #include "iaa_crypto_stats.h"
19
20 static u64 total_comp_calls;
21 static u64 total_decomp_calls;
22 static u64 total_sw_decomp_calls;
23 static u64 max_comp_delay_ns;
24 static u64 max_decomp_delay_ns;
25 static u64 max_acomp_delay_ns;
26 static u64 max_adecomp_delay_ns;
27 static u64 total_comp_bytes_out;
28 static u64 total_decomp_bytes_in;
29 static u64 total_completion_einval_errors;
30 static u64 total_completion_timeout_errors;
31 static u64 total_completion_comp_buf_overflow_errors;
32
33 static struct dentry *iaa_crypto_debugfs_root;
34
update_total_comp_calls(void)35 void update_total_comp_calls(void)
36 {
37 total_comp_calls++;
38 }
39
update_total_comp_bytes_out(int n)40 void update_total_comp_bytes_out(int n)
41 {
42 total_comp_bytes_out += n;
43 }
44
update_total_decomp_calls(void)45 void update_total_decomp_calls(void)
46 {
47 total_decomp_calls++;
48 }
49
update_total_sw_decomp_calls(void)50 void update_total_sw_decomp_calls(void)
51 {
52 total_sw_decomp_calls++;
53 }
54
update_total_decomp_bytes_in(int n)55 void update_total_decomp_bytes_in(int n)
56 {
57 total_decomp_bytes_in += n;
58 }
59
update_completion_einval_errs(void)60 void update_completion_einval_errs(void)
61 {
62 total_completion_einval_errors++;
63 }
64
update_completion_timeout_errs(void)65 void update_completion_timeout_errs(void)
66 {
67 total_completion_timeout_errors++;
68 }
69
update_completion_comp_buf_overflow_errs(void)70 void update_completion_comp_buf_overflow_errs(void)
71 {
72 total_completion_comp_buf_overflow_errors++;
73 }
74
update_max_comp_delay_ns(u64 start_time_ns)75 void update_max_comp_delay_ns(u64 start_time_ns)
76 {
77 u64 time_diff;
78
79 time_diff = ktime_get_ns() - start_time_ns;
80
81 if (time_diff > max_comp_delay_ns)
82 max_comp_delay_ns = time_diff;
83 }
84
update_max_decomp_delay_ns(u64 start_time_ns)85 void update_max_decomp_delay_ns(u64 start_time_ns)
86 {
87 u64 time_diff;
88
89 time_diff = ktime_get_ns() - start_time_ns;
90
91 if (time_diff > max_decomp_delay_ns)
92 max_decomp_delay_ns = time_diff;
93 }
94
update_max_acomp_delay_ns(u64 start_time_ns)95 void update_max_acomp_delay_ns(u64 start_time_ns)
96 {
97 u64 time_diff;
98
99 time_diff = ktime_get_ns() - start_time_ns;
100
101 if (time_diff > max_acomp_delay_ns)
102 max_acomp_delay_ns = time_diff;
103 }
104
update_max_adecomp_delay_ns(u64 start_time_ns)105 void update_max_adecomp_delay_ns(u64 start_time_ns)
106 {
107 u64 time_diff;
108
109 time_diff = ktime_get_ns() - start_time_ns;
110
111 if (time_diff > max_adecomp_delay_ns)
112 max_adecomp_delay_ns = time_diff;
113 }
114
update_wq_comp_calls(struct idxd_wq * idxd_wq)115 void update_wq_comp_calls(struct idxd_wq *idxd_wq)
116 {
117 struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
118
119 wq->comp_calls++;
120 wq->iaa_device->comp_calls++;
121 }
122
update_wq_comp_bytes(struct idxd_wq * idxd_wq,int n)123 void update_wq_comp_bytes(struct idxd_wq *idxd_wq, int n)
124 {
125 struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
126
127 wq->comp_bytes += n;
128 wq->iaa_device->comp_bytes += n;
129 }
130
update_wq_decomp_calls(struct idxd_wq * idxd_wq)131 void update_wq_decomp_calls(struct idxd_wq *idxd_wq)
132 {
133 struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
134
135 wq->decomp_calls++;
136 wq->iaa_device->decomp_calls++;
137 }
138
update_wq_decomp_bytes(struct idxd_wq * idxd_wq,int n)139 void update_wq_decomp_bytes(struct idxd_wq *idxd_wq, int n)
140 {
141 struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
142
143 wq->decomp_bytes += n;
144 wq->iaa_device->decomp_bytes += n;
145 }
146
reset_iaa_crypto_stats(void)147 static void reset_iaa_crypto_stats(void)
148 {
149 total_comp_calls = 0;
150 total_decomp_calls = 0;
151 total_sw_decomp_calls = 0;
152 max_comp_delay_ns = 0;
153 max_decomp_delay_ns = 0;
154 max_acomp_delay_ns = 0;
155 max_adecomp_delay_ns = 0;
156 total_comp_bytes_out = 0;
157 total_decomp_bytes_in = 0;
158 total_completion_einval_errors = 0;
159 total_completion_timeout_errors = 0;
160 total_completion_comp_buf_overflow_errors = 0;
161 }
162
reset_wq_stats(struct iaa_wq * wq)163 static void reset_wq_stats(struct iaa_wq *wq)
164 {
165 wq->comp_calls = 0;
166 wq->comp_bytes = 0;
167 wq->decomp_calls = 0;
168 wq->decomp_bytes = 0;
169 }
170
reset_device_stats(struct iaa_device * iaa_device)171 static void reset_device_stats(struct iaa_device *iaa_device)
172 {
173 struct iaa_wq *iaa_wq;
174
175 iaa_device->comp_calls = 0;
176 iaa_device->comp_bytes = 0;
177 iaa_device->decomp_calls = 0;
178 iaa_device->decomp_bytes = 0;
179
180 list_for_each_entry(iaa_wq, &iaa_device->wqs, list)
181 reset_wq_stats(iaa_wq);
182 }
183
wq_show(struct seq_file * m,struct iaa_wq * iaa_wq)184 static void wq_show(struct seq_file *m, struct iaa_wq *iaa_wq)
185 {
186 seq_printf(m, " name: %s\n", iaa_wq->wq->name);
187 seq_printf(m, " comp_calls: %llu\n", iaa_wq->comp_calls);
188 seq_printf(m, " comp_bytes: %llu\n", iaa_wq->comp_bytes);
189 seq_printf(m, " decomp_calls: %llu\n", iaa_wq->decomp_calls);
190 seq_printf(m, " decomp_bytes: %llu\n\n", iaa_wq->decomp_bytes);
191 }
192
device_stats_show(struct seq_file * m,struct iaa_device * iaa_device)193 static void device_stats_show(struct seq_file *m, struct iaa_device *iaa_device)
194 {
195 struct iaa_wq *iaa_wq;
196
197 seq_puts(m, "iaa device:\n");
198 seq_printf(m, " id: %d\n", iaa_device->idxd->id);
199 seq_printf(m, " n_wqs: %d\n", iaa_device->n_wq);
200 seq_printf(m, " comp_calls: %llu\n", iaa_device->comp_calls);
201 seq_printf(m, " comp_bytes: %llu\n", iaa_device->comp_bytes);
202 seq_printf(m, " decomp_calls: %llu\n", iaa_device->decomp_calls);
203 seq_printf(m, " decomp_bytes: %llu\n", iaa_device->decomp_bytes);
204 seq_puts(m, " wqs:\n");
205
206 list_for_each_entry(iaa_wq, &iaa_device->wqs, list)
207 wq_show(m, iaa_wq);
208 }
209
global_stats_show(struct seq_file * m)210 static void global_stats_show(struct seq_file *m)
211 {
212 seq_puts(m, "global stats:\n");
213 seq_printf(m, " total_comp_calls: %llu\n", total_comp_calls);
214 seq_printf(m, " total_decomp_calls: %llu\n", total_decomp_calls);
215 seq_printf(m, " total_sw_decomp_calls: %llu\n", total_sw_decomp_calls);
216 seq_printf(m, " total_comp_bytes_out: %llu\n", total_comp_bytes_out);
217 seq_printf(m, " total_decomp_bytes_in: %llu\n", total_decomp_bytes_in);
218 seq_printf(m, " total_completion_einval_errors: %llu\n",
219 total_completion_einval_errors);
220 seq_printf(m, " total_completion_timeout_errors: %llu\n",
221 total_completion_timeout_errors);
222 seq_printf(m, " total_completion_comp_buf_overflow_errors: %llu\n\n",
223 total_completion_comp_buf_overflow_errors);
224 }
225
wq_stats_show(struct seq_file * m,void * v)226 static int wq_stats_show(struct seq_file *m, void *v)
227 {
228 struct iaa_device *iaa_device;
229
230 mutex_lock(&iaa_devices_lock);
231
232 global_stats_show(m);
233
234 list_for_each_entry(iaa_device, &iaa_devices, list)
235 device_stats_show(m, iaa_device);
236
237 mutex_unlock(&iaa_devices_lock);
238
239 return 0;
240 }
241
iaa_crypto_stats_reset(void * data,u64 value)242 static int iaa_crypto_stats_reset(void *data, u64 value)
243 {
244 struct iaa_device *iaa_device;
245
246 reset_iaa_crypto_stats();
247
248 mutex_lock(&iaa_devices_lock);
249
250 list_for_each_entry(iaa_device, &iaa_devices, list)
251 reset_device_stats(iaa_device);
252
253 mutex_unlock(&iaa_devices_lock);
254
255 return 0;
256 }
257
wq_stats_open(struct inode * inode,struct file * file)258 static int wq_stats_open(struct inode *inode, struct file *file)
259 {
260 return single_open(file, wq_stats_show, file);
261 }
262
263 static const struct file_operations wq_stats_fops = {
264 .open = wq_stats_open,
265 .read = seq_read,
266 .llseek = seq_lseek,
267 .release = single_release,
268 };
269
270 DEFINE_DEBUGFS_ATTRIBUTE(wq_stats_reset_fops, NULL, iaa_crypto_stats_reset, "%llu\n");
271
iaa_crypto_debugfs_init(void)272 int __init iaa_crypto_debugfs_init(void)
273 {
274 if (!debugfs_initialized())
275 return -ENODEV;
276
277 iaa_crypto_debugfs_root = debugfs_create_dir("iaa_crypto", NULL);
278 if (!iaa_crypto_debugfs_root)
279 return -ENOMEM;
280
281 debugfs_create_u64("max_comp_delay_ns", 0644,
282 iaa_crypto_debugfs_root, &max_comp_delay_ns);
283 debugfs_create_u64("max_decomp_delay_ns", 0644,
284 iaa_crypto_debugfs_root, &max_decomp_delay_ns);
285 debugfs_create_u64("max_acomp_delay_ns", 0644,
286 iaa_crypto_debugfs_root, &max_comp_delay_ns);
287 debugfs_create_u64("max_adecomp_delay_ns", 0644,
288 iaa_crypto_debugfs_root, &max_decomp_delay_ns);
289 debugfs_create_u64("total_comp_calls", 0644,
290 iaa_crypto_debugfs_root, &total_comp_calls);
291 debugfs_create_u64("total_decomp_calls", 0644,
292 iaa_crypto_debugfs_root, &total_decomp_calls);
293 debugfs_create_u64("total_sw_decomp_calls", 0644,
294 iaa_crypto_debugfs_root, &total_sw_decomp_calls);
295 debugfs_create_u64("total_comp_bytes_out", 0644,
296 iaa_crypto_debugfs_root, &total_comp_bytes_out);
297 debugfs_create_u64("total_decomp_bytes_in", 0644,
298 iaa_crypto_debugfs_root, &total_decomp_bytes_in);
299 debugfs_create_file("wq_stats", 0644, iaa_crypto_debugfs_root, NULL,
300 &wq_stats_fops);
301 debugfs_create_file("stats_reset", 0644, iaa_crypto_debugfs_root, NULL,
302 &wq_stats_reset_fops);
303
304 return 0;
305 }
306
iaa_crypto_debugfs_cleanup(void)307 void __exit iaa_crypto_debugfs_cleanup(void)
308 {
309 debugfs_remove_recursive(iaa_crypto_debugfs_root);
310 }
311
312 MODULE_LICENSE("GPL");
313