]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
00ce1db1 TT |
2 | #undef TRACE_SYSTEM |
3 | #define TRACE_SYSTEM random | |
4 | ||
5 | #if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ) | |
6 | #define _TRACE_RANDOM_H | |
7 | ||
8 | #include <linux/writeback.h> | |
9 | #include <linux/tracepoint.h> | |
10 | ||
5910895f TT |
11 | TRACE_EVENT(add_device_randomness, |
12 | TP_PROTO(int bytes, unsigned long IP), | |
13 | ||
14 | TP_ARGS(bytes, IP), | |
15 | ||
16 | TP_STRUCT__entry( | |
17 | __field( int, bytes ) | |
18 | __field(unsigned long, IP ) | |
19 | ), | |
20 | ||
21 | TP_fast_assign( | |
22 | __entry->bytes = bytes; | |
23 | __entry->IP = IP; | |
24 | ), | |
25 | ||
bbedb179 | 26 | TP_printk("bytes %d caller %pS", |
5910895f TT |
27 | __entry->bytes, (void *)__entry->IP) |
28 | ); | |
29 | ||
00ce1db1 TT |
30 | DECLARE_EVENT_CLASS(random__mix_pool_bytes, |
31 | TP_PROTO(const char *pool_name, int bytes, unsigned long IP), | |
32 | ||
33 | TP_ARGS(pool_name, bytes, IP), | |
34 | ||
35 | TP_STRUCT__entry( | |
36 | __field( const char *, pool_name ) | |
37 | __field( int, bytes ) | |
38 | __field(unsigned long, IP ) | |
39 | ), | |
40 | ||
41 | TP_fast_assign( | |
42 | __entry->pool_name = pool_name; | |
43 | __entry->bytes = bytes; | |
44 | __entry->IP = IP; | |
45 | ), | |
46 | ||
bbedb179 | 47 | TP_printk("%s pool: bytes %d caller %pS", |
00ce1db1 TT |
48 | __entry->pool_name, __entry->bytes, (void *)__entry->IP) |
49 | ); | |
50 | ||
51 | DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, | |
52 | TP_PROTO(const char *pool_name, int bytes, unsigned long IP), | |
53 | ||
54 | TP_ARGS(pool_name, bytes, IP) | |
55 | ); | |
56 | ||
57 | DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, | |
58 | TP_PROTO(const char *pool_name, int bytes, unsigned long IP), | |
59 | ||
60 | TP_ARGS(pool_name, bytes, IP) | |
61 | ); | |
62 | ||
63 | TRACE_EVENT(credit_entropy_bits, | |
64 | TP_PROTO(const char *pool_name, int bits, int entropy_count, | |
65 | int entropy_total, unsigned long IP), | |
66 | ||
67 | TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP), | |
68 | ||
69 | TP_STRUCT__entry( | |
70 | __field( const char *, pool_name ) | |
71 | __field( int, bits ) | |
72 | __field( int, entropy_count ) | |
73 | __field( int, entropy_total ) | |
74 | __field(unsigned long, IP ) | |
75 | ), | |
76 | ||
77 | TP_fast_assign( | |
78 | __entry->pool_name = pool_name; | |
79 | __entry->bits = bits; | |
80 | __entry->entropy_count = entropy_count; | |
81 | __entry->entropy_total = entropy_total; | |
82 | __entry->IP = IP; | |
83 | ), | |
84 | ||
85 | TP_printk("%s pool: bits %d entropy_count %d entropy_total %d " | |
bbedb179 | 86 | "caller %pS", __entry->pool_name, __entry->bits, |
00ce1db1 TT |
87 | __entry->entropy_count, __entry->entropy_total, |
88 | (void *)__entry->IP) | |
89 | ); | |
90 | ||
6265e169 TT |
91 | TRACE_EVENT(push_to_pool, |
92 | TP_PROTO(const char *pool_name, int pool_bits, int input_bits), | |
93 | ||
94 | TP_ARGS(pool_name, pool_bits, input_bits), | |
95 | ||
96 | TP_STRUCT__entry( | |
97 | __field( const char *, pool_name ) | |
98 | __field( int, pool_bits ) | |
99 | __field( int, input_bits ) | |
100 | ), | |
101 | ||
102 | TP_fast_assign( | |
103 | __entry->pool_name = pool_name; | |
104 | __entry->pool_bits = pool_bits; | |
105 | __entry->input_bits = input_bits; | |
106 | ), | |
107 | ||
108 | TP_printk("%s: pool_bits %d input_pool_bits %d", | |
109 | __entry->pool_name, __entry->pool_bits, | |
110 | __entry->input_bits) | |
111 | ); | |
112 | ||
f80bbd8b TT |
113 | TRACE_EVENT(debit_entropy, |
114 | TP_PROTO(const char *pool_name, int debit_bits), | |
115 | ||
116 | TP_ARGS(pool_name, debit_bits), | |
117 | ||
118 | TP_STRUCT__entry( | |
119 | __field( const char *, pool_name ) | |
120 | __field( int, debit_bits ) | |
121 | ), | |
122 | ||
123 | TP_fast_assign( | |
124 | __entry->pool_name = pool_name; | |
125 | __entry->debit_bits = debit_bits; | |
126 | ), | |
127 | ||
128 | TP_printk("%s: debit_bits %d", __entry->pool_name, | |
129 | __entry->debit_bits) | |
130 | ); | |
131 | ||
132 | TRACE_EVENT(add_input_randomness, | |
133 | TP_PROTO(int input_bits), | |
134 | ||
135 | TP_ARGS(input_bits), | |
136 | ||
137 | TP_STRUCT__entry( | |
138 | __field( int, input_bits ) | |
139 | ), | |
140 | ||
141 | TP_fast_assign( | |
142 | __entry->input_bits = input_bits; | |
143 | ), | |
144 | ||
145 | TP_printk("input_pool_bits %d", __entry->input_bits) | |
146 | ); | |
147 | ||
148 | TRACE_EVENT(add_disk_randomness, | |
149 | TP_PROTO(dev_t dev, int input_bits), | |
150 | ||
151 | TP_ARGS(dev, input_bits), | |
152 | ||
153 | TP_STRUCT__entry( | |
154 | __field( dev_t, dev ) | |
155 | __field( int, input_bits ) | |
156 | ), | |
157 | ||
158 | TP_fast_assign( | |
159 | __entry->dev = dev; | |
160 | __entry->input_bits = input_bits; | |
161 | ), | |
162 | ||
163 | TP_printk("dev %d,%d input_pool_bits %d", MAJOR(__entry->dev), | |
164 | MINOR(__entry->dev), __entry->input_bits) | |
165 | ); | |
166 | ||
167 | TRACE_EVENT(xfer_secondary_pool, | |
168 | TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, | |
169 | int pool_entropy, int input_entropy), | |
170 | ||
171 | TP_ARGS(pool_name, xfer_bits, request_bits, pool_entropy, | |
172 | input_entropy), | |
173 | ||
174 | TP_STRUCT__entry( | |
175 | __field( const char *, pool_name ) | |
176 | __field( int, xfer_bits ) | |
177 | __field( int, request_bits ) | |
178 | __field( int, pool_entropy ) | |
179 | __field( int, input_entropy ) | |
180 | ), | |
181 | ||
182 | TP_fast_assign( | |
183 | __entry->pool_name = pool_name; | |
184 | __entry->xfer_bits = xfer_bits; | |
185 | __entry->request_bits = request_bits; | |
186 | __entry->pool_entropy = pool_entropy; | |
187 | __entry->input_entropy = input_entropy; | |
188 | ), | |
189 | ||
190 | TP_printk("pool %s xfer_bits %d request_bits %d pool_entropy %d " | |
191 | "input_entropy %d", __entry->pool_name, __entry->xfer_bits, | |
192 | __entry->request_bits, __entry->pool_entropy, | |
193 | __entry->input_entropy) | |
194 | ); | |
195 | ||
5910895f | 196 | DECLARE_EVENT_CLASS(random__get_random_bytes, |
00ce1db1 TT |
197 | TP_PROTO(int nbytes, unsigned long IP), |
198 | ||
199 | TP_ARGS(nbytes, IP), | |
200 | ||
201 | TP_STRUCT__entry( | |
202 | __field( int, nbytes ) | |
203 | __field(unsigned long, IP ) | |
204 | ), | |
205 | ||
206 | TP_fast_assign( | |
207 | __entry->nbytes = nbytes; | |
208 | __entry->IP = IP; | |
209 | ), | |
210 | ||
bbedb179 | 211 | TP_printk("nbytes %d caller %pS", __entry->nbytes, (void *)__entry->IP) |
00ce1db1 TT |
212 | ); |
213 | ||
5910895f TT |
214 | DEFINE_EVENT(random__get_random_bytes, get_random_bytes, |
215 | TP_PROTO(int nbytes, unsigned long IP), | |
216 | ||
217 | TP_ARGS(nbytes, IP) | |
218 | ); | |
219 | ||
220 | DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, | |
221 | TP_PROTO(int nbytes, unsigned long IP), | |
222 | ||
223 | TP_ARGS(nbytes, IP) | |
224 | ); | |
225 | ||
00ce1db1 TT |
226 | DECLARE_EVENT_CLASS(random__extract_entropy, |
227 | TP_PROTO(const char *pool_name, int nbytes, int entropy_count, | |
228 | unsigned long IP), | |
229 | ||
230 | TP_ARGS(pool_name, nbytes, entropy_count, IP), | |
231 | ||
232 | TP_STRUCT__entry( | |
233 | __field( const char *, pool_name ) | |
234 | __field( int, nbytes ) | |
235 | __field( int, entropy_count ) | |
236 | __field(unsigned long, IP ) | |
237 | ), | |
238 | ||
239 | TP_fast_assign( | |
240 | __entry->pool_name = pool_name; | |
241 | __entry->nbytes = nbytes; | |
242 | __entry->entropy_count = entropy_count; | |
243 | __entry->IP = IP; | |
244 | ), | |
245 | ||
bbedb179 | 246 | TP_printk("%s pool: nbytes %d entropy_count %d caller %pS", |
00ce1db1 TT |
247 | __entry->pool_name, __entry->nbytes, __entry->entropy_count, |
248 | (void *)__entry->IP) | |
249 | ); | |
250 | ||
251 | ||
252 | DEFINE_EVENT(random__extract_entropy, extract_entropy, | |
253 | TP_PROTO(const char *pool_name, int nbytes, int entropy_count, | |
254 | unsigned long IP), | |
255 | ||
256 | TP_ARGS(pool_name, nbytes, entropy_count, IP) | |
257 | ); | |
258 | ||
259 | DEFINE_EVENT(random__extract_entropy, extract_entropy_user, | |
260 | TP_PROTO(const char *pool_name, int nbytes, int entropy_count, | |
261 | unsigned long IP), | |
262 | ||
263 | TP_ARGS(pool_name, nbytes, entropy_count, IP) | |
264 | ); | |
265 | ||
f80bbd8b TT |
266 | TRACE_EVENT(random_read, |
267 | TP_PROTO(int got_bits, int need_bits, int pool_left, int input_left), | |
00ce1db1 | 268 | |
f80bbd8b TT |
269 | TP_ARGS(got_bits, need_bits, pool_left, input_left), |
270 | ||
271 | TP_STRUCT__entry( | |
272 | __field( int, got_bits ) | |
273 | __field( int, need_bits ) | |
274 | __field( int, pool_left ) | |
275 | __field( int, input_left ) | |
276 | ), | |
277 | ||
278 | TP_fast_assign( | |
279 | __entry->got_bits = got_bits; | |
280 | __entry->need_bits = need_bits; | |
281 | __entry->pool_left = pool_left; | |
282 | __entry->input_left = input_left; | |
283 | ), | |
284 | ||
285 | TP_printk("got_bits %d still_needed_bits %d " | |
286 | "blocking_pool_entropy_left %d input_entropy_left %d", | |
287 | __entry->got_bits, __entry->got_bits, __entry->pool_left, | |
288 | __entry->input_left) | |
289 | ); | |
290 | ||
291 | TRACE_EVENT(urandom_read, | |
292 | TP_PROTO(int got_bits, int pool_left, int input_left), | |
293 | ||
294 | TP_ARGS(got_bits, pool_left, input_left), | |
295 | ||
296 | TP_STRUCT__entry( | |
297 | __field( int, got_bits ) | |
298 | __field( int, pool_left ) | |
299 | __field( int, input_left ) | |
300 | ), | |
301 | ||
302 | TP_fast_assign( | |
303 | __entry->got_bits = got_bits; | |
304 | __entry->pool_left = pool_left; | |
305 | __entry->input_left = input_left; | |
306 | ), | |
307 | ||
308 | TP_printk("got_bits %d nonblocking_pool_entropy_left %d " | |
309 | "input_entropy_left %d", __entry->got_bits, | |
310 | __entry->pool_left, __entry->input_left) | |
311 | ); | |
00ce1db1 TT |
312 | |
313 | #endif /* _TRACE_RANDOM_H */ | |
314 | ||
315 | /* This part must be outside protection */ | |
316 | #include <trace/define_trace.h> |