1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 Intel Corporation
5 #include <sys/socket.h>
14 #include <rte_memcpy.h>
16 #include <rte_ethdev.h>
17 #include <rte_lcore.h>
19 #include <rte_errno.h>
20 #include <rte_string_fns.h>
22 #include "rte_pdump.h"
24 #define SOCKET_PATH_VAR_RUN "/var/run"
25 #define SOCKET_PATH_HOME "HOME"
26 #define DPDK_DIR "/.dpdk"
27 #define SOCKET_DIR "/pdump_sockets"
28 #define SERVER_SOCKET "%s/pdump_server_socket"
29 #define CLIENT_SOCKET "%s/pdump_client_socket_%d_%u"
30 #define DEVICE_ID_SIZE 64
31 /* Macros for printing using RTE_LOG */
32 #define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
34 enum pdump_operation {
43 static pthread_t pdump_thread;
44 static int pdump_socket_fd;
45 static char server_socket_dir[PATH_MAX];
46 static char client_socket_dir[PATH_MAX];
48 struct pdump_request {
54 char device[DEVICE_ID_SIZE];
56 struct rte_ring *ring;
57 struct rte_mempool *mp;
61 char device[DEVICE_ID_SIZE];
63 struct rte_ring *ring;
64 struct rte_mempool *mp;
70 struct pdump_response {
76 static struct pdump_rxtx_cbs {
77 struct rte_ring *ring;
78 struct rte_mempool *mp;
79 const struct rte_eth_rxtx_callback *cb;
81 } rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
82 tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
85 pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
87 if (rte_pktmbuf_tailroom(seg) < m->data_len) {
89 "User mempool: insufficient data_len of mbuf\n");
94 seg->vlan_tci = m->vlan_tci;
96 seg->tx_offload = m->tx_offload;
97 seg->ol_flags = m->ol_flags;
98 seg->packet_type = m->packet_type;
99 seg->vlan_tci_outer = m->vlan_tci_outer;
100 seg->data_len = m->data_len;
101 seg->pkt_len = seg->data_len;
102 rte_memcpy(rte_pktmbuf_mtod(seg, void *),
103 rte_pktmbuf_mtod(m, void *),
104 rte_pktmbuf_data_len(seg));
109 static inline struct rte_mbuf *
110 pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
112 struct rte_mbuf *m_dup, *seg, **prev;
116 m_dup = rte_pktmbuf_alloc(mp);
117 if (unlikely(m_dup == NULL))
127 if (pdump_pktmbuf_copy_data(seg, m) < 0) {
129 rte_pktmbuf_free_seg(seg);
130 rte_pktmbuf_free(m_dup);
135 } while ((m = m->next) != NULL &&
136 (seg = rte_pktmbuf_alloc(mp)) != NULL);
139 m_dup->nb_segs = nseg;
140 m_dup->pkt_len = pktlen;
142 /* Allocation of new indirect segment failed */
143 if (unlikely(seg == NULL)) {
144 rte_pktmbuf_free(m_dup);
148 __rte_mbuf_sanity_check(m_dup, 1);
153 pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
158 struct rte_mbuf *dup_bufs[nb_pkts];
159 struct pdump_rxtx_cbs *cbs;
160 struct rte_ring *ring;
161 struct rte_mempool *mp;
167 for (i = 0; i < nb_pkts; i++) {
168 p = pdump_pktmbuf_copy(pkts[i], mp);
170 dup_bufs[d_pkts++] = p;
173 ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts, NULL);
174 if (unlikely(ring_enq < d_pkts)) {
175 RTE_LOG(DEBUG, PDUMP,
176 "only %d of packets enqueued to ring\n", ring_enq);
178 rte_pktmbuf_free(dup_bufs[ring_enq]);
179 } while (++ring_enq < d_pkts);
184 pdump_rx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
185 struct rte_mbuf **pkts, uint16_t nb_pkts,
186 uint16_t max_pkts __rte_unused,
189 pdump_copy(pkts, nb_pkts, user_params);
194 pdump_tx(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
195 struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
197 pdump_copy(pkts, nb_pkts, user_params);
202 pdump_register_rx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
203 struct rte_ring *ring, struct rte_mempool *mp,
207 struct pdump_rxtx_cbs *cbs = NULL;
209 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
210 for (; qid < end_q; qid++) {
211 cbs = &rx_cbs[port][qid];
212 if (cbs && operation == ENABLE) {
215 "failed to add rx callback for port=%d "
216 "and queue=%d, callback already exists\n",
222 cbs->cb = rte_eth_add_first_rx_callback(port, qid,
224 if (cbs->cb == NULL) {
226 "failed to add rx callback, errno=%d\n",
231 if (cbs && operation == DISABLE) {
234 if (cbs->cb == NULL) {
236 "failed to delete non existing rx "
237 "callback for port=%d and queue=%d\n",
241 ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
244 "failed to remove rx callback, errno=%d\n",
256 pdump_register_tx_callbacks(uint16_t end_q, uint16_t port, uint16_t queue,
257 struct rte_ring *ring, struct rte_mempool *mp,
262 struct pdump_rxtx_cbs *cbs = NULL;
264 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
265 for (; qid < end_q; qid++) {
266 cbs = &tx_cbs[port][qid];
267 if (cbs && operation == ENABLE) {
270 "failed to add tx callback for port=%d "
271 "and queue=%d, callback already exists\n",
277 cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
279 if (cbs->cb == NULL) {
281 "failed to add tx callback, errno=%d\n",
286 if (cbs && operation == DISABLE) {
289 if (cbs->cb == NULL) {
291 "failed to delete non existing tx "
292 "callback for port=%d and queue=%d\n",
296 ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
299 "failed to remove tx callback, errno=%d\n",
311 set_pdump_rxtx_cbs(struct pdump_request *p)
313 uint16_t nb_rx_q = 0, nb_tx_q = 0, end_q, queue;
318 struct rte_ring *ring;
319 struct rte_mempool *mp;
323 if (operation == ENABLE) {
324 ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
328 "failed to get port id for device id=%s\n",
329 p->data.en_v1.device);
332 queue = p->data.en_v1.queue;
333 ring = p->data.en_v1.ring;
334 mp = p->data.en_v1.mp;
336 ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
340 "failed to get port id for device id=%s\n",
341 p->data.dis_v1.device);
344 queue = p->data.dis_v1.queue;
345 ring = p->data.dis_v1.ring;
346 mp = p->data.dis_v1.mp;
349 /* validation if packet capture is for all queues */
350 if (queue == RTE_PDUMP_ALL_QUEUES) {
351 struct rte_eth_dev_info dev_info;
353 rte_eth_dev_info_get(port, &dev_info);
354 nb_rx_q = dev_info.nb_rx_queues;
355 nb_tx_q = dev_info.nb_tx_queues;
356 if (nb_rx_q == 0 && flags & RTE_PDUMP_FLAG_RX) {
358 "number of rx queues cannot be 0\n");
361 if (nb_tx_q == 0 && flags & RTE_PDUMP_FLAG_TX) {
363 "number of tx queues cannot be 0\n");
366 if ((nb_tx_q == 0 || nb_rx_q == 0) &&
367 flags == RTE_PDUMP_FLAG_RXTX) {
369 "both tx&rx queues must be non zero\n");
374 /* register RX callback */
375 if (flags & RTE_PDUMP_FLAG_RX) {
376 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
377 ret = pdump_register_rx_callbacks(end_q, port, queue, ring, mp,
383 /* register TX callback */
384 if (flags & RTE_PDUMP_FLAG_TX) {
385 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
386 ret = pdump_register_tx_callbacks(end_q, port, queue, ring, mp,
395 /* get socket path (/var/run if root, $HOME otherwise) */
397 pdump_get_socket_path(char *buffer, int bufsz, enum rte_pdump_socktype type)
399 char dpdk_dir[PATH_MAX] = {0};
400 char dir[PATH_MAX] = {0};
401 char *dir_home = NULL;
404 if (type == RTE_PDUMP_SOCKET_SERVER && server_socket_dir[0] != 0)
405 strlcpy(dir, server_socket_dir, sizeof(dir));
406 else if (type == RTE_PDUMP_SOCKET_CLIENT && client_socket_dir[0] != 0)
407 strlcpy(dir, client_socket_dir, sizeof(dir));
410 dir_home = getenv(SOCKET_PATH_HOME);
413 "Failed to get environment variable"
414 " value for %s, %s:%d\n",
415 SOCKET_PATH_HOME, __func__, __LINE__);
418 snprintf(dpdk_dir, sizeof(dpdk_dir), "%s%s",
421 snprintf(dpdk_dir, sizeof(dpdk_dir), "%s%s",
422 SOCKET_PATH_VAR_RUN, DPDK_DIR);
424 mkdir(dpdk_dir, 0700);
425 snprintf(dir, sizeof(dir), "%s%s",
426 dpdk_dir, SOCKET_DIR);
429 ret = mkdir(dir, 0700);
430 /* if user passed socket path is invalid, return immediately */
431 if (ret < 0 && errno != EEXIST) {
433 "Failed to create dir:%s:%s\n", dir,
439 if (type == RTE_PDUMP_SOCKET_SERVER)
440 snprintf(buffer, bufsz, SERVER_SOCKET, dir);
442 snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
449 pdump_create_server_socket(void)
452 struct sockaddr_un addr;
455 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
456 RTE_PDUMP_SOCKET_SERVER);
459 "Failed to get server socket path: %s:%d\n",
463 addr.sun_family = AF_UNIX;
465 /* remove if file already exists */
466 unlink(addr.sun_path);
468 /* set up a server socket */
469 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
472 "Failed to create server socket: %s, %s:%d\n",
473 strerror(errno), __func__, __LINE__);
477 addr_len = sizeof(struct sockaddr_un);
478 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
481 "Failed to bind to server socket: %s, %s:%d\n",
482 strerror(errno), __func__, __LINE__);
487 /* save the socket in local configuration */
488 pdump_socket_fd = socket_fd;
493 static __attribute__((noreturn)) void *
494 pdump_thread_main(__rte_unused void *arg)
496 struct sockaddr_un cli_addr;
498 struct pdump_request cli_req;
499 struct pdump_response resp;
503 /* host thread, never break out */
505 /* recv client requests */
506 cli_len = sizeof(cli_addr);
507 n = recvfrom(pdump_socket_fd, &cli_req,
508 sizeof(struct pdump_request), 0,
509 (struct sockaddr *)&cli_addr, &cli_len);
512 "failed to recv from client:%s, %s:%d\n",
513 strerror(errno), __func__, __LINE__);
517 ret = set_pdump_rxtx_cbs(&cli_req);
519 resp.ver = cli_req.ver;
520 resp.res_op = cli_req.op;
521 resp.err_value = ret;
522 n = sendto(pdump_socket_fd, &resp,
523 sizeof(struct pdump_response),
524 0, (struct sockaddr *)&cli_addr, cli_len);
527 "failed to send to client:%s, %s:%d\n",
528 strerror(errno), __func__, __LINE__);
534 rte_pdump_init(const char *path)
537 char thread_name[RTE_MAX_THREAD_NAME_LEN];
539 ret = rte_pdump_set_socket_dir(path, RTE_PDUMP_SOCKET_SERVER);
543 ret = pdump_create_server_socket();
546 "Failed to create server socket:%s:%d\n",
551 /* create the host thread to wait/handle pdump requests */
552 ret = pthread_create(&pdump_thread, NULL, pdump_thread_main, NULL);
555 "Failed to create the pdump thread:%s, %s:%d\n",
556 strerror(ret), __func__, __LINE__);
559 /* Set thread_name for aid in debugging. */
560 snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, "pdump-thread");
561 ret = rte_thread_setname(pdump_thread, thread_name);
563 RTE_LOG(DEBUG, PDUMP,
564 "Failed to set thread name for pdump handling\n");
571 rte_pdump_uninit(void)
575 ret = pthread_cancel(pdump_thread);
578 "Failed to cancel the pdump thread:%s, %s:%d\n",
579 strerror(ret), __func__, __LINE__);
583 ret = close(pdump_socket_fd);
586 "Failed to close server socket: %s, %s:%d\n",
587 strerror(errno), __func__, __LINE__);
591 struct sockaddr_un addr;
593 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
594 RTE_PDUMP_SOCKET_SERVER);
597 "Failed to get server socket path: %s:%d\n",
601 ret = unlink(addr.sun_path);
604 "Failed to remove server socket addr: %s, %s:%d\n",
605 strerror(errno), __func__, __LINE__);
613 pdump_create_client_socket(struct pdump_request *p)
618 struct pdump_response server_resp;
619 struct sockaddr_un addr, serv_addr, from;
620 socklen_t addr_len, serv_len;
624 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
627 "client socket(): %s:pid(%d):tid(%u), %s:%d\n",
628 strerror(errno), pid, rte_sys_gettid(),
634 ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
635 RTE_PDUMP_SOCKET_CLIENT);
638 "Failed to get client socket path: %s:%d\n",
643 addr.sun_family = AF_UNIX;
644 addr_len = sizeof(struct sockaddr_un);
647 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
650 "client bind(): %s, %s:%d\n",
651 strerror(errno), __func__, __LINE__);
656 serv_len = sizeof(struct sockaddr_un);
657 memset(&serv_addr, 0, sizeof(serv_addr));
658 ret = pdump_get_socket_path(serv_addr.sun_path,
659 sizeof(serv_addr.sun_path),
660 RTE_PDUMP_SOCKET_SERVER);
663 "Failed to get server socket path: %s:%d\n",
668 serv_addr.sun_family = AF_UNIX;
670 n = sendto(socket_fd, p, sizeof(struct pdump_request), 0,
671 (struct sockaddr *)&serv_addr, serv_len);
674 "failed to send to server:%s, %s:%d\n",
675 strerror(errno), __func__, __LINE__);
681 n = recvfrom(socket_fd, &server_resp,
682 sizeof(struct pdump_response), 0,
683 (struct sockaddr *)&from, &serv_len);
686 "failed to recv from server:%s, %s:%d\n",
687 strerror(errno), __func__, __LINE__);
692 ret = server_resp.err_value;
697 unlink(addr.sun_path);
702 pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
704 if (ring == NULL || mp == NULL) {
705 RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
710 if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
711 RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
712 " is not valid for pdump, should have MP and MC settings\n");
716 if (ring->prod.single || ring->cons.single) {
717 RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
718 " is not valid for pdump, should have MP and MC settings\n");
727 pdump_validate_flags(uint32_t flags)
729 if (flags != RTE_PDUMP_FLAG_RX && flags != RTE_PDUMP_FLAG_TX &&
730 flags != RTE_PDUMP_FLAG_RXTX) {
732 "invalid flags, should be either rx/tx/rxtx\n");
741 pdump_validate_port(uint16_t port, char *name)
745 if (port >= RTE_MAX_ETHPORTS) {
746 RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
752 ret = rte_eth_dev_get_name_by_port(port, name);
755 "port id to name mapping failed for port id=%u, %s:%d\n",
756 port, __func__, __LINE__);
765 pdump_prepare_client_request(char *device, uint16_t queue,
768 struct rte_ring *ring,
769 struct rte_mempool *mp,
773 struct pdump_request req = {.ver = 1,};
777 if ((operation & ENABLE) != 0) {
778 snprintf(req.data.en_v1.device, sizeof(req.data.en_v1.device),
780 req.data.en_v1.queue = queue;
781 req.data.en_v1.ring = ring;
782 req.data.en_v1.mp = mp;
783 req.data.en_v1.filter = filter;
785 snprintf(req.data.dis_v1.device, sizeof(req.data.dis_v1.device),
787 req.data.dis_v1.queue = queue;
788 req.data.dis_v1.ring = NULL;
789 req.data.dis_v1.mp = NULL;
790 req.data.dis_v1.filter = NULL;
793 ret = pdump_create_client_socket(&req);
796 "client request for pdump enable/disable failed\n");
805 rte_pdump_enable(uint16_t port, uint16_t queue, uint32_t flags,
806 struct rte_ring *ring,
807 struct rte_mempool *mp,
812 char name[DEVICE_ID_SIZE];
814 ret = pdump_validate_port(port, name);
817 ret = pdump_validate_ring_mp(ring, mp);
820 ret = pdump_validate_flags(flags);
824 ret = pdump_prepare_client_request(name, queue, flags,
825 ENABLE, ring, mp, filter);
831 rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
833 struct rte_ring *ring,
834 struct rte_mempool *mp,
839 ret = pdump_validate_ring_mp(ring, mp);
842 ret = pdump_validate_flags(flags);
846 ret = pdump_prepare_client_request(device_id, queue, flags,
847 ENABLE, ring, mp, filter);
853 rte_pdump_disable(uint16_t port, uint16_t queue, uint32_t flags)
856 char name[DEVICE_ID_SIZE];
858 ret = pdump_validate_port(port, name);
861 ret = pdump_validate_flags(flags);
865 ret = pdump_prepare_client_request(name, queue, flags,
866 DISABLE, NULL, NULL, NULL);
872 rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
877 ret = pdump_validate_flags(flags);
881 ret = pdump_prepare_client_request(device_id, queue, flags,
882 DISABLE, NULL, NULL, NULL);
888 rte_pdump_set_socket_dir(const char *path, enum rte_pdump_socktype type)
893 if (type == RTE_PDUMP_SOCKET_SERVER) {
894 count = sizeof(server_socket_dir);
895 ret = strlcpy(server_socket_dir, path, count);
897 count = sizeof(client_socket_dir);
898 ret = strlcpy(client_socket_dir, path, count);
901 if (ret < 0 || ret >= count) {
903 "Invalid socket path:%s:%d\n",
905 if (type == RTE_PDUMP_SOCKET_SERVER)
906 server_socket_dir[0] = 0;
908 client_socket_dir[0] = 0;