tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: iaa - Change iaa statistics to atomic64_t
Change all the iaa statistics to use atomic64_t instead of the current
u64, to avoid potentially inconsistent counts.
Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
authored by
Tom Zanussi
and committed by
Herbert Xu
43698cd6
c21fb22d
+77
-64
+8
-8
drivers/crypto/intel/iaa/iaa_crypto.h
+8
-8
drivers/crypto/intel/iaa/iaa_crypto.h
···
49
49
50
50
struct iaa_device *iaa_device;
51
51
52
-
u64 comp_calls;
53
-
u64 comp_bytes;
54
-
u64 decomp_calls;
55
-
u64 decomp_bytes;
52
+
atomic64_t comp_calls;
53
+
atomic64_t comp_bytes;
54
+
atomic64_t decomp_calls;
55
+
atomic64_t decomp_bytes;
56
56
};
57
57
58
58
struct iaa_device_compression_mode {
···
73
73
int n_wq;
74
74
struct list_head wqs;
75
75
76
-
u64 comp_calls;
77
-
u64 comp_bytes;
78
-
u64 decomp_calls;
79
-
u64 decomp_bytes;
76
+
atomic64_t comp_calls;
77
+
atomic64_t comp_bytes;
78
+
atomic64_t decomp_calls;
79
+
atomic64_t decomp_bytes;
80
80
};
81
81
82
82
struct wq_table_entry {
+69
-56
drivers/crypto/intel/iaa/iaa_crypto_stats.c
+69
-56
drivers/crypto/intel/iaa/iaa_crypto_stats.c
···
17
17
#include "iaa_crypto.h"
18
18
#include "iaa_crypto_stats.h"
19
19
20
-
static u64 total_comp_calls;
21
-
static u64 total_decomp_calls;
22
-
static u64 total_sw_decomp_calls;
23
-
static u64 total_comp_bytes_out;
24
-
static u64 total_decomp_bytes_in;
25
-
static u64 total_completion_einval_errors;
26
-
static u64 total_completion_timeout_errors;
27
-
static u64 total_completion_comp_buf_overflow_errors;
20
+
static atomic64_t total_comp_calls;
21
+
static atomic64_t total_decomp_calls;
22
+
static atomic64_t total_sw_decomp_calls;
23
+
static atomic64_t total_comp_bytes_out;
24
+
static atomic64_t total_decomp_bytes_in;
25
+
static atomic64_t total_completion_einval_errors;
26
+
static atomic64_t total_completion_timeout_errors;
27
+
static atomic64_t total_completion_comp_buf_overflow_errors;
28
28
29
29
static struct dentry *iaa_crypto_debugfs_root;
30
30
31
31
void update_total_comp_calls(void)
32
32
{
33
-
total_comp_calls++;
33
+
atomic64_inc(&total_comp_calls);
34
34
}
35
35
36
36
void update_total_comp_bytes_out(int n)
37
37
{
38
-
total_comp_bytes_out += n;
38
+
atomic64_add(n, &total_comp_bytes_out);
39
39
}
40
40
41
41
void update_total_decomp_calls(void)
42
42
{
43
-
total_decomp_calls++;
43
+
atomic64_inc(&total_decomp_calls);
44
44
}
45
45
46
46
void update_total_sw_decomp_calls(void)
47
47
{
48
-
total_sw_decomp_calls++;
48
+
atomic64_inc(&total_sw_decomp_calls);
49
49
}
50
50
51
51
void update_total_decomp_bytes_in(int n)
52
52
{
53
-
total_decomp_bytes_in += n;
53
+
atomic64_add(n, &total_decomp_bytes_in);
54
54
}
55
55
56
56
void update_completion_einval_errs(void)
57
57
{
58
-
total_completion_einval_errors++;
58
+
atomic64_inc(&total_completion_einval_errors);
59
59
}
60
60
61
61
void update_completion_timeout_errs(void)
62
62
{
63
-
total_completion_timeout_errors++;
63
+
atomic64_inc(&total_completion_timeout_errors);
64
64
}
65
65
66
66
void update_completion_comp_buf_overflow_errs(void)
67
67
{
68
-
total_completion_comp_buf_overflow_errors++;
68
+
atomic64_inc(&total_completion_comp_buf_overflow_errors);
69
69
}
70
70
71
71
void update_wq_comp_calls(struct idxd_wq *idxd_wq)
72
72
{
73
73
struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
74
74
75
-
wq->comp_calls++;
76
-
wq->iaa_device->comp_calls++;
75
+
atomic64_inc(&wq->comp_calls);
76
+
atomic64_inc(&wq->iaa_device->comp_calls);
77
77
}
78
78
79
79
void update_wq_comp_bytes(struct idxd_wq *idxd_wq, int n)
80
80
{
81
81
struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
82
82
83
-
wq->comp_bytes += n;
84
-
wq->iaa_device->comp_bytes += n;
83
+
atomic64_add(n, &wq->comp_bytes);
84
+
atomic64_add(n, &wq->iaa_device->comp_bytes);
85
85
}
86
86
87
87
void update_wq_decomp_calls(struct idxd_wq *idxd_wq)
88
88
{
89
89
struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
90
90
91
-
wq->decomp_calls++;
92
-
wq->iaa_device->decomp_calls++;
91
+
atomic64_inc(&wq->decomp_calls);
92
+
atomic64_inc(&wq->iaa_device->decomp_calls);
93
93
}
94
94
95
95
void update_wq_decomp_bytes(struct idxd_wq *idxd_wq, int n)
96
96
{
97
97
struct iaa_wq *wq = idxd_wq_get_private(idxd_wq);
98
98
99
-
wq->decomp_bytes += n;
100
-
wq->iaa_device->decomp_bytes += n;
99
+
atomic64_add(n, &wq->decomp_bytes);
100
+
atomic64_add(n, &wq->iaa_device->decomp_bytes);
101
101
}
102
102
103
103
static void reset_iaa_crypto_stats(void)
104
104
{
105
-
total_comp_calls = 0;
106
-
total_decomp_calls = 0;
107
-
total_sw_decomp_calls = 0;
108
-
total_comp_bytes_out = 0;
109
-
total_decomp_bytes_in = 0;
110
-
total_completion_einval_errors = 0;
111
-
total_completion_timeout_errors = 0;
112
-
total_completion_comp_buf_overflow_errors = 0;
105
+
atomic64_set(&total_comp_calls, 0);
106
+
atomic64_set(&total_decomp_calls, 0);
107
+
atomic64_set(&total_sw_decomp_calls, 0);
108
+
atomic64_set(&total_comp_bytes_out, 0);
109
+
atomic64_set(&total_decomp_bytes_in, 0);
110
+
atomic64_set(&total_completion_einval_errors, 0);
111
+
atomic64_set(&total_completion_timeout_errors, 0);
112
+
atomic64_set(&total_completion_comp_buf_overflow_errors, 0);
113
113
}
114
114
115
115
static void reset_wq_stats(struct iaa_wq *wq)
116
116
{
117
-
wq->comp_calls = 0;
118
-
wq->comp_bytes = 0;
119
-
wq->decomp_calls = 0;
120
-
wq->decomp_bytes = 0;
117
+
atomic64_set(&wq->comp_calls, 0);
118
+
atomic64_set(&wq->comp_bytes, 0);
119
+
atomic64_set(&wq->decomp_calls, 0);
120
+
atomic64_set(&wq->decomp_bytes, 0);
121
121
}
122
122
123
123
static void reset_device_stats(struct iaa_device *iaa_device)
124
124
{
125
125
struct iaa_wq *iaa_wq;
126
126
127
-
iaa_device->comp_calls = 0;
128
-
iaa_device->comp_bytes = 0;
129
-
iaa_device->decomp_calls = 0;
130
-
iaa_device->decomp_bytes = 0;
127
+
atomic64_set(&iaa_device->comp_calls, 0);
128
+
atomic64_set(&iaa_device->comp_bytes, 0);
129
+
atomic64_set(&iaa_device->decomp_calls, 0);
130
+
atomic64_set(&iaa_device->decomp_bytes, 0);
131
131
132
132
list_for_each_entry(iaa_wq, &iaa_device->wqs, list)
133
133
reset_wq_stats(iaa_wq);
···
136
136
static void wq_show(struct seq_file *m, struct iaa_wq *iaa_wq)
137
137
{
138
138
seq_printf(m, " name: %s\n", iaa_wq->wq->name);
139
-
seq_printf(m, " comp_calls: %llu\n", iaa_wq->comp_calls);
140
-
seq_printf(m, " comp_bytes: %llu\n", iaa_wq->comp_bytes);
141
-
seq_printf(m, " decomp_calls: %llu\n", iaa_wq->decomp_calls);
142
-
seq_printf(m, " decomp_bytes: %llu\n\n", iaa_wq->decomp_bytes);
139
+
seq_printf(m, " comp_calls: %llu\n",
140
+
atomic64_read(&iaa_wq->comp_calls));
141
+
seq_printf(m, " comp_bytes: %llu\n",
142
+
atomic64_read(&iaa_wq->comp_bytes));
143
+
seq_printf(m, " decomp_calls: %llu\n",
144
+
atomic64_read(&iaa_wq->decomp_calls));
145
+
seq_printf(m, " decomp_bytes: %llu\n\n",
146
+
atomic64_read(&iaa_wq->decomp_bytes));
143
147
}
144
148
145
149
static void device_stats_show(struct seq_file *m, struct iaa_device *iaa_device)
···
153
149
seq_puts(m, "iaa device:\n");
154
150
seq_printf(m, " id: %d\n", iaa_device->idxd->id);
155
151
seq_printf(m, " n_wqs: %d\n", iaa_device->n_wq);
156
-
seq_printf(m, " comp_calls: %llu\n", iaa_device->comp_calls);
157
-
seq_printf(m, " comp_bytes: %llu\n", iaa_device->comp_bytes);
158
-
seq_printf(m, " decomp_calls: %llu\n", iaa_device->decomp_calls);
159
-
seq_printf(m, " decomp_bytes: %llu\n", iaa_device->decomp_bytes);
152
+
seq_printf(m, " comp_calls: %llu\n",
153
+
atomic64_read(&iaa_device->comp_calls));
154
+
seq_printf(m, " comp_bytes: %llu\n",
155
+
atomic64_read(&iaa_device->comp_bytes));
156
+
seq_printf(m, " decomp_calls: %llu\n",
157
+
atomic64_read(&iaa_device->decomp_calls));
158
+
seq_printf(m, " decomp_bytes: %llu\n",
159
+
atomic64_read(&iaa_device->decomp_bytes));
160
160
seq_puts(m, " wqs:\n");
161
161
162
162
list_for_each_entry(iaa_wq, &iaa_device->wqs, list)
···
170
162
static int global_stats_show(struct seq_file *m, void *v)
171
163
{
172
164
seq_puts(m, "global stats:\n");
173
-
seq_printf(m, " total_comp_calls: %llu\n", total_comp_calls);
174
-
seq_printf(m, " total_decomp_calls: %llu\n", total_decomp_calls);
175
-
seq_printf(m, " total_sw_decomp_calls: %llu\n", total_sw_decomp_calls);
176
-
seq_printf(m, " total_comp_bytes_out: %llu\n", total_comp_bytes_out);
177
-
seq_printf(m, " total_decomp_bytes_in: %llu\n", total_decomp_bytes_in);
165
+
seq_printf(m, " total_comp_calls: %llu\n",
166
+
atomic64_read(&total_comp_calls));
167
+
seq_printf(m, " total_decomp_calls: %llu\n",
168
+
atomic64_read(&total_decomp_calls));
169
+
seq_printf(m, " total_sw_decomp_calls: %llu\n",
170
+
atomic64_read(&total_sw_decomp_calls));
171
+
seq_printf(m, " total_comp_bytes_out: %llu\n",
172
+
atomic64_read(&total_comp_bytes_out));
173
+
seq_printf(m, " total_decomp_bytes_in: %llu\n",
174
+
atomic64_read(&total_decomp_bytes_in));
178
175
seq_printf(m, " total_completion_einval_errors: %llu\n",
179
-
total_completion_einval_errors);
176
+
atomic64_read(&total_completion_einval_errors));
180
177
seq_printf(m, " total_completion_timeout_errors: %llu\n",
181
-
total_completion_timeout_errors);
178
+
atomic64_read(&total_completion_timeout_errors));
182
179
seq_printf(m, " total_completion_comp_buf_overflow_errors: %llu\n\n",
183
-
total_completion_comp_buf_overflow_errors);
180
+
atomic64_read(&total_completion_comp_buf_overflow_errors));
184
181
185
182
return 0;
186
183
}