| 1 | |
| 2 | |
| 3 | * trace_seq.c
|
| 4 | *
|
| 5 | * Copyright (C) 2008-2014 Red Hat Inc, Steven Rostedt <[email protected]>
|
| 6 | *
|
| 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 | *
|
| 19 | * A write to the buffer will either succeed or fail. That is, unlike
|
| 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 | *
|
| 25 |
|
| 26 | #include <linux/uaccess.h>
|
| 27 | #include <linux/seq_file.h>
|
| 28 | #include <linux/trace_seq.h>
|
| 29 |
|
| 30 |
|
| 31 | #define TRACE_SEQ_BUF_LEFT(s) seq_buf_buffer_left(&(s)->seq)
|
| 32 |
|
| 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 | }
|
| 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 |
|
| 51 | int trace_print_seq(struct seq_file *m, struct trace_seq *s)
|
| 52 | {
|
| 53 | int ret;
|
| 54 |
|
| 55 | __trace_seq_init(s);
|
| 56 |
|
| 57 | ret = seq_buf_print_seq(m, &s->seq);
|
| 58 |
|
| 59 | |
| 60 | * Only reset this buffer if we successfully wrote to the
|
| 61 | * seq_file buffer. This lets the caller try again or
|
| 62 | * do something else with the contents.
|
| 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 | *
|
| 75 | * The tracer may use either sequence operations or its own
|
| 76 | * copy to user routines. To simplify formatting of a trace
|
| 77 | * trace_seq_printf() is used to store strings into a special
|
| 78 | * buffer (@s). Then the output may be either used by
|
| 79 | * the sequencer or pulled into another buffer.
|
| 80 |
|
| 81 | void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
|
| 82 | {
|
| 83 | unsigned int save_len = s->seq.len;
|
| 84 | va_list ap;
|
| 85 |
|
| 86 | if (s->full)
|
| 87 | return;
|
| 88 |
|
| 89 | __trace_seq_init(s);
|
| 90 |
|
| 91 | va_start(ap, fmt);
|
| 92 | seq_buf_vprintf(&s->seq, fmt, ap);
|
| 93 | va_end(ap);
|
| 94 |
|
| 95 |
|
| 96 | if (unlikely(seq_buf_has_overflowed(&s->seq))) {
|
| 97 | s->seq.len = save_len;
|
| 98 | s->full = 1;
|
| 99 | }
|
| 100 | }
|
| 101 | EXPORT_SYMBOL_GPL(trace_seq_printf);
|
| 102 |
|
| 103 | |
| 104 | * trace_seq_bitmask - write a bitmask array in its ASCII representation
|
| 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 | *
|
| 109 | * Writes a ASCII representation of a bitmask string into @s.
|
| 110 |
|
| 111 | void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
|
| 112 | int nmaskbits)
|
| 113 | {
|
| 114 | unsigned int save_len = s->seq.len;
|
| 115 |
|
| 116 | if (s->full)
|
| 117 | return;
|
| 118 |
|
| 119 | __trace_seq_init(s);
|
| 120 |
|
| 121 | seq_buf_printf(&s->seq, "%*pb", nmaskbits, maskp);
|
| 122 |
|
| 123 | if (unlikely(seq_buf_has_overflowed(&s->seq))) {
|
| 124 | s->seq.len = save_len;
|
| 125 | s->full = 1;
|
| 126 | }
|
| 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
|
| 136 | * copy to user routines. To simplify formatting of a trace
|
| 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 |
|
| 141 | void trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
|
| 142 | {
|
| 143 | unsigned int save_len = s->seq.len;
|
| 144 |
|
| 145 | if (s->full)
|
| 146 | return;
|
| 147 |
|
| 148 | __trace_seq_init(s);
|
| 149 |
|
| 150 | seq_buf_vprintf(&s->seq, fmt, args);
|
| 151 |
|
| 152 |
|
| 153 | if (unlikely(seq_buf_has_overflowed(&s->seq))) {
|
| 154 | s->seq.len = save_len;
|
| 155 | s->full = 1;
|
| 156 | }
|
| 157 | }
|
| 158 | EXPORT_SYMBOL_GPL(trace_seq_vprintf);
|
| 159 |
|
| 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.
|
| 174 |
|
| 175 | void trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
|
| 176 | {
|
| 177 | unsigned int save_len = s->seq.len;
|
| 178 |
|
| 179 | if (s->full)
|
| 180 | return;
|
| 181 |
|
| 182 | __trace_seq_init(s);
|
| 183 |
|
| 184 | seq_buf_bprintf(&s->seq, fmt, binary);
|
| 185 |
|
| 186 |
|
| 187 | if (unlikely(seq_buf_has_overflowed(&s->seq))) {
|
| 188 | s->seq.len = save_len;
|
| 189 | s->full = 1;
|
| 190 | return;
|
| 191 | }
|
| 192 | }
|
| 193 | EXPORT_SYMBOL_GPL(trace_seq_bprintf);
|
| 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 |
|
| 205 | void trace_seq_puts(struct trace_seq *s, const char *str)
|
| 206 | {
|
| 207 | unsigned int len = strlen(str);
|
| 208 |
|
| 209 | if (s->full)
|
| 210 | return;
|
| 211 |
|
| 212 | __trace_seq_init(s);
|
| 213 |
|
| 214 | if (len > TRACE_SEQ_BUF_LEFT(s)) {
|
| 215 | s->full = 1;
|
| 216 | return;
|
| 217 | }
|
| 218 |
|
| 219 | seq_buf_putmem(&s->seq, str, len);
|
| 220 | }
|
| 221 | EXPORT_SYMBOL_GPL(trace_seq_puts);
|
| 222 |
|
| 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
|
| 229 | * copy to user routines. This function records a simple character
|
| 230 | * into a special buffer (@s) for later retrieval by a sequencer
|
| 231 | * or other mechanism.
|
| 232 |
|
| 233 | void trace_seq_putc(struct trace_seq *s, unsigned char c)
|
| 234 | {
|
| 235 | if (s->full)
|
| 236 | return;
|
| 237 |
|
| 238 | __trace_seq_init(s);
|
| 239 |
|
| 240 | if (TRACE_SEQ_BUF_LEFT(s) < 1) {
|
| 241 | s->full = 1;
|
| 242 | return;
|
| 243 | }
|
| 244 |
|
| 245 | seq_buf_putc(&s->seq, c);
|
| 246 | }
|
| 247 | EXPORT_SYMBOL_GPL(trace_seq_putc);
|
| 248 |
|
| 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.
|
| 258 |
|
| 259 | void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len)
|
| 260 | {
|
| 261 | if (s->full)
|
| 262 | return;
|
| 263 |
|
| 264 | __trace_seq_init(s);
|
| 265 |
|
| 266 | if (len > TRACE_SEQ_BUF_LEFT(s)) {
|
| 267 | s->full = 1;
|
| 268 | return;
|
| 269 | }
|
| 270 |
|
| 271 | seq_buf_putmem(&s->seq, mem, len);
|
| 272 | }
|
| 273 | EXPORT_SYMBOL_GPL(trace_seq_putmem);
|
| 274 |
|
| 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.
|
| 284 |
|
| 285 | void trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
|
| 286 | unsigned int len)
|
| 287 | {
|
| 288 | unsigned int save_len = s->seq.len;
|
| 289 |
|
| 290 | if (s->full)
|
| 291 | return;
|
| 292 |
|
| 293 | __trace_seq_init(s);
|
| 294 |
|
| 295 |
|
| 296 | if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) {
|
| 297 | s->full = 1;
|
| 298 | return;
|
| 299 | }
|
| 300 |
|
| 301 |
|
| 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;
|
| 308 | }
|
| 309 | }
|
| 310 | EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
|
| 311 |
|
| 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 |
|
| 324 | int trace_seq_path(struct trace_seq *s, const struct path *path)
|
| 325 | {
|
| 326 | unsigned int save_len = s->seq.len;
|
| 327 |
|
| 328 | if (s->full)
|
| 329 | return 0;
|
| 330 |
|
| 331 | __trace_seq_init(s);
|
| 332 |
|
| 333 | if (TRACE_SEQ_BUF_LEFT(s) < 1) {
|
| 334 | s->full = 1;
|
| 335 | return 0;
|
| 336 | }
|
| 337 |
|
| 338 | seq_buf_path(&s->seq, path, "\n");
|
| 339 |
|
| 340 | if (unlikely(seq_buf_has_overflowed(&s->seq))) {
|
| 341 | s->seq.len = save_len;
|
| 342 | s->full = 1;
|
| 343 | return 0;
|
| 344 | }
|
| 345 |
|
| 346 | return 1;
|
| 347 | }
|
| 348 | EXPORT_SYMBOL_GPL(trace_seq_path);
|
| 349 |
|
| 350 | |
| 351 | * trace_seq_to_user - copy the sequence buffer to user space
|
| 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
|
| 366 | * sequence (@s->len == @s->readpos).
|
| 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)
|
| 371 | {
|
| 372 | __trace_seq_init(s);
|
| 373 | return seq_buf_to_user(&s->seq, ubuf, cnt);
|
| 374 | }
|
| 375 | EXPORT_SYMBOL_GPL(trace_seq_to_user);
|
| 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 | {
|
| 381 | unsigned int save_len = s->seq.len;
|
| 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);
|
| 406 |
|
| 407 | |
| 408 | * trace_seq_acquire - acquire seq buffer with size len
|
| 409 | * @s: trace sequence descriptor
|
| 410 | * @len: size of buffer to be acquired
|
| 411 | *
|
| 412 | * acquire buffer with size of @len from trace_seq for output usage,
|
| 413 | * user can fill string into that buffer.
|
| 414 | *
|
| 415 | * Returns start address of acquired buffer.
|
| 416 | *
|
| 417 | * it allow multiple usage in one trace output function call.
|
| 418 |
|
| 419 | char *trace_seq_acquire(struct trace_seq *s, unsigned int len)
|
| 420 | {
|
| 421 | char *ret = trace_seq_buffer_ptr(s);
|
| 422 |
|
| 423 | if (!WARN_ON_ONCE(seq_buf_buffer_left(&s->seq) < len))
|
| 424 | seq_buf_commit(&s->seq, len);
|
| 425 |
|
| 426 | return ret;
|
| 427 | }
|
| 428 | EXPORT_SYMBOL(trace_seq_acquire);
|