aboutsummaryrefslogtreecommitdiffstats
path: root/src/vat/vat.h
blob: 32de90e44117665bf8ecfa2df227c5049781e489 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
/*
 * Copyright (c) 2015 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __included_vat_h__
#define __included_vat_h__

#define _GNU_SOURCE
#include <stdio.h>
#include <setjmp.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <vppinfra/clib.h>
#include <vppinfra/format.h>
#include <vppinfra/error.h>
#include <vppinfra/elog.h>
#include <vppinfra/time.h>
#include <vppinfra/macros.h>
#include <vppinfra/socket.h>
#include <vnet/vnet.h>
#include <vlib/vlib.h>
#include <vlib/unix/unix.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>

#include "vat/json_format.h"

#include <vlib/vlib.h>

typedef struct
{
  u8 *interface_name;
  u32 sw_if_index;
  /*
   * Subinterface ID. A number 0-N to uniquely identify this
   * subinterface under the super interface
   */
  u32 sub_id;

  /* Number of tags 0-2 */
  u8 sub_number_of_tags;
  u16 sub_outer_vlan_id;
  u16 sub_inner_vlan_id;

  union
  {
    u16 raw_flags;
    struct
    {
      u16 no_tags:1;
      u16 one_tag:1;
      u16 two_tags:1;
      /* 0 = dot1q, 1=dot1ad */
      u16 sub_dot1ad:1;
      u16 sub_exact_match:1;
      u16 sub_default:1;
      u16 sub_outer_vlan_id_any:1;
      u16 sub_inner_vlan_id_any:1;
    };
  };

  /* vlan tag rewrite */
  u32 vtr_op;
  u32 vtr_push_dot1q;
  u32 vtr_tag1;
  u32 vtr_tag2;
} sw_interface_subif_t;

typedef struct
{
  u8 ip[16];
  u8 prefix_length;
} ip_address_details_t;

typedef struct
{
  u8 present;
  ip_address_details_t *addr;
} ip_details_t;

typedef struct
{
  u64 packets;
  u64 bytes;
} interface_counter_t;

typedef struct
{
  struct in_addr address;
  u8 address_length;
  u64 packets;
  u64 bytes;
} ip4_fib_counter_t;

typedef struct
{
  struct in6_addr address;
  u8 address_length;
  u64 packets;
  u64 bytes;
} ip6_fib_counter_t;

typedef struct
{
  struct in_addr address;
  vnet_link_t linkt;
  u64 packets;
  u64 bytes;
} ip4_nbr_counter_t;

typedef struct
{
  struct in6_addr address;
  vnet_link_t linkt;
  u64 packets;
  u64 bytes;
} ip6_nbr_counter_t;

struct vat_registered_features_t;

typedef struct
{
  /* vpe input queue */
  svm_queue_t *vl_input_queue;

  /* interface name table */
  uword *sw_if_index_by_interface_name;

  /* subinterface table */
  sw_interface_subif_t *sw_if_subif_table;

  /* Graph node table */
  uword *graph_node_index_by_name;
  vlib_node_t ***graph_nodes;

  /* ip tables */
  ip_details_t *ip_details_by_sw_if_index[2];

  /* sw_if_index of currently processed interface */
  u32 current_sw_if_index;

  /* remember that we are dumping ipv6 */
  u8 is_ipv6;

  /* function table */
  uword *function_by_name;

  /* help strings */
  uword *help_by_name;

  /* macro table */
  clib_macro_main_t macro_main;

  /* Errors by number */
  uword *error_string_by_error_number;

  /* Main thread can spin (w/ timeout) here if needed */
  u32 async_mode;
  u32 async_errors;
  volatile u32 result_ready;
  volatile i32 retval;
  volatile u32 sw_if_index;
  volatile u8 *shmem_result;
  u8 *cmd_reply;

  /* our client index */
  u32 my_client_index;
  int client_index_invalid;

  /* Time is of the essence... */
  clib_time_t clib_time;

  /* Unwind (so we can quit) */
  jmp_buf jump_buf;
  int jump_buf_set;
  volatile int do_exit;

  /* temporary parse buffer */
  unformat_input_t *input;

  /* input buffer */
  u8 *inbuf;

  /* stdio input / output FILEs */
  FILE *ifp, *ofp;
  u8 *current_file;
  u32 input_line_number;

  /* exec mode toggle */
  int exec_mode;

  /* Regenerate the interface table */
  volatile int regenerate_interface_table;

  /* flag for JSON output format */
  u8 json_output;

  /* flag for interface event display */
  u8 interface_event_display;

  /* JSON tree used in composing dump api call results */
  vat_json_node_t json_tree;

  /* counters */
  u64 **simple_interface_counters;
  interface_counter_t **combined_interface_counters;
  ip4_fib_counter_t **ip4_fib_counters;
  u32 *ip4_fib_counters_vrf_id_by_index;
  ip6_fib_counter_t **ip6_fib_counters;
  u32 *ip6_fib_counters_vrf_id_by_index;
  ip4_nbr_counter_t **ip4_nbr_counters;
  ip6_nbr_counter_t **ip6_nbr_counters;

  ssvm_private_t stat_segment;
  clib_spinlock_t *stat_segment_lockp;

  socket_client_main_t *socket_client_main;
  u8 *socket_name;

  elog_main_t elog_main;

  struct vat_registered_features_t *feature_function_registrations;

  /* Convenience */
  vlib_main_t *vlib_main;
} vat_main_t;

extern vat_main_t vat_main;

void vat_suspend (vlib_main_t * vm, f64 interval);
f64 vat_time_now (vat_main_t * vam);
void errmsg (char *fmt, ...);
void vat_api_hookup (vat_main_t * vam);
int api_sw_interface_dump (vat_main_t * vam);
void do_one_file (vat_main_t * vam);
int exec (vat_main_t * vam);

/* Plugin API library functions */
extern char *vat_plugin_path;
extern char *vat_plugin_name_filter;
void vat_plugin_api_reference (void);
uword unformat_sw_if_index (unformat_input_t * input, va_list * args);
uword unformat_ip4_address (unformat_input_t * input, va_list * args);
uword unformat_ethernet_address (unformat_input_t * input, va_list * args);
uword unformat_ethernet_type_host_byte_order (unformat_input_t * input,
					      va_list * args);
uword unformat_ip6_address (unformat_input_t * input, va_list * args);
u8 *format_ip4_address (u8 * s, va_list * args);
u8 *format_ip6_address (u8 * s, va_list * args);
u8 *format_ip46_address (u8 * s, va_list * args);
u8 *format_ethernet_address (u8 * s, va_list * args);

int vat_socket_connect (vat_main_t * vam);

#if VPP_API_TEST_BUILTIN
#define print api_cli_output
void api_cli_output (void *, const char *fmt, ...);
#else
#define print fformat_append_cr
void fformat_append_cr (FILE *, const char *fmt, ...);
#endif


typedef clib_error_t *(vat_feature_function_t) (vat_main_t * vam);
typedef struct vat_registered_features_t
{
  vat_feature_function_t *function;
  struct vat_registered_features_t *next;
} vat_registered_features_t;


#define VAT_REGISTER_FEATURE_FUNCTION(x)                               \
    vat_registered_features_t _vat_feature_function_##x;               \
static void __vlib_add_config_function_##x (void)                      \
    __attribute__((__constructor__)) ;                                 \
static void __vlib_add_config_function_##x (void)                      \
{                                                                      \
  vat_main_t * vam = &vat_main;                                                \
  _vat_feature_function_##x.next = vam->feature_function_registrations;        \
  vam->feature_function_registrations = &_vat_feature_function_##x;    \
}                                                                      \
 vat_registered_features_t _vat_feature_function_##x =		       \
   {								       \
    .function = x,						       \
   }


#endif /* __included_vat_h__ */

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */
an> */ always_inline uword clib_bitmap_set_no_check (uword * a, uword i, uword new_value) { uword i0 = i / BITS (a[0]); uword i1 = i % BITS (a[0]); uword bit = (uword) 1 << i1; uword ai, old_value; /* Removed ASSERT since uword * a may not be a vector. */ /* ASSERT (i0 < vec_len (a)); */ ai = a[i0]; old_value = (ai & bit) != 0; ai &= ~bit; ai |= ((uword) (new_value != 0)) << i1; a[i0] = ai; return old_value; } /** Sets the ith bit of a bitmap to new_value Removes trailing zeros from the bitmap @param ai - pointer to the bitmap @param i - the bit position to interrogate @param value - new value for the bit @returns the old value of the bit */ always_inline uword * clib_bitmap_set (uword * ai, uword i, uword value) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword a; /* Check for writing a zero to beyond end of bitmap. */ if (value == 0 && i0 >= vec_len (ai)) return ai; /* Implied trailing zeros. */ clib_bitmap_vec_validate (ai, i0); a = ai[i0]; a &= ~((uword) 1 << i1); a |= ((uword) (value != 0)) << i1; ai[i0] = a; /* If bits have been cleared, test for zero. */ if (a == 0) ai = _clib_bitmap_remove_trailing_zeros (ai); return ai; } /** Gets the ith bit value from a bitmap @param ai - pointer to the bitmap @param i - the bit position to interrogate @returns the indicated bit value */ always_inline uword clib_bitmap_get (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); return i0 < vec_len (ai) && 0 != ((ai[i0] >> i1) & 1); } /** Gets the ith bit value from a bitmap Does not sanity-check the bit position. Be careful. @param ai - pointer to the bitmap @param i - the bit position to interrogate @returns the indicated bit value, or garbage if the bit position is out of range. */ always_inline uword clib_bitmap_get_no_check (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); return 0 != ((ai[i0] >> i1) & 1); } always_inline uword clib_bitmap_get_multiple_no_check (uword * ai, uword i, uword n_bits) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); ASSERT (i1 + n_bits <= BITS (uword)); return 0 != ((ai[i0] >> i1) & pow2_mask (n_bits)); } /** Gets the ith through ith + n_bits bit values from a bitmap @param bitmap - pointer to the bitmap @param i - the first bit position to retrieve @param n_bits - the number of bit positions to retrieve @returns the indicated range of bits */ always_inline uword clib_bitmap_get_multiple (uword * bitmap, uword i, uword n_bits) { uword i0, i1, result; uword l = vec_len (bitmap); ASSERT (n_bits <= BITS (result)); i0 = i / BITS (bitmap[0]); i1 = i % BITS (bitmap[0]); /* Check first word. */ result = 0; if (i0 < l) { result |= (bitmap[i0] >> i1); if (n_bits < BITS (bitmap[0])) result &= (((uword) 1 << n_bits) - 1); } /* Check for overlap into next word. */ i0++; if (i1 + n_bits > BITS (bitmap[0]) && i0 < l) { n_bits -= BITS (bitmap[0]) - i1; result |= (bitmap[i0] & (((uword) 1 << n_bits) - 1)) << (BITS (bitmap[0]) - i1); } return result; } /** sets the ith through ith + n_bits bits in a bitmap @param bitmap - pointer to the bitmap @param i - the first bit position to retrieve @param value - the values to set @param n_bits - the number of bit positions to set @returns a pointer to the updated bitmap, which may expand and move */ always_inline uword * clib_bitmap_set_multiple (uword * bitmap, uword i, uword value, uword n_bits) { uword i0, i1, l, t, m; ASSERT (n_bits <= BITS (value)); i0 = i / BITS (bitmap[0]); i1 = i % BITS (bitmap[0]); /* Allocate bitmap. */ clib_bitmap_vec_validate (bitmap, (i + n_bits) / BITS (bitmap[0])); l = vec_len (bitmap); m = ~0; if (n_bits < BITS (value)) m = (((uword) 1 << n_bits) - 1); value &= m; /* Insert into first word. */ t = bitmap[i0]; t &= ~(m << i1); t |= value << i1; bitmap[i0] = t; /* Insert into second word. */ i0++; if (i1 + n_bits > BITS (bitmap[0]) && i0 < l) { t = BITS (bitmap[0]) - i1; value >>= t; n_bits -= t; t = bitmap[i0]; m = ((uword) 1 << n_bits) - 1; t &= ~m; t |= value; bitmap[i0] = t; } return bitmap; } always_inline uword * clfib_bitmap_set_region (uword * bitmap, uword i, uword value, uword n_bits) { uword a0, a1, b0; uword i_end, mask; a0 = i / BITS (bitmap[0]); a1 = i % BITS (bitmap[0]); i_end = i + n_bits; b0 = i_end / BITS (bitmap[0]); clib_bitmap_vec_validate (bitmap, b0); /* First word. */ mask = n_bits < BITS (bitmap[0]) ? pow2_mask (n_bits) : ~0; mask <<= a1; if (value) bitmap[a0] |= mask; else bitmap[a0] &= ~mask; for (a0++; a0 < b0; a0++) bitmap[a0] = value ? ~0 : 0; if (a0 == b0) { word n_bits_left = n_bits - (BITS (bitmap[0]) - a1); mask = pow2_mask (n_bits_left); if (value) bitmap[a0] |= mask; else bitmap[a0] &= ~mask; } return bitmap; } /** Macro to iterate across set bits in a bitmap @param i - the current set bit @param ai - the bitmap @param body - the expression to evaluate for each set bit */ #define clib_bitmap_foreach(i,ai,body) \ do { \ uword __bitmap_i, __bitmap_ai, __bitmap_len, __bitmap_first_set; \ __bitmap_len = vec_len ((ai)); \ for (__bitmap_i = 0; __bitmap_i < __bitmap_len; __bitmap_i++) \ { \ __bitmap_ai = (ai)[__bitmap_i]; \ while (__bitmap_ai != 0) \ { \ __bitmap_first_set = first_set (__bitmap_ai); \ (i) = (__bitmap_i * BITS ((ai)[0]) \ + min_log2 (__bitmap_first_set)); \ do { body; } while (0); \ __bitmap_ai ^= __bitmap_first_set; \ } \ } \ } while (0) /** Return the lowest numbered set bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered set bit, or ~0 if the entire bitmap is zero */ always_inline uword clib_bitmap_first_set (uword * ai) { uword i; for (i = 0; i < vec_len (ai); i++) { uword x = ai[i]; if (x != 0) return i * BITS (ai[0]) + log2_first_set (x); } return ~0; } /** Return the higest numbered set bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered set bit, or ~0 if the entire bitmap is zero */ always_inline uword clib_bitmap_last_set (uword * ai) { uword i; for (i = vec_len (ai); i > 0; i--) { uword x = ai[i - 1]; if (x != 0) { uword first_bit; count_leading_zeros (first_bit, x); return (i) * BITS (ai[0]) - first_bit - 1; } } return ~0; } /** Return the lowest numbered clear bit in a bitmap @param ai - pointer to the bitmap @returns lowest numbered clear bit */ always_inline uword clib_bitmap_first_clear (uword * ai) { uword i; for (i = 0; i < vec_len (ai); i++) { uword x = ~ai[i]; if (x != 0) return i * BITS (ai[0]) + log2_first_set (x); } return i * BITS (ai[0]); } /** Return the number of set bits in a bitmap @param ai - pointer to the bitmap @returns the number of set bits in the bitmap */ always_inline uword clib_bitmap_count_set_bits (uword * ai) { uword i; uword n_set = 0; for (i = 0; i < vec_len (ai); i++) n_set += count_set_bits (ai[i]); return n_set; } /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai and bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_and (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai & ~bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_andnot (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai & ~bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_or (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai or bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_or (uword * ai, uword * bi); /** Logical operator across two bitmaps @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns ai = ai xor bi. ai is modified, bi is not modified */ always_inline uword *clib_bitmap_xor (uword * ai, uword * bi); /* ALU function definition macro for functions taking two bitmaps. */ #define _(name, body, check_zero) \ always_inline uword * \ clib_bitmap_##name (uword * ai, uword * bi) \ { \ uword i, a, b, bi_len, n_trailing_zeros; \ \ n_trailing_zeros = 0; \ bi_len = vec_len (bi); \ if (bi_len > 0) \ clib_bitmap_vec_validate (ai, bi_len - 1); \ for (i = 0; i < vec_len (ai); i++) \ { \ a = ai[i]; \ b = i < bi_len ? bi[i] : 0; \ do { body; } while (0); \ ai[i] = a; \ if (check_zero) \ n_trailing_zeros = a ? 0 : (n_trailing_zeros + 1); \ } \ if (check_zero) \ _vec_len (ai) -= n_trailing_zeros; \ return ai; \ } /* ALU functions: */ _(and, a = a & b, 1) _(andnot, a = a & ~b, 1) _(or, a = a | b, 0) _(xor, a = a ^ b, 1) #undef _ /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai and bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_and (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai & ~bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_andnot (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai or bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_or (uword * ai, uword * bi); /** Logical operator across two bitmaps which duplicates the first bitmap @param ai - pointer to the destination bitmap @param bi - pointer to the source bitmap @returns aiDup = ai xor bi. Neither ai nor bi are modified */ always_inline uword * clib_bitmap_dup_xor (uword * ai, uword * bi); #define _(name) \ always_inline uword * \ clib_bitmap_dup_##name (uword * ai, uword * bi) \ { return clib_bitmap_##name (clib_bitmap_dup (ai), bi); } _(and); _(andnot); _(or); _(xor); #undef _ /* ALU function definition macro for functions taking one bitmap and an immediate. */ #define _(name, body, check_zero) \ always_inline uword * \ clib_bitmap_##name (uword * ai, uword i) \ { \ uword i0 = i / BITS (ai[0]); \ uword i1 = i % BITS (ai[0]); \ uword a, b; \ clib_bitmap_vec_validate (ai, i0); \ a = ai[i0]; \ b = (uword) 1 << i1; \ do { body; } while (0); \ ai[i0] = a; \ if (check_zero && a == 0) \ ai = _clib_bitmap_remove_trailing_zeros (ai); \ return ai; \ } /* ALU functions immediate: */ _(andi, a = a & b, 1) _(andnoti, a = a & ~b, 1) _(ori, a = a | b, 0) _(xori, a = a ^ b, 1) #undef _ /** Return a random bitmap of the requested length @param ai - pointer to the destination bitmap @param n_bits - number of bits to allocate @param [in,out] seed - pointer to the random number seed @returns a reasonably random bitmap based. See random.h. */ always_inline uword * clib_bitmap_random (uword * ai, uword n_bits, u32 * seed) { vec_reset_length (ai); if (n_bits > 0) { uword i = n_bits - 1; uword i0, i1; uword log2_rand_max; log2_rand_max = min_log2 (random_u32_max ()); i0 = i / BITS (ai[0]); i1 = i % BITS (ai[0]); clib_bitmap_vec_validate (ai, i0); for (i = 0; i <= i0; i++) { uword n; for (n = 0; n < BITS (ai[i]); n += log2_rand_max) ai[i] |= random_u32 (seed) << n; } if (i1 + 1 < BITS (ai[0])) ai[i0] &= (((uword) 1 << (i1 + 1)) - 1); } return ai; } /** Return the next set bit in a bitmap starting at bit i @param ai - pointer to the bitmap @param i - first bit position to test @returns first set bit position at or after i, ~0 if no further set bits are found */ always_inline uword clib_bitmap_next_set (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword t; if (i0 < vec_len (ai)) { t = (ai[i0] >> i1) << i1; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); for (i0++; i0 < vec_len (ai); i0++) { t = ai[i0]; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); } } return ~0; } /** Return the next clear bit in a bitmap starting at bit i @param ai - pointer to the bitmap @param i - first bit position to test @returns first clear bit position at or after i */ always_inline uword clib_bitmap_next_clear (uword * ai, uword i) { uword i0 = i / BITS (ai[0]); uword i1 = i % BITS (ai[0]); uword t; if (i0 < vec_len (ai)) { t = (~ai[i0] >> i1) << i1; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); for (i0++; i0 < vec_len (ai); i0++) { t = ~ai[i0]; if (t) return log2_first_set (t) + i0 * BITS (ai[0]); } } return i; } /** unformat a list of bit ranges into a bitmap (eg "0-3,5-7,11" ) uword * bitmap; rv = unformat ("%U", unformat_bitmap_list, &bitmap); Standard unformat_function_t arguments @param input - pointer an unformat_input_t @param va - varargs list comprising a single uword ** @returns 1 on success, 0 on failure */ static inline uword unformat_bitmap_list (unformat_input_t * input, va_list * va) { uword **bitmap_return = va_arg (*va, uword **); uword *bitmap = 0; u32 a, b; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { int i; if (unformat (input, "%u-%u,", &a, &b)) ; else if (unformat (input, "%u,", &a)) b = a; else if (unformat (input, "%u-%u", &a, &b)) ; else if (unformat (input, "%u", &a)) b = a; else if (bitmap) { unformat_put_input (input); break; } else goto error; if (b < a) goto error; for (i = a; i <= b; i++) bitmap = clib_bitmap_set (bitmap, i, 1); } *bitmap_return = bitmap; return 1; error: clib_bitmap_free (bitmap); return 0; } /** Format a bitmap as a string of hex bytes uword * bitmap; s = format ("%U", format_bitmap_hex, bitmap); Standard format_function_t arguments @param s - string under construction @param args - varargs list comprising a single uword * @returns string under construction */ static inline u8 * format_bitmap_hex (u8 * s, va_list * args) { uword *bitmap = va_arg (*args, uword *); int i, is_trailing_zero = 1; if (!bitmap) return format (s, "0"); i = vec_bytes (bitmap) * 2; while (i > 0) { u8 x = clib_bitmap_get_multiple (bitmap, --i * 4, 4); if (x && is_trailing_zero) is_trailing_zero = 0; if (x || !is_trailing_zero) s = format (s, "%x", x); } return s; } #endif /* included_clib_bitmap_h */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */