Commit | Line | Data |
---|---|---|
bcea3f96 | 1 | // SPDX-License-Identifier: GPL-2.0 |
12306276 SRRH |
2 | /* |
3 | * trace_seq.c | |
4 | * | |
5 | * Copyright (C) 2008-2014 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> | |
6 | * | |
36aabfff SRRH |
7 | * The trace_seq is a handy tool that allows you to pass a descriptor around |
8 | * to a buffer that other functions can write to. It is similar to the | |
9 | * seq_file functionality but has some differences. | |
10 | * | |
11 | * To use it, the trace_seq must be initialized with trace_seq_init(). | |
12 | * This will set up the counters within the descriptor. You can call | |
13 | * trace_seq_init() more than once to reset the trace_seq to start | |
14 | * from scratch. | |
15 | * | |
f2cc020d | 16 | * A write to the buffer will either succeed or fail. That is, unlike |
36aabfff SRRH |
17 | * sprintf() there will not be a partial write (well it may write into |
18 | * the buffer but it wont update the pointers). This allows users to | |
19 | * try to write something into the trace_seq buffer and if it fails | |
20 | * they can flush it and try again. | |
21 | * | |
12306276 SRRH |
22 | */ |
23 | #include <linux/uaccess.h> | |
24 | #include <linux/seq_file.h> | |
25 | #include <linux/trace_seq.h> | |
26 | ||
36aabfff | 27 | /* How much buffer is left on the trace_seq? */ |
3a161d99 | 28 | #define TRACE_SEQ_BUF_LEFT(s) seq_buf_buffer_left(&(s)->seq) |
36aabfff | 29 | |
3a161d99 SRRH |
30 | /* |
31 | * trace_seq should work with being initialized with 0s. | |
32 | */ | |
33 | static inline void __trace_seq_init(struct trace_seq *s) | |
34 | { | |
35 | if (unlikely(!s->seq.size)) | |
36 | trace_seq_init(s); | |
37 | } | |
36aabfff SRRH |
38 | |
39 | /** | |
40 | * trace_print_seq - move the contents of trace_seq into a seq_file | |
41 | * @m: the seq_file descriptor that is the destination | |
42 | * @s: the trace_seq descriptor that is the source. | |
43 | * | |
44 | * Returns 0 on success and non zero on error. If it succeeds to | |
45 | * write to the seq_file it will reset the trace_seq, otherwise | |
46 | * it does not modify the trace_seq to let the caller try again. | |
47 | */ | |
12306276 SRRH |
48 | int trace_print_seq(struct seq_file *m, struct trace_seq *s) |
49 | { | |
12306276 SRRH |
50 | int ret; |
51 | ||
3a161d99 SRRH |
52 | __trace_seq_init(s); |
53 | ||
54 | ret = seq_buf_print_seq(m, &s->seq); | |
12306276 SRRH |
55 | |
56 | /* | |
57 | * Only reset this buffer if we successfully wrote to the | |
36aabfff SRRH |
58 | * seq_file buffer. This lets the caller try again or |
59 | * do something else with the contents. | |
12306276 SRRH |
60 | */ |
61 | if (!ret) | |
62 | trace_seq_init(s); | |
63 | ||
64 | return ret; | |
65 | } | |
66 | ||
67 | /** | |
68 | * trace_seq_printf - sequence printing of trace information | |
69 | * @s: trace sequence descriptor | |
70 | * @fmt: printf format string | |
71 | * | |
12306276 | 72 | * The tracer may use either sequence operations or its own |
f2cc020d | 73 | * copy to user routines. To simplify formatting of a trace |
36aabfff | 74 | * trace_seq_printf() is used to store strings into a special |
12306276 SRRH |
75 | * buffer (@s). Then the output may be either used by |
76 | * the sequencer or pulled into another buffer. | |
77 | */ | |
dba39448 | 78 | void trace_seq_printf(struct trace_seq *s, const char *fmt, ...) |
12306276 | 79 | { |
3a161d99 | 80 | unsigned int save_len = s->seq.len; |
12306276 | 81 | va_list ap; |
12306276 | 82 | |
3a161d99 | 83 | if (s->full) |
dba39448 | 84 | return; |
12306276 | 85 | |
3a161d99 SRRH |
86 | __trace_seq_init(s); |
87 | ||
12306276 | 88 | va_start(ap, fmt); |
3a161d99 | 89 | seq_buf_vprintf(&s->seq, fmt, ap); |
12306276 SRRH |
90 | va_end(ap); |
91 | ||
92 | /* If we can't write it all, don't bother writing anything */ | |
3a161d99 SRRH |
93 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { |
94 | s->seq.len = save_len; | |
12306276 | 95 | s->full = 1; |
12306276 | 96 | } |
12306276 SRRH |
97 | } |
98 | EXPORT_SYMBOL_GPL(trace_seq_printf); | |
99 | ||
100 | /** | |
36aabfff | 101 | * trace_seq_bitmask - write a bitmask array in its ASCII representation |
12306276 SRRH |
102 | * @s: trace sequence descriptor |
103 | * @maskp: points to an array of unsigned longs that represent a bitmask | |
104 | * @nmaskbits: The number of bits that are valid in @maskp | |
105 | * | |
12306276 SRRH |
106 | * Writes a ASCII representation of a bitmask string into @s. |
107 | */ | |
dba39448 | 108 | void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp, |
36aabfff | 109 | int nmaskbits) |
12306276 | 110 | { |
3a161d99 | 111 | unsigned int save_len = s->seq.len; |
12306276 | 112 | |
3a161d99 | 113 | if (s->full) |
dba39448 | 114 | return; |
12306276 | 115 | |
3a161d99 SRRH |
116 | __trace_seq_init(s); |
117 | ||
1a40243b | 118 | seq_buf_printf(&s->seq, "%*pb", nmaskbits, maskp); |
3a161d99 SRRH |
119 | |
120 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { | |
121 | s->seq.len = save_len; | |
122 | s->full = 1; | |
123 | } | |
12306276 SRRH |
124 | } |
125 | EXPORT_SYMBOL_GPL(trace_seq_bitmask); | |
126 | ||
127 | /** | |
128 | * trace_seq_vprintf - sequence printing of trace information | |
129 | * @s: trace sequence descriptor | |
130 | * @fmt: printf format string | |
6c95d71b | 131 | * @args: Arguments for the format string |
12306276 SRRH |
132 | * |
133 | * The tracer may use either sequence operations or its own | |
f2cc020d | 134 | * copy to user routines. To simplify formatting of a trace |
12306276 SRRH |
135 | * trace_seq_printf is used to store strings into a special |
136 | * buffer (@s). Then the output may be either used by | |
137 | * the sequencer or pulled into another buffer. | |
138 | */ | |
dba39448 | 139 | void trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args) |
12306276 | 140 | { |
3a161d99 | 141 | unsigned int save_len = s->seq.len; |
12306276 | 142 | |
3a161d99 | 143 | if (s->full) |
dba39448 | 144 | return; |
12306276 | 145 | |
3a161d99 SRRH |
146 | __trace_seq_init(s); |
147 | ||
148 | seq_buf_vprintf(&s->seq, fmt, args); | |
12306276 SRRH |
149 | |
150 | /* If we can't write it all, don't bother writing anything */ | |
3a161d99 SRRH |
151 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { |
152 | s->seq.len = save_len; | |
12306276 | 153 | s->full = 1; |
12306276 | 154 | } |
12306276 SRRH |
155 | } |
156 | EXPORT_SYMBOL_GPL(trace_seq_vprintf); | |
157 | ||
36aabfff SRRH |
158 | /** |
159 | * trace_seq_bprintf - Write the printf string from binary arguments | |
160 | * @s: trace sequence descriptor | |
161 | * @fmt: The format string for the @binary arguments | |
162 | * @binary: The binary arguments for @fmt. | |
163 | * | |
164 | * When recording in a fast path, a printf may be recorded with just | |
165 | * saving the format and the arguments as they were passed to the | |
166 | * function, instead of wasting cycles converting the arguments into | |
167 | * ASCII characters. Instead, the arguments are saved in a 32 bit | |
168 | * word array that is defined by the format string constraints. | |
169 | * | |
170 | * This function will take the format and the binary array and finish | |
171 | * the conversion into the ASCII string within the buffer. | |
36aabfff | 172 | */ |
dba39448 | 173 | void trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary) |
12306276 | 174 | { |
3a161d99 | 175 | unsigned int save_len = s->seq.len; |
12306276 | 176 | |
3a161d99 | 177 | if (s->full) |
dba39448 | 178 | return; |
12306276 | 179 | |
3a161d99 SRRH |
180 | __trace_seq_init(s); |
181 | ||
182 | seq_buf_bprintf(&s->seq, fmt, binary); | |
12306276 SRRH |
183 | |
184 | /* If we can't write it all, don't bother writing anything */ | |
3a161d99 SRRH |
185 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { |
186 | s->seq.len = save_len; | |
12306276 | 187 | s->full = 1; |
dba39448 | 188 | return; |
12306276 | 189 | } |
12306276 | 190 | } |
36aabfff | 191 | EXPORT_SYMBOL_GPL(trace_seq_bprintf); |
12306276 SRRH |
192 | |
193 | /** | |
194 | * trace_seq_puts - trace sequence printing of simple string | |
195 | * @s: trace sequence descriptor | |
196 | * @str: simple string to record | |
197 | * | |
198 | * The tracer may use either the sequence operations or its own | |
199 | * copy to user routines. This function records a simple string | |
200 | * into a special buffer (@s) for later retrieval by a sequencer | |
201 | * or other mechanism. | |
202 | */ | |
dba39448 | 203 | void trace_seq_puts(struct trace_seq *s, const char *str) |
12306276 | 204 | { |
36aabfff | 205 | unsigned int len = strlen(str); |
12306276 SRRH |
206 | |
207 | if (s->full) | |
dba39448 | 208 | return; |
12306276 | 209 | |
3a161d99 SRRH |
210 | __trace_seq_init(s); |
211 | ||
36aabfff | 212 | if (len > TRACE_SEQ_BUF_LEFT(s)) { |
12306276 | 213 | s->full = 1; |
dba39448 | 214 | return; |
12306276 SRRH |
215 | } |
216 | ||
3a161d99 | 217 | seq_buf_putmem(&s->seq, str, len); |
12306276 | 218 | } |
36aabfff | 219 | EXPORT_SYMBOL_GPL(trace_seq_puts); |
12306276 | 220 | |
36aabfff SRRH |
221 | /** |
222 | * trace_seq_putc - trace sequence printing of simple character | |
223 | * @s: trace sequence descriptor | |
224 | * @c: simple character to record | |
225 | * | |
226 | * The tracer may use either the sequence operations or its own | |
f2cc020d | 227 | * copy to user routines. This function records a simple character |
36aabfff SRRH |
228 | * into a special buffer (@s) for later retrieval by a sequencer |
229 | * or other mechanism. | |
36aabfff | 230 | */ |
dba39448 | 231 | void trace_seq_putc(struct trace_seq *s, unsigned char c) |
12306276 SRRH |
232 | { |
233 | if (s->full) | |
dba39448 | 234 | return; |
12306276 | 235 | |
3a161d99 SRRH |
236 | __trace_seq_init(s); |
237 | ||
36aabfff | 238 | if (TRACE_SEQ_BUF_LEFT(s) < 1) { |
12306276 | 239 | s->full = 1; |
dba39448 | 240 | return; |
12306276 SRRH |
241 | } |
242 | ||
3a161d99 | 243 | seq_buf_putc(&s->seq, c); |
12306276 | 244 | } |
36aabfff | 245 | EXPORT_SYMBOL_GPL(trace_seq_putc); |
12306276 | 246 | |
36aabfff SRRH |
247 | /** |
248 | * trace_seq_putmem - write raw data into the trace_seq buffer | |
249 | * @s: trace sequence descriptor | |
250 | * @mem: The raw memory to copy into the buffer | |
251 | * @len: The length of the raw memory to copy (in bytes) | |
252 | * | |
253 | * There may be cases where raw memory needs to be written into the | |
254 | * buffer and a strcpy() would not work. Using this function allows | |
255 | * for such cases. | |
36aabfff | 256 | */ |
dba39448 | 257 | void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len) |
12306276 SRRH |
258 | { |
259 | if (s->full) | |
dba39448 | 260 | return; |
12306276 | 261 | |
3a161d99 SRRH |
262 | __trace_seq_init(s); |
263 | ||
36aabfff | 264 | if (len > TRACE_SEQ_BUF_LEFT(s)) { |
12306276 | 265 | s->full = 1; |
dba39448 | 266 | return; |
12306276 SRRH |
267 | } |
268 | ||
3a161d99 | 269 | seq_buf_putmem(&s->seq, mem, len); |
12306276 | 270 | } |
36aabfff | 271 | EXPORT_SYMBOL_GPL(trace_seq_putmem); |
12306276 | 272 | |
36aabfff SRRH |
273 | /** |
274 | * trace_seq_putmem_hex - write raw memory into the buffer in ASCII hex | |
275 | * @s: trace sequence descriptor | |
276 | * @mem: The raw memory to write its hex ASCII representation of | |
277 | * @len: The length of the raw memory to copy (in bytes) | |
278 | * | |
279 | * This is similar to trace_seq_putmem() except instead of just copying the | |
280 | * raw memory into the buffer it writes its ASCII representation of it | |
281 | * in hex characters. | |
36aabfff | 282 | */ |
dba39448 | 283 | void trace_seq_putmem_hex(struct trace_seq *s, const void *mem, |
36aabfff | 284 | unsigned int len) |
12306276 | 285 | { |
3a161d99 | 286 | unsigned int save_len = s->seq.len; |
12306276 SRRH |
287 | |
288 | if (s->full) | |
dba39448 | 289 | return; |
12306276 | 290 | |
3a161d99 SRRH |
291 | __trace_seq_init(s); |
292 | ||
293 | /* Each byte is represented by two chars */ | |
294 | if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) { | |
295 | s->full = 1; | |
296 | return; | |
297 | } | |
298 | ||
299 | /* The added spaces can still cause an overflow */ | |
300 | seq_buf_putmem_hex(&s->seq, mem, len); | |
301 | ||
302 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { | |
303 | s->seq.len = save_len; | |
304 | s->full = 1; | |
305 | return; | |
6d2289f3 | 306 | } |
12306276 | 307 | } |
36aabfff | 308 | EXPORT_SYMBOL_GPL(trace_seq_putmem_hex); |
12306276 | 309 | |
36aabfff SRRH |
310 | /** |
311 | * trace_seq_path - copy a path into the sequence buffer | |
312 | * @s: trace sequence descriptor | |
313 | * @path: path to write into the sequence buffer. | |
314 | * | |
315 | * Write a path name into the sequence buffer. | |
316 | * | |
317 | * Returns 1 if we successfully written all the contents to | |
318 | * the buffer. | |
319 | * Returns 0 if we the length to write is bigger than the | |
320 | * reserved buffer space. In this case, nothing gets written. | |
321 | */ | |
12306276 SRRH |
322 | int trace_seq_path(struct trace_seq *s, const struct path *path) |
323 | { | |
3a161d99 | 324 | unsigned int save_len = s->seq.len; |
12306276 SRRH |
325 | |
326 | if (s->full) | |
327 | return 0; | |
328 | ||
3a161d99 SRRH |
329 | __trace_seq_init(s); |
330 | ||
36aabfff | 331 | if (TRACE_SEQ_BUF_LEFT(s) < 1) { |
12306276 SRRH |
332 | s->full = 1; |
333 | return 0; | |
334 | } | |
335 | ||
dd23180a | 336 | seq_buf_path(&s->seq, path, "\n"); |
3a161d99 SRRH |
337 | |
338 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { | |
339 | s->seq.len = save_len; | |
340 | s->full = 1; | |
341 | return 0; | |
12306276 SRRH |
342 | } |
343 | ||
dd23180a | 344 | return 1; |
12306276 | 345 | } |
36aabfff | 346 | EXPORT_SYMBOL_GPL(trace_seq_path); |
12306276 | 347 | |
36aabfff | 348 | /** |
f2cc020d | 349 | * trace_seq_to_user - copy the sequence buffer to user space |
36aabfff SRRH |
350 | * @s: trace sequence descriptor |
351 | * @ubuf: The userspace memory location to copy to | |
352 | * @cnt: The amount to copy | |
353 | * | |
354 | * Copies the sequence buffer into the userspace memory pointed to | |
355 | * by @ubuf. It starts from the last read position (@s->readpos) | |
356 | * and writes up to @cnt characters or till it reaches the end of | |
357 | * the content in the buffer (@s->len), which ever comes first. | |
358 | * | |
359 | * On success, it returns a positive number of the number of bytes | |
360 | * it copied. | |
361 | * | |
362 | * On failure it returns -EBUSY if all of the content in the | |
363 | * sequence has been already read, which includes nothing in the | |
f2cc020d | 364 | * sequence (@s->len == @s->readpos). |
36aabfff SRRH |
365 | * |
366 | * Returns -EFAULT if the copy to userspace fails. | |
367 | */ | |
368 | int trace_seq_to_user(struct trace_seq *s, char __user *ubuf, int cnt) | |
12306276 | 369 | { |
d0ed46b6 | 370 | int ret; |
3a161d99 | 371 | __trace_seq_init(s); |
d0ed46b6 MWO |
372 | ret = seq_buf_to_user(&s->seq, ubuf, s->readpos, cnt); |
373 | if (ret > 0) | |
374 | s->readpos += ret; | |
375 | return ret; | |
12306276 | 376 | } |
36aabfff | 377 | EXPORT_SYMBOL_GPL(trace_seq_to_user); |
ef56e047 PM |
378 | |
379 | int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str, | |
380 | int prefix_type, int rowsize, int groupsize, | |
381 | const void *buf, size_t len, bool ascii) | |
382 | { | |
72879ee0 | 383 | unsigned int save_len = s->seq.len; |
ef56e047 PM |
384 | |
385 | if (s->full) | |
386 | return 0; | |
387 | ||
388 | __trace_seq_init(s); | |
389 | ||
390 | if (TRACE_SEQ_BUF_LEFT(s) < 1) { | |
391 | s->full = 1; | |
392 | return 0; | |
393 | } | |
394 | ||
395 | seq_buf_hex_dump(&(s->seq), prefix_str, | |
396 | prefix_type, rowsize, groupsize, | |
397 | buf, len, ascii); | |
398 | ||
399 | if (unlikely(seq_buf_has_overflowed(&s->seq))) { | |
400 | s->seq.len = save_len; | |
401 | s->full = 1; | |
402 | return 0; | |
403 | } | |
404 | ||
405 | return 1; | |
406 | } | |
407 | EXPORT_SYMBOL(trace_seq_hex_dump); | |
a9c4bdd5 LY |
408 | |
409 | /* | |
410 | * trace_seq_acquire - acquire seq buffer with size len | |
411 | * @s: trace sequence descriptor | |
412 | * @len: size of buffer to be acquired | |
413 | * | |
414 | * acquire buffer with size of @len from trace_seq for output usage, | |
415 | * user can fill string into that buffer. | |
416 | * | |
417 | * Returns start address of acquired buffer. | |
418 | * | |
419 | * it allow multiple usage in one trace output function call. | |
420 | */ | |
421 | char *trace_seq_acquire(struct trace_seq *s, unsigned int len) | |
422 | { | |
423 | char *ret = trace_seq_buffer_ptr(s); | |
424 | ||
425 | if (!WARN_ON_ONCE(seq_buf_buffer_left(&s->seq) < len)) | |
426 | seq_buf_commit(&s->seq, len); | |
427 | ||
428 | return ret; | |
429 | } | |
430 | EXPORT_SYMBOL(trace_seq_acquire); |