FD.io VPP  v19.01.3-6-g70449b9b9
Vector Packet Processing
main.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2017 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17 
18 #include <stdlib.h>
19 #include <stdint.h>
20 #include <net/if.h>
21 #include <sys/types.h>
22 #include <fcntl.h>
23 #include <sys/ioctl.h>
24 #include <sys/socket.h>
25 #include <sys/un.h>
26 #include <sys/uio.h>
27 #include <sys/mman.h>
28 #include <sys/prctl.h>
29 #include <inttypes.h>
30 #include <string.h>
31 #include <stdio.h>
32 #include <netdb.h>
33 #include <linux/ip.h>
34 #include <linux/icmp.h>
35 #include <arpa/inet.h>
36 #include <stdlib.h>
37 #include <netinet/if_ether.h>
38 #include <net/if_arp.h>
39 #include <asm/byteorder.h>
40 #include <byteswap.h>
41 #include <string.h>
42 #include <sys/epoll.h>
43 #include <errno.h>
44 #include <unistd.h>
45 #include <signal.h>
46 
47 #include <time.h>
48 
49 #include <libmemif.h>
50 #include <icmp_proto.h>
51 
52 #define APP_NAME "ICMP_Responder"
53 #define IF_NAME "memif_connection"
54 
55 #define HEADROOM 0x80 /* 128b */
56 #define ENCAP 0x60
57 
58 #ifdef ICMP_DBG
59 #define DBG(...) do { \
60  printf (APP_NAME":%s:%d: ", __func__, __LINE__); \
61  printf (__VA_ARGS__); \
62  printf ("\n"); \
63  } while (0)
64 #define LOG(...) do { \
65  if (enable_log) { \
66  dprintf (out_fd, __VA_ARGS__); \
67  dprintf (out_fd, "\n"); \
68  } \
69  } while (0)
70 #define LOG_FILE "/tmp/memif_time_test.txt"
71 #else
72 #define DBG(...)
73 #define LOG(...)
74 #endif
75 
76 #define INFO(...) do { \
77  printf ("INFO: "__VA_ARGS__); \
78  printf ("\n"); \
79  } while (0)
80 
81 
82 /* maximum tx/rx memif buffers */
83 #define MAX_MEMIF_BUFS 256
84 #define MAX_CONNS 50
85 
86 int epfd;
87 int out_fd;
88 uint8_t enable_log;
89 
90 typedef struct
91 {
92  uint16_t index;
93  /* memif conenction handle */
95  /* buffers */
97  /* allocated tx buffers counter */
98  /* number of tx buffers pointing to shared memory */
99  uint16_t tx_buf_num;
100  /* allcoated rx buffers counter */
101  /* number of rx buffers pointing to shared memory */
102  uint16_t rx_buf_num;
103  /* interface ip address */
104  uint8_t ip_addr[4];
105  uint64_t tx_counter, rx_counter, tx_err_counter;
106  uint64_t t_sec, t_nsec;
108 
109 typedef struct
110 {
111  uint16_t index;
113  uint64_t packet_count;
114  uint16_t sequence;
115  uint64_t tx;
116  uint8_t ip_daddr[4];
117  uint8_t hw_daddr[6];
118  struct timespec *start, end;
119 } icmpr_flow_t;
120 
121 memif_connection_t memif_connection[MAX_CONNS];
124 
125 /* print details for all memif connections */
126 static void
128 {
129  memif_details_t md;
130  ssize_t buflen;
131  char *buf;
132  int err, i, e;
133  buflen = 2048;
134  buf = malloc (buflen);
135  printf ("MEMIF DETAILS\n");
136  printf ("==============================\n");
137  for (i = 0; i < MAX_CONNS; i++)
138  {
139  memif_connection_t *c = &memif_connection[i];
140 
141  memset (&md, 0, sizeof (md));
142  memset (buf, 0, buflen);
143 
144  err = memif_get_details (c->conn, &md, buf, buflen);
145  if (err != MEMIF_ERR_SUCCESS)
146  {
147  if (err != MEMIF_ERR_NOCONN)
148  INFO ("%s", memif_strerror (err));
149  continue;
150  }
151 
152  printf ("interface index: %d\n", i);
153 
154  printf ("\tinterface ip: %u.%u.%u.%u\n",
155  c->ip_addr[0], c->ip_addr[1], c->ip_addr[2], c->ip_addr[3]);
156  printf ("\tinterface name: %s\n", (char *) md.if_name);
157  printf ("\tapp name: %s\n", (char *) md.inst_name);
158  printf ("\tremote interface name: %s\n", (char *) md.remote_if_name);
159  printf ("\tremote app name: %s\n", (char *) md.remote_inst_name);
160  printf ("\tid: %u\n", md.id);
161  printf ("\tsecret: %s\n", (char *) md.secret);
162  printf ("\trole: ");
163  if (md.role)
164  printf ("slave\n");
165  else
166  printf ("master\n");
167  printf ("\tmode: ");
168  switch (md.mode)
169  {
170  case 0:
171  printf ("ethernet\n");
172  break;
173  case 1:
174  printf ("ip\n");
175  break;
176  case 2:
177  printf ("punt/inject\n");
178  break;
179  default:
180  printf ("unknown\n");
181  break;
182  }
183  printf ("\tsocket filename: %s\n", (char *) md.socket_filename);
184  printf ("\trx queues:\n");
185  for (e = 0; e < md.rx_queues_num; e++)
186  {
187  printf ("\t\tqueue id: %u\n", md.rx_queues[e].qid);
188  printf ("\t\tring size: %u\n", md.rx_queues[e].ring_size);
189  printf ("\t\tring rx mode: %s\n",
190  md.rx_queues[e].flags ? "polling" : "interrupt");
191  printf ("\t\tring head: %u\n", md.rx_queues[e].head);
192  printf ("\t\tring tail: %u\n", md.rx_queues[e].tail);
193  printf ("\t\tbuffer size: %u\n", md.rx_queues[e].buffer_size);
194  }
195  printf ("\ttx queues:\n");
196  for (e = 0; e < md.tx_queues_num; e++)
197  {
198  printf ("\t\tqueue id: %u\n", md.tx_queues[e].qid);
199  printf ("\t\tring size: %u\n", md.tx_queues[e].ring_size);
200  printf ("\t\tring rx mode: %s\n",
201  md.tx_queues[e].flags ? "polling" : "interrupt");
202  printf ("\t\tring head: %u\n", md.tx_queues[e].head);
203  printf ("\t\tring tail: %u\n", md.tx_queues[e].tail);
204  printf ("\t\tbuffer size: %u\n", md.tx_queues[e].buffer_size);
205  }
206  printf ("\tlink: ");
207  if (md.link_up_down)
208  printf ("up\n");
209  else
210  printf ("down\n");
211  }
212  free (buf);
213 }
214 
215 int
216 add_epoll_fd (int fd, uint32_t events)
217 {
218  if (fd < 0)
219  {
220  DBG ("invalid fd %d", fd);
221  return -1;
222  }
223  struct epoll_event evt;
224  memset (&evt, 0, sizeof (evt));
225  evt.events = events;
226  evt.data.fd = fd;
227  if (epoll_ctl (epfd, EPOLL_CTL_ADD, fd, &evt) < 0)
228  {
229  DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
230  return -1;
231  }
232  DBG ("fd %d added to epoll", fd);
233  return 0;
234 }
235 
236 int
237 mod_epoll_fd (int fd, uint32_t events)
238 {
239  if (fd < 0)
240  {
241  DBG ("invalid fd %d", fd);
242  return -1;
243  }
244  struct epoll_event evt;
245  memset (&evt, 0, sizeof (evt));
246  evt.events = events;
247  evt.data.fd = fd;
248  if (epoll_ctl (epfd, EPOLL_CTL_MOD, fd, &evt) < 0)
249  {
250  DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
251  return -1;
252  }
253  DBG ("fd %d moddified on epoll", fd);
254  return 0;
255 }
256 
257 int
258 del_epoll_fd (int fd)
259 {
260  if (fd < 0)
261  {
262  DBG ("invalid fd %d", fd);
263  return -1;
264  }
265  struct epoll_event evt;
266  memset (&evt, 0, sizeof (evt));
267  if (epoll_ctl (epfd, EPOLL_CTL_DEL, fd, &evt) < 0)
268  {
269  DBG ("epoll_ctl: %s fd %d", strerror (errno), fd);
270  return -1;
271  }
272  DBG ("fd %d removed from epoll", fd);
273  return 0;
274 }
275 
276 /* informs user about connected status. private_ctx is used by user to identify connection
277  (multiple connections WIP) */
278 int
279 on_connect (memif_conn_handle_t conn, void *private_ctx)
280 {
281  INFO ("memif connected!");
282  memif_refill_queue (conn, 0, -1, HEADROOM);
283  enable_log = 1;
284  return 0;
285 }
286 
287 /* informs user about disconnected status. private_ctx is used by user to identify connection
288  (multiple connections WIP) */
289 int
290 on_disconnect (memif_conn_handle_t conn, void *private_ctx)
291 {
292  INFO ("memif disconnected!");
293  return 0;
294 }
295 
296 /* user needs to watch new fd or stop watching fd that is about to be closed.
297  control fd will be modified during connection establishment to minimize CPU usage */
298 int
299 control_fd_update (int fd, uint8_t events)
300 {
301  /* convert memif event definitions to epoll events */
302  if (events & MEMIF_FD_EVENT_DEL)
303  return del_epoll_fd (fd);
304 
305  uint32_t evt = 0;
306  if (events & MEMIF_FD_EVENT_READ)
307  evt |= EPOLLIN;
308  if (events & MEMIF_FD_EVENT_WRITE)
309  evt |= EPOLLOUT;
310 
311  if (events & MEMIF_FD_EVENT_MOD)
312  return mod_epoll_fd (fd, evt);
313 
314  return add_epoll_fd (fd, evt);
315 }
316 
317 /* called when event is polled on interrupt file descriptor.
318  there are packets in shared memory ready to be received */
319 /* handle packet processing in rx buffer then enqueue this buffer to tx and transmit */
320 int
321 on_interrupt (memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
322 {
323  long index = *((long *) private_ctx);
324  memif_connection_t *c = &memif_connection[index];
325  if (c->index != index)
326  {
327  INFO ("invalid context: %ld/%u", index, c->index);
328  return 0;
329  }
330 
331  int err = MEMIF_ERR_SUCCESS, ret_val;
332  uint16_t rx = 0, tx = 0;
333  uint16_t fb = 0;
334  int i = 0; /* rx buffer iterator */
335  int j = 0; /* tx bufferiterator */
336 
337  /* loop while there are packets in shm */
338  do
339  {
340  /* receive data from shared memory buffers (dequeue rx buffers) */
341  err = memif_rx_burst (c->conn, qid, c->bufs, MAX_MEMIF_BUFS, &rx);
342  ret_val = err;
343  c->rx_counter += rx;
344  c->rx_buf_num += rx;
345  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF))
346  {
347  INFO ("memif_rx_burst: %s", memif_strerror (err));
348  goto error;
349  }
350 
351  /* process bufers in place */
352  for (i = 0; i < rx; i++)
353  {
354  resolve_packet2 ((void *) (c->bufs + i)->data,
355  &(c->bufs + i)->len, c->ip_addr);
356  }
357 
358  /* enque processed buffers to tx ring */
359  err = memif_buffer_enq_tx (c->conn, qid, c->bufs, i, &tx);
360  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF_RING))
361  {
362  INFO ("memif_buffer_alloc: %s", memif_strerror (err));
363  goto error;
364  }
365  c->rx_buf_num -= tx;
366  c->tx_buf_num += tx;
367  c->tx_err_counter += i - tx;
368 
369  /* mark memif buffers and shared memory buffers as free */
370  err = memif_refill_queue (c->conn, qid, rx, HEADROOM);
371  if (err != MEMIF_ERR_SUCCESS)
372  INFO ("memif_buffer_free: %s", memif_strerror (err));
373  c->rx_buf_num -= rx;
374 
375  DBG ("freed %d buffers. %u/%u alloc/free buffers",
376  fb, rx, MAX_MEMIF_BUFS - rx);
377 
378  /* transmit allocated buffers */
379  err = memif_tx_burst (c->conn, qid, c->bufs, rx, &tx);
380  if (err != MEMIF_ERR_SUCCESS)
381  {
382  INFO ("memif_tx_burst: %s", memif_strerror (err));
383  goto error;
384  }
385  c->tx_counter += tx;
386 
387  }
388  while (ret_val == MEMIF_ERR_NOBUF);
389 
390  return 0;
391 
392 error:
393  err = memif_refill_queue (c->conn, qid, -1, HEADROOM);
394  if (err != MEMIF_ERR_SUCCESS)
395  INFO ("memif_buffer_free: %s", memif_strerror (err));
396  c->rx_buf_num = 0;
397  DBG ("freed %d buffers. %u/%u alloc/free buffers",
398  fb, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
399  return 0;
400 }
401 
402 /* add ethernet encap to packet in rx buffer then enqueue this buffer to tx and tranmit */
403 int
404 on_interrupt0 (memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
405 {
406  long index = *((long *) private_ctx);
407  memif_connection_t *c = &memif_connection[index];
408  if (c->index != index)
409  {
410  INFO ("invalid context: %ld/%u", index, c->index);
411  return 0;
412  }
413 
414  int err = MEMIF_ERR_SUCCESS, ret_val;
415  uint16_t rx = 0, tx = 0;
416  uint16_t fb = 0;
417  int i = 0; /* rx buffer iterator */
418  int j = 0; /* tx bufferiterator */
419 
420  /* loop while there are packets in shm */
421  do
422  {
423  /* receive data from shared memory buffers (dequeue rx buffers) */
424  err = memif_rx_burst (c->conn, qid, c->bufs, MAX_MEMIF_BUFS, &rx);
425  ret_val = err;
426  c->rx_counter += rx;
427  c->rx_buf_num += rx;
428  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF))
429  {
430  INFO ("memif_rx_burst: %s", memif_strerror (err));
431  goto error;
432  }
433 
434  /* process bufers in place */
435  for (i = 0; i < rx; i++)
436  {
437  resolve_packet3 (&c->bufs[i].data, &c->bufs[i].len, c->ip_addr);
438  }
439  /* enque processed buffers to tx ring */
440  err = memif_buffer_enq_tx (c->conn, qid, c->bufs, rx, &tx);
441  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF_RING))
442  {
443  INFO ("memif_buffer_alloc: %s", memif_strerror (err));
444  goto error;
445  }
446  c->rx_buf_num -= tx;
447  c->tx_buf_num += tx;
448  c->tx_err_counter += i - tx;
449 
450  /* mark memif buffers and shared memory buffers as free */
451  err = memif_refill_queue (c->conn, qid, rx, HEADROOM);
452  if (err != MEMIF_ERR_SUCCESS)
453  INFO ("memif_buffer_free: %s", memif_strerror (err));
454  c->rx_buf_num -= rx;
455 
456  DBG ("freed %d buffers. %u/%u alloc/free buffers",
457  fb, rx, MAX_MEMIF_BUFS - rx);
458 
459  /* transmit allocated buffers */
460  err = memif_tx_burst (c->conn, qid, c->bufs, i, &tx);
461  if (err != MEMIF_ERR_SUCCESS)
462  {
463  INFO ("memif_tx_burst: %s", memif_strerror (err));
464  goto error;
465  }
466  c->tx_counter += tx;
467 
468  }
469  while (ret_val == MEMIF_ERR_NOBUF);
470 
471  return 0;
472 
473 error:
474  err = memif_refill_queue (c->conn, qid, -1, HEADROOM);
475  if (err != MEMIF_ERR_SUCCESS)
476  INFO ("memif_buffer_free: %s", memif_strerror (err));
477  c->rx_buf_num = 0;
478  DBG ("freed %d buffers. %u/%u alloc/free buffers",
479  fb, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
480  return 0;
481 }
482 
483 /* called when event is polled on interrupt file descriptor.
484  there are packets in shared memory ready to be received */
485 /* dev test modification: handle only ARP requests */
486 int
487 on_interrupt1 (memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
488 {
489  long index = *((long *) private_ctx);
490  memif_connection_t *c = &memif_connection[index];
491  if (c->index != index)
492  {
493  INFO ("invalid context: %ld/%u", index, c->index);
494  return 0;
495  }
496 
497  int err = MEMIF_ERR_SUCCESS, ret_val;
498  int i;
499  uint16_t rx, tx;
500  uint16_t fb;
501  uint16_t pck_seq;
502 
503  do
504  {
505  /* receive data from shared memory buffers */
506  err = memif_rx_burst (c->conn, qid, c->bufs, MAX_MEMIF_BUFS, &rx);
507  ret_val = err;
508  c->rx_buf_num += rx;
509  c->rx_counter += rx;
510  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF))
511  {
512  INFO ("memif_rx_burst: %s", memif_strerror (err));
513  goto error;
514  }
515 
516  for (i = 0; i < rx; i++)
517  {
518  if (((struct ether_header *) (c->bufs + i)->data)->ether_type ==
519  0x0608)
520  {
521  /* process data in place */
522  resolve_packet2 ((void *) (c->bufs + i)->data,
523  &(c->bufs + i)->len, c->ip_addr);
524  /* enque buffer to tx ring */
525  memif_buffer_enq_tx (c->conn, qid, c->bufs, 1, &tx);
526  c->rx_buf_num -= tx;
527  memif_tx_burst (c->conn, qid, c->bufs, 1, &tx);
528  }
529  }
530 
531  err = memif_refill_queue (c->conn, qid, -1, HEADROOM);
532  if (err != MEMIF_ERR_SUCCESS)
533  INFO ("memif_buffer_free: %s", memif_strerror (err));
534  c->rx_buf_num -= rx;
535 
536  }
537  while (ret_val == MEMIF_ERR_NOBUF);
538 
539  return 0;
540 
541 error:
542  err = memif_refill_queue (c->conn, qid, -1, HEADROOM);
543  if (err != MEMIF_ERR_SUCCESS)
544  INFO ("memif_buffer_free: %s", memif_strerror (err));
545  c->rx_buf_num = 0;
546  DBG ("freed %d buffers. %u/%u alloc/free buffers",
547  fb, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
548  return 0;
549 }
550 
551 int
552 icmpr_memif_create (long index, long mode, char *s)
553 {
554  if (index >= MAX_CONNS)
555  {
556  INFO ("connection array overflow");
557  return 0;
558  }
559  if (index < 0)
560  {
561  INFO ("don't even try...");
562  return 0;
563  }
564  memif_connection_t *c = &memif_connection[index];
565 
566  /* setting memif connection arguments */
567  memif_conn_args_t args;
568  int fd = -1;
569  memset (&args, 0, sizeof (args));
570  args.is_master = mode;
571  args.log2_ring_size = 11;
572  args.buffer_size = 2048;
573  args.num_s2m_rings = 1;
574  args.num_m2s_rings = 1;
575  strncpy ((char *) args.interface_name, IF_NAME, strlen (IF_NAME));
576  args.mode = 0;
577  /* socket filename is not specified, because this app is supposed to
578  connect to VPP over memif. so default socket filename will be used */
579  /* default socketfile = /run/vpp/memif.sock */
580 
581  args.interface_id = index;
582  /* last argument for memif_create (void * private_ctx) is used by user
583  to identify connection. this context is returned with callbacks */
584  int err;
585  /* default interrupt */
586  if (s == NULL)
587  {
588  err = memif_create (&c->conn,
590  &ctx[index]);
591  if (err != MEMIF_ERR_SUCCESS)
592  {
593  INFO ("memif_create: %s", memif_strerror (err));
594  return 0;
595  }
596  }
597  else
598  {
599  if (strncmp (s, "0", 1) == 0)
600  {
601  err = memif_create (&c->conn,
603  &ctx[index]);
604  if (err != MEMIF_ERR_SUCCESS)
605  {
606  INFO ("memif_create: %s", memif_strerror (err));
607  return 0;
608  }
609  }
610  else if (strncmp (s, "1", 1) == 0)
611  {
612  err = memif_create (&c->conn,
614  &ctx[index]);
615  if (err != MEMIF_ERR_SUCCESS)
616  {
617  INFO ("memif_create: %s", memif_strerror (err));
618  return 0;
619  }
620  }
621  else
622  {
623  INFO ("Unknown interrupt descriptor");
624  goto done;
625  }
626  }
627 
628  c->index = index;
629  /* alloc memif buffers */
630  c->rx_buf_num = 0;
631  c->tx_buf_num = 0;
632  c->bufs =
633  (memif_buffer_t *) malloc (sizeof (memif_buffer_t) * MAX_MEMIF_BUFS);
634 
635  c->ip_addr[0] = 192;
636  c->ip_addr[1] = 168;
637  c->ip_addr[2] = c->index + 1;
638  c->ip_addr[3] = 2;
639 
640  c->tx_err_counter = c->tx_counter = c->rx_counter = 0;
641 
642 done:
643  return 0;
644 }
645 
646 int
647 icmpr_memif_delete (long index)
648 {
649  if (index >= MAX_CONNS)
650  {
651  INFO ("connection array overflow");
652  return 0;
653  }
654  if (index < 0)
655  {
656  INFO ("don't even try...");
657  return 0;
658  }
659  memif_connection_t *c = &memif_connection[index];
660 
661  if (c->bufs)
662  free (c->bufs);
663  c->bufs = NULL;
664  c->tx_buf_num = 0;
665  c->rx_buf_num = 0;
666 
667  int err;
668  /* disconenct then delete memif connection */
669  err = memif_delete (&c->conn);
670  if (err != MEMIF_ERR_SUCCESS)
671  INFO ("memif_delete: %s", memif_strerror (err));
672  if (c->conn != NULL)
673  INFO ("memif delete fail");
674  return 0;
675 }
676 
677 void
679 {
680  printf ("LIBMEMIF EXAMPLE APP: %s", APP_NAME);
681 #ifdef ICMP_DBG
682  printf (" (debug)");
683 #endif
684  printf ("\n");
685  printf ("==============================\n");
686  printf ("libmemif version: %s", LIBMEMIF_VERSION);
687 #ifdef MEMIF_DBG
688  printf (" (debug)");
689 #endif
690  printf ("\n");
691  printf ("memif version: %d\n", memif_get_version ());
692  printf ("commands:\n");
693  printf ("\thelp - prints this help\n");
694  printf ("\texit - exit app\n");
695  printf
696  ("\tconn <index> <mode> [<interrupt-desc>] - create memif. index is also used as interface id, mode 0 = slave 1 = master, interrupt-desc none = default 0 = if ring is full wait 1 = handle only ARP requests\n");
697  printf ("\tdel <index> - delete memif\n");
698  printf ("\tshow - show connection details\n");
699  printf ("\tip-set <index> <ip-addr> - set interface ip address\n");
700  printf
701  ("\trx-mode <index> <qid> <polling|interrupt> - set queue rx mode\n");
702  printf ("\tsh-count - print counters\n");
703  printf ("\tcl-count - clear counters\n");
704  printf
705  ("\tsend <index> <tx> <ip> <mac> - send icmp, ommit mac to transmit on ip layer\n");
706 }
707 
708 int
710 {
711  /* application cleanup */
712  int err;
713  long i;
714  if (out_fd > 0)
715  close (out_fd);
716  out_fd = -1;
717  for (i = 0; i < MAX_CONNS; i++)
718  {
719  memif_connection_t *c = &memif_connection[i];
720  if (c->conn)
721  icmpr_memif_delete (i);
722  }
723 
724  err = memif_cleanup ();
725  if (err != MEMIF_ERR_SUCCESS)
726  INFO ("memif_delete: %s", memif_strerror (err));
727 
728  return 0;
729 }
730 
731 int
732 icmpr_set_ip (long index, char *ip)
733 {
734  if (index >= MAX_CONNS)
735  {
736  INFO ("connection array overflow");
737  return 0;
738  }
739  if (index < 0)
740  {
741  INFO ("don't even try...");
742  return 0;
743  }
744  memif_connection_t *c = &memif_connection[index];
745  if (c->conn == NULL)
746  {
747  INFO ("no connection at index %ld", index);
748  return 0;
749  }
750 
751  char *end;
752  char *ui;
753  uint8_t tmp[4];
754  ui = strtok (ip, ".");
755  if (ui == NULL)
756  goto error;
757  tmp[0] = strtol (ui, &end, 10);
758 
759  ui = strtok (NULL, ".");
760  if (ui == NULL)
761  goto error;
762  tmp[1] = strtol (ui, &end, 10);
763 
764  ui = strtok (NULL, ".");
765  if (ui == NULL)
766  goto error;
767  tmp[2] = strtol (ui, &end, 10);
768 
769  ui = strtok (NULL, ".");
770  if (ui == NULL)
771  goto error;
772  tmp[3] = strtol (ui, &end, 10);
773 
774  c->ip_addr[0] = tmp[0];
775  c->ip_addr[1] = tmp[1];
776  c->ip_addr[2] = tmp[2];
777  c->ip_addr[3] = tmp[3];
778 
779  INFO ("memif %ld ip address set to %u.%u.%u.%u",
780  index, c->ip_addr[0], c->ip_addr[1], c->ip_addr[2], c->ip_addr[3]);
781 
782  return 0;
783 
784 error:
785  INFO ("invalid ip address");
786  return 0;
787 }
788 
789 int
790 icmpr_set_rx_mode (long index, long qid, char *mode)
791 {
792  if (index >= MAX_CONNS)
793  {
794  INFO ("connection array overflow");
795  return 0;
796  }
797  if (index < 0)
798  {
799  INFO ("don't even try...");
800  return 0;
801  }
802  memif_connection_t *c = &memif_connection[index];
803 
804  if (c->conn == NULL)
805  {
806  INFO ("no connection at index %ld", index);
807  return 0;
808  }
809 
810  if (strncmp (mode, "interrupt", 9) == 0)
811  {
813  }
814 
815  else if (strncmp (mode, "polling", 7) == 0)
816  {
818  }
819  else
820  INFO ("expected rx mode <interrupt|polling>");
821  return 0;
822 }
823 
824 void
826 {
827  int i;
828  for (i = 0; i < MAX_CONNS; i++)
829  {
830  memif_connection_t *c = &memif_connection[i];
831  if (c->conn == NULL)
832  continue;
833  printf ("===============================\n");
834  printf ("interface index: %d\n", c->index);
835  printf ("\trx: %lu\n", c->rx_counter);
836  printf ("\ttx: %lu\n", c->tx_counter);
837  printf ("\ttx_err: %lu\n", c->tx_err_counter);
838  printf ("\tts: %lus %luns\n", c->t_sec, c->t_nsec);
839  }
840 }
841 
842 void
844 {
845  int i;
846  for (i = 0; i < MAX_CONNS; i++)
847  {
848  memif_connection_t *c = &memif_connection[i];
849  if (c->conn == NULL)
850  continue;
851  c->t_sec = c->t_nsec = c->tx_err_counter = c->tx_counter =
852  c->rx_counter = 0;
853  }
854 }
855 
856 void
858 {
859  memif_connection_t *c = &memif_connection[flow->index];
860  if (c->conn == NULL)
861  {
862  INFO ("No connection at index %d. Stopping flow...\n", flow->index);
863  goto stop_flow;
864  }
865  uint16_t tx, i;
866  int err = MEMIF_ERR_SUCCESS;
867 
868  if (!flow->start)
869  {
870  flow->start = malloc (sizeof (struct timespec));
871  memset (flow->start, 0, sizeof (struct timespec));
872  timespec_get (flow->start, TIME_UTC);
873  }
874 
875  i = 0;
876  err = memif_buffer_alloc (c->conn, 0, c->bufs,
878  flow->packet_count ? flow->packet_count :
879  MAX_MEMIF_BUFS, &tx, 64);
880  if ((err != MEMIF_ERR_SUCCESS) && (err != MEMIF_ERR_NOBUF_RING))
881  {
882  INFO ("memif_buffer_alloc: %s Stopping flow...\n",
883  memif_strerror (err));
884  goto stop_flow;
885  }
886  c->tx_buf_num += tx;
887 
888  while (tx)
889  {
890  generate_packet2 ((void *) c->bufs[i].data,
891  &c->bufs[i].len, c->ip_addr,
892  flow->ip_daddr, flow->hw_daddr, (flow->sequence)++,
893  flow->mode);
894  i++;
895  tx--;
896  }
897  err = memif_tx_burst (c->conn, 0, c->bufs, i, &tx);
898  if (err != MEMIF_ERR_SUCCESS)
899  {
900  INFO ("memif_tx_burst: %s Stopping flow...\n", memif_strerror (err));
901  goto stop_flow;
902  }
903  c->tx_buf_num -= tx;
904  c->tx_counter += tx;
905  flow->tx += tx;
906  flow->packet_count -= tx;
907 
908  if (flow->packet_count == 0)
909  {
910  timespec_get (&flow->end, TIME_UTC);
911  INFO ("Flow finished!");
912  INFO ("Flow length: %lu", flow->tx);
913  uint64_t t1 = flow->end.tv_sec - flow->start->tv_sec;
914  uint64_t t2;
915  if (flow->end.tv_nsec > flow->start->tv_nsec)
916  {
917  t2 = flow->end.tv_nsec - flow->start->tv_nsec;
918  }
919  else
920  {
921  t2 = flow->start->tv_nsec - flow->end.tv_nsec;
922  t1--;
923  }
924  c->t_sec = t1;
925  c->t_nsec = t2;
926  INFO ("Flow time: %lus %luns", t1, t2);
927  double tmp = t1;
928  tmp += t2 / 1e+9;
929  tmp = flow->tx / tmp;
930  INFO ("Average pps: %f", tmp);
931  INFO ("Stopping flow...");
932  goto stop_flow;
933  }
934 
935  return;
936 
937 stop_flow:
938  if (flow)
939  {
940  if (flow->start)
941  free (flow->start);
942  free (flow);
943  }
944  flow = NULL;
945  return;
946 }
947 
948 int
949 icmpr_send (long index, long packet_num, char *input)
950 {
951  if (flow)
952  {
953  printf ("only one flow allowed\n");
954  return 0;
955  }
956 
957  memif_connection_t *c = &memif_connection[index];
958  char *end;
959  char *ui;
960  uint8_t tmp[6];
961  if (c->conn == NULL)
962  return -1;
963 
964  flow = malloc (sizeof (icmpr_flow_t));
965  flow->index = index;
966  flow->packet_count = packet_num;
967  flow->sequence = 0;
968  flow->tx = 0;
969  flow->start = NULL;
970  memset (&flow->end, 0, sizeof (struct timespec));
971 
972  INFO ("packet count: %lu", flow->packet_count);
973  printf ("%s\n", input);
974 
975  ui = strtok (input, ".");
976  if (ui == NULL)
977  goto error;
978  tmp[0] = strtol (ui, &end, 10);
979 
980  ui = strtok (NULL, ".");
981  if (ui == NULL)
982  goto error;
983  tmp[1] = strtol (ui, &end, 10);
984 
985  ui = strtok (NULL, ".");
986  if (ui == NULL)
987  goto error;
988  tmp[2] = strtol (ui, &end, 10);
989 
990  ui = strtok (NULL, ".");
991  if (ui == NULL)
992  goto error;
993  tmp[3] = strtol (ui, &end, 10);
994 
995  flow->ip_daddr[0] = tmp[0];
996  flow->ip_daddr[1] = tmp[1];
997  flow->ip_daddr[2] = tmp[2];
998  flow->ip_daddr[3] = tmp[3];
999 
1000  ui = strtok (NULL, " ");
1001  if (ui == NULL)
1002  {
1003  flow->mode = ICMPR_FLOW_MODE_IP;
1004  return 0;
1005  }
1006 
1007  ui = strtok (NULL, ":");
1008  if (ui == NULL)
1009  goto error;
1010  tmp[0] = strtol (ui, &end, 16);
1011  ui = strtok (NULL, ":");
1012  if (ui == NULL)
1013  goto error;
1014  tmp[1] = strtol (ui, &end, 16);
1015  ui = strtok (NULL, ":");
1016  if (ui == NULL)
1017  goto error;
1018  tmp[2] = strtol (ui, &end, 16);
1019  ui = strtok (NULL, ":");
1020  if (ui == NULL)
1021  goto error;
1022  tmp[3] = strtol (ui, &end, 16);
1023  ui = strtok (NULL, ":");
1024  if (ui == NULL)
1025  goto error;
1026  tmp[4] = strtol (ui, &end, 16);
1027  ui = strtok (NULL, ":");
1028  if (ui == NULL)
1029  goto error;
1030  tmp[5] = strtol (ui, &end, 16);
1031 
1032  flow->hw_daddr[0] = tmp[0];
1033  flow->hw_daddr[1] = tmp[1];
1034  flow->hw_daddr[2] = tmp[2];
1035  flow->hw_daddr[3] = tmp[3];
1036  flow->hw_daddr[4] = tmp[4];
1037  flow->hw_daddr[5] = tmp[5];
1038 
1039  flow->mode = ICMPR_FLOW_MODE_ETH;
1040 
1041  return 0;
1042 
1043 error:
1044  INFO ("Invalid input\n");
1045  if (flow)
1046  free (flow);
1047  flow = NULL;
1048  return 0;
1049 }
1050 
1051 int
1053 {
1054  int i;
1055  char *in = (char *) malloc (256);
1056  char *ui = fgets (in, 256, stdin);
1057  char *end;
1058  long a;
1059  if (in[0] == '\n')
1060  goto done;
1061  ui = strtok (in, " ");
1062  if (strncmp (ui, "exit", 4) == 0)
1063  {
1064  free (in);
1065  icmpr_free ();
1066  exit (EXIT_SUCCESS);
1067  }
1068  else if (strncmp (ui, "help", 4) == 0)
1069  {
1070  print_help ();
1071  goto done;
1072  }
1073  else if (strncmp (ui, "conn", 4) == 0)
1074  {
1075  ui = strtok (NULL, " ");
1076  if (ui != NULL)
1077  a = strtol (ui, &end, 10);
1078  else
1079  {
1080  INFO ("expected id");
1081  goto done;
1082  }
1083  ui = strtok (NULL, " ");
1084  if (ui != NULL)
1085  icmpr_memif_create (a, strtol (ui, &end, 10), strtok (NULL, " "));
1086  else
1087  INFO ("expected mode <0|1>");
1088  goto done;
1089  }
1090  else if (strncmp (ui, "del", 3) == 0)
1091  {
1092  ui = strtok (NULL, " ");
1093  if (ui != NULL)
1094  icmpr_memif_delete (strtol (ui, &end, 10));
1095  else
1096  INFO ("expected id");
1097  goto done;
1098  }
1099  else if (strncmp (ui, "show", 4) == 0)
1100  {
1102  goto done;
1103  }
1104  else if (strncmp (ui, "ip-set", 6) == 0)
1105  {
1106  ui = strtok (NULL, " ");
1107  if (ui != NULL)
1108  icmpr_set_ip (strtol (ui, &end, 10), strtok (NULL, " "));
1109  else
1110  INFO ("expected id");
1111  goto done;
1112  }
1113  else if (strncmp (ui, "rx-mode", 7) == 0)
1114  {
1115  ui = strtok (NULL, " ");
1116  if (ui != NULL)
1117  a = strtol (ui, &end, 10);
1118  else
1119  {
1120  INFO ("expected id");
1121  goto done;
1122  }
1123  ui = strtok (NULL, " ");
1124  if (ui != NULL)
1125  icmpr_set_rx_mode (a, strtol (ui, &end, 10), strtok (NULL, " "));
1126  else
1127  INFO ("expected qid");
1128  goto done;
1129  }
1130  else if (strncmp (ui, "sh-count", 8) == 0)
1131  {
1133  }
1134  else if (strncmp (ui, "cl-count", 8) == 0)
1135  {
1137  }
1138  else if (strncmp (ui, "send", 4) == 0)
1139  {
1140  ui = strtok (NULL, " ");
1141  if (ui != NULL)
1142  a = strtol (ui, &end, 10);
1143  else
1144  {
1145  INFO ("expected id");
1146  goto done;
1147  }
1148  ui = strtok (NULL, " ");
1149  if (ui != NULL)
1150  icmpr_send (a, strtol (ui, &end, 10), strtok (NULL, " "));
1151  else
1152  INFO ("expected count");
1153  goto done;
1154  }
1155  else
1156  {
1157  INFO ("unknown command: %s", ui);
1158  goto done;
1159  }
1160 
1161  return 0;
1162 done:
1163  free (in);
1164  return 0;
1165 }
1166 
1167 int
1168 poll_event (int timeout)
1169 {
1170  struct epoll_event evt, *e;
1171  int app_err = 0, memif_err = 0, en = 0;
1172  int tmp, nfd;
1173  uint32_t events = 0;
1174  struct timespec start, end;
1175  memset (&evt, 0, sizeof (evt));
1176  evt.events = EPOLLIN | EPOLLOUT;
1177  sigset_t sigset;
1178  sigemptyset (&sigset);
1179  en = epoll_pwait (epfd, &evt, 1, timeout, &sigset);
1180  /* id event polled */
1181  timespec_get (&start, TIME_UTC);
1182  if (en < 0)
1183  {
1184  DBG ("epoll_pwait: %s", strerror (errno));
1185  return -1;
1186  }
1187  if (en > 0)
1188  {
1189  /* this app does not use any other file descriptors than stds and memif control fds */
1190  if (evt.data.fd > 2)
1191  {
1192  /* event of memif control fd */
1193  /* convert epolle events to memif events */
1194  if (evt.events & EPOLLIN)
1195  events |= MEMIF_FD_EVENT_READ;
1196  if (evt.events & EPOLLOUT)
1197  events |= MEMIF_FD_EVENT_WRITE;
1198  if (evt.events & EPOLLERR)
1199  events |= MEMIF_FD_EVENT_ERROR;
1200  memif_err = memif_control_fd_handler (evt.data.fd, events);
1201  if (memif_err != MEMIF_ERR_SUCCESS)
1202  INFO ("memif_control_fd_handler: %s", memif_strerror (memif_err));
1203  }
1204  else if (evt.data.fd == 0)
1205  {
1206  app_err = user_input_handler ();
1207  }
1208  else
1209  {
1210  DBG ("unexpected event at memif_epfd. fd %d", evt.data.fd);
1211  }
1212  }
1213 
1214  timespec_get (&end, TIME_UTC);
1215  LOG ("interrupt: %ld", end.tv_nsec - start.tv_nsec);
1216 
1217  if ((app_err < 0) || (memif_err < 0))
1218  {
1219  if (app_err < 0)
1220  DBG ("user input handler error");
1221  if (memif_err < 0)
1222  DBG ("memif control fd handler error");
1223  return -1;
1224  }
1225 
1226  return 0;
1227 }
1228 
1229 int
1231 {
1232  epfd = epoll_create (1);
1233  add_epoll_fd (0, EPOLLIN);
1234 
1235  flow = NULL;
1236 
1237 #ifdef LOG_FILE
1238  remove (LOG_FILE);
1239  enable_log = 0;
1240 
1241  out_fd = open (LOG_FILE, O_WRONLY | O_CREAT, S_IRWXO);
1242  if (out_fd < 0)
1243  INFO ("Error opening log file: %s", strerror (errno));
1244 #endif /* LOG_FILE */
1245 
1246  /* initialize memory interface */
1247  int err, i;
1248  /* if valid callback is passed as argument, fd event polling will be done by user
1249  all file descriptors and events will be passed to user in this callback */
1250  /* if callback is set to NULL libmemif will handle fd event polling */
1252  if (err != MEMIF_ERR_SUCCESS)
1253  {
1254  INFO ("memif_init: %s", memif_strerror (err));
1255  icmpr_free ();
1256  exit (-1);
1257  }
1258 
1259  for (i = 0; i < MAX_CONNS; i++)
1260  {
1261  memif_connection[i].conn = NULL;
1262  ctx[i] = i;
1263  }
1264 
1265  print_help ();
1266 
1267  /* main loop */
1268  while (1)
1269  {
1270  if (poll_event (0) < 0)
1271  {
1272  DBG ("poll_event error!");
1273  }
1274  if (flow)
1275  {
1276  icmpr_send_proc ();
1277  }
1278  }
1279 }
uint64_t rx_counter
Definition: main.c:129
void * icmpr_send_proc(void *data)
Definition: main.c:721
int icmpr_memif_delete()
Definition: main.c:193
void print_help()
Definition: main.c:204
int add_epoll_fd(int fd, uint32_t events)
Definition: main.c:302
a
Definition: bitmap.h:538
uint8_t * inst_name
Definition: libmemif.h:364
uint8_t * secret
Definition: libmemif.h:369
icmpr_flow_mode_t mode
Definition: main.c:112
int on_disconnect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:186
#define MEMIF_FD_EVENT_READ
user needs to set events that occured on fd and pass them to memif_control_fd_handler ...
Definition: libmemif.h:88
int on_interrupt0(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Definition: main.c:448
uint8_t num_m2s_rings
Definition: libmemif.h:259
int del_epoll_fd(int fd)
Definition: main.c:344
Optimized string handling code, including c11-compliant "safe C library" variants.
#define NULL
Definition: clib.h:58
uint16_t buffer_size
Definition: libmemif.h:260
int on_interrupt1(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Definition: main.c:569
uint32_t interface_id
Definition: libmemif.h:264
uint64_t packet_count
Definition: main.c:113
int i
int resolve_packet2(void *pck, uint32_t *size, uint8_t ip_addr[4])
Definition: icmp_proto.c:381
uint64_t tx
Definition: main.c:115
int generate_packet2(void *pck, uint32_t *size, uint8_t saddr[4], uint8_t daddr[4], uint8_t hw_daddr[6], uint32_t seq, icmpr_flow_mode_t mode)
Definition: icmp_proto.c:343
int out_fd
Definition: main.c:92
void icmpr_print_counters()
Definition: main.c:272
int icmpr_set_ip(long index, char *ip)
Definition: main.c:810
uint8_t * remote_inst_name
Definition: libmemif.h:366
int poll_event(int timeout)
Definition: main.c:978
#define LIBMEMIF_VERSION
Libmemif version.
Definition: libmemif.h:26
int memif_refill_queue(memif_conn_handle_t conn, uint16_t qid, uint16_t count, uint16_t headroom)
Memif refill ring.
Definition: main.c:1778
int on_connect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:177
uint8_t num_s2m_rings
Definition: libmemif.h:258
uint32_t len
Definition: libmemif.h:287
struct timespec * start
Definition: main.c:118
#define LOG(...)
Definition: main.c:73
int icmpr_free()
Definition: main.c:258
int memif_get_details(memif_conn_handle_t conn, memif_details_t *md, char *buf, ssize_t buflen)
Memif get details.
Definition: main.c:1984
int icmpr_set_rx_mode(long index, long qid, char *mode)
Definition: main.c:868
memif_interface_mode_t mode
Definition: libmemif.h:266
uint8_t mode
Definition: libmemif.h:371
uint8_t link_up_down
Definition: libmemif.h:381
char * memif_strerror(int err_code)
Memif strerror.
Definition: main.c:159
int icmpr_memif_create(int is_master)
Definition: main.c:337
memif_conn_handle_t conn
Definition: main.c:76
static void print_memif_details()
Definition: main.c:127
#define INFO(...)
Definition: main.c:76
uint8_t ip_addr[4]
Definition: main.c:90
uint16_t rx_buf_num
Definition: main.c:88
uint8_t interface_name[32]
Definition: libmemif.h:265
void * data
Definition: libmemif.h:293
uint16_t buffer_size
Definition: libmemif.h:323
int user_input_handler()
Definition: main.c:897
uint8_t * socket_filename
Definition: libmemif.h:372
#define TIME_UTC
Definition: main.c:51
#define MEMIF_FD_EVENT_DEL
if set, informs that fd is going to be closed (user may want to stop watching for events on this fd) ...
Definition: libmemif.h:93
int memif_set_rx_mode(memif_conn_handle_t c, memif_rx_mode_t rx_mode, uint16_t qid)
Memif set rx mode.
Definition: main.c:611
long ctx[MAX_CONNS]
Definition: main.c:144
struct memif_connection memif_connection_t
uint8_t is_master
Definition: libmemif.h:262
uint8_t rx_queues_num
Definition: libmemif.h:375
int memif_init(memif_control_fd_update_t *on_control_fd_update, char *app_name, memif_alloc_t *memif_alloc, memif_realloc_t *memif_realloc, memif_free_t *memif_free)
Memif initialization.
Definition: main.c:455
#define APP_NAME
Definition: main.c:52
int memif_buffer_enq_tx(memif_conn_handle_t conn, uint16_t qid, memif_buffer_t *bufs, uint16_t count, uint16_t *count_out)
Memif buffer enq tx.
Definition: main.c:1573
#define HEADROOM
Definition: main.c:55
uint64_t tx_counter
Definition: main.c:129
int resolve_packet3(void **pck_, uint32_t *size, uint8_t ip_addr[4])
Definition: icmp_proto.c:458
uint16_t tx_buf_num
Definition: main.c:83
int on_interrupt(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Definition: main.c:287
svmdb_client_t * c
int memif_tx_burst(memif_conn_handle_t conn, uint16_t qid, memif_buffer_t *bufs, uint16_t count, uint16_t *tx)
Memif transmit buffer burst.
Definition: main.c:1832
uint8_t hw_daddr[6]
Definition: main.c:117
int memif_buffer_alloc(memif_conn_handle_t conn, uint16_t qid, memif_buffer_t *bufs, uint16_t count, uint16_t *count_out, uint16_t size)
Memif buffer alloc.
Definition: main.c:1652
uint8_t ip_daddr[4]
Definition: main.c:116
memif_queue_details_t * rx_queues
Definition: libmemif.h:377
uint16_t index
Definition: main.c:111
#define DBG(...)
Definition: main.c:72
uint8_t role
Definition: libmemif.h:370
uint8_t enable_log
Definition: main.c:93
int memif_cleanup()
Memif cleanup.
Definition: main.c:2162
uint16_t sequence
Definition: main.c:114
int memif_create(memif_conn_handle_t *c, memif_conn_args_t *args, memif_connection_update_t *on_connect, memif_connection_update_t *on_disconnect, memif_interrupt_t *on_interrupt, void *private_ctx)
Memory interface create function.
Definition: main.c:629
struct timespec end
Definition: main.c:118
uint64_t t_sec
Definition: main.c:130
uint8_t tx_queues_num
Definition: libmemif.h:376
void * memif_conn_handle_t
Memif connection handle pointer of type void, pointing to internal structure.
Definition: libmemif.h:101
int memif_control_fd_handler(int fd, uint8_t events)
Memif control file descriptor handler.
Definition: main.c:893
int mod_epoll_fd(int fd, uint32_t events)
Definition: main.c:323
int control_fd_update(int fd, uint8_t events)
Definition: main.c:378
uint8_t log2_ring_size
Definition: libmemif.h:261
void icmpr_reset_counters()
Definition: main.c:289
uint64_t tx_err_counter
Definition: main.c:129
int epfd
Definition: main.c:94
uint32_t id
Definition: libmemif.h:368
int memif_rx_burst(memif_conn_handle_t conn, uint16_t qid, memif_buffer_t *bufs, uint16_t count, uint16_t *rx)
Memif receive buffer burst.
Definition: main.c:1899
uint64_t t_nsec
Definition: main.c:130
int memif_delete(memif_conn_handle_t *conn)
Memif delete.
Definition: main.c:1234
vl_api_gbp_vxlan_tunnel_mode_t mode
Definition: gbp.api:349
memif_buffer_t * bufs
Definition: main.c:96
#define MEMIF_FD_EVENT_ERROR
inform libmemif that error occured on fd
Definition: libmemif.h:91
#define MEMIF_FD_EVENT_MOD
update events
Definition: libmemif.h:95
int main(int argc, char *argv[])
Definition: main.c:97
int icmpr_send(long index, long packet_num, char *hw, char *ip)
Definition: main.c:818
memif_queue_details_t * tx_queues
Definition: libmemif.h:378
uint8_t * if_name
Definition: libmemif.h:363
uint16_t index
Definition: main.c:74
Memif buffer.
Definition: libmemif.h:283
#define MEMIF_FD_EVENT_WRITE
Definition: libmemif.h:89
uint16_t memif_get_version()
Memif get version.
Definition: main.c:176
#define IF_NAME
Definition: main.c:53
Memif connection arguments.
Definition: libmemif.h:253
#define MAX_CONNS
Definition: main.c:84
Memif details.
Definition: libmemif.h:361
icmpr_flow_mode_t
Definition: icmp_proto.h:21
icmpr_flow_t * flow
Definition: main.c:123
uint8_t * remote_if_name
Definition: libmemif.h:365
#define MAX_MEMIF_BUFS
Definition: main.c:83