Ethernet mode, IP mode, or Punt/Inject. At this moment, only Ethernet mode is
supported in DPDK memif implementation.
-Memif works in two roles: master and slave. Slave connects to master over an
+Memif works in two roles: server and client. Client connects to server over an
existing socket. It is also a producer of shared memory file and initializes
the shared memory. Each interface can be connected to one peer interface
-at same time. The peer interface is identified by id parameter. Master
-creates the socket and listens for any slave connection requests. The socket
+at same time. The peer interface is identified by id parameter. Server
+creates the socket and listens for any client connection requests. The socket
may already exist on the system. Be sure to remove any such sockets, if you
-are creating a master interface, or you will see an "Address already in use"
+are creating a server interface, or you will see an "Address already in use"
error. Function ``rte_pmd_memif_remove()``, which removes memif interface,
will also remove a listener socket, if it is not being used by any other
interface.
messages. Each memif has a unique id per socket. This id is used to identify
peer interface. If you are connecting multiple
interfaces using same socket, be sure to specify unique ids ``id=0``, ``id=1``,
-etc. Note that if you assign a socket to a master interface it becomes a
-listener socket. Listener socket can not be used by a slave interface on same
+etc. Note that if you assign a socket to a server interface it becomes a
+listener socket. Listener socket can not be used by a client interface on same
client.
.. csv-table:: **Memif configuration options**
:header: "Option", "Description", "Default", "Valid value"
"id=0", "Used to identify peer interface", "0", "uint32_t"
- "role=master", "Set memif role", "slave", "master|slave"
+ "role=server", "Set memif role", "client", "server|client"
"bsize=1024", "Size of single packet buffer", "2048", "uint16_t"
"rsize=11", "Log2 of ring size. If rsize is 10, actual ring size is 1024", "10", "1-14"
"socket=/tmp/memif.sock", "Socket filename", "/tmp/memif.sock", "string len 108"
+ "socket-abstract=no", "Set usage of abstract socket address", "yes", "yes|no"
"mac=01:23:45:ab:cd:ef", "Mac address", "01:ab:23:cd:45:ef", ""
"secret=abc123", "Secret is an optional security option, which if specified, must be matched by peer", "", "string len 24"
- "zero-copy=yes", "Enable/disable zero-copy slave mode. Only relevant to slave, requires '--single-file-segments' eal argument", "no", "yes|no"
+ "zero-copy=yes", "Enable/disable zero-copy client mode. Only relevant to client, requires '--single-file-segments' eal argument", "no", "yes|no"
**Connection establishment**
In order to create memif connection, two memif interfaces, each in separate
-process, are needed. One interface in ``master`` role and other in
-``slave`` role. It is not possible to connect two interfaces in a single
+process, are needed. One interface in ``server`` role and other in
+``client`` role. It is not possible to connect two interfaces in a single
process. Each interface can be connected to one interface at same time,
identified by matching id parameter.
Memif driver uses unix domain socket to exchange required information between
memif interfaces. Socket file path is specified at interface creation see
-*Memif configuration options* table above. If socket is used by ``master``
+*Memif configuration options* table above. If socket is used by ``server``
interface, it's marked as listener socket (in scope of current process) and
listens to connection requests from other processes. One socket can be used by
-multiple interfaces. One process can have ``slave`` and ``master`` interfaces
+multiple interfaces. One process can have ``client`` and ``server`` interfaces
at the same time, provided each role is assigned unique socket.
For detailed information on memif control messages, see: net/memif/memif.h.
-Slave interface attempts to make a connection on assigned socket. Process
+Client interface attempts to make a connection on assigned socket. Process
listening on this socket will extract the connection request and create a new
connected socket (control channel). Then it sends the 'hello' message
-(``MEMIF_MSG_TYPE_HELLO``), containing configuration boundaries. Slave interface
+(``MEMIF_MSG_TYPE_HELLO``), containing configuration boundaries. Client interface
adjusts its configuration accordingly, and sends 'init' message
(``MEMIF_MSG_TYPE_INIT``). This message among others contains interface id. Driver
-uses this id to find master interface, and assigns the control channel to this
+uses this id to find server interface, and assigns the control channel to this
interface. If such interface is found, 'ack' message (``MEMIF_MSG_TYPE_ACK``) is
-sent. Slave interface sends 'add region' message (``MEMIF_MSG_TYPE_ADD_REGION``) for
-every region allocated. Master responds to each of these messages with 'ack'
-message. Same behavior applies to rings. Slave sends 'add ring' message
-(``MEMIF_MSG_TYPE_ADD_RING``) for every initialized ring. Master again responds to
-each message with 'ack' message. To finalize the connection, slave interface
+sent. Client interface sends 'add region' message (``MEMIF_MSG_TYPE_ADD_REGION``) for
+every region allocated. Server responds to each of these messages with 'ack'
+message. Same behavior applies to rings. Client sends 'add ring' message
+(``MEMIF_MSG_TYPE_ADD_RING``) for every initialized ring. Server again responds to
+each message with 'ack' message. To finalize the connection, client interface
sends 'connect' message (``MEMIF_MSG_TYPE_CONNECT``). Upon receiving this message
-master maps regions to its address space, initializes rings and responds with
+server maps regions to its address space, initializes rings and responds with
'connected' message (``MEMIF_MSG_TYPE_CONNECTED``). Disconnect
-(``MEMIF_MSG_TYPE_DISCONNECT``) can be sent by both master and slave interfaces at
+(``MEMIF_MSG_TYPE_DISCONNECT``) can be sent by both server and client interfaces at
any time, due to driver error or if the interface is being deleted.
Files
**Shared memory format**
-Slave is producer and master is consumer. Memory regions, are mapped shared memory files,
-created by memif slave and provided to master at connection establishment.
+Client is producer and server is consumer. Memory regions, are mapped shared memory files,
+created by memif client and provided to server at connection establishment.
Regions contain rings and buffers. Rings and buffers can also be separated into multiple
regions. For no-zero-copy, rings and buffers are stored inside single memory
region to reduce the number of opened files.
- net/memif/memif.h *- descriptor and ring definitions*
- net/memif/rte_eth_memif.c *- eth_memif_rx() eth_memif_tx()*
-Zero-copy slave
-~~~~~~~~~~~~~~~
+Zero-copy client
+~~~~~~~~~~~~~~~~
-Zero-copy slave can be enabled with memif configuration option 'zero-copy=yes'. This option
-is only relevant to slave and requires eal argument '--single-file-segments'.
+Zero-copy client can be enabled with memif configuration option 'zero-copy=yes'. This option
+is only relevant to client and requires eal argument '--single-file-segments'.
This limitation is in place, because it is too expensive to identify memseg
for each packet buffer, resulting in worse performance than with zero-copy disabled.
With single file segments we can calculate offset from the beginning of the file
**Shared memory format**
-Region 0 is created by memif driver and contains rings. Slave interface exposes DPDK memory (memseg).
+Region 0 is created by memif driver and contains rings. Client interface exposes DPDK memory (memseg).
Instead of using memfd_create() to create new shared file, existing memsegs are used.
-Master interface functions the same as with zero-copy disabled.
+Server interface functions the same as with zero-copy disabled.
region 0:
----------------------------
In this example we run two instances of testpmd application and transmit packets over memif.
-First create ``master`` interface::
+First create ``server`` interface::
- #./build/app/testpmd -l 0-1 --proc-type=primary --file-prefix=pmd1 --vdev=net_memif,role=master -- -i
+ #./<build_dir>/app/dpdk-testpmd -l 0-1 --proc-type=primary --file-prefix=pmd1 --vdev=net_memif,role=server -- -i
-Now create ``slave`` interface (master must be already running so the slave will connect)::
+Now create ``client`` interface (server must be already running so the client will connect)::
- #./build/app/testpmd -l 2-3 --proc-type=primary --file-prefix=pmd2 --vdev=net_memif -- -i
+ #./<build_dir>/app/dpdk-testpmd -l 2-3 --proc-type=primary --file-prefix=pmd2 --vdev=net_memif -- -i
-You can also enable ``zero-copy`` on ``slave`` interface::
+You can also enable ``zero-copy`` on ``client`` interface::
- #./build/app/testpmd -l 2-3 --proc-type=primary --file-prefix=pmd2 --vdev=net_memif,zero-copy=yes --single-file-segments -- -i
+ #./<build_dir>/app/dpdk-testpmd -l 2-3 --proc-type=primary --file-prefix=pmd2 --vdev=net_memif,zero-copy=yes --single-file-segments -- -i
Start forwarding packets::
- Slave:
+ Client:
testpmd> start
- Master:
+ Server:
testpmd> start tx_first
Show status::
------------------------
For information on how to get and run VPP please see `<https://wiki.fd.io/view/VPP>`_.
-Start VPP in interactive mode (should be by default). Create memif master interface in VPP::
+Start VPP in interactive mode (should be by default). Create memif server interface in VPP::
- vpp# create interface memif id 0 master no-zero-copy
+ vpp# create interface memif id 0 server no-zero-copy
vpp# set interface state memif0/0 up
vpp# set interface ip address memif0/0 192.168.1.1/24
Now create memif interface by running testpmd with these command line options::
- #./testpmd --vdev=net_memif,socket=/run/vpp/memif.sock -- -i
+ #./dpdk-testpmd --vdev=net_memif,socket=/run/vpp/memif.sock -- -i
-Testpmd should now create memif slave interface and try to connect to master.
+Testpmd should now create memif client interface and try to connect to server.
In testpmd set forward option to icmpecho and start forwarding::
testpmd> set fwd icmpecho
To set the loopback, just use the same socket and id with different roles::
- #./testpmd --vdev=net_memif0,role=master,id=0 --vdev=net_memif1,role=slave,id=0 -- -i
+ #./dpdk-testpmd --vdev=net_memif0,role=server,id=0 --vdev=net_memif1,role=client,id=0 -- -i
Then start the communication::
git.droids-corp.org / dpdk.git / blobdiff