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