~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/lib/traceevent/trace-seq.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: LGPL-2.1
  2 /*
  3  * Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  4  *
  5  */
  6 #include "trace-seq.h"
  7 
  8 #include <stdio.h>
  9 #include <stdlib.h>
 10 #include <string.h>
 11 #include <stdarg.h>
 12 
 13 #include <asm/bug.h>
 14 #include "event-parse.h"
 15 #include "event-utils.h"
 16 
 17 /*
 18  * The TRACE_SEQ_POISON is to catch the use of using
 19  * a trace_seq structure after it was destroyed.
 20  */
 21 #define TRACE_SEQ_POISON        ((void *)0xdeadbeef)
 22 #define TRACE_SEQ_CHECK(s)                                              \
 23 do {                                                                    \
 24         if (WARN_ONCE((s)->buffer == TRACE_SEQ_POISON,                  \
 25                       "Usage of trace_seq after it was destroyed"))     \
 26                 (s)->state = TRACE_SEQ__BUFFER_POISONED;                \
 27 } while (0)
 28 
 29 #define TRACE_SEQ_CHECK_RET_N(s, n)             \
 30 do {                                            \
 31         TRACE_SEQ_CHECK(s);                     \
 32         if ((s)->state != TRACE_SEQ__GOOD)      \
 33                 return n;                       \
 34 } while (0)
 35 
 36 #define TRACE_SEQ_CHECK_RET(s)   TRACE_SEQ_CHECK_RET_N(s, )
 37 #define TRACE_SEQ_CHECK_RET0(s)  TRACE_SEQ_CHECK_RET_N(s, 0)
 38 
 39 /**
 40  * trace_seq_init - initialize the trace_seq structure
 41  * @s: a pointer to the trace_seq structure to initialize
 42  */
 43 void trace_seq_init(struct trace_seq *s)
 44 {
 45         s->len = 0;
 46         s->readpos = 0;
 47         s->buffer_size = TRACE_SEQ_BUF_SIZE;
 48         s->buffer = malloc(s->buffer_size);
 49         if (s->buffer != NULL)
 50                 s->state = TRACE_SEQ__GOOD;
 51         else
 52                 s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
 53 }
 54 
 55 /**
 56  * trace_seq_reset - re-initialize the trace_seq structure
 57  * @s: a pointer to the trace_seq structure to reset
 58  */
 59 void trace_seq_reset(struct trace_seq *s)
 60 {
 61         if (!s)
 62                 return;
 63         TRACE_SEQ_CHECK(s);
 64         s->len = 0;
 65         s->readpos = 0;
 66 }
 67 
 68 /**
 69  * trace_seq_destroy - free up memory of a trace_seq
 70  * @s: a pointer to the trace_seq to free the buffer
 71  *
 72  * Only frees the buffer, not the trace_seq struct itself.
 73  */
 74 void trace_seq_destroy(struct trace_seq *s)
 75 {
 76         if (!s)
 77                 return;
 78         TRACE_SEQ_CHECK_RET(s);
 79         free(s->buffer);
 80         s->buffer = TRACE_SEQ_POISON;
 81 }
 82 
 83 static void expand_buffer(struct trace_seq *s)
 84 {
 85         char *buf;
 86 
 87         buf = realloc(s->buffer, s->buffer_size + TRACE_SEQ_BUF_SIZE);
 88         if (WARN_ONCE(!buf, "Can't allocate trace_seq buffer memory")) {
 89                 s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
 90                 return;
 91         }
 92 
 93         s->buffer = buf;
 94         s->buffer_size += TRACE_SEQ_BUF_SIZE;
 95 }
 96 
 97 /**
 98  * trace_seq_printf - sequence printing of trace information
 99  * @s: trace sequence descriptor
100  * @fmt: printf format string
101  *
102  * It returns 0 if the trace oversizes the buffer's free
103  * space, the number of characters printed, or a negative
104  * value in case of an error.
105  *
106  * The tracer may use either sequence operations or its own
107  * copy to user routines. To simplify formating of a trace
108  * trace_seq_printf is used to store strings into a special
109  * buffer (@s). Then the output may be either used by
110  * the sequencer or pulled into another buffer.
111  */
112 int
113 trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
114 {
115         va_list ap;
116         int len;
117         int ret;
118 
119  try_again:
120         TRACE_SEQ_CHECK_RET0(s);
121 
122         len = (s->buffer_size - 1) - s->len;
123 
124         va_start(ap, fmt);
125         ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
126         va_end(ap);
127 
128         if (ret >= len) {
129                 expand_buffer(s);
130                 goto try_again;
131         }
132 
133         if (ret > 0)
134                 s->len += ret;
135 
136         return ret;
137 }
138 
139 /**
140  * trace_seq_vprintf - sequence printing of trace information
141  * @s: trace sequence descriptor
142  * @fmt: printf format string
143  *
144  * It returns 0 if the trace oversizes the buffer's free
145  * space, the number of characters printed, or a negative
146  * value in case of an error.
147  * *
148  * The tracer may use either sequence operations or its own
149  * copy to user routines. To simplify formating of a trace
150  * trace_seq_printf is used to store strings into a special
151  * buffer (@s). Then the output may be either used by
152  * the sequencer or pulled into another buffer.
153  */
154 int
155 trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
156 {
157         int len;
158         int ret;
159 
160  try_again:
161         TRACE_SEQ_CHECK_RET0(s);
162 
163         len = (s->buffer_size - 1) - s->len;
164 
165         ret = vsnprintf(s->buffer + s->len, len, fmt, args);
166 
167         if (ret >= len) {
168                 expand_buffer(s);
169                 goto try_again;
170         }
171 
172         if (ret > 0)
173                 s->len += ret;
174 
175         return ret;
176 }
177 
178 /**
179  * trace_seq_puts - trace sequence printing of simple string
180  * @s: trace sequence descriptor
181  * @str: simple string to record
182  *
183  * The tracer may use either the sequence operations or its own
184  * copy to user routines. This function records a simple string
185  * into a special buffer (@s) for later retrieval by a sequencer
186  * or other mechanism.
187  */
188 int trace_seq_puts(struct trace_seq *s, const char *str)
189 {
190         int len;
191 
192         TRACE_SEQ_CHECK_RET0(s);
193 
194         len = strlen(str);
195 
196         while (len > ((s->buffer_size - 1) - s->len))
197                 expand_buffer(s);
198 
199         TRACE_SEQ_CHECK_RET0(s);
200 
201         memcpy(s->buffer + s->len, str, len);
202         s->len += len;
203 
204         return len;
205 }
206 
207 int trace_seq_putc(struct trace_seq *s, unsigned char c)
208 {
209         TRACE_SEQ_CHECK_RET0(s);
210 
211         while (s->len >= (s->buffer_size - 1))
212                 expand_buffer(s);
213 
214         TRACE_SEQ_CHECK_RET0(s);
215 
216         s->buffer[s->len++] = c;
217 
218         return 1;
219 }
220 
221 void trace_seq_terminate(struct trace_seq *s)
222 {
223         TRACE_SEQ_CHECK_RET(s);
224 
225         /* There's always one character left on the buffer */
226         s->buffer[s->len] = 0;
227 }
228 
229 int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp)
230 {
231         TRACE_SEQ_CHECK(s);
232 
233         switch (s->state) {
234         case TRACE_SEQ__GOOD:
235                 return fprintf(fp, "%.*s", s->len, s->buffer);
236         case TRACE_SEQ__BUFFER_POISONED:
237                 fprintf(fp, "%s\n", "Usage of trace_seq after it was destroyed");
238                 break;
239         case TRACE_SEQ__MEM_ALLOC_FAILED:
240                 fprintf(fp, "%s\n", "Can't allocate trace_seq buffer memory");
241                 break;
242         }
243         return -1;
244 }
245 
246 int trace_seq_do_printf(struct trace_seq *s)
247 {
248         return trace_seq_do_fprintf(s, stdout);
249 }
250 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp