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