FD.io VPP  v19.04.4-rc0-5-ge88582fac
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 "2.1"
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 allocator alloc
105  @param size - requested allocation size
106 
107  custom memory allocator: alloc function template
108 */
109 typedef void *(memif_alloc_t) (size_t size);
110 
111 
112 /** \brief Memif realloc
113  @param ptr - pointer to memory block
114  @param size - requested allocation size
115 
116  custom memory reallocation
117 */
118 typedef void *(memif_realloc_t) (void *ptr, size_t size);
119 
120 /** \brief Memif allocator free
121  @param size - requested allocation size
122 
123  custom memory allocator: free function template
124 */
125 typedef void (memif_free_t) (void *ptr);
126 
127 /**
128  * @defgroup CALLBACKS Callback functions definitions
129  * @ingroup libmemif
130  *
131  * @{
132  */
133 
134 /** \brief Memif control file descriptor update (callback function)
135  @param fd - new file descriptor to watch
136  @param events - event type(s) to watch for
137 
138  This callback is called when there is new fd to watch for events on
139  or if fd is about to be closed (user mey want to stop watching for events on this fd).
140 */
141 typedef int (memif_control_fd_update_t) (int fd, uint8_t events);
142 
143 /** \brief Memif connection status update (callback function)
144  @param conn - memif connection handle
145  @param private_ctx - private context
146 
147  Informs user about connection status connected/disconnected.
148  On connected -> start watching for events on interrupt fd (optional).
149 */
151  void *private_ctx);
152 
153 /** \brief Memif interrupt occured (callback function)
154  @param conn - memif connection handle
155  @param private_ctx - private context
156  @param qid - queue id on which interrupt occured
157 
158  Called when event is received on interrupt fd.
159 */
160 typedef int (memif_interrupt_t) (memif_conn_handle_t conn, void *private_ctx,
161  uint16_t qid);
162 
163 /** @} */
164 
165 /**
166  * @defgroup EXTERNAL_REGION External region APIs
167  * @ingroup libmemif
168  *
169  * @{
170  */
171 
172 /** \brief Get external buffer offset (optional)
173  @param private_ctx - private context
174 
175  Find unallocated external buffer and return its offset.
176 */
177 typedef uint32_t (memif_get_external_buffer_offset_t) (void *private_ctx);
178 
179 /** \brief Add external region
180  @param[out] addr - region address
181  @param size - requested region size
182  @param fd[out] - file descriptor
183  @param private_ctx - private context
184 
185  Called by slave. Add external region created by client.
186 */
187 typedef int (memif_add_external_region_t) (void * *addr, uint32_t size,
188  int *fd, void *private_ctx);
189 
190 /** \brief Get external region address
191  @param size - requested region size
192  @param fd - file descriptor
193  @param private_ctx - private context
194 
195  Called by master. Get region address from client.
196 
197  \return region address
198 */
199 typedef void *(memif_get_external_region_addr_t) (uint32_t size, int fd,
200  void *private_ctx);
201 
202 /** \brief Delete external region
203  @param addr - region address
204  @param size - region size
205  @param fd - file descriptor
206  @param private_ctx - private context
207 
208  Delete external region.
209 */
210 typedef int (memif_del_external_region_t) (void *addr, uint32_t size, int fd,
211  void *private_ctx);
212 
213 /** \brief Register external region
214  @param ar - add external region callback
215  @param gr - get external region addr callback
216  @param dr - delete external region callback
217  @param go - get external buffer offset callback (optional)
218 */
223 
224 /** @} */
225 
226 /**
227  * @defgroup ARGS_N_BUFS Connection arguments and buffers
228  * @ingroup libmemif
229  *
230  * @{
231  */
232 
233 #ifndef _MEMIF_H_
234 typedef enum
235 {
240 #endif /* _MEMIF_H_ */
241 
242 /** \brief Memif connection arguments
243  @param socket_filename - socket filename
244  @param secret - otional parameter used as interface autenthication
245  @param num_s2m_rings - number of slave to master rings
246  @param num_m2s_rings - number of master to slave rings
247  @param buffer_size - size of buffer in shared memory
248  @param log2_ring_size - logarithm base 2 of ring size
249  @param is_master - 0 == master, 1 == slave
250  @param interface_id - id used to identify peer connection
251  @param interface_name - interface name
252  @param mode - 0 == ethernet, 1 == ip , 2 == punt/inject
253 */
254 typedef struct
255 {
256  uint8_t *socket_filename; /*!< default = /run/vpp/memif.sock */
257  uint8_t secret[24]; /*!< optional (interface authentication) */
258 
259  uint8_t num_s2m_rings; /*!< default = 1 */
260  uint8_t num_m2s_rings; /*!< default = 1 */
261  uint16_t buffer_size; /*!< default = 2048 */
262  uint8_t log2_ring_size; /*!< default = 10 (1024) */
263  uint8_t is_master;
264 
265  uint32_t interface_id;
266  uint8_t interface_name[32];
269 
270 /*! memif receive mode */
271 typedef enum
272 {
273  MEMIF_RX_MODE_INTERRUPT = 0, /*!< interrupt mode */
274  MEMIF_RX_MODE_POLLING /*!< polling mode */
276 
277 /** \brief Memif buffer
278  @param desc_index - ring descriptor index
279  @param ring - pointer to ring containing descriptor for this buffer
280  @param len - available length
281  @param flags - memif buffer flags
282  @param data - pointer to shared memory data
283 */
284 typedef struct
285 {
286  uint16_t desc_index;
287  void *ring;
288  uint32_t len;
289 /** next buffer present (chained buffers) */
290 #define MEMIF_BUFFER_FLAG_NEXT (1 << 0)
291 /** states that buffer is from rx ring */
292 #define MEMIF_BUFFER_FLAG_RX (1 << 1)
293  uint8_t flags;
294  void *data;
296 /** @} */
297 
298 /**
299  * @defgroup MEMIF_DETAILS Memif details structs
300  * @ingroup libmemif
301  *
302  * @{
303  */
304 
305 /** \brief Memif queue details
306  @param region - region index
307  @param qid - queue id
308  @param ring_size - size of ring buffer in sharem memory
309  @param flags - ring flags
310  @param head - ring head pointer
311  @param tail - ring tail pointer
312  @param buffer_size - buffer size on sharem memory
313 */
314 typedef struct
315 {
316  uint8_t region;
317  uint8_t qid;
318  uint32_t ring_size;
319 /** if set queue is in polling mode, else in interrupt mode */
320 #define MEMIF_QUEUE_FLAG_POLLING 1
321  uint16_t flags;
322  uint16_t head;
323  uint16_t tail;
324  uint16_t buffer_size;
326 
327 /** \brief Memif region details
328  @param index - region index
329  @param addr - region address
330  @param size - region size
331  @param fd - file descriptor
332  @param is_external - if not zero then region is defined by client
333 */
334 typedef struct
335 {
336  uint8_t index;
337  void *addr;
338  uint32_t size;
339  int fd;
340  uint8_t is_external;
342 
343 /** \brief Memif details
344  @param if_name - interface name
345  @param inst_name - application name
346  @param remote_if_name - peer interface name
347  @param remote_inst_name - peer application name
348  @param id - connection id
349  @param secret - secret
350  @param role - 0 = master, 1 = slave
351  @param mode - 0 = ethernet, 1 = ip , 2 = punt/inject
352  @param socket_filename - socket filename
353  @param regions_num - number of regions
354  @param regions - struct containing region details
355  @param rx_queues_num - number of receive queues
356  @param tx_queues_num - number of transmit queues
357  @param rx_queues - struct containing receive queue details
358  @param tx_queues - struct containing transmit queue details
359  @param error - error string
360  @param link_up_down - 1 = up (connected), 2 = down (disconnected)
361 */
362 typedef struct
363 {
364  uint8_t *if_name;
365  uint8_t *inst_name;
366  uint8_t *remote_if_name;
368 
369  uint32_t id;
370  uint8_t *secret; /* optional */
371  uint8_t role; /* 0 = master, 1 = slave */
372  uint8_t mode; /* 0 = ethernet, 1 = ip, 2 = punt/inject */
373  uint8_t *socket_filename;
374  uint8_t regions_num;
376  uint8_t rx_queues_num;
377  uint8_t tx_queues_num;
380 
381  uint8_t *error;
382  uint8_t link_up_down; /* 1 = up, 0 = down */
384 /** @} */
385 
386 /**
387  * @defgroup API_CALLS Api calls
388  * @ingroup libmemif
389  *
390  * @{
391  */
392 
393 /** \brief Memif get version
394 
395  \return ((MEMIF_VERSION_MAJOR << 8) | MEMIF_VERSION_MINOR)
396 */
397 uint16_t memif_get_version ();
398 
399 /** \biref Memif get queue event file descriptor
400  @param conn - memif connection handle
401  @param qid - queue id
402  @param[out] fd - returns event file descriptor
403 
404  \return memif_err_t
405 */
406 
407 int memif_get_queue_efd (memif_conn_handle_t conn, uint16_t qid, int *fd);
408 
409 /** \brief Memif set rx mode
410  @param conn - memif connection handle
411  @param rx_mode - receive mode
412  @param qid - queue id
413 
414  \return memif_err_t
415 */
417  uint16_t qid);
418 
419 /** \brief Memif strerror
420  @param err_code - error code
421 
422  Converts error code to error message.
423 
424  \return Error string
425 */
426 char *memif_strerror (int err_code);
427 
428 /** \brief Memif get details
429  @param conn - memif conenction handle
430  @param md - pointer to memif details struct
431  @param buf - buffer containing details strings
432  @param buflen - length of buffer
433 
434  \return memif_err_t
435 */
437  char *buf, ssize_t buflen);
438 
439 /** \brief Memif initialization
440  @param on_control_fd_update - if control fd updates inform user to watch new fd
441  @param app_name - application name (will be truncated to 32 chars)
442  @param memif_alloc - cutom memory allocator, NULL = default
443  @param memif_realloc - custom memory reallocation, NULL = default
444  @param memif_free - custom memory free, NULL = default
445 
446  if param on_control_fd_update is set to NULL,
447  libmemif will handle file descriptor event polling
448  if a valid callback is set, file descriptor event polling needs to be done by
449  user application, all file descriptors and event types will be passed in
450  this callback to user application
451 
452  Initialize internal libmemif structures. Create timerfd (used to periodically request connection by
453  disconnected memifs in slave mode, with no additional API call). This fd is passed to user with memif_control_fd_update_t
454  timer is inactive at this state. It activates with if there is at least one memif in slave mode.
455 
456  \return memif_err_t
457 */
458 int memif_init (memif_control_fd_update_t * on_control_fd_update,
459  char *app_name, memif_alloc_t * memif_alloc,
460  memif_realloc_t * memif_realloc, memif_free_t * memif_free);
461 
462 /** \brief Memif cleanup
463 
464  Free libmemif internal allocations.
465 
466  \return 0
467 */
468 int memif_cleanup ();
469 
470 /** \brief Memory interface create function
471  @param conn - connection handle for user app
472  @param args - memory interface connection arguments
473  @param on_connect - inform user about connected status
474  @param on_disconnect - inform user about disconnected status
475  @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
476  @param private_ctx - private contex passed back to user with callback
477 
478  Creates memory interface.
479 
480  SLAVE-MODE -
481  Start timer that will send events to timerfd. If this fd is passed to memif_control_fd_handler
482  every disconnected memif in slave mode will send connection request.
483  On success new fd is passed to user with memif_control_fd_update_t.
484 
485  MASTER-MODE -
486  Create listener socket and pass fd to user with memif_cntrol_fd_update_t.
487  If this fd is passed to memif_control_fd_handler accept will be called and
488  new fd will be passed to user with memif_control_fd_update_t.
489 
490 
491  \return memif_err_t
492 */
496  memif_interrupt_t * on_interrupt, void *private_ctx);
497 
498 /** \brief Memif control file descriptor handler
499  @param fd - file descriptor on which the event occured
500  @param events - event type(s) that occured
501 
502  If event occures on any control fd, call memif_control_fd_handler.
503  Internal - lib will "identify" fd (timerfd, lsitener, control) and handle event accordingly.
504 
505  FD-TYPE -
506  TIMERFD -
507  Every disconnected memif in slave mode will request connection.
508  LISTENER or CONTROL -
509  Handle socket messaging (internal connection establishment).
510  INTERRUPT -
511  Call on_interrupt callback (if set).
512 
513  \return memif_err_t
514 
515 */
516 int memif_control_fd_handler (int fd, uint8_t events);
517 
518 /** \brief Memif delete
519  @param conn - pointer to memif connection handle
520 
521 
522  disconnect session (free queues and regions, close file descriptors, unmap shared memory)
523  set connection handle to NULL, to avoid possible double free
524 
525  \return memif_err_t
526 */
527 int memif_delete (memif_conn_handle_t * conn);
528 
529 /** \brief Memif buffer enq tx
530  @param conn - memif conenction handle
531  @param qid - number indentifying queue
532  @param bufs - memif buffers
533  @param count - number of memif buffers to enque
534  @param count_out - returns number of allocated buffers
535 
536  Slave is producer of buffers.
537  If connection handle points to master returns MEMIF_ERR_INVAL_ARG.
538 
539  \return memif_err_t
540 */
541 int memif_buffer_enq_tx (memif_conn_handle_t conn, uint16_t qid,
542  memif_buffer_t * bufs, uint16_t count,
543  uint16_t * count_out);
544 
545 /** \brief Memif buffer alloc
546  @param conn - memif conenction handle
547  @param qid - number indentifying queue
548  @param bufs - memif buffers
549  @param count - number of memif buffers to allocate
550  @param count_out - returns number of allocated buffers
551  @param size - buffer size, may return chained buffers if size > buffer_size
552 
553  \return memif_err_t
554 */
555 int memif_buffer_alloc (memif_conn_handle_t conn, uint16_t qid,
556  memif_buffer_t * bufs, uint16_t count,
557  uint16_t * count_out, uint16_t size);
558 
559 /** \brief Memif refill ring
560  @param conn - memif conenction handle
561  @param qid - number indentifying queue
562  @param count - number of buffers to be placed on ring
563  @param headroom - offset the buffer by headroom
564 
565  \return memif_err_t
566 */
567 int memif_refill_queue (memif_conn_handle_t conn, uint16_t qid,
568  uint16_t count, uint16_t headroom);
569 
570 /** \brief Memif transmit buffer burst
571  @param conn - memif conenction handle
572  @param qid - number indentifying queue
573  @param bufs - memif buffers
574  @param count - number of memif buffers to transmit
575  @param tx - returns number of transmitted buffers
576 
577  \return memif_err_t
578 */
579 int memif_tx_burst (memif_conn_handle_t conn, uint16_t qid,
580  memif_buffer_t * bufs, uint16_t count, uint16_t * tx);
581 
582 /** \brief Memif receive buffer burst
583  @param conn - memif conenction handle
584  @param qid - number indentifying queue
585  @param bufs - memif buffers
586  @param count - number of memif buffers to receive
587  @param rx - returns number of received buffers
588 
589  \return memif_err_t
590 */
591 int memif_rx_burst (memif_conn_handle_t conn, uint16_t qid,
592  memif_buffer_t * bufs, uint16_t count, uint16_t * rx);
593 
594 /** \brief Memif poll event
595  @param timeout - timeout in seconds
596 
597  Passive event polling -
598  timeout = 0 - dont wait for event, check event queue if there is an event and return.
599  timeout = -1 - wait until event
600 
601  \return memif_err_t
602 */
603 int memif_poll_event (int timeout);
604 
605 /** \brief Send signal to stop concurrently running memif_poll_event().
606 
607  The function, however, does not wait for memif_poll_event() to stop.
608  memif_poll_event() may still return simply because an event has occured
609  or the timeout has elapsed, but if called repeatedly in an infinite loop,
610  a canceled memif_poll_event() is guaranted to return MEMIF_ERR_POLL_CANCEL
611  in the shortest possible time.
612  This feature was not available in the first release.
613  Use macro MEMIF_HAVE_CANCEL_POLL_EVENT to check if the feature is present.
614 
615  \return memif_err_t
616 */
617 #define MEMIF_HAVE_CANCEL_POLL_EVENT 1
619 
620 /** \brief Set connection request timer value
621  @param timer - new timer value
622 
623  Timer on which all disconnected slaves request connection.
624  See system call 'timer_settime' man-page.
625 
626  \return memif_err_t
627 */
628 int memif_set_connection_request_timer(struct itimerspec timer);
629 
630 /** \brief Send connection request
631  @param conn - memif connection handle
632 
633  Only slave interface can request connection.
634 
635  \return memif_err_t
636 */
638 /** @} */
639 
640 #endif /* _LIBMEMIF_H_ */
uint8_t * inst_name
Definition: libmemif.h:365
uint8_t * secret
Definition: libmemif.h:370
Memif region details.
Definition: libmemif.h:334
int on_disconnect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:186
void * ring
Definition: libmemif.h:287
uint8_t num_m2s_rings
Definition: libmemif.h:260
uint16_t buffer_size
Definition: libmemif.h:261
memif_interface_mode_t
Definition: memif.h:53
uint32_t interface_id
Definition: libmemif.h:265
uint16_t desc_index
Definition: libmemif.h:286
vhost_vring_addr_t addr
Definition: vhost_user.h:121
uint8_t * remote_inst_name
Definition: libmemif.h:367
int() memif_control_fd_update_t(int fd, uint8_t events)
Memif control file descriptor update (callback function)
Definition: libmemif.h:141
int memif_refill_queue(memif_conn_handle_t conn, uint16_t qid, uint16_t count, uint16_t headroom)
Memif refill ring.
Definition: main.c:1820
int on_connect(memif_conn_handle_t conn, void *private_ctx)
Definition: main.c:177
uint8_t num_s2m_rings
Definition: libmemif.h:259
uint32_t len
Definition: libmemif.h:288
int memif_get_details(memif_conn_handle_t conn, memif_details_t *md, char *buf, ssize_t buflen)
Memif get details.
Definition: main.c:2026
memif_interface_mode_t mode
Definition: libmemif.h:267
uint8_t mode
Definition: libmemif.h:372
uint8_t link_up_down
Definition: libmemif.h:382
char * memif_strerror(int err_code)
Memif strerror.
Definition: main.c:159
uint8_t * error
Definition: libmemif.h:381
uword size
void * data
Definition: libmemif.h:294
uint16_t buffer_size
Definition: libmemif.h:324
uint8_t * socket_filename
Definition: libmemif.h:373
int() memif_add_external_region_t(void **addr, uint32_t size, int *fd, void *private_ctx)
Add external region.
Definition: libmemif.h:187
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:630
int() memif_del_external_region_t(void *addr, uint32_t size, int fd, void *private_ctx)
Delete external region.
Definition: libmemif.h:210
int() memif_interrupt_t(memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
Memif interrupt occured (callback function)
Definition: libmemif.h:160
uint8_t is_master
Definition: libmemif.h:263
uint8_t rx_queues_num
Definition: libmemif.h:376
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:474
int() memif_connection_update_t(memif_conn_handle_t conn, void *private_ctx)
Memif connection status update (callback function)
Definition: libmemif.h:150
int memif_get_queue_efd(memif_conn_handle_t conn, uint16_t qid, int *fd)
Memif get queue event file descriptor
Definition: main.c:2184
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:1615
uint8_t flags
Definition: libmemif.h:293
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:374
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:1874
void() memif_free_t(void *ptr)
Memif allocator free.
Definition: libmemif.h:125
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:1694
int memif_poll_event(int timeout)
Memif poll event.
Definition: main.c:1089
memif_queue_details_t * rx_queues
Definition: libmemif.h:378
uint8_t role
Definition: libmemif.h:371
void *() memif_realloc_t(void *ptr, size_t size)
Memif realloc.
Definition: libmemif.h:118
int memif_cleanup()
Memif cleanup.
Definition: main.c:2204
uint32_t() memif_get_external_buffer_offset_t(void *private_ctx)
Get external buffer offset (optional)
Definition: libmemif.h:177
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:648
uint8_t tx_queues_num
Definition: libmemif.h:377
size_t count
Definition: vapi.c:47
memif_err_t
Definition: libmemif.h:34
memif_interface_mode_t
Definition: libmemif.h:234
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:455
int memif_control_fd_handler(int fd, uint8_t events)
Memif control file descriptor handler.
Definition: main.c:982
int memif_request_connection(memif_conn_handle_t conn)
Send connection request.
Definition: main.c:915
uint8_t log2_ring_size
Definition: libmemif.h:262
uint32_t id
Definition: libmemif.h:369
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:1941
memif_rx_mode_t
Definition: libmemif.h:271
void *() memif_alloc_t(size_t size)
Memif allocator alloc.
Definition: libmemif.h:109
void *() memif_get_external_region_addr_t(uint32_t size, int fd, void *private_ctx)
Get external region address.
Definition: libmemif.h:199
int memif_delete(memif_conn_handle_t *conn)
Memif delete.
Definition: main.c:1276
Memif queue details.
Definition: libmemif.h:314
memif_region_details_t * regions
Definition: libmemif.h:375
int memif_cancel_poll_event()
Definition: main.c:1130
memif_queue_details_t * tx_queues
Definition: libmemif.h:379
uint8_t * if_name
Definition: libmemif.h:364
Memif buffer.
Definition: libmemif.h:284
uint16_t memif_get_version()
Memif get version.
Definition: main.c:176
Memif connection arguments.
Definition: libmemif.h:254
Memif details.
Definition: libmemif.h:362
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:421
uint8_t * remote_if_name
Definition: libmemif.h:366
uint8_t * socket_filename
Definition: libmemif.h:256