FD.io VPP  v17.07.01-10-g3be13f0
Vector Packet Processing
main_stub.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 #include <vlib/vlib.h>
16 #include <vlib/unix/unix.h>
17 #include <math.h>
18 
19 int
20 main (int argc, char *argv[])
21 {
22  return vlib_unix_main (argc, argv);
23 }
24 
25 static clib_error_t *
27 {
28  clib_error_t *error;
29 
30  if ((error =
31  unix_physmem_init (vm, /* fail_if_physical_memory_not_present */ 0)))
32  return error;
33 
34  if ((error = vlib_call_init_function (vm, unix_cli_init)))
35  return error;
36 
37  return error;
38 }
39 
41 
42 #if 0
43 /* Node test code. */
44 typedef struct
45 {
46  int scalar;
47  int vector[0];
48 } my_frame_t;
49 
50 static u8 *
51 format_my_node_frame (u8 * s, va_list * va)
52 {
53  vlib_frame_t *f = va_arg (*va, vlib_frame_t *);
54  my_frame_t *g = vlib_frame_args (f);
55  int i;
56 
57  s = format (s, "scalar %d, vector { ", g->scalar);
58  for (i = 0; i < f->n_vectors; i++)
59  s = format (s, "%d, ", g->vector[i]);
60  s = format (s, " }");
61 
62  return s;
63 }
64 
65 static uword
66 my_func (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
67 {
68  vlib_node_t *node;
69  my_frame_t *y;
70  u32 i, n_left = 0;
71  static int serial;
72  int verbose;
73 
74  node = vlib_get_node (vm, rt->node_index);
75 
76  verbose = 0;
77 
78  if (verbose && f)
79  vlib_cli_output (vm, "%v: call frame %p %U", node->name,
80  f, format_my_node_frame, f);
81 
82  if (rt->n_next_nodes > 0)
83  {
84  vlib_frame_t *next = vlib_get_next_frame (vm, rt, /* next index */ 0);
85  n_left = VLIB_FRAME_SIZE - next->n_vectors;
86  y = vlib_frame_args (next);
87  y->scalar = serial++;
88  }
89  else
90  y = 0;
91 
92  for (i = 0; i < 5; i++)
93  {
94  if (y)
95  {
96  ASSERT (n_left > 0);
97  n_left--;
98  y->vector[i] = y->scalar + i;
99  }
100  }
101  if (y)
102  vlib_put_next_frame (vm, rt, /* next index */ 0, n_left);
103 
104  if (verbose)
105  vlib_cli_output (vm, "%v: return frame %p", node->name, f);
106 
107  return i;
108 }
109 
110 /* *INDENT-OFF* */
111 VLIB_REGISTER_NODE (my_node1,static) = {
112  .function = my_func,
113  .type = VLIB_NODE_TYPE_INPUT,
114  .name = "my-node1",
115  .scalar_size = sizeof (my_frame_t),
116  .vector_size = STRUCT_SIZE_OF (my_frame_t, vector[0]),
117  .n_next_nodes = 1,
118  .next_nodes = {
119  [0] = "my-node2",
120  },
121 };
122 /* *INDENT-ON* */
123 
124 /* *INDENT-OFF* */
125 VLIB_REGISTER_NODE (my_node2,static) = {
126  .function = my_func,
127  .name = "my-node2",
128  .scalar_size = sizeof (my_frame_t),
129  .vector_size = STRUCT_SIZE_OF (my_frame_t, vector[0]),
130 };
131 /* *INDENT-ON* */
132 
133 #endif
134 
135 #if 0
136 
137 typedef enum
138 {
139  MY_EVENT_TYPE1,
140  MY_EVENT_TYPE2,
141 } my_process_completion_type_t;
142 
143 typedef struct
144 {
145  int a;
146  f64 b;
147 } my_process_event_data_t;
148 
149 static u8 *
150 format_my_process_event_data (u8 * s, va_list * va)
151 {
152  my_process_event_data_t *d = va_arg (*va, my_process_event_data_t *);
153  return format (s, "{ a %d b %.6f}", d->a, d->b);
154 }
155 
156 static uword
157 my_proc (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
158 {
159  vlib_node_t *node;
160  u32 i;
161 
162  node = vlib_get_node (vm, rt->node_index);
163 
164  vlib_cli_output (vm, "%v: call frame %p", node->name, f);
165 
166  for (i = 0; i < 5; i++)
167  {
168  vlib_cli_output (vm, "%v: %d", node->name, i);
169  vlib_process_suspend (vm, 1e0 /* secs */ );
170  }
171 
172  vlib_cli_output (vm, "%v: return frame %p", node->name, f);
173 
174  if (0)
175  {
176  uword n_events_seen, type, *data = 0;
177 
178  for (n_events_seen = 0; n_events_seen < 2;)
179  {
181  type = vlib_process_get_events (vm, &data);
182  n_events_seen += vec_len (data);
183  vlib_cli_output (vm, "%U %v: completion #%d type %d data 0x%wx",
184  format_time_interval, "h:m:s:u",
185  vlib_time_now (vm), node->name, i, type, data[0]);
186  _vec_len (data) = 0;
187  }
188 
189  vec_free (data);
190  }
191  else
192  {
193  uword n_events_seen, i, type;
194  my_process_event_data_t *data;
195  for (n_events_seen = 0; n_events_seen < 2;)
196  {
198  data = vlib_process_get_event_data (vm, &type);
199  vec_foreach_index (i, data)
200  {
201  vlib_cli_output (vm, "%U event type %d data %U",
202  format_time_interval, "h:m:s:u",
203  vlib_time_now (vm), type,
204  format_my_process_event_data, data);
205  }
206  n_events_seen += vec_len (data);
207  vlib_process_put_event_data (vm, data);
208  }
209  }
210 
211  return i;
212 }
213 
214 /* *INDENT-OFF* */
215 VLIB_REGISTER_NODE (my_proc_node,static) = {
216  .function = my_proc,
217  .type = VLIB_NODE_TYPE_PROCESS,
218  .name = "my-proc",
219 };
220 /* *INDENT-ON* */
221 
222 static uword
223 my_proc_input (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
224 {
225  static int i;
226 
227  if (i++ < 2)
228  {
229  if (0)
230  vlib_process_signal_event (vm, my_proc_node.index,
231  i == 1 ? MY_EVENT_TYPE1 : MY_EVENT_TYPE2,
232  0x12340000 + i);
233  else
234  {
235  my_process_event_data_t *d;
236  f64 dt = 5;
238  i * dt,
239  my_proc_node.index,
240  i ==
241  1 ? MY_EVENT_TYPE1 :
242  MY_EVENT_TYPE2,
243  1 /* elts */ ,
244  sizeof (d[0]));
245  d->a = i;
246  d->b = vlib_time_now (vm);
247  }
248  }
249  else
250  vlib_node_set_state (vm, rt->node_index, VLIB_NODE_STATE_DISABLED);
251 
252  return 0;
253 }
254 
255 /* *INDENT-OFF* */
256 VLIB_REGISTER_NODE (my_proc_input_node,static) = {
257  .function = my_proc_input,
258  .type = VLIB_NODE_TYPE_INPUT,
259  .name = "my-proc-input",
260 };
261 /* *INDENT-ON* */
262 
263 static uword
264 _unformat_farith (unformat_input_t * i, va_list * args)
265 {
266  u32 prec = va_arg (*args, u32);
267  f64 *result = va_arg (*args, f64 *);
268  f64 tmp[2];
269 
270  /* Binary operations in from lowest to highest precedence. */
271  char *binops[] = {
272  "+%U", "-%U", "/%U", "*%U", "^%U",
273  };
274 
275  if (prec <= ARRAY_LEN (binops) - 1
276  && unformat_user (i, _unformat_farith, prec + 1, &tmp[0]))
277  {
278  int p;
279  for (p = prec; p < ARRAY_LEN (binops); p++)
280  {
281  if (unformat (i, binops[p], _unformat_farith, prec + 0, &tmp[1]))
282  {
283  switch (binops[p][0])
284  {
285  case '+':
286  result[0] = tmp[0] + tmp[1];
287  break;
288  case '-':
289  result[0] = tmp[0] - tmp[1];
290  break;
291  case '/':
292  result[0] = tmp[0] / tmp[1];
293  break;
294  case '*':
295  result[0] = tmp[0] * tmp[1];
296  break;
297  case '^':
298  result[0] = pow (tmp[0], tmp[1]);
299  break;
300  default:
301  abort ();
302  }
303  return 1;
304  }
305  }
306  result[0] = tmp[0];
307  return 1;
308  }
309 
310  else if (unformat (i, "-%U", _unformat_farith, prec + 0, &tmp[0]))
311  {
312  result[0] = -tmp[0];
313  return 1;
314  }
315 
316  else if (unformat (i, "(%U)", _unformat_farith, 0, &tmp[0]))
317  {
318  result[0] = tmp[0];
319  return 1;
320  }
321 
322  else if (unformat (i, "%f", result))
323  return 1;
324 
325  else
326  return 0;
327 }
328 
329 static uword
330 unformat_farith (unformat_input_t * i, va_list * args)
331 {
332  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
333  f64 *result = va_arg (*args, f64 *);
334  return unformat_user (i, _unformat_farith, 0, result);
335 }
336 
337 static uword
338 unformat_integer (unformat_input_t * i, va_list * args)
339 {
340  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
341  u32 *data = va_arg (*args, u32 *);
342  return unformat (i, "%d", data);
343 }
344 
345 static VLIB_CLI_PARSE_RULE (my_parse_rule1) =
346 {
347 .name = "decimal_integer",.short_help =
348  "a decimal integer",.unformat_function = unformat_integer,.data_size =
349  sizeof (u32),};
350 
351 static VLIB_CLI_PARSE_RULE (my_parse_rule2) =
352 {
353 .name = "float_expression",.short_help =
354  "floating point expression",.unformat_function =
355  unformat_farith,.data_size = sizeof (f64),};
356 
357 static clib_error_t *
358 bar_command (vlib_main_t * vm,
359  unformat_input_t * input, vlib_cli_command_t * cmd)
360 {
361  switch (cmd->function_arg)
362  {
363  case 2:
364  {
365  u32 *d, *e;
366  d = vlib_cli_get_parse_rule_result (vm, 0);
367  e = vlib_cli_get_parse_rule_result (vm, 1);
368  vlib_cli_output (vm, "bar2 %d %d", d[0], e[0]);
369  break;
370  }
371 
372  case 1:
373  {
374  u32 *d = vlib_cli_get_parse_rule_result (vm, 0);
375  vlib_cli_output (vm, "bar1 %d", d[0]);
376  break;
377  }
378 
379  case 3:
380  {
381  f64 *d = vlib_cli_get_parse_rule_result (vm, 0);
382  vlib_cli_output (vm, "expr %.6f", d[0]);
383  }
384  }
385 
386  return 0;
387 }
388 
389 /* *INDENT-OFF* */
390 VLIB_CLI_COMMAND (bar_command2, static) = {
391  .path = "bar %decimal_integer",
392  .short_help = "bar1 command",
393  .function = bar_command,
394  .function_arg = 1,
395 };
396 VLIB_CLI_COMMAND (bar_command1, static) = {
397  .path = "bar %decimal_integer %decimal_integer",
398  .short_help = "bar2 command",
399  .function = bar_command,
400  .function_arg = 2,
401 };
402 VLIB_CLI_COMMAND (bar_command3, static) = {
403  .path = "zap %float_expression",
404  .short_help = "bar3 command",
405  .function = bar_command,
406  .function_arg = 3,
407 };
408 /* *INDENT-ON* */
409 
410 #endif
411 
412 /*
413  * fd.io coding-style-patch-verification: ON
414  *
415  * Local Variables:
416  * eval: (c-set-style "gnu")
417  * End:
418  */
#define vec_foreach_index(var, v)
Iterate over vector indices.
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define CLIB_UNUSED(x)
Definition: clib.h:79
#define VLIB_CLI_PARSE_RULE(x)
Definition: cli.h:166
a
Definition: bitmap.h:516
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:619
static void * vlib_cli_get_parse_rule_result(vlib_main_t *vm, uword index)
Definition: cli_funcs.h:44
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:192
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:459
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
add_epi add_epi sub_epi sub_epi adds_epu subs_epu i16x8 y
Definition: vector_sse2.h:293
int main(int argc, char *argv[])
Definition: main_stub.c:20
static clib_error_t * unix_cli_init(vlib_main_t *vm)
Definition: cli.c:3143
static uword unformat_integer(unformat_input_t *input, va_list *va, uword base, uword is_signed, uword data_bytes)
Definition: unformat.c:424
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:448
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:542
#define vlib_call_init_function(vm, x)
Definition: init.h:162
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:946
struct _unformat_input_t unformat_input_t
#define VLIB_FRAME_SIZE
Definition: node.h:329
u32 node_index
Node index.
Definition: node.h:441
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:366
u8 * name
Definition: node.h:222
uword function_arg
Definition: cli.h:105
static void * vlib_process_signal_event_at_time(vlib_main_t *vm, f64 dt, uword node_index, uword type_opaque, uword n_data_elts, uword n_data_elt_bytes)
Definition: node_funcs.h:870
u16 n_vectors
Definition: node.h:345
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
#define ARRAY_LEN(x)
Definition: clib.h:59
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static void * vlib_frame_args(vlib_frame_t *f)
Get pointer to frame scalar data.
Definition: node_funcs.h:286
static void vlib_node_set_state(vlib_main_t *vm, u32 node_index, vlib_node_state_t new_state)
Set node dispatch state.
Definition: node_funcs.h:146
u64 uword
Definition: types.h:112
static void * vlib_process_get_event_data(vlib_main_t *vm, uword *return_event_type_opaque)
Definition: node_funcs.h:489
#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
clib_error_t * unix_physmem_init(vlib_main_t *vm, int physical_memory_required)
Definition: physmem.c:209
u8 * format_time_interval(u8 *s, va_list *args)
Definition: std-formats.c:122
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:144
static void vlib_process_put_event_data(vlib_main_t *vm, void *event_data)
Definition: node_funcs.h:526
#define STRUCT_SIZE_OF(t, f)
Definition: clib.h:64
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
static clib_error_t * main_stub_init(vlib_main_t *vm)
Definition: main_stub.c:26
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
int vlib_unix_main(int argc, char *argv[])
Definition: main.c:538