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>
51 #include "rte_pdump.h"
53 #define SOCKET_PATH_VAR_RUN "/var/run/pdump_sockets"
54 #define SOCKET_PATH_HOME "HOME/pdump_sockets"
55 #define SERVER_SOCKET "%s/pdump_server_socket"
56 #define CLIENT_SOCKET "%s/pdump_client_socket_%d_%u"
57 #define DEVICE_ID_SIZE 64
58 /* Macros for printing using RTE_LOG */
59 #define RTE_LOGTYPE_PDUMP RTE_LOGTYPE_USER1
61 enum pdump_operation {
70 static pthread_t pdump_thread;
71 static int pdump_socket_fd;
72 static char server_socket_dir[PATH_MAX];
73 static char client_socket_dir[PATH_MAX];
75 struct pdump_request {
81 char device[DEVICE_ID_SIZE];
83 struct rte_ring *ring;
84 struct rte_mempool *mp;
88 char device[DEVICE_ID_SIZE];
90 struct rte_ring *ring;
91 struct rte_mempool *mp;
97 struct pdump_response {
103 static struct pdump_rxtx_cbs {
104 struct rte_ring *ring;
105 struct rte_mempool *mp;
106 struct rte_eth_rxtx_callback *cb;
108 } rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT],
109 tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
112 pdump_pktmbuf_copy_data(struct rte_mbuf *seg, const struct rte_mbuf *m)
114 if (rte_pktmbuf_tailroom(seg) < m->data_len) {
116 "User mempool: insufficient data_len of mbuf\n");
121 seg->vlan_tci = m->vlan_tci;
123 seg->tx_offload = m->tx_offload;
124 seg->ol_flags = m->ol_flags;
125 seg->packet_type = m->packet_type;
126 seg->vlan_tci_outer = m->vlan_tci_outer;
127 seg->data_len = m->data_len;
128 seg->pkt_len = seg->data_len;
129 rte_memcpy(rte_pktmbuf_mtod(seg, void *),
130 rte_pktmbuf_mtod(m, void *),
131 rte_pktmbuf_data_len(seg));
136 static inline struct rte_mbuf *
137 pdump_pktmbuf_copy(struct rte_mbuf *m, struct rte_mempool *mp)
139 struct rte_mbuf *m_dup, *seg, **prev;
143 m_dup = rte_pktmbuf_alloc(mp);
144 if (unlikely(m_dup == NULL))
154 if (pdump_pktmbuf_copy_data(seg, m) < 0) {
155 rte_pktmbuf_free(m_dup);
160 } while ((m = m->next) != NULL &&
161 (seg = rte_pktmbuf_alloc(mp)) != NULL);
164 m_dup->nb_segs = nseg;
165 m_dup->pkt_len = pktlen;
167 /* Allocation of new indirect segment failed */
168 if (unlikely(seg == NULL)) {
169 rte_pktmbuf_free(m_dup);
173 __rte_mbuf_sanity_check(m_dup, 1);
178 pdump_copy(struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
183 struct rte_mbuf *dup_bufs[nb_pkts];
184 struct pdump_rxtx_cbs *cbs;
185 struct rte_ring *ring;
186 struct rte_mempool *mp;
192 for (i = 0; i < nb_pkts; i++) {
193 p = pdump_pktmbuf_copy(pkts[i], mp);
195 dup_bufs[d_pkts++] = p;
198 ring_enq = rte_ring_enqueue_burst(ring, (void *)dup_bufs, d_pkts);
199 if (unlikely(ring_enq < d_pkts)) {
200 RTE_LOG(DEBUG, PDUMP,
201 "only %d of packets enqueued to ring\n", ring_enq);
203 rte_pktmbuf_free(dup_bufs[ring_enq]);
204 } while (++ring_enq < d_pkts);
209 pdump_rx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
210 struct rte_mbuf **pkts, uint16_t nb_pkts,
211 uint16_t max_pkts __rte_unused,
214 pdump_copy(pkts, nb_pkts, user_params);
219 pdump_tx(uint8_t port __rte_unused, uint16_t qidx __rte_unused,
220 struct rte_mbuf **pkts, uint16_t nb_pkts, void *user_params)
222 pdump_copy(pkts, nb_pkts, user_params);
227 pdump_get_dombdf(char *device_id, char *domBDF, size_t len)
230 struct rte_pci_addr dev_addr = {0};
232 /* identify if device_id is pci address or name */
233 ret = eal_parse_pci_DomBDF(device_id, &dev_addr);
238 ret = snprintf(domBDF, len, "%u:%u:%u.%u", dev_addr.domain,
239 dev_addr.bus, dev_addr.devid,
242 ret = snprintf(domBDF, len, "%u:%u.%u", dev_addr.bus,
250 pdump_regitser_rx_callbacks(uint16_t end_q, uint8_t port, uint16_t queue,
251 struct rte_ring *ring, struct rte_mempool *mp,
255 struct pdump_rxtx_cbs *cbs = NULL;
257 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
258 for (; qid < end_q; qid++) {
259 cbs = &rx_cbs[port][qid];
260 if (cbs && operation == ENABLE) {
263 "failed to add rx callback for port=%d "
264 "and queue=%d, callback already exists\n",
270 cbs->cb = rte_eth_add_first_rx_callback(port, qid,
272 if (cbs->cb == NULL) {
274 "failed to add rx callback, errno=%d\n",
279 if (cbs && operation == DISABLE) {
282 if (cbs->cb == NULL) {
284 "failed to delete non existing rx "
285 "callback for port=%d and queue=%d\n",
289 ret = rte_eth_remove_rx_callback(port, qid, cbs->cb);
292 "failed to remove rx callback, errno=%d\n",
304 pdump_regitser_tx_callbacks(uint16_t end_q, uint8_t port, uint16_t queue,
305 struct rte_ring *ring, struct rte_mempool *mp,
310 struct pdump_rxtx_cbs *cbs = NULL;
312 qid = (queue == RTE_PDUMP_ALL_QUEUES) ? 0 : queue;
313 for (; qid < end_q; qid++) {
314 cbs = &tx_cbs[port][qid];
315 if (cbs && operation == ENABLE) {
318 "failed to add tx callback for port=%d "
319 "and queue=%d, callback already exists\n",
325 cbs->cb = rte_eth_add_tx_callback(port, qid, pdump_tx,
327 if (cbs->cb == NULL) {
329 "failed to add tx callback, errno=%d\n",
334 if (cbs && operation == DISABLE) {
337 if (cbs->cb == NULL) {
339 "failed to delete non existing tx "
340 "callback for port=%d and queue=%d\n",
344 ret = rte_eth_remove_tx_callback(port, qid, cbs->cb);
347 "failed to remove tx callback, errno=%d\n",
359 set_pdump_rxtx_cbs(struct pdump_request *p)
361 uint16_t nb_rx_q, nb_tx_q = 0, end_q, queue;
366 struct rte_ring *ring;
367 struct rte_mempool *mp;
371 if (operation == ENABLE) {
372 ret = rte_eth_dev_get_port_by_name(p->data.en_v1.device,
376 "failed to get potid for device id=%s\n",
377 p->data.en_v1.device);
380 queue = p->data.en_v1.queue;
381 ring = p->data.en_v1.ring;
382 mp = p->data.en_v1.mp;
384 ret = rte_eth_dev_get_port_by_name(p->data.dis_v1.device,
388 "failed to get potid for device id=%s\n",
389 p->data.dis_v1.device);
392 queue = p->data.dis_v1.queue;
393 ring = p->data.dis_v1.ring;
394 mp = p->data.dis_v1.mp;
397 /* validation if packet capture is for all queues */
398 if (queue == RTE_PDUMP_ALL_QUEUES) {
399 struct rte_eth_dev_info dev_info;
401 rte_eth_dev_info_get(port, &dev_info);
402 nb_rx_q = dev_info.nb_rx_queues;
403 nb_tx_q = dev_info.nb_tx_queues;
404 if (nb_rx_q == 0 && flags & RTE_PDUMP_FLAG_RX) {
406 "number of rx queues cannot be 0\n");
409 if (nb_tx_q == 0 && flags & RTE_PDUMP_FLAG_TX) {
411 "number of tx queues cannot be 0\n");
414 if ((nb_tx_q == 0 || nb_rx_q == 0) &&
415 flags == RTE_PDUMP_FLAG_RXTX) {
417 "both tx&rx queues must be non zero\n");
422 /* register RX callback */
423 if (flags & RTE_PDUMP_FLAG_RX) {
424 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_rx_q : queue + 1;
425 ret = pdump_regitser_rx_callbacks(end_q, port, queue, ring, mp,
431 /* register TX callback */
432 if (flags & RTE_PDUMP_FLAG_TX) {
433 end_q = (queue == RTE_PDUMP_ALL_QUEUES) ? nb_tx_q : queue + 1;
434 ret = pdump_regitser_tx_callbacks(end_q, port, queue, ring, mp,
443 /* get socket path (/var/run if root, $HOME otherwise) */
445 pdump_get_socket_path(char *buffer, int bufsz, enum rte_pdump_socktype type)
447 const char *dir = NULL;
449 if (type == RTE_PDUMP_SOCKET_SERVER && server_socket_dir[0] != 0)
450 dir = server_socket_dir;
451 else if (type == RTE_PDUMP_SOCKET_CLIENT && client_socket_dir[0] != 0)
452 dir = client_socket_dir;
455 dir = getenv(SOCKET_PATH_HOME);
457 dir = SOCKET_PATH_VAR_RUN;
461 if (type == RTE_PDUMP_SOCKET_SERVER)
462 snprintf(buffer, bufsz, SERVER_SOCKET, dir);
464 snprintf(buffer, bufsz, CLIENT_SOCKET, dir, getpid(),
469 pdump_create_server_socket(void)
472 struct sockaddr_un addr;
475 pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
476 RTE_PDUMP_SOCKET_SERVER);
477 addr.sun_family = AF_UNIX;
479 /* remove if file already exists */
480 unlink(addr.sun_path);
482 /* set up a server socket */
483 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
486 "Failed to create server socket: %s, %s:%d\n",
487 strerror(errno), __func__, __LINE__);
491 addr_len = sizeof(struct sockaddr_un);
492 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
495 "Failed to bind to server socket: %s, %s:%d\n",
496 strerror(errno), __func__, __LINE__);
501 /* save the socket in local configuration */
502 pdump_socket_fd = socket_fd;
507 static __attribute__((noreturn)) void *
508 pdump_thread_main(__rte_unused void *arg)
510 struct sockaddr_un cli_addr;
512 struct pdump_request cli_req;
513 struct pdump_response resp;
517 /* host thread, never break out */
519 /* recv client requests */
520 cli_len = sizeof(cli_addr);
521 n = recvfrom(pdump_socket_fd, &cli_req,
522 sizeof(struct pdump_request), 0,
523 (struct sockaddr *)&cli_addr, &cli_len);
526 "failed to recv from client:%s, %s:%d\n",
527 strerror(errno), __func__, __LINE__);
531 ret = set_pdump_rxtx_cbs(&cli_req);
533 resp.ver = cli_req.ver;
534 resp.res_op = cli_req.op;
535 resp.err_value = ret;
536 n = sendto(pdump_socket_fd, &resp,
537 sizeof(struct pdump_response),
538 0, (struct sockaddr *)&cli_addr, cli_len);
541 "failed to send to client:%s, %s:%d\n",
542 strerror(errno), __func__, __LINE__);
548 rte_pdump_init(const char *path)
551 char thread_name[RTE_MAX_THREAD_NAME_LEN];
553 ret = rte_pdump_set_socket_dir(path, RTE_PDUMP_SOCKET_SERVER);
557 ret = pdump_create_server_socket();
560 "Failed to create server socket:%s:%d\n",
565 /* create the host thread to wait/handle pdump requests */
566 ret = pthread_create(&pdump_thread, NULL, pdump_thread_main, NULL);
569 "Failed to create the pdump thread:%s, %s:%d\n",
570 strerror(errno), __func__, __LINE__);
573 /* Set thread_name for aid in debugging. */
574 snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, "pdump-thread");
575 ret = rte_thread_setname(pdump_thread, thread_name);
577 RTE_LOG(DEBUG, PDUMP,
578 "Failed to set thread name for pdump handling\n");
585 rte_pdump_uninit(void)
589 ret = pthread_cancel(pdump_thread);
592 "Failed to cancel the pdump thread:%s, %s:%d\n",
593 strerror(errno), __func__, __LINE__);
597 ret = close(pdump_socket_fd);
600 "Failed to close server socket: %s, %s:%d\n",
601 strerror(errno), __func__, __LINE__);
605 struct sockaddr_un addr;
607 pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
608 RTE_PDUMP_SOCKET_SERVER);
609 ret = unlink(addr.sun_path);
612 "Failed to remove server socket addr: %s, %s:%d\n",
613 strerror(errno), __func__, __LINE__);
621 pdump_create_client_socket(struct pdump_request *p)
626 struct pdump_response server_resp;
627 struct sockaddr_un addr, serv_addr, from;
628 socklen_t addr_len, serv_len;
632 socket_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
635 "client socket(): %s:pid(%d):tid(%u), %s:%d\n",
636 strerror(errno), pid, rte_sys_gettid(),
642 pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
643 RTE_PDUMP_SOCKET_CLIENT);
644 addr.sun_family = AF_UNIX;
645 addr_len = sizeof(struct sockaddr_un);
648 ret = bind(socket_fd, (struct sockaddr *) &addr, addr_len);
651 "client bind(): %s, %s:%d\n",
652 strerror(errno), __func__, __LINE__);
657 serv_len = sizeof(struct sockaddr_un);
658 memset(&serv_addr, 0, sizeof(serv_addr));
659 pdump_get_socket_path(serv_addr.sun_path,
660 sizeof(serv_addr.sun_path),
661 RTE_PDUMP_SOCKET_SERVER);
662 serv_addr.sun_family = AF_UNIX;
664 n = sendto(socket_fd, p, sizeof(struct pdump_request), 0,
665 (struct sockaddr *)&serv_addr, serv_len);
668 "failed to send to server:%s, %s:%d\n",
669 strerror(errno), __func__, __LINE__);
674 n = recvfrom(socket_fd, &server_resp,
675 sizeof(struct pdump_response), 0,
676 (struct sockaddr *)&from, &serv_len);
679 "failed to recv from server:%s, %s:%d\n",
680 strerror(errno), __func__, __LINE__);
684 ret = server_resp.err_value;
688 unlink(addr.sun_path);
693 pdump_validate_ring_mp(struct rte_ring *ring, struct rte_mempool *mp)
695 if (ring == NULL || mp == NULL) {
696 RTE_LOG(ERR, PDUMP, "NULL ring or mempool are passed %s:%d\n",
701 if (mp->flags & MEMPOOL_F_SP_PUT || mp->flags & MEMPOOL_F_SC_GET) {
702 RTE_LOG(ERR, PDUMP, "mempool with either SP or SC settings"
703 " is not valid for pdump, should have MP and MC settings\n");
707 if (ring->prod.sp_enqueue || ring->cons.sc_dequeue) {
708 RTE_LOG(ERR, PDUMP, "ring with either SP or SC settings"
709 " is not valid for pdump, should have MP and MC settings\n");
718 pdump_validate_flags(uint32_t flags)
720 if (flags != RTE_PDUMP_FLAG_RX && flags != RTE_PDUMP_FLAG_TX &&
721 flags != RTE_PDUMP_FLAG_RXTX) {
723 "invalid flags, should be either rx/tx/rxtx\n");
732 pdump_validate_port(uint8_t port, char *name)
736 if (port >= RTE_MAX_ETHPORTS) {
737 RTE_LOG(ERR, PDUMP, "Invalid port id %u, %s:%d\n", port,
743 ret = rte_eth_dev_get_name_by_port(port, name);
746 "port id to name mapping failed for port id=%u, %s:%d\n",
747 port, __func__, __LINE__);
756 pdump_prepare_client_request(char *device, uint16_t queue,
759 struct rte_ring *ring,
760 struct rte_mempool *mp,
764 struct pdump_request req = {.ver = 1,};
768 if ((operation & ENABLE) != 0) {
769 strncpy(req.data.en_v1.device, device, strlen(device));
770 req.data.en_v1.queue = queue;
771 req.data.en_v1.ring = ring;
772 req.data.en_v1.mp = mp;
773 req.data.en_v1.filter = filter;
775 strncpy(req.data.dis_v1.device, device, strlen(device));
776 req.data.dis_v1.queue = queue;
777 req.data.dis_v1.ring = NULL;
778 req.data.dis_v1.mp = NULL;
779 req.data.dis_v1.filter = NULL;
782 ret = pdump_create_client_socket(&req);
785 "client request for pdump enable/disable failed\n");
794 rte_pdump_enable(uint8_t port, uint16_t queue, uint32_t flags,
795 struct rte_ring *ring,
796 struct rte_mempool *mp,
801 char name[DEVICE_ID_SIZE];
803 ret = pdump_validate_port(port, name);
806 ret = pdump_validate_ring_mp(ring, mp);
809 ret = pdump_validate_flags(flags);
813 ret = pdump_prepare_client_request(name, queue, flags,
814 ENABLE, ring, mp, filter);
820 rte_pdump_enable_by_deviceid(char *device_id, uint16_t queue,
822 struct rte_ring *ring,
823 struct rte_mempool *mp,
827 char domBDF[DEVICE_ID_SIZE];
829 ret = pdump_validate_ring_mp(ring, mp);
832 ret = pdump_validate_flags(flags);
836 if (pdump_get_dombdf(device_id, domBDF, sizeof(domBDF)) > 0)
837 ret = pdump_prepare_client_request(domBDF, queue, flags,
838 ENABLE, ring, mp, filter);
840 ret = pdump_prepare_client_request(device_id, queue, flags,
841 ENABLE, ring, mp, filter);
847 rte_pdump_disable(uint8_t port, uint16_t queue, uint32_t flags)
850 char name[DEVICE_ID_SIZE];
852 ret = pdump_validate_port(port, name);
855 ret = pdump_validate_flags(flags);
859 ret = pdump_prepare_client_request(name, queue, flags,
860 DISABLE, NULL, NULL, NULL);
866 rte_pdump_disable_by_deviceid(char *device_id, uint16_t queue,
870 char domBDF[DEVICE_ID_SIZE];
872 ret = pdump_validate_flags(flags);
876 if (pdump_get_dombdf(device_id, domBDF, sizeof(domBDF)) > 0)
877 ret = pdump_prepare_client_request(domBDF, queue, flags,
878 DISABLE, NULL, NULL, NULL);
880 ret = pdump_prepare_client_request(device_id, queue, flags,
881 DISABLE, NULL, NULL, NULL);
887 rte_pdump_set_socket_dir(const char *path, enum rte_pdump_socktype type)
892 if (type == RTE_PDUMP_SOCKET_SERVER) {
893 count = sizeof(server_socket_dir);
894 ret = snprintf(server_socket_dir, count, "%s", path);
896 count = sizeof(client_socket_dir);
897 ret = snprintf(client_socket_dir, count, "%s", path);
900 if (ret < 0 || ret >= count) {
902 "Invalid socket path:%s:%d\n",
904 if (type == RTE_PDUMP_SOCKET_SERVER)
905 server_socket_dir[0] = 0;
907 client_socket_dir[0] = 0;