FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
std-formats.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
17 
18  Permission is hereby granted, free of charge, to any person obtaining
19  a copy of this software and associated documentation files (the
20  "Software"), to deal in the Software without restriction, including
21  without limitation the rights to use, copy, modify, merge, publish,
22  distribute, sublicense, and/or sell copies of the Software, and to
23  permit persons to whom the Software is furnished to do so, subject to
24  the following conditions:
25 
26  The above copyright notice and this permission notice shall be
27  included in all copies or substantial portions of the Software.
28 
29  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
33  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
34  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
35  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 */
37 
38 #include <vppinfra/format.h>
39 #include <ctype.h>
40 
41 /* Format vectors. */
42 u8 *
43 format_vec32 (u8 * s, va_list * va)
44 {
45  u32 *v = va_arg (*va, u32 *);
46  char *fmt = va_arg (*va, char *);
47  uword i;
48  for (i = 0; i < vec_len (v); i++)
49  {
50  if (i > 0)
51  s = format (s, ", ");
52  s = format (s, fmt, v[i]);
53  }
54  return s;
55 }
56 
57 u8 *
58 format_vec_uword (u8 * s, va_list * va)
59 {
60  uword *v = va_arg (*va, uword *);
61  char *fmt = va_arg (*va, char *);
62  uword i;
63  for (i = 0; i < vec_len (v); i++)
64  {
65  if (i > 0)
66  s = format (s, ", ");
67  s = format (s, fmt, v[i]);
68  }
69  return s;
70 }
71 
72 /* Ascii buffer and length. */
73 u8 *
74 format_ascii_bytes (u8 * s, va_list * va)
75 {
76  u8 *v = va_arg (*va, u8 *);
77  uword n_bytes = va_arg (*va, uword);
78  vec_add (s, v, n_bytes);
79  return s;
80 }
81 
82 /* Format hex dump. */
83 u8 *
84 format_hex_bytes (u8 * s, va_list * va)
85 {
86  u8 *bytes = va_arg (*va, u8 *);
87  int n_bytes = va_arg (*va, int);
88  uword i;
89 
90  /* Print short or long form depending on byte count. */
91  uword short_form = n_bytes <= 32;
92  uword indent = format_get_indent (s);
93 
94  if (n_bytes == 0)
95  return s;
96 
97  for (i = 0; i < n_bytes; i++)
98  {
99  if (!short_form && (i % 32) == 0)
100  s = format (s, "%08x: ", i);
101 
102  s = format (s, "%02x", bytes[i]);
103 
104  if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
105  s = format (s, "\n%U", format_white_space, indent);
106  }
107 
108  return s;
109 }
110 
111 /* Add variable number of spaces. */
112 u8 *
113 format_white_space (u8 * s, va_list * va)
114 {
115  uword n = va_arg (*va, uword);
116  while (n-- > 0)
117  vec_add1 (s, ' ');
118  return s;
119 }
120 
121 u8 *
122 format_time_interval (u8 * s, va_list * args)
123 {
124  u8 *fmt = va_arg (*args, u8 *);
125  f64 t = va_arg (*args, f64);
126  u8 *f;
127 
128  const f64 seconds_per_minute = 60;
129  const f64 seconds_per_hour = 60 * seconds_per_minute;
130  const f64 seconds_per_day = 24 * seconds_per_hour;
131  uword days, hours, minutes, secs, msecs, usecs;
132 
133  days = t / seconds_per_day;
134  t -= days * seconds_per_day;
135 
136  hours = t / seconds_per_hour;
137  t -= hours * seconds_per_hour;
138 
139  minutes = t / seconds_per_minute;
140  t -= minutes * seconds_per_minute;
141 
142  secs = t;
143  t -= secs;
144 
145  msecs = 1e3 * t;
146  usecs = 1e6 * t;
147 
148  for (f = fmt; *f; f++)
149  {
150  uword what, c;
151  char *what_fmt = "%d";
152 
153  switch (c = *f)
154  {
155  default:
156  vec_add1 (s, c);
157  continue;
158 
159  case 'd':
160  what = days;
161  what_fmt = "%d";
162  break;
163  case 'h':
164  what = hours;
165  what_fmt = "%02d";
166  break;
167  case 'm':
168  what = minutes;
169  what_fmt = "%02d";
170  break;
171  case 's':
172  what = secs;
173  what_fmt = "%02d";
174  break;
175  case 'f':
176  what = msecs;
177  what_fmt = "%03d";
178  break;
179  case 'u':
180  what = usecs;
181  what_fmt = "%06d";
182  break;
183  }
184 
185  s = format (s, what_fmt, what);
186  }
187 
188  return s;
189 }
190 
191 /* Unparse memory size e.g. 100, 100k, 100m, 100g. */
192 u8 *
193 format_memory_size (u8 * s, va_list * va)
194 {
195  uword size = va_arg (*va, uword);
196  uword l, u, log_u;
197 
198  l = size > 0 ? min_log2 (size) : 0;
199  if (l < 10)
200  log_u = 0;
201  else if (l < 20)
202  log_u = 10;
203  else if (l < 30)
204  log_u = 20;
205  else
206  log_u = 30;
207 
208  u = (uword) 1 << log_u;
209  if (size & (u - 1))
210  s = format (s, "%.2f", (f64) size / (f64) u);
211  else
212  s = format (s, "%d", size >> log_u);
213 
214  if (log_u != 0)
215  s = format (s, "%c", " kmg"[log_u / 10]);
216 
217  return s;
218 }
219 
220 /* Parse memory size e.g. 100, 100k, 100m, 100g. */
221 uword
222 unformat_memory_size (unformat_input_t * input, va_list * va)
223 {
224  uword amount, shift, c;
225  uword *result = va_arg (*va, uword *);
226 
227  if (!unformat (input, "%wd%_", &amount))
228  return 0;
229 
230  c = unformat_get_input (input);
231  switch (c)
232  {
233  case 'k':
234  case 'K':
235  shift = 10;
236  break;
237  case 'm':
238  case 'M':
239  shift = 20;
240  break;
241  case 'g':
242  case 'G':
243  shift = 30;
244  break;
245  default:
246  shift = 0;
247  unformat_put_input (input);
248  break;
249  }
250 
251  *result = amount << shift;
252  return 1;
253 }
254 
255 /* Format c identifier: e.g. a_name -> "a name".
256  Words for both vector names and null terminated c strings. */
257 u8 *
258 format_c_identifier (u8 * s, va_list * va)
259 {
260  u8 *id = va_arg (*va, u8 *);
261  uword i, l;
262 
263  l = ~0;
264  if (clib_mem_is_vec (id))
265  l = vec_len (id);
266 
267  if (id)
268  for (i = 0; id[i] != 0 && i < l; i++)
269  {
270  u8 c = id[i];
271 
272  if (c == '_')
273  c = ' ';
274  vec_add1 (s, c);
275  }
276 
277  return s;
278 }
279 
280 u8 *
281 format_hexdump (u8 * s, va_list * args)
282 {
283  u8 *data = va_arg (*args, u8 *);
284  uword len = va_arg (*args, uword);
285  int i, index = 0;
286  const int line_len = 16;
287  u8 *line_hex = 0;
288  u8 *line_str = 0;
289  uword indent = format_get_indent (s);
290 
291  if (!len)
292  return s;
293 
294  for (i = 0; i < len; i++)
295  {
296  line_hex = format (line_hex, "%02x ", data[i]);
297  line_str = format (line_str, "%c", isprint (data[i]) ? data[i] : '.');
298  if (!((i + 1) % line_len))
299  {
300  s = format (s, "%U%05x: %v[%v]",
301  format_white_space, index ? indent : 0,
302  index, line_hex, line_str);
303  if (i < len - 1)
304  s = format (s, "\n");
305  index = i + 1;
306  vec_reset_length (line_hex);
307  vec_reset_length (line_str);
308  }
309  }
310 
311  while (i++ % line_len)
312  line_hex = format (line_hex, " ");
313 
314  if (vec_len (line_hex))
315  s = format (s, "%U%05x: %v[%v]",
316  format_white_space, indent, index, line_hex, line_str);
317 
318  vec_free (line_hex);
319  vec_free (line_str);
320 
321  return s;
322 }
323 
324 /*
325  * fd.io coding-style-patch-verification: ON
326  *
327  * Local Variables:
328  * eval: (c-set-style "gnu")
329  * End:
330  */
static uword unformat_get_input(unformat_input_t *input)
Definition: format.h:190
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
u8 * format_ascii_bytes(u8 *s, va_list *va)
Definition: std-formats.c:74
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
static void unformat_put_input(unformat_input_t *input)
Definition: format.h:203
u8 * format_hexdump(u8 *s, va_list *args)
Definition: std-formats.c:281
static uword min_log2(uword x)
Definition: clib.h:183
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:559
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
u8 * format_hex_bytes(u8 *s, va_list *va)
Definition: std-formats.c:84
static uword format_get_indent(u8 *s)
Definition: format.h:72
#define v
Definition: acl.c:314
u8 * format_memory_size(u8 *s, va_list *va)
Definition: std-formats.c:193
svmdb_client_t * c
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
u8 * format_vec32(u8 *s, va_list *va)
Definition: std-formats.c:43
unsigned int u32
Definition: types.h:88
u64 size
Definition: vhost-user.h:74
u8 * format_c_identifier(u8 *s, va_list *va)
Definition: std-formats.c:258
u64 uword
Definition: types.h:112
u8 * format_vec_uword(u8 *s, va_list *va)
Definition: std-formats.c:58
uword unformat_memory_size(unformat_input_t *input, va_list *va)
Definition: std-formats.c:222
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
double f64
Definition: types.h:142
unsigned char u8
Definition: types.h:56
u8 * format_time_interval(u8 *s, va_list *args)
Definition: std-formats.c:122
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static uword clib_mem_is_vec(void *v)
Predicate function, says whether the supplied vector is a clib heap object.
Definition: vec.h:165
struct _unformat_input_t unformat_input_t