4 * Copyright(c) 2016 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include <sys/socket.h>
38 #include <sys/types.h>
43 #include <rte_memcpy.h>
45 #include <rte_ethdev.h>
46 #include <rte_lcore.h>
48 #include <rte_errno.h>
50 #include "rte_pdump.h"
52 #define SOCKET_PATH_VAR_RUN "/var/run"
53 #define SOCKET_PATH_HOME "HOME"
54 #define DPDK_DIR "/.dpdk"
55 #define SOCKET_DIR "/pdump_sockets"
56 #define SERVER_SOCKET "%s/pdump_server_socket"
57 #define CLIENT_SOCKET "%s/pdump_client_socket_%d_%u"
58 #define DEVICE_ID_SIZE 64
59 /* Macros for printing using RTE_LOG */
60 #define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
62 enum pdump_operation {
71 static pthread_t pdump_thread;
72 static int pdump_socket_fd;
73 static char server_socket_dir[PATH_MAX];
74 static char client_socket_dir[PATH_MAX];
76 struct pdump_request {
82 char device[DEVICE_ID_SIZE];
84 struct rte_ring *ring;
85 struct rte_mempool *mp;
89 char device[DEVICE_ID_SIZE];
91 struct rte_ring *ring;
92 struct rte_mempool *mp;
98 struct pdump_response {
104 static struct pdump_rxtx_cbs {
105 struct rte_ring *ring;
106 struct rte_mempool *mp;
107 struct rte_eth_rxtx_callback *cb;
109 } rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
110 tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
113 pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
115 if (rte_pktmbuf_tailroom(seg) < m->data_len) {
117 "User mempool: insufficient data_len of mbuf\n");
122 seg->vlan_tci = m->vlan_tci;
124 seg->tx_offload = m->tx_offload;
125 seg->ol_flags = m->ol_flags;
126 seg->packet_type = m->packet_type;
127 seg->vlan_tci_outer = m->vlan_tci_outer;
128 seg->data_len = m->data_len;
129 seg->pkt_len = seg->data_len;
130 rte_memcpy(rte_pktmbuf_mtod(seg, void *),
131 rte_pktmbuf_mtod(m, void *),
132 rte_pktmbuf_data_len(seg));
137 static inline struct rte_mbuf *
138 pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
140 struct rte_mbuf *m_dup, *seg, **prev;
144 m_dup = rte_pktmbuf_alloc(mp);
145 if (unlikely(m_dup == NULL))
155 if (pdump_pktmbuf_copy_data(seg, m) < 0) {
157 rte_pktmbuf_free_seg(seg);
158 rte_pktmbuf_free(m_dup);
163 } while ((m = m->next) != NULL &&
164 (seg = rte_pktmbuf_alloc(mp)) != NULL);
167 m_dup->nb_segs = nseg;
168 m_dup->pkt_len = pktlen;
170 /* Allocation of new indirect segment failed */
171 if (unlikely(seg == NULL)) {
172 rte_pktmbuf_free(m_dup);
176 __rte_mbuf_sanity_check(m_dup, 1);
181 pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
186 struct rte_mbuf *dup_bufs[nb_pkts];
187 struct pdump_rxtx_cbs *cbs;
188 struct rte_ring *ring;
189 struct rte_mempool *mp;
195 for (i = 0; i < nb_pkts; i++) {
196 p = pdump_pktmbuf_copy(pkts[i], mp);
198 dup_bufs[d_pkts++] = p;
201 ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts, NULL);
202 if (unlikely(ring_enq < d_pkts)) {
203 RTE_LOG(DEBUG, PDUMP,
204 "only %d of packets enqueued to ring\n", ring_enq);
206 rte_pktmbuf_free(dup_bufs[ring_enq]);
207 } while (++ring_enq < d_pkts);
212 pdump_rx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
213 struct rte_mbuf **pkts, uint16_t nb_pkts,
214 uint16_t max_pkts __rte_unused,
217 pdump_copy(pkts, nb_pkts, user_params);
222 pdump_tx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
223 struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
225 pdump_copy(pkts, nb_pkts, user_params);
230 pdump_register_rx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
231 struct rte_ring *ring, struct rte_mempool *mp,
235 struct pdump_rxtx_cbs *cbs = NULL;
237 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
238 for (; qid < end_q; qid++) {
239 cbs = &rx_cbs[port][qid];
240 if (cbs && operation == ENABLE) {
243 "failed to add rx callback for port=%d "
244 "and queue=%d, callback already exists\n",
250 cbs->cb = rte_eth_add_first_rx_callback(port, qid,
252 if (cbs->cb == NULL) {
254 "failed to add rx callback, errno=%d\n",
259 if (cbs && operation == DISABLE) {
262 if (cbs->cb == NULL) {
264 "failed to delete non existing rx "
265 "callback for port=%d and queue=%d\n",
269 ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
272 "failed to remove rx callback, errno=%d\n",
284 pdump_register_tx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
285 struct rte_ring *ring, struct rte_mempool *mp,
290 struct pdump_rxtx_cbs *cbs = NULL;
292 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
293 for (; qid < end_q; qid++) {
294 cbs = &tx_cbs[port][qid];
295 if (cbs && operation == ENABLE) {
298 "failed to add tx callback for port=%d "
299 "and queue=%d, callback already exists\n",
305 cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
307 if (cbs->cb == NULL) {
309 "failed to add tx callback, errno=%d\n",
314 if (cbs && operation == DISABLE) {
317 if (cbs->cb == NULL) {
319 "failed to delete non existing tx "
320 "callback for port=%d and queue=%d\n",
324 ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
327 "failed to remove tx callback, errno=%d\n",
339 set_pdump_rxtx_cbs(struct pdump_request *p)
341 uint16_t nb_rx_q = 0, nb_tx_q = 0, end_q, queue;
346 struct rte_ring *ring;
347 struct rte_mempool *mp;
351 if (operation == ENABLE) {
352 ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
356 "failed to get port id for device id=%s\n",
357 p->data.en_v1.device);
360 queue = p->data.en_v1.queue;
361 ring = p->data.en_v1.ring;
362 mp = p->data.en_v1.mp;
364 ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
368 "failed to get port id for device id=%s\n",
369 p->data.dis_v1.device);
372 queue = p->data.dis_v1.queue;
373 ring = p->data.dis_v1.ring;
374 mp = p->data.dis_v1.mp;
377 /* validation if packet capture is for all queues */
378 if (queue == RTE_PDUMP_ALL_QUEUES) {
379 struct rte_eth_dev_info dev_info;
381 rte_eth_dev_info_get(port, &dev_info);
382 nb_rx_q = dev_info.nb_rx_queues;
383 nb_tx_q = dev_info.nb_tx_queues;
384 if (nb_rx_q == 0 && flags & RTE_PDUMP_FLAG_RX) {
386 "number of rx queues cannot be 0\n");
389 if (nb_tx_q == 0 && flags & RTE_PDUMP_FLAG_TX) {
391 "number of tx queues cannot be 0\n");
394 if ((nb_tx_q == 0 || nb_rx_q == 0) &&
395 flags == RTE_PDUMP_FLAG_RXTX) {
397 "both tx&rx queues must be non zero\n");
402 /* register RX callback */
403 if (flags & RTE_PDUMP_FLAG_RX) {
404 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
405 ret = pdump_register_rx_callbacks(end_q, port, queue, ring, mp,
411 /* register TX callback */
412 if (flags & RTE_PDUMP_FLAG_TX) {
413 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
414 ret = pdump_register_tx_callbacks(end_q, port, queue, ring, mp,
423 /* get socket path (/var/run if root, $HOME otherwise) */
425 pdump_get_socket_path(char *buffer, int bufsz, enum rte_pdump_socktype type)
427 char dpdk_dir[PATH_MAX] = {0};
428 char dir[PATH_MAX] = {0};
429 char *dir_home = NULL;
432 if (type == RTE_PDUMP_SOCKET_SERVER && server_socket_dir[0] != 0)
433 snprintf(dir, sizeof(dir), "%s", server_socket_dir);
434 else if (type == RTE_PDUMP_SOCKET_CLIENT && client_socket_dir[0] != 0)
435 snprintf(dir, sizeof(dir), "%s", client_socket_dir);
438 dir_home = getenv(SOCKET_PATH_HOME);
441 "Failed to get environment variable"
442 " value for %s, %s:%d\n",
443 SOCKET_PATH_HOME, __func__, __LINE__);
446 snprintf(dpdk_dir, sizeof(dpdk_dir), "%s%s",
449 snprintf(dpdk_dir, sizeof(dpdk_dir), "%s%s",
450 SOCKET_PATH_VAR_RUN, DPDK_DIR);
452 mkdir(dpdk_dir, 0700);
453 snprintf(dir, sizeof(dir), "%s%s",
454 dpdk_dir, SOCKET_DIR);
457 ret = mkdir(dir, 0700);
458 /* if user passed socket path is invalid, return immediately */
459 if (ret < 0 && errno != EEXIST) {
461 "Failed to create dir:%s:%s\n", dir,
467 if (type == RTE_PDUMP_SOCKET_SERVER)
468 snprintf(buffer, bufsz, SERVER_SOCKET, dir);
470 snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
477 pdump_create_server_socket(void)
480 struct sockaddr_un addr;
483 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
484 RTE_PDUMP_SOCKET_SERVER);
487 "Failed to get server socket path: %s:%d\n",
491 addr.sun_family = AF_UNIX;
493 /* remove if file already exists */
494 unlink(addr.sun_path);
496 /* set up a server socket */
497 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
500 "Failed to create server socket: %s, %s:%d\n",
501 strerror(errno), __func__, __LINE__);
505 addr_len = sizeof(struct sockaddr_un);
506 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
509 "Failed to bind to server socket: %s, %s:%d\n",
510 strerror(errno), __func__, __LINE__);
515 /* save the socket in local configuration */
516 pdump_socket_fd = socket_fd;
521 static __attribute__((noreturn)) void *
522 pdump_thread_main(__rte_unused void *arg)
524 struct sockaddr_un cli_addr;
526 struct pdump_request cli_req;
527 struct pdump_response resp;
531 /* host thread, never break out */
533 /* recv client requests */
534 cli_len = sizeof(cli_addr);
535 n = recvfrom(pdump_socket_fd, &cli_req,
536 sizeof(struct pdump_request), 0,
537 (struct sockaddr *)&cli_addr, &cli_len);
540 "failed to recv from client:%s, %s:%d\n",
541 strerror(errno), __func__, __LINE__);
545 ret = set_pdump_rxtx_cbs(&cli_req);
547 resp.ver = cli_req.ver;
548 resp.res_op = cli_req.op;
549 resp.err_value = ret;
550 n = sendto(pdump_socket_fd, &resp,
551 sizeof(struct pdump_response),
552 0, (struct sockaddr *)&cli_addr, cli_len);
555 "failed to send to client:%s, %s:%d\n",
556 strerror(errno), __func__, __LINE__);
562 rte_pdump_init(const char *path)
565 char thread_name[RTE_MAX_THREAD_NAME_LEN];
567 ret = rte_pdump_set_socket_dir(path, RTE_PDUMP_SOCKET_SERVER);
571 ret = pdump_create_server_socket();
574 "Failed to create server socket:%s:%d\n",
579 /* create the host thread to wait/handle pdump requests */
580 ret = pthread_create(&pdump_thread, NULL, pdump_thread_main, NULL);
583 "Failed to create the pdump thread:%s, %s:%d\n",
584 strerror(ret), __func__, __LINE__);
587 /* Set thread_name for aid in debugging. */
588 snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, "pdump-thread");
589 ret = rte_thread_setname(pdump_thread, thread_name);
591 RTE_LOG(DEBUG, PDUMP,
592 "Failed to set thread name for pdump handling\n");
599 rte_pdump_uninit(void)
603 ret = pthread_cancel(pdump_thread);
606 "Failed to cancel the pdump thread:%s, %s:%d\n",
607 strerror(ret), __func__, __LINE__);
611 ret = close(pdump_socket_fd);
614 "Failed to close server socket: %s, %s:%d\n",
615 strerror(errno), __func__, __LINE__);
619 struct sockaddr_un addr;
621 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
622 RTE_PDUMP_SOCKET_SERVER);
625 "Failed to get server socket path: %s:%d\n",
629 ret = unlink(addr.sun_path);
632 "Failed to remove server socket addr: %s, %s:%d\n",
633 strerror(errno), __func__, __LINE__);
641 pdump_create_client_socket(struct pdump_request *p)
646 struct pdump_response server_resp;
647 struct sockaddr_un addr, serv_addr, from;
648 socklen_t addr_len, serv_len;
652 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
655 "client socket(): %s:pid(%d):tid(%u), %s:%d\n",
656 strerror(errno), pid, rte_sys_gettid(),
662 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
663 RTE_PDUMP_SOCKET_CLIENT);
666 "Failed to get client socket path: %s:%d\n",
671 addr.sun_family = AF_UNIX;
672 addr_len = sizeof(struct sockaddr_un);
675 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
678 "client bind(): %s, %s:%d\n",
679 strerror(errno), __func__, __LINE__);
684 serv_len = sizeof(struct sockaddr_un);
685 memset(&serv_addr, 0, sizeof(serv_addr));
686 ret = pdump_get_socket_path(serv_addr.sun_path,
687 sizeof(serv_addr.sun_path),
688 RTE_PDUMP_SOCKET_SERVER);
691 "Failed to get server socket path: %s:%d\n",
696 serv_addr.sun_family = AF_UNIX;
698 n = sendto(socket_fd, p, sizeof(struct pdump_request), 0,
699 (struct sockaddr *)&serv_addr, serv_len);
702 "failed to send to server:%s, %s:%d\n",
703 strerror(errno), __func__, __LINE__);
709 n = recvfrom(socket_fd, &server_resp,
710 sizeof(struct pdump_response), 0,
711 (struct sockaddr *)&from, &serv_len);
714 "failed to recv from server:%s, %s:%d\n",
715 strerror(errno), __func__, __LINE__);
720 ret = server_resp.err_value;
725 unlink(addr.sun_path);
730 pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
732 if (ring == NULL || mp == NULL) {
733 RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
738 if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
739 RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
740 " is not valid for pdump, should have MP and MC settings\n");
744 if (ring->prod.single || ring->cons.single) {
745 RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
746 " is not valid for pdump, should have MP and MC settings\n");
755 pdump_validate_flags(uint32_t flags)
757 if (flags != RTE_PDUMP_FLAG_RX && flags != RTE_PDUMP_FLAG_TX &&
758 flags != RTE_PDUMP_FLAG_RXTX) {
760 "invalid flags, should be either rx/tx/rxtx\n");
769 pdump_validate_port(uint16_t port, char *name)
773 if (port >= RTE_MAX_ETHPORTS) {
774 RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
780 ret = rte_eth_dev_get_name_by_port(port, name);
783 "port id to name mapping failed for port id=%u, %s:%d\n",
784 port, __func__, __LINE__);
793 pdump_prepare_client_request(char *device, uint16_t queue,
796 struct rte_ring *ring,
797 struct rte_mempool *mp,
801 struct pdump_request req = {.ver = 1,};
805 if ((operation & ENABLE) != 0) {
806 snprintf(req.data.en_v1.device, sizeof(req.data.en_v1.device),
808 req.data.en_v1.queue = queue;
809 req.data.en_v1.ring = ring;
810 req.data.en_v1.mp = mp;
811 req.data.en_v1.filter = filter;
813 snprintf(req.data.dis_v1.device, sizeof(req.data.dis_v1.device),
815 req.data.dis_v1.queue = queue;
816 req.data.dis_v1.ring = NULL;
817 req.data.dis_v1.mp = NULL;
818 req.data.dis_v1.filter = NULL;
821 ret = pdump_create_client_socket(&req);
824 "client request for pdump enable/disable failed\n");
833 rte_pdump_enable(uint16_t port, uint16_t queue, uint32_t flags,
834 struct rte_ring *ring,
835 struct rte_mempool *mp,
840 char name[DEVICE_ID_SIZE];
842 ret = pdump_validate_port(port, name);
845 ret = pdump_validate_ring_mp(ring, mp);
848 ret = pdump_validate_flags(flags);
852 ret = pdump_prepare_client_request(name, queue, flags,
853 ENABLE, ring, mp, filter);
859 rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
861 struct rte_ring *ring,
862 struct rte_mempool *mp,
867 ret = pdump_validate_ring_mp(ring, mp);
870 ret = pdump_validate_flags(flags);
874 ret = pdump_prepare_client_request(device_id, queue, flags,
875 ENABLE, ring, mp, filter);
881 rte_pdump_disable(uint16_t port, uint16_t queue, uint32_t flags)
884 char name[DEVICE_ID_SIZE];
886 ret = pdump_validate_port(port, name);
889 ret = pdump_validate_flags(flags);
893 ret = pdump_prepare_client_request(name, queue, flags,
894 DISABLE, NULL, NULL, NULL);
900 rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
905 ret = pdump_validate_flags(flags);
909 ret = pdump_prepare_client_request(device_id, queue, flags,
910 DISABLE, NULL, NULL, NULL);
916 rte_pdump_set_socket_dir(const char *path, enum rte_pdump_socktype type)
921 if (type == RTE_PDUMP_SOCKET_SERVER) {
922 count = sizeof(server_socket_dir);
923 ret = snprintf(server_socket_dir, count, "%s", path);
925 count = sizeof(client_socket_dir);
926 ret = snprintf(client_socket_dir, count, "%s", path);
929 if (ret < 0 || ret >= count) {
931 "Invalid socket path:%s:%d\n",
933 if (type == RTE_PDUMP_SOCKET_SERVER)
934 server_socket_dir[0] = 0;
936 client_socket_dir[0] = 0;