FD.io VPP  v19.08-27-gf4dcae4
Vector Packet Processing
libmemif.h
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 /** @file
19  * @defgroup libmemif
20  */
21 
22 #ifndef _LIBMEMIF_H_
23 #define _LIBMEMIF_H_
24 
25 /** Libmemif version. */
26 #define LIBMEMIF_VERSION "3.0"
27 /** Default name of application using libmemif. */
28 #define MEMIF_DEFAULT_APP_NAME "libmemif-app"
29 
30 #include <inttypes.h>
31 #include <sys/timerfd.h>
32 
33 /*! Error codes */
34 typedef enum
35 {
36  MEMIF_ERR_SUCCESS = 0, /*!< success */
37 /* SYSCALL ERRORS */
38  MEMIF_ERR_SYSCALL, /*!< other syscall error */
39  MEMIF_ERR_CONNREFUSED, /*!< connection refused */
40  MEMIF_ERR_ACCES, /*!< permission denied */
41  MEMIF_ERR_NO_FILE, /*!< file does not exist */
42  MEMIF_ERR_FILE_LIMIT, /*!< system open file limit */
43  MEMIF_ERR_PROC_FILE_LIMIT, /*!< process open file limit */
44  MEMIF_ERR_ALREADY, /*!< connection already requested */
45  MEMIF_ERR_AGAIN, /*!< fd is not socket, or operation would block */
46  MEMIF_ERR_BAD_FD, /*!< invalid fd */
47  MEMIF_ERR_NOMEM, /*!< out of memory */
48 /* LIBMEMIF ERRORS */
49  MEMIF_ERR_INVAL_ARG, /*!< invalid argument */
50  MEMIF_ERR_NOCONN, /*!< handle points to no connection */
51  MEMIF_ERR_CONN, /*!< handle points to existing connection */
52  MEMIF_ERR_CB_FDUPDATE, /*!< user defined callback memif_control_fd_update_t error */
53  MEMIF_ERR_FILE_NOT_SOCK, /*!< file specified by socket filename
54  exists, but it's not socket */
55  MEMIF_ERR_NO_SHMFD, /*!< missing shm fd */
56  MEMIF_ERR_COOKIE, /*!< wrong cookie on ring */
57  MEMIF_ERR_NOBUF_RING, /*!< ring buffer full */
58  MEMIF_ERR_NOBUF, /*!< not enough memif buffers */
59  MEMIF_ERR_NOBUF_DET, /*!< memif details needs larger buffer */
60  MEMIF_ERR_INT_WRITE, /*!< send interrupt error */
61  MEMIF_ERR_MFMSG, /*!< malformed msg received */
62  MEMIF_ERR_QID, /*!< invalid queue id */
63 /* MEMIF PROTO ERRORS */
64  MEMIF_ERR_PROTO, /*!< incompatible protocol version */
65  MEMIF_ERR_ID, /*!< unmatched interface id */
66  MEMIF_ERR_ACCSLAVE, /*!< slave cannot accept connection requests */
67  MEMIF_ERR_ALRCONN, /*!< memif is already connected */
68  MEMIF_ERR_MODE, /*!< mode mismatch */
69  MEMIF_ERR_SECRET, /*!< secret mismatch */
70  MEMIF_ERR_NOSECRET, /*!< secret required */
71  MEMIF_ERR_MAXREG, /*!< max region limit reached */
72  MEMIF_ERR_MAXRING, /*!< max ring limit reached */
73  MEMIF_ERR_NO_INTFD, /*!< missing interrupt fd */
74  MEMIF_ERR_DISCONNECT, /*!< disconenct received */
75  MEMIF_ERR_DISCONNECTED, /*!< peer interface disconnected */
76  MEMIF_ERR_UNKNOWN_MSG, /*!< unknown message type */
77  MEMIF_ERR_POLL_CANCEL, /*!< memif_poll_event() was cancelled */
78  MEMIF_ERR_MAX_RING, /*!< too large ring size */
79  MEMIF_ERR_PRIVHDR, /*!< private hdrs not supported */
80 } memif_err_t;
81 
82 /**
83  * @defgroup MEMIF_FD_EVENT Types of events that need to be watched for specific fd.
84  * @ingroup libmemif
85  * @{
86  */
87 
88 /** user needs to set events that occured on fd and pass them to memif_control_fd_handler */
89 #define MEMIF_FD_EVENT_READ (1 << 0)
90 #define MEMIF_FD_EVENT_WRITE (1 << 1)
91 /** inform libmemif that error occured on fd */
92 #define MEMIF_FD_EVENT_ERROR (1 << 2)
93 /** if set, informs that fd is going to be closed (user may want to stop watching for events on this fd) */
94 #define MEMIF_FD_EVENT_DEL (1 << 3)
95 /** update events */
96 #define MEMIF_FD_EVENT_MOD (1 << 4)
97 /** @} */
98 
99 /** \brief Memif connection handle
100  pointer of type void, pointing to internal structure
101 */
102 typedef void *memif_conn_handle_t;
103 
104 /** \brief Memif socket handle
105  pointer of type void, pointing to internal structure
106 */
107 typedef void *memif_socket_handle_t;
108 
109 /** \brief Memif allocator alloc
110  @param size - requested allocation size
111 
112  custom memory allocator: alloc function template
113 */
114 typedef void *(memif_alloc_t) (size_t size);
115 
116 
117 /** \brief Memif realloc
118  @param ptr - pointer to memory block
119  @param size - requested allocation size
120 
121  custom memory reallocation
122 */
123 typedef void *(memif_realloc_t) (void *ptr, size_t size);
124 
125 /** \brief Memif allocator free
126  @param size - requested allocation size
127 
128  custom memory allocator: free function template
129 */
130 typedef void (memif_free_t) (void *ptr);
131 
132 /**
133  * @defgroup CALLBACKS Callback functions definitions
134  * @ingroup libmemif
135  *
136  * @{
137  */
138 
139 /** \brief Memif control file descriptor update (callback function)
140  @param fd - new file descriptor to watch
141  @param events - event type(s) to watch for
142 
143  This callback is called when there is new fd to watch for events on
144  or if fd is about to be closed (user mey want to stop watching for events on this fd).
145 */
146 typedef int (memif_control_fd_update_t) (int fd, uint8_t events,
147  void *private_ctx);
148 
149 /** \brief Memif connection status update (callback function)
150  @param conn - memif connection handle
151  @param private_ctx - private context
152 
153  Informs user about connection status connected/disconnected.
154  On connected -> start watching for events on interrupt fd (optional).
155 */
157  void *private_ctx);
158 
159 /** \brief Memif interrupt occured (callback function)
160  @param conn - memif connection handle
161  @param private_ctx - private context
162  @param qid - queue id on which interrupt occured
163 
164  Called when event is received on interrupt fd.
165 */
166 typedef int (memif_interrupt_t) (memif_conn_handle_t conn, void *private_ctx,
167  uint16_t qid);
168 
169 /** @} */
170 
171 /**
172  * @defgroup EXTERNAL_REGION External region APIs
173  * @ingroup libmemif
174  *
175  * @{
176  */
177 
178 /** \brief Get external buffer offset (optional)
179  @param private_ctx - private context
180 
181  Find unallocated external buffer and return its offset.
182 */
183 typedef uint32_t (memif_get_external_buffer_offset_t) (void *private_ctx);
184 
185 /** \brief Add external region
186  @param[out] addr - region address
187  @param size - requested region size
188  @param fd[out] - file descriptor
189  @param private_ctx - private context
190 
191  Called by slave. Add external region created by client.
192 */
193 typedef int (memif_add_external_region_t) (void * *addr, uint32_t size,
194  int *fd, void *private_ctx);
195 
196 /** \brief Get external region address
197  @param size - requested region size
198  @param fd - file descriptor
199  @param private_ctx - private context
200 
201  Called by master. Get region address from client.
202 
203  \return region address
204 */
205 typedef void *(memif_get_external_region_addr_t) (uint32_t size, int fd,
206  void *private_ctx);
207 
208 /** \brief Delete external region
209  @param addr - region address
210  @param size - region size
211  @param fd - file descriptor
212  @param private_ctx - private context
213 
214  Delete external region.
215 */
216 typedef int (memif_del_external_region_t) (void *addr, uint32_t size, int fd,
217  void *private_ctx);
218 
219 /** \brief Register external region
220  @param ar - add external region callback
221  @param gr - get external region addr callback
222  @param dr - delete external region callback
223  @param go - get external buffer offset callback (optional)
224 */
229 
230 /** @} */
231 
232 /**
233  * @defgroup ARGS_N_BUFS Connection arguments and buffers
234  * @ingroup libmemif
235  *
236  * @{
237  */
238 
239 #ifndef _MEMIF_H_
240 typedef enum
241 {
246 #endif /* _MEMIF_H_ */
247 
248 /** \brief Memif connection arguments
249  @param socket - memif socket handle, if NULL default socket will be used
250  @param secret - otional parameter used as interface autenthication
251  @param num_s2m_rings - number of slave to master rings
252  @param num_m2s_rings - number of master to slave rings
253  @param buffer_size - size of buffer in shared memory
254  @param log2_ring_size - logarithm base 2 of ring size
255  @param is_master - 0 == master, 1 == slave
256  @param interface_id - id used to identify peer connection
257  @param interface_name - interface name
258  @param mode - 0 == ethernet, 1 == ip , 2 == punt/inject
259 */
260 typedef struct
261 {
262  memif_socket_handle_t socket; /*!< default = /run/vpp/memif.sock */
263  uint8_t secret[24]; /*!< optional (interface authentication) */
264 
265  uint8_t num_s2m_rings; /*!< default = 1 */
266  uint8_t num_m2s_rings; /*!< default = 1 */
267  uint16_t buffer_size; /*!< default = 2048 */
268  uint8_t log2_ring_size; /*!< default = 10 (1024) */
269  uint8_t is_master;
270 
271  uint32_t interface_id;
272  uint8_t interface_name[32];
275 
276 /*! memif receive mode */
277 typedef enum
278 {
279  MEMIF_RX_MODE_INTERRUPT = 0, /*!< interrupt mode */
280  MEMIF_RX_MODE_POLLING /*!< polling mode */
282 
283 /** \brief Memif buffer
284  @param desc_index - ring descriptor index
285  @param ring - pointer to ring containing descriptor for this buffer
286  @param len - available length
287  @param flags - memif buffer flags
288  @param data - pointer to shared memory data
289 */
290 typedef struct
291 {
292  uint16_t desc_index;
293  void *ring;
294  uint32_t len;
295 /** next buffer present (chained buffers) */
296 #define MEMIF_BUFFER_FLAG_NEXT (1 << 0)
297 /** states that buffer is from rx ring */
298 #define MEMIF_BUFFER_FLAG_RX (1 << 1)
299  uint8_t flags;
300  void *data;
302 /** @} */
303 
304 /**
305  * @defgroup MEMIF_DETAILS Memif details structs
306  * @ingroup libmemif
307  *
308  * @{
309  */
310 
311 /** \brief Memif queue details
312  @param region - region index
313  @param qid - queue id
314  @param ring_size - size of ring buffer in sharem memory
315  @param flags - ring flags
316  @param head - ring head pointer
317  @param tail - ring tail pointer
318  @param buffer_size - buffer size on sharem memory
319 */
320 typedef struct
321 {
322  uint8_t region;
323  uint8_t qid;
324  uint32_t ring_size;
325 /** if set queue is in polling mode, else in interrupt mode */
326 #define MEMIF_QUEUE_FLAG_POLLING 1
327  uint16_t flags;
328  uint16_t head;
329  uint16_t tail;
330  uint16_t buffer_size;
332 
333 /** \brief Memif region details
334  @param index - region index
335  @param addr - region address
336  @param size - region size
337  @param fd - file descriptor
338  @param is_external - if not zero then region is defined by client
339 */
340 typedef struct
341 {
342  uint8_t index;
343  void *addr;
344  uint32_t size;
345  int fd;
346  uint8_t is_external;
348 
349 /** \brief Memif details
350  @param if_name - interface name
351  @param inst_name - application name
352  @param remote_if_name - peer interface name
353  @param remote_inst_name - peer application name
354  @param id - connection id
355  @param secret - secret
356  @param role - 0 = master, 1 = slave
357  @param mode - 0 = ethernet, 1 = ip , 2 = punt/inject
358  @param socket_filename - socket filename
359  @param regions_num - number of regions
360  @param regions - struct containing region details
361  @param rx_queues_num - number of receive queues
362  @param tx_queues_num - number of transmit queues
363  @param rx_queues - struct containing receive queue details
364  @param tx_queues - struct containing transmit queue details
365  @param error - error string
366  @param link_up_down - 1 = up (connected), 2 = down (disconnected)
367 */
368 typedef struct
369 {
370  uint8_t *if_name;
371  uint8_t *inst_name;
372  uint8_t *remote_if_name;
374 
375  uint32_t id;
376  uint8_t *secret; /* optional */
377  uint8_t role; /* 0 = master, 1 = slave */
378  uint8_t mode; /* 0 = ethernet, 1 = ip, 2 = punt/inject */
379  uint8_t *socket_filename;
380  uint8_t regions_num;
382  uint8_t rx_queues_num;
383  uint8_t tx_queues_num;
386 
387  uint8_t *error;
388  uint8_t link_up_down; /* 1 = up, 0 = down */
390 /** @} */
391 
392 /**
393  * @defgroup API_CALLS Api calls
394  * @ingroup libmemif
395  *
396  * @{
397  */
398 
399 /** \brief Memif get version
400 
401  \return ((MEMIF_VERSION_MAJOR << 8) | MEMIF_VERSION_MINOR)
402 */
403 uint16_t memif_get_version ();
404 
405 /** \biref Memif get queue event file descriptor
406  @param conn - memif connection handle
407  @param qid - queue id
408  @param[out] fd - returns event file descriptor
409 
410  \return memif_err_t
411 */
412 
413 int memif_get_queue_efd (memif_conn_handle_t conn, uint16_t qid, int *fd);
414 
415 /** \brief Memif set rx mode
416  @param conn - memif connection handle
417  @param rx_mode - receive mode
418  @param qid - queue id
419 
420  \return memif_err_t
421 */
423  uint16_t qid);
424 
425 /** \brief Memif strerror
426  @param err_code - error code
427 
428  Converts error code to error message.
429 
430  \return Error string
431 */
432 char *memif_strerror (int err_code);
433 
434 /** \brief Memif get details
435  @param conn - memif conenction handle
436  @param md - pointer to memif details struct
437  @param buf - buffer containing details strings
438  @param buflen - length of buffer
439 
440  \return memif_err_t
441 */
443  char *buf, ssize_t buflen);
444 
445 /** \brief Memif initialization
446  @param on_control_fd_update - if control fd updates inform user to watch new fd
447  @param app_name - application name (will be truncated to 32 chars)
448  @param memif_alloc - cutom memory allocator, NULL = default
449  @param memif_realloc - custom memory reallocation, NULL = default
450  @param memif_free - custom memory free, NULL = default
451 
452  if param on_control_fd_update is set to NULL,
453  libmemif will handle file descriptor event polling
454  if a valid callback is set, file descriptor event polling needs to be done by
455  user application, all file descriptors and event types will be passed in
456  this callback to user application
457 
458  Initialize internal libmemif structures. Create timerfd (used to periodically request connection by
459  disconnected memifs in slave mode, with no additional API call). This fd is passed to user with memif_control_fd_update_t
460  timer is inactive at this state. It activates with if there is at least one memif in slave mode.
461 
462  \return memif_err_t
463 */
464 int memif_init (memif_control_fd_update_t * on_control_fd_update,
465  char *app_name, memif_alloc_t * memif_alloc,
466  memif_realloc_t * memif_realloc, memif_free_t * memif_free);
467 
468 /** \brief Memif cleanup
469 
470  Free libmemif internal allocations.
471 
472  \return 0
473 */
474 int memif_cleanup ();
475 
476 /** \brief Memory interface create function
477  @param conn - connection handle for client app
478  @param args - memory interface connection arguments
479  @param on_connect - inform user about connected status
480  @param on_disconnect - inform user about disconnected status
481  @param on_interrupt - informs user about interrupt, if set to null user will not be notified about interrupt, user can use memif_get_queue_efd call to get interrupt fd to poll for events
482  @param private_ctx - private contex passed back to user with callback
483 
484  Creates memory interface.
485 
486  SLAVE-MODE -
487  Start timer that will send events to timerfd. If this fd is passed to memif_control_fd_handler
488  every disconnected memif in slave mode will send connection request.
489  On success new fd is passed to user with memif_control_fd_update_t.
490 
491  MASTER-MODE -
492  Create listener socket and pass fd to user with memif_cntrol_fd_update_t.
493  If this fd is passed to memif_control_fd_handler accept will be called and
494  new fd will be passed to user with memif_control_fd_update_t.
495 
496 
497  \return memif_err_t
498 */
502  memif_interrupt_t * on_interrupt, void *private_ctx);
503 
504 /** \brief Memif control file descriptor handler
505  @param fd - file descriptor on which the event occured
506  @param events - event type(s) that occured
507 
508  If event occures on any control fd, call memif_control_fd_handler.
509  Internal - lib will "identify" fd (timerfd, lsitener, control) and handle event accordingly.
510 
511  FD-TYPE -
512  TIMERFD -
513  Every disconnected memif in slave mode will request connection.
514  LISTENER or CONTROL -
515  Handle socket messaging (internal connection establishment).
516  INTERRUPT -
517  Call on_interrupt callback (if set).
518 
519  \return memif_err_t
520 
521 */
522 int memif_control_fd_handler (int fd, uint8_t events);
523 
524 /** \brief Memif delete
525  @param conn - pointer to memif connection handle
526 
527 
528  disconnect session (free queues and regions, close file descriptors, unmap shared memory)
529  set connection handle to NULL, to avoid possible double free
530 
531  \return memif_err_t
532 */
533 int memif_delete (memif_conn_handle_t * conn);
534 
535 /** \brief Memif buffer enq tx
536  @param conn - memif conenction handle
537  @param qid - number indentifying queue
538  @param bufs - memif buffers
539  @param count - number of memif buffers to enque
540  @param count_out - returns number of allocated buffers
541 
542  Slave is producer of buffers.
543  If connection handle points to master returns MEMIF_ERR_INVAL_ARG.
544 
545  \return memif_err_t
546 */
547 int memif_buffer_enq_tx (memif_conn_handle_t conn, uint16_t qid,
548  memif_buffer_t * bufs, uint16_t count,
549  uint16_t * count_out);
550 
551 /** \brief Memif buffer alloc
552  @param conn - memif conenction handle
553  @param qid - number indentifying queue
554  @param bufs - memif buffers
555  @param count - number of memif buffers to allocate
556  @param count_out - returns number of allocated buffers
557  @param size - buffer size, may return chained buffers if size > buffer_size
558 
559  \return memif_err_t
560 */
561 int memif_buffer_alloc (memif_conn_handle_t conn, uint16_t qid,
562  memif_buffer_t * bufs, uint16_t count,
563  uint16_t * count_out, uint16_t size);
564 
565 /** \brief Memif refill ring
566  @param conn - memif conenction handle
567  @param qid - number indentifying queue
568  @param count - number of buffers to be placed on ring
569  @param headroom - offset the buffer by headroom
570 
571  \return memif_err_t
572 */
573 int memif_refill_queue (memif_conn_handle_t conn, uint16_t qid,
574  uint16_t count, uint16_t headroom);
575 
576 /** \brief Memif transmit buffer burst
577  @param conn - memif conenction handle
578  @param qid - number indentifying queue
579  @param bufs - memif buffers
580  @param count - number of memif buffers to transmit
581  @param tx - returns number of transmitted buffers
582 
583  \return memif_err_t
584 */
585 int memif_tx_burst (memif_conn_handle_t conn, uint16_t qid,
586  memif_buffer_t * bufs, uint16_t count, uint16_t * tx);
587 
588 /** \brief Memif receive buffer burst
589  @param conn - memif conenction handle
590  @param qid - number indentifying queue
591  @param bufs - memif buffers
592  @param count - number of memif buffers to receive
593  @param rx - returns number of received buffers
594 
595  \return memif_err_t
596 */
597 int memif_rx_burst (memif_conn_handle_t conn, uint16_t qid,
598  memif_buffer_t * bufs, uint16_t count, uint16_t * rx);
599 
600 /** \brief Memif poll event
601  @param timeout - timeout in seconds
602 
603  Passive event polling -
604  timeout = 0 - dont wait for event, check event queue if there is an event and return.
605  timeout = -1 - wait until event
606 
607  \return memif_err_t
608 */
609 int memif_poll_event (int timeout);
610 
611 /** \brief Send signal to stop concurrently running memif_poll_event().
612 
613  The function, however, does not wait for memif_poll_event() to stop.
614  memif_poll_event() may still return simply because an event has occured
615  or the timeout has elapsed, but if called repeatedly in an infinite loop,
616  a canceled memif_poll_event() is guaranted to return MEMIF_ERR_POLL_CANCEL
617  in the shortest possible time.
618  This feature was not available in the first release.
619  Use macro MEMIF_HAVE_CANCEL_POLL_EVENT to check if the feature is present.
620 
621  \return memif_err_t
622 */
623 #define MEMIF_HAVE_CANCEL_POLL_EVENT 1
625 
626 /** \brief Set connection request timer value
627  @param timer - new timer value
628 
629  Timer on which all disconnected slaves request connection.
630  See system call 'timer_settime' man-page.
631 
632  \return memif_err_t
633 */
634 int memif_set_connection_request_timer (struct itimerspec timer);
635 
636 /** \brief Send connection request
637  @param conn - memif connection handle
638 
639  Only slave interface can request connection.
640 
641  \return memif_err_t
642 */
644 
645 /** \brief Create memif socket
646  @param sock - socket handle for client app
647  @param filename - path to socket file
648  @param private_ctx - private context
649 
650  The first time an interface is assigned a socket, its type is determined.
651  For master role it's 'listener', for slave role it's 'client'. Each interface
652  requires socket of its respective type. Default socket is creted if no
653  socket handle is passed to memif_create(). It's private context is NULL.
654  If all interfaces using this socket are deleted, the socket returns
655  to its default state.
656 
657  \return memif_err_t
658 */
659 int memif_create_socket (memif_socket_handle_t * sock, const char * filename,
660  void * private_ctx);
661 
662 /** \brief Delete memif socket
663  @param sock - socket handle for client app
664 
665  When trying to free socket in use, socket will not be freed and
666  MEMIF_ERR_INVAL_ARG is returned.
667 
668  \return memif_err_t
669 */
671 
672 /** @} */
673 
674 #endif /* _LIBMEMIF_H_ */
uint8_t * inst_name
Definition: libmemif.h:371
uint8_t * secret
Definition: libmemif.h:376
Memif region details.
Definition: libmemif.h:340
int on_disconnect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:186
void * ring
Definition: libmemif.h:293
int( memif_control_fd_update_t)(int fd, uint8_t events, void *private_ctx)
Memif control file descriptor update (callback function)
Definition: libmemif.h:146
uint8_t num_m2s_rings
Definition: libmemif.h:266
uint16_t buffer_size
Definition: libmemif.h:267
memif_interface_mode_t
Definition: memif.h:53
uint32_t interface_id
Definition: libmemif.h:271
memif_socket_handle_t socket
Definition: libmemif.h:262
uint16_t desc_index
Definition: libmemif.h:292
vhost_vring_addr_t addr
Definition: vhost_user.h:147
uint8_t * remote_inst_name
Definition: libmemif.h:373
int memif_refill_queue(memif_conn_handle_t conn, uint16_t qid, uint16_t count, uint16_t headroom)
Memif refill ring.
Definition: main.c:1868
int on_connect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:177
uint8_t num_s2m_rings
Definition: libmemif.h:265
uint32_t len
Definition: libmemif.h:294
int memif_get_details(memif_conn_handle_t conn, memif_details_t *md, char *buf, ssize_t buflen)
Memif get details.
Definition: main.c:2074
uint8_t mode
Definition: libmemif.h:378
uint8_t link_up_down
Definition: libmemif.h:388
char * memif_strerror(int err_code)
Memif strerror.
Definition: main.c:159
void *( memif_realloc_t)(void *ptr, size_t size)
Memif realloc.
Definition: libmemif.h:123
uint8_t * error
Definition: libmemif.h:387
uword size
void * data
Definition: libmemif.h:300
uint16_t buffer_size
Definition: libmemif.h:330
uint8_t * socket_filename
Definition: libmemif.h:379
int memif_set_rx_mode(memif_conn_handle_t conn, memif_rx_mode_t rx_mode, uint16_t qid)
Memif set rx mode.
Definition: main.c:632
int( memif_interrupt_t)(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Memif interrupt occured (callback function)
Definition: libmemif.h:166
int( memif_connection_update_t)(memif_conn_handle_t conn, void *private_ctx)
Memif connection status update (callback function)
Definition: libmemif.h:156
void * memif_socket_handle_t
Memif socket handle pointer of type void, pointing to internal structure.
Definition: libmemif.h:107
int memif_create_socket(memif_socket_handle_t *sock, const char *filename, void *private_ctx)
Create memif socket.
Definition: main.c:723
uint8_t is_master
Definition: libmemif.h:269
uint8_t rx_queues_num
Definition: libmemif.h:382
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:476
void *( memif_get_external_region_addr_t)(uint32_t size, int fd, void *private_ctx)
Get external region address.
Definition: libmemif.h:205
int memif_get_queue_efd(memif_conn_handle_t conn, uint16_t qid, int *fd)
Memif get queue event file descriptor
Definition: main.c:2234
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:1662
void( memif_free_t)(void *ptr)
Memif allocator free.
Definition: libmemif.h:130
int( memif_del_external_region_t)(void *addr, uint32_t size, int fd, void *private_ctx)
Delete external region.
Definition: libmemif.h:216
uint8_t flags
Definition: libmemif.h:299
int on_interrupt(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Definition: main.c:287
uint8_t regions_num
Definition: libmemif.h:380
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:1922
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:1742
int memif_poll_event(int timeout)
Memif poll event.
Definition: main.c:1127
memif_queue_details_t * rx_queues
Definition: libmemif.h:384
uint8_t role
Definition: libmemif.h:377
vl_api_vxlan_gbp_api_tunnel_mode_t mode
Definition: vxlan_gbp.api:44
int memif_cleanup()
Memif cleanup.
Definition: main.c:2257
int memif_create(memif_conn_handle_t *conn, 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:802
uint8_t tx_queues_num
Definition: libmemif.h:383
int( memif_add_external_region_t)(void **addr, uint32_t size, int *fd, void *private_ctx)
Add external region.
Definition: libmemif.h:193
size_t count
Definition: vapi.c:47
memif_err_t
Definition: libmemif.h:34
memif_interface_mode_t
Definition: libmemif.h:240
void * memif_conn_handle_t
Memif connection handle pointer of type void, pointing to internal structure.
Definition: libmemif.h:102
int memif_set_connection_request_timer(struct itimerspec timer)
Set connection request timer value.
Definition: main.c:457
int memif_control_fd_handler(int fd, uint8_t events)
Memif control file descriptor handler.
Definition: main.c:1015
int memif_request_connection(memif_conn_handle_t conn)
Send connection request.
Definition: main.c:941
uint8_t log2_ring_size
Definition: libmemif.h:268
uint32_t id
Definition: libmemif.h:375
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:1989
memif_rx_mode_t
Definition: libmemif.h:277
int memif_delete(memif_conn_handle_t *conn)
Memif delete.
Definition: main.c:1335
Memif queue details.
Definition: libmemif.h:320
memif_region_details_t * regions
Definition: libmemif.h:381
int memif_cancel_poll_event()
Definition: main.c:1168
memif_queue_details_t * tx_queues
Definition: libmemif.h:385
uint32_t( memif_get_external_buffer_offset_t)(void *private_ctx)
Get external buffer offset (optional)
Definition: libmemif.h:183
uint8_t * if_name
Definition: libmemif.h:370
int memif_delete_socket(memif_socket_handle_t *sock)
Delete memif socket.
Definition: main.c:1315
Memif buffer.
Definition: libmemif.h:290
uint16_t memif_get_version()
Memif get version.
Definition: main.c:176
Memif connection arguments.
Definition: libmemif.h:260
Memif details.
Definition: libmemif.h:368
void memif_register_external_region(memif_add_external_region_t *ar, memif_get_external_region_addr_t *gr, memif_del_external_region_t *dr, memif_get_external_buffer_offset_t *go)
Register external region.
Definition: main.c:423
uint8_t * remote_if_name
Definition: libmemif.h:372
void *( memif_alloc_t)(size_t size)
Memif allocator alloc.
Definition: libmemif.h:114