diff --git a/sys/dev/ena/ena.c b/sys/dev/ena/ena.c index 1ec3d3b2b6e..3fd2dcf214f 100644 --- a/sys/dev/ena/ena.c +++ b/sys/dev/ena/ena.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include #include #include +#include #include #include #include @@ -48,41 +49,39 @@ __FBSDID("$FreeBSD$"); #include #include #include -#include + +#include +#include #include #include -#include #include +#include + +#include +#include #include #include #include -#include #include #include #include #include +#include #include - -#include #include +#include #include #include #include #include #include -#include -#include - -#include -#include - -#include "ena_datapath.h" #include "ena.h" -#include "ena_sysctl.h" +#include "ena_datapath.h" #include "ena_rss.h" +#include "ena_sysctl.h" #ifdef DEV_NETMAP #include "ena_netmap.h" @@ -91,96 +90,95 @@ __FBSDID("$FreeBSD$"); /********************************************************* * Function prototypes *********************************************************/ -static int ena_probe(device_t); -static void ena_intr_msix_mgmnt(void *); -static void ena_free_pci_resources(struct ena_adapter *); -static int ena_change_mtu(if_t, int); +static int ena_probe(device_t); +static void ena_intr_msix_mgmnt(void *); +static void ena_free_pci_resources(struct ena_adapter *); +static int ena_change_mtu(if_t, int); static inline void ena_alloc_counters(counter_u64_t *, int); static inline void ena_free_counters(counter_u64_t *, int); static inline void ena_reset_counters(counter_u64_t *, int); -static void ena_init_io_rings_common(struct ena_adapter *, - struct ena_ring *, uint16_t); -static void ena_init_io_rings_basic(struct ena_adapter *); -static void ena_init_io_rings_advanced(struct ena_adapter *); -static void ena_init_io_rings(struct ena_adapter *); -static void ena_free_io_ring_resources(struct ena_adapter *, unsigned int); -static void ena_free_all_io_rings_resources(struct ena_adapter *); -static int ena_setup_tx_dma_tag(struct ena_adapter *); -static int ena_free_tx_dma_tag(struct ena_adapter *); -static int ena_setup_rx_dma_tag(struct ena_adapter *); -static int ena_free_rx_dma_tag(struct ena_adapter *); -static void ena_release_all_tx_dmamap(struct ena_ring *); -static int ena_setup_tx_resources(struct ena_adapter *, int); -static void ena_free_tx_resources(struct ena_adapter *, int); -static int ena_setup_all_tx_resources(struct ena_adapter *); -static void ena_free_all_tx_resources(struct ena_adapter *); -static int ena_setup_rx_resources(struct ena_adapter *, unsigned int); -static void ena_free_rx_resources(struct ena_adapter *, unsigned int); -static int ena_setup_all_rx_resources(struct ena_adapter *); -static void ena_free_all_rx_resources(struct ena_adapter *); +static void ena_init_io_rings_common(struct ena_adapter *, struct ena_ring *, + uint16_t); +static void ena_init_io_rings_basic(struct ena_adapter *); +static void ena_init_io_rings_advanced(struct ena_adapter *); +static void ena_init_io_rings(struct ena_adapter *); +static void ena_free_io_ring_resources(struct ena_adapter *, unsigned int); +static void ena_free_all_io_rings_resources(struct ena_adapter *); +static int ena_setup_tx_dma_tag(struct ena_adapter *); +static int ena_free_tx_dma_tag(struct ena_adapter *); +static int ena_setup_rx_dma_tag(struct ena_adapter *); +static int ena_free_rx_dma_tag(struct ena_adapter *); +static void ena_release_all_tx_dmamap(struct ena_ring *); +static int ena_setup_tx_resources(struct ena_adapter *, int); +static void ena_free_tx_resources(struct ena_adapter *, int); +static int ena_setup_all_tx_resources(struct ena_adapter *); +static void ena_free_all_tx_resources(struct ena_adapter *); +static int ena_setup_rx_resources(struct ena_adapter *, unsigned int); +static void ena_free_rx_resources(struct ena_adapter *, unsigned int); +static int ena_setup_all_rx_resources(struct ena_adapter *); +static void ena_free_all_rx_resources(struct ena_adapter *); static inline int ena_alloc_rx_mbuf(struct ena_adapter *, struct ena_ring *, struct ena_rx_buffer *); -static void ena_free_rx_mbuf(struct ena_adapter *, struct ena_ring *, +static void ena_free_rx_mbuf(struct ena_adapter *, struct ena_ring *, struct ena_rx_buffer *); -static void ena_free_rx_bufs(struct ena_adapter *, unsigned int); -static void ena_refill_all_rx_bufs(struct ena_adapter *); -static void ena_free_all_rx_bufs(struct ena_adapter *); -static void ena_free_tx_bufs(struct ena_adapter *, unsigned int); -static void ena_free_all_tx_bufs(struct ena_adapter *); -static void ena_destroy_all_tx_queues(struct ena_adapter *); -static void ena_destroy_all_rx_queues(struct ena_adapter *); -static void ena_destroy_all_io_queues(struct ena_adapter *); -static int ena_create_io_queues(struct ena_adapter *); -static int ena_handle_msix(void *); -static int ena_enable_msix(struct ena_adapter *); -static void ena_setup_mgmnt_intr(struct ena_adapter *); -static int ena_setup_io_intr(struct ena_adapter *); -static int ena_request_mgmnt_irq(struct ena_adapter *); -static int ena_request_io_irq(struct ena_adapter *); -static void ena_free_mgmnt_irq(struct ena_adapter *); -static void ena_free_io_irq(struct ena_adapter *); -static void ena_free_irqs(struct ena_adapter*); -static void ena_disable_msix(struct ena_adapter *); -static void ena_unmask_all_io_irqs(struct ena_adapter *); -static int ena_up_complete(struct ena_adapter *); -static uint64_t ena_get_counter(if_t, ift_counter); -static int ena_media_change(if_t); -static void ena_media_status(if_t, struct ifmediareq *); -static void ena_init(void *); -static int ena_ioctl(if_t, u_long, caddr_t); -static int ena_get_dev_offloads(struct ena_com_dev_get_features_ctx *); -static void ena_update_host_info(struct ena_admin_host_info *, if_t); -static void ena_update_hwassist(struct ena_adapter *); -static int ena_setup_ifnet(device_t, struct ena_adapter *, +static void ena_free_rx_bufs(struct ena_adapter *, unsigned int); +static void ena_refill_all_rx_bufs(struct ena_adapter *); +static void ena_free_all_rx_bufs(struct ena_adapter *); +static void ena_free_tx_bufs(struct ena_adapter *, unsigned int); +static void ena_free_all_tx_bufs(struct ena_adapter *); +static void ena_destroy_all_tx_queues(struct ena_adapter *); +static void ena_destroy_all_rx_queues(struct ena_adapter *); +static void ena_destroy_all_io_queues(struct ena_adapter *); +static int ena_create_io_queues(struct ena_adapter *); +static int ena_handle_msix(void *); +static int ena_enable_msix(struct ena_adapter *); +static void ena_setup_mgmnt_intr(struct ena_adapter *); +static int ena_setup_io_intr(struct ena_adapter *); +static int ena_request_mgmnt_irq(struct ena_adapter *); +static int ena_request_io_irq(struct ena_adapter *); +static void ena_free_mgmnt_irq(struct ena_adapter *); +static void ena_free_io_irq(struct ena_adapter *); +static void ena_free_irqs(struct ena_adapter *); +static void ena_disable_msix(struct ena_adapter *); +static void ena_unmask_all_io_irqs(struct ena_adapter *); +static int ena_up_complete(struct ena_adapter *); +static uint64_t ena_get_counter(if_t, ift_counter); +static int ena_media_change(if_t); +static void ena_media_status(if_t, struct ifmediareq *); +static void ena_init(void *); +static int ena_ioctl(if_t, u_long, caddr_t); +static int ena_get_dev_offloads(struct ena_com_dev_get_features_ctx *); +static void ena_update_host_info(struct ena_admin_host_info *, if_t); +static void ena_update_hwassist(struct ena_adapter *); +static int ena_setup_ifnet(device_t, struct ena_adapter *, struct ena_com_dev_get_features_ctx *); -static int ena_enable_wc(device_t, struct resource *); -static int ena_set_queues_placement_policy(device_t, struct ena_com_dev *, +static int ena_enable_wc(device_t, struct resource *); +static int ena_set_queues_placement_policy(device_t, struct ena_com_dev *, struct ena_admin_feature_llq_desc *, struct ena_llq_configurations *); -static int ena_map_llq_mem_bar(device_t, struct ena_com_dev *); -static uint32_t ena_calc_max_io_queue_num(device_t, struct ena_com_dev *, +static int ena_map_llq_mem_bar(device_t, struct ena_com_dev *); +static uint32_t ena_calc_max_io_queue_num(device_t, struct ena_com_dev *, struct ena_com_dev_get_features_ctx *); -static int ena_calc_io_queue_size(struct ena_calc_queue_size_ctx *); -static void ena_config_host_info(struct ena_com_dev *, device_t); -static int ena_attach(device_t); -static int ena_detach(device_t); -static int ena_device_init(struct ena_adapter *, device_t, +static int ena_calc_io_queue_size(struct ena_calc_queue_size_ctx *); +static void ena_config_host_info(struct ena_com_dev *, device_t); +static int ena_attach(device_t); +static int ena_detach(device_t); +static int ena_device_init(struct ena_adapter *, device_t, struct ena_com_dev_get_features_ctx *, int *); -static int ena_enable_msix_and_set_admin_interrupts(struct ena_adapter *); +static int ena_enable_msix_and_set_admin_interrupts(struct ena_adapter *); static void ena_update_on_link_change(void *, struct ena_admin_aenq_entry *); -static void unimplemented_aenq_handler(void *, - struct ena_admin_aenq_entry *); -static int ena_copy_eni_metrics(struct ena_adapter *); -static void ena_timer_service(void *); +static void unimplemented_aenq_handler(void *, struct ena_admin_aenq_entry *); +static int ena_copy_eni_metrics(struct ena_adapter *); +static void ena_timer_service(void *); static char ena_version[] = DEVICE_NAME DRV_MODULE_NAME " v" DRV_MODULE_VERSION; static ena_vendor_info_t ena_vendor_info_array[] = { - { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_PF, 0}, - { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_PF_RSERV0, 0}, - { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_VF, 0}, - { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_VF_RSERV0, 0}, - /* Last entry */ - { 0, 0, 0 } + { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_PF, 0 }, + { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_PF_RSERV0, 0 }, + { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_VF, 0 }, + { PCI_VENDOR_ID_AMAZON, PCI_DEV_ID_ENA_VF_RSERV0, 0 }, + /* Last entry */ + { 0, 0, 0 } }; struct sx ena_global_lock; @@ -195,14 +193,14 @@ ena_dmamap_callback(void *arg, bus_dma_segment_t *segs, int nseg, int error) { if (error != 0) return; - *(bus_addr_t *) arg = segs[0].ds_addr; + *(bus_addr_t *)arg = segs[0].ds_addr; } int -ena_dma_alloc(device_t dmadev, bus_size_t size, - ena_mem_handle_t *dma, int mapflags, bus_size_t alignment, int domain) +ena_dma_alloc(device_t dmadev, bus_size_t size, ena_mem_handle_t *dma, + int mapflags, bus_size_t alignment, int domain) { - struct ena_adapter* adapter = device_get_softc(dmadev); + struct ena_adapter *adapter = device_get_softc(dmadev); device_t pdev = adapter->pdev; uint32_t maxsize; uint64_t dma_space_addr; @@ -215,16 +213,16 @@ ena_dma_alloc(device_t dmadev, bus_size_t size, dma_space_addr = BUS_SPACE_MAXADDR; error = bus_dma_tag_create(bus_get_dma_tag(dmadev), /* parent */ - alignment, 0, /* alignment, bounds */ - dma_space_addr, /* lowaddr of exclusion window */ - BUS_SPACE_MAXADDR,/* highaddr of exclusion window */ - NULL, NULL, /* filter, filterarg */ - maxsize, /* maxsize */ - 1, /* nsegments */ - maxsize, /* maxsegsize */ - BUS_DMA_ALLOCNOW, /* flags */ - NULL, /* lockfunc */ - NULL, /* lockarg */ + alignment, 0, /* alignment, bounds */ + dma_space_addr, /* lowaddr of exclusion window */ + BUS_SPACE_MAXADDR, /* highaddr of exclusion window */ + NULL, NULL, /* filter, filterarg */ + maxsize, /* maxsize */ + 1, /* nsegments */ + maxsize, /* maxsegsize */ + BUS_DMA_ALLOCNOW, /* flags */ + NULL, /* lockfunc */ + NULL, /* lockarg */ &dma->tag); if (unlikely(error != 0)) { ena_log(pdev, ERR, "bus_dma_tag_create failed: %d\n", error); @@ -238,7 +236,7 @@ ena_dma_alloc(device_t dmadev, bus_size_t size, goto fail_map_create; } - error = bus_dmamem_alloc(dma->tag, (void**) &dma->vaddr, + error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr, BUS_DMA_COHERENT | BUS_DMA_ZERO, &dma->map); if (unlikely(error != 0)) { ena_log(pdev, ERR, "bus_dmamem_alloc(%ju) failed: %d\n", @@ -247,8 +245,8 @@ ena_dma_alloc(device_t dmadev, bus_size_t size, } dma->paddr = 0; - error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, - size, ena_dmamap_callback, &dma->paddr, mapflags); + error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size, + ena_dmamap_callback, &dma->paddr, mapflags); if (unlikely((error != 0) || (dma->paddr == 0))) { ena_log(pdev, ERR, "bus_dmamap_load failed: %d\n", error); goto fail_map_load; @@ -287,8 +285,8 @@ ena_free_pci_resources(struct ena_adapter *adapter) } if (adapter->msix != NULL) { - bus_release_resource(pdev, SYS_RES_MEMORY, - adapter->msix_rid, adapter->msix); + bus_release_resource(pdev, SYS_RES_MEMORY, adapter->msix_rid, + adapter->msix); } } @@ -296,8 +294,8 @@ static int ena_probe(device_t dev) { ena_vendor_info_t *ent; - uint16_t pci_vendor_id = 0; - uint16_t pci_device_id = 0; + uint16_t pci_vendor_id = 0; + uint16_t pci_device_id = 0; pci_vendor_id = pci_get_vendor(dev); pci_device_id = pci_get_device(dev); @@ -306,15 +304,14 @@ ena_probe(device_t dev) while (ent->vendor_id != 0) { if ((pci_vendor_id == ent->vendor_id) && (pci_device_id == ent->device_id)) { - ena_log_raw(DBG, "vendor=%x device=%x\n", - pci_vendor_id, pci_device_id); + ena_log_raw(DBG, "vendor=%x device=%x\n", pci_vendor_id, + pci_device_id); device_set_desc(dev, DEVICE_DESC); return (BUS_PROBE_DEFAULT); } ent++; - } return (ENXIO); @@ -328,8 +325,7 @@ ena_change_mtu(if_t ifp, int new_mtu) int rc; if ((new_mtu > adapter->max_mtu) || (new_mtu < ENA_MIN_MTU)) { - ena_log(pdev, ERR, "Invalid MTU setting. " - "new_mtu: %d max mtu: %d min mtu: %d\n", + ena_log(pdev, ERR, "Invalid MTU setting. new_mtu: %d max mtu: %d min mtu: %d\n", new_mtu, adapter->max_mtu, ENA_MIN_MTU); return (EINVAL); } @@ -376,7 +372,6 @@ static void ena_init_io_rings_common(struct ena_adapter *adapter, struct ena_ring *ring, uint16_t qid) { - ring->qid = qid; ring->adapter = adapter; ring->ena_dev = adapter->ena_dev; @@ -432,8 +427,8 @@ ena_init_io_rings_advanced(struct ena_adapter *adapter) /* Allocate a buf ring */ txr->buf_ring_size = adapter->buf_ring_size; - txr->br = buf_ring_alloc(txr->buf_ring_size, M_DEVBUF, - M_WAITOK, &txr->ring_mtx); + txr->br = buf_ring_alloc(txr->buf_ring_size, M_DEVBUF, M_WAITOK, + &txr->ring_mtx); /* Allocate Tx statistics. */ ena_alloc_counters((counter_u64_t *)&txr->tx_stats, @@ -492,7 +487,6 @@ ena_free_all_io_rings_resources(struct ena_adapter *adapter) for (i = 0; i < adapter->num_io_queues; i++) ena_free_io_ring_resources(adapter, i); - } static int @@ -504,7 +498,7 @@ ena_setup_tx_dma_tag(struct ena_adapter *adapter) ret = bus_dma_tag_create(bus_get_dma_tag(adapter->pdev), 1, 0, /* alignment, bounds */ ENA_DMA_BIT_MASK(adapter->dma_width), /* lowaddr of excl window */ - BUS_SPACE_MAXADDR, /* highaddr of excl window */ + BUS_SPACE_MAXADDR, /* highaddr of excl window */ NULL, NULL, /* filter, filterarg */ ENA_TSO_MAXSIZE, /* maxsize */ adapter->max_tx_sgl_size - 1, /* nsegments */ @@ -539,7 +533,7 @@ ena_setup_rx_dma_tag(struct ena_adapter *adapter) ret = bus_dma_tag_create(bus_get_dma_tag(adapter->pdev), /* parent */ 1, 0, /* alignment, bounds */ ENA_DMA_BIT_MASK(adapter->dma_width), /* lowaddr of excl window */ - BUS_SPACE_MAXADDR, /* highaddr of excl window */ + BUS_SPACE_MAXADDR, /* highaddr of excl window */ NULL, NULL, /* filter, filterarg */ ena_mbuf_sz, /* maxsize */ adapter->max_rx_sgl_size, /* nsegments */ @@ -570,7 +564,7 @@ ena_release_all_tx_dmamap(struct ena_ring *tx_ring) { struct ena_adapter *adapter = tx_ring->adapter; struct ena_tx_buffer *tx_info; - bus_dma_tag_t tx_tag = adapter->tx_buf_tag;; + bus_dma_tag_t tx_tag = adapter->tx_buf_tag; int i; #ifdef DEV_NETMAP struct ena_netmap_tx_info *nm_info; @@ -661,8 +655,7 @@ ena_setup_tx_resources(struct ena_adapter *adapter, int qid) &tx_ring->tx_buffer_info[i].dmamap); if (unlikely(err != 0)) { ena_log(pdev, ERR, - "Unable to create Tx DMA map for buffer %d\n", - i); + "Unable to create Tx DMA map for buffer %d\n", i); goto err_map_release; } @@ -674,8 +667,8 @@ ena_setup_tx_resources(struct ena_adapter *adapter, int qid) &map[j]); if (unlikely(err != 0)) { ena_log(pdev, ERR, - "Unable to create " - "Tx DMA for buffer %d %d\n", i, j); + "Unable to create Tx DMA for buffer %d %d\n", + i, j); goto err_map_release; } } @@ -737,8 +730,7 @@ ena_free_tx_resources(struct ena_adapter *adapter, int qid) int j; #endif /* DEV_NETMAP */ - while (taskqueue_cancel(tx_ring->enqueue_tq, &tx_ring->enqueue_task, - NULL)) + while (taskqueue_cancel(tx_ring->enqueue_tq, &tx_ring->enqueue_task, NULL)) taskqueue_drain(tx_ring->enqueue_tq, &tx_ring->enqueue_task); taskqueue_free(tx_ring->enqueue_tq); @@ -995,8 +987,8 @@ ena_free_all_rx_resources(struct ena_adapter *adapter) } static inline int -ena_alloc_rx_mbuf(struct ena_adapter *adapter, - struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info) +ena_alloc_rx_mbuf(struct ena_adapter *adapter, struct ena_ring *rx_ring, + struct ena_rx_buffer *rx_info) { device_t pdev = adapter->pdev; struct ena_com_buf *ena_buf; @@ -1027,8 +1019,9 @@ ena_alloc_rx_mbuf(struct ena_adapter *adapter, rx_info->mbuf->m_pkthdr.len = rx_info->mbuf->m_len = mlen; /* Map packets for DMA */ - ena_log(pdev, DBG, "Using tag %p for buffers' DMA mapping, mbuf %p len: %d\n", - adapter->rx_buf_tag,rx_info->mbuf, rx_info->mbuf->m_len); + ena_log(pdev, DBG, + "Using tag %p for buffers' DMA mapping, mbuf %p len: %d\n", + adapter->rx_buf_tag, rx_info->mbuf, rx_info->mbuf->m_len); error = bus_dmamap_load_mbuf_sg(adapter->rx_buf_tag, rx_info->map, rx_info->mbuf, segs, &nsegs, BUS_DMA_NOWAIT); if (unlikely((error != 0) || (nsegs != 1))) { @@ -1036,7 +1029,6 @@ ena_alloc_rx_mbuf(struct ena_adapter *adapter, "failed to map mbuf, error: %d, nsegs: %d\n", error, nsegs); counter_u64_add(rx_ring->rx_stats.dma_mapping_err, 1); goto exit; - } bus_dmamap_sync(adapter->rx_buf_tag, rx_info->map, BUS_DMASYNC_PREREAD); @@ -1045,8 +1037,9 @@ ena_alloc_rx_mbuf(struct ena_adapter *adapter, ena_buf->paddr = segs[0].ds_addr; ena_buf->len = mlen; - ena_log(pdev, DBG, "ALLOC RX BUF: mbuf %p, rx_info %p, len %d, paddr %#jx\n", - rx_info->mbuf, rx_info,ena_buf->len, (uintmax_t)ena_buf->paddr); + ena_log(pdev, DBG, + "ALLOC RX BUF: mbuf %p, rx_info %p, len %d, paddr %#jx\n", + rx_info->mbuf, rx_info, ena_buf->len, (uintmax_t)ena_buf->paddr); return (0); @@ -1060,7 +1053,6 @@ static void ena_free_rx_mbuf(struct ena_adapter *adapter, struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info) { - if (rx_info->mbuf == NULL) { ena_log(adapter->pdev, WARN, "Trying to free unallocated buffer\n"); @@ -1103,7 +1095,8 @@ ena_refill_rx_bufs(struct ena_ring *rx_ring, uint32_t num) rx_info = &rx_ring->rx_buffer_info[req_id]; #ifdef DEV_NETMAP if (ena_rx_ring_in_netmap(adapter, rx_ring->qid)) - rc = ena_netmap_alloc_rx_slot(adapter, rx_ring, rx_info); + rc = ena_netmap_alloc_rx_slot(adapter, rx_ring, + rx_info); else #endif /* DEV_NETMAP */ rc = ena_alloc_rx_mbuf(adapter, rx_ring, rx_info); @@ -1128,8 +1121,8 @@ ena_refill_rx_bufs(struct ena_ring *rx_ring, uint32_t num) if (unlikely(i < num)) { counter_u64_add(rx_ring->rx_stats.refil_partial, 1); ena_log_io(pdev, WARN, - "refilled rx qid %d with only %d mbufs (from %d)\n", - rx_ring->qid, i, num); + "refilled rx qid %d with only %d mbufs (from %d)\n", + rx_ring->qid, i, num); } if (likely(i != 0)) @@ -1177,7 +1170,6 @@ ena_update_buf_ring_size(struct ena_adapter *adapter, ENA_FLAG_SET_ATOMIC(ENA_FLAG_DEV_UP_BEFORE_RESET, adapter); ena_trigger_reset(adapter, ENA_REGS_RESET_OS_TRIGGER); - } } @@ -1326,7 +1318,8 @@ ena_refill_all_rx_bufs(struct ena_adapter *adapter) if (unlikely(rc != bufs_num)) ena_log_io(adapter->pdev, WARN, "refilling Queue %d failed. " - "Allocated %d buffers from: %d\n", i, rc, bufs_num); + "Allocated %d buffers from: %d\n", + i, rc, bufs_num); #ifdef DEV_NETMAP rx_ring->initialized = true; #endif /* DEV_NETMAP */ @@ -1362,13 +1355,13 @@ ena_free_tx_bufs(struct ena_adapter *adapter, unsigned int qid) if (print_once) { ena_log(adapter->pdev, WARN, - "free uncompleted tx mbuf qid %d idx 0x%x\n", - qid, i); + "free uncompleted tx mbuf qid %d idx 0x%x\n", qid, + i); print_once = false; } else { ena_log(adapter->pdev, DBG, - "free uncompleted tx mbuf qid %d idx 0x%x\n", - qid, i); + "free uncompleted tx mbuf qid %d idx 0x%x\n", qid, + i); } bus_dmamap_sync(adapter->tx_buf_tag, tx_info->dmamap, @@ -1384,7 +1377,6 @@ ena_free_tx_bufs(struct ena_adapter *adapter, unsigned int qid) static void ena_free_all_tx_bufs(struct ena_adapter *adapter) { - for (int i = 0; i < adapter->num_io_queues; i++) ena_free_tx_bufs(adapter, i); } @@ -1421,10 +1413,8 @@ ena_destroy_all_io_queues(struct ena_adapter *adapter) for (i = 0; i < adapter->num_io_queues; i++) { queue = &adapter->que[i]; - while (taskqueue_cancel(queue->cleanup_tq, - &queue->cleanup_task, NULL)) - taskqueue_drain(queue->cleanup_tq, - &queue->cleanup_task); + while (taskqueue_cancel(queue->cleanup_tq, &queue->cleanup_task, NULL)) + taskqueue_drain(queue->cleanup_tq, &queue->cleanup_task); taskqueue_free(queue->cleanup_tq); } @@ -1463,12 +1453,12 @@ ena_create_io_queues(struct ena_adapter *adapter) } ring = &adapter->tx_ring[i]; rc = ena_com_get_io_handlers(ena_dev, ena_qid, - &ring->ena_com_io_sq, - &ring->ena_com_io_cq); + &ring->ena_com_io_sq, &ring->ena_com_io_cq); if (rc != 0) { ena_log(adapter->pdev, ERR, "Failed to get TX queue handlers. TX queue num" - " %d rc: %d\n", i, rc); + " %d rc: %d\n", + i, rc); ena_com_destroy_io_queue(ena_dev, ena_qid); goto err_tx; } @@ -1499,12 +1489,12 @@ ena_create_io_queues(struct ena_adapter *adapter) ring = &adapter->rx_ring[i]; rc = ena_com_get_io_handlers(ena_dev, ena_qid, - &ring->ena_com_io_sq, - &ring->ena_com_io_cq); + &ring->ena_com_io_sq, &ring->ena_com_io_cq); if (unlikely(rc != 0)) { ena_log(adapter->pdev, ERR, "Failed to get RX queue handlers. RX queue num" - " %d rc: %d\n", i, rc); + " %d rc: %d\n", + i, rc); ena_com_destroy_io_queue(ena_dev, ena_qid); goto err_rx; } @@ -1526,8 +1516,7 @@ ena_create_io_queues(struct ena_adapter *adapter) cpu_mask = &queue->cpu_mask; #endif taskqueue_start_threads_cpuset(&queue->cleanup_tq, 1, PI_NET, - cpu_mask, - "%s queue %d cleanup", + cpu_mask, "%s queue %d cleanup", device_get_nameunit(adapter->pdev), i); } @@ -1601,8 +1590,7 @@ ena_enable_msix(struct ena_adapter *adapter) adapter->msix_entries = malloc(msix_vecs * sizeof(struct msix_entry), M_DEVBUF, M_WAITOK | M_ZERO); - ena_log(dev, DBG, "trying to enable MSI-X, vectors: %d\n", - msix_vecs); + ena_log(dev, DBG, "trying to enable MSI-X, vectors: %d\n", msix_vecs); for (i = 0; i < msix_vecs; i++) { adapter->msix_entries[i].entry = i; @@ -1613,8 +1601,8 @@ ena_enable_msix(struct ena_adapter *adapter) msix_req = msix_vecs; rc = pci_alloc_msix(dev, &msix_vecs); if (unlikely(rc != 0)) { - ena_log(dev, ERR, - "Failed to enable MSIX, vectors %d rc %d\n", msix_vecs, rc); + ena_log(dev, ERR, "Failed to enable MSIX, vectors %d rc %d\n", + msix_vecs, rc); rc = ENOSPC; goto err_msix_free; @@ -1629,8 +1617,10 @@ ena_enable_msix(struct ena_adapter *adapter) rc = ENOSPC; goto err_msix_free; } - ena_log(dev, ERR, "Enable only %d MSI-x (out of %d), reduce " - "the number of queues\n", msix_vecs, msix_req); + ena_log(dev, ERR, + "Enable only %d MSI-x (out of %d), reduce " + "the number of queues\n", + msix_vecs, msix_req); } adapter->msix_vecs = msix_vecs; @@ -1648,10 +1638,8 @@ err_msix_free: static void ena_setup_mgmnt_intr(struct ena_adapter *adapter) { - - snprintf(adapter->irq_tbl[ENA_MGMNT_IRQ_IDX].name, - ENA_IRQNAME_SIZE, "ena-mgmnt@pci:%s", - device_get_nameunit(adapter->pdev)); + snprintf(adapter->irq_tbl[ENA_MGMNT_IRQ_IDX].name, ENA_IRQNAME_SIZE, + "ena-mgmnt@pci:%s", device_get_nameunit(adapter->pdev)); /* * Handler is NULL on purpose, it will be set * when mgmnt interrupt is acquired @@ -1736,11 +1724,11 @@ ena_request_mgmnt_irq(struct ena_adapter *adapter) } rc = bus_setup_intr(adapter->pdev, irq->res, - INTR_TYPE_NET | INTR_MPSAFE, NULL, ena_intr_msix_mgmnt, - irq->data, &irq->cookie); + INTR_TYPE_NET | INTR_MPSAFE, NULL, ena_intr_msix_mgmnt, irq->data, + &irq->cookie); if (unlikely(rc != 0)) { - ena_log(pdev, ERR, "failed to register " - "interrupt handler for irq %ju: %d\n", + ena_log(pdev, ERR, + "failed to register interrupt handler for irq %ju: %d\n", rman_get_start(irq->res), rc); goto err_res_free; } @@ -1750,11 +1738,12 @@ ena_request_mgmnt_irq(struct ena_adapter *adapter) err_res_free: ena_log(pdev, INFO, "releasing resource for irq %d\n", irq->vector); - rcc = bus_release_resource(adapter->pdev, SYS_RES_IRQ, - irq->vector, irq->res); + rcc = bus_release_resource(adapter->pdev, SYS_RES_IRQ, irq->vector, + irq->res); if (unlikely(rcc != 0)) - ena_log(pdev, ERR, "dev has no parent while " - "releasing res for irq: %d\n", irq->vector); + ena_log(pdev, ERR, + "dev has no parent while releasing res for irq: %d\n", + irq->vector); irq->res = NULL; return (rc); @@ -1786,17 +1775,17 @@ ena_request_io_irq(struct ena_adapter *adapter) &irq->vector, flags); if (unlikely(irq->res == NULL)) { rc = ENOMEM; - ena_log(pdev, ERR, "could not allocate irq vector: %d\n", - irq->vector); + ena_log(pdev, ERR, + "could not allocate irq vector: %d\n", irq->vector); goto err; } rc = bus_setup_intr(adapter->pdev, irq->res, - INTR_TYPE_NET | INTR_MPSAFE, irq->handler, NULL, - irq->data, &irq->cookie); - if (unlikely(rc != 0)) { - ena_log(pdev, ERR, "failed to register " - "interrupt handler for irq %ju: %d\n", + INTR_TYPE_NET | INTR_MPSAFE, irq->handler, NULL, irq->data, + &irq->cookie); + if (unlikely(rc != 0)) { + ena_log(pdev, ERR, + "failed to register interrupt handler for irq %ju: %d\n", rman_get_start(irq->res), rc); goto err; } @@ -1805,8 +1794,8 @@ ena_request_io_irq(struct ena_adapter *adapter) #ifdef RSS rc = bus_bind_intr(adapter->pdev, irq->res, irq->cpu); if (unlikely(rc != 0)) { - ena_log(pdev, ERR, "failed to bind " - "interrupt handler for irq %ju to cpu %d: %d\n", + ena_log(pdev, ERR, + "failed to bind interrupt handler for irq %ju to cpu %d: %d\n", rman_get_start(irq->res), irq->cpu, rc); goto err; } @@ -1827,9 +1816,11 @@ err: /* Once we entered err: section and irq->requested is true we free both intr and resources */ if (irq->requested) - rcc = bus_teardown_intr(adapter->pdev, irq->res, irq->cookie); + rcc = bus_teardown_intr(adapter->pdev, irq->res, + irq->cookie); if (unlikely(rcc != 0)) - ena_log(pdev, ERR, "could not release irq: %d, error: %d\n", + ena_log(pdev, ERR, + "could not release irq: %d, error: %d\n", irq->vector, rcc); /* If we entered err: section without irq->requested set we know @@ -1842,8 +1833,9 @@ err: irq->vector, irq->res); } if (unlikely(rcc != 0)) - ena_log(pdev, ERR, "dev has no parent while " - "releasing res for irq: %d\n", irq->vector); + ena_log(pdev, ERR, + "dev has no parent while releasing res for irq: %d\n", + irq->vector); irq->requested = false; irq->res = NULL; } @@ -1874,8 +1866,9 @@ ena_free_mgmnt_irq(struct ena_adapter *adapter) irq->vector, irq->res); irq->res = NULL; if (unlikely(rc != 0)) - ena_log(pdev, ERR, "dev has no parent while " - "releasing res for irq: %d\n", irq->vector); + ena_log(pdev, ERR, + "dev has no parent while releasing res for irq: %d\n", + irq->vector); } } @@ -1893,7 +1886,8 @@ ena_free_io_irq(struct ena_adapter *adapter) rc = bus_teardown_intr(adapter->pdev, irq->res, irq->cookie); if (unlikely(rc != 0)) { - ena_log(pdev, ERR, "failed to tear down irq: %d\n", + ena_log(pdev, ERR, + "failed to tear down irq: %d\n", irq->vector); } irq->requested = 0; @@ -1906,8 +1900,8 @@ ena_free_io_irq(struct ena_adapter *adapter) irq->vector, irq->res); irq->res = NULL; if (unlikely(rc != 0)) { - ena_log(pdev, ERR, "dev has no parent" - " while releasing res for irq: %d\n", + ena_log(pdev, ERR, + "dev has no parent while releasing res for irq: %d\n", irq->vector); } } @@ -1915,9 +1909,8 @@ ena_free_io_irq(struct ena_adapter *adapter) } static void -ena_free_irqs(struct ena_adapter* adapter) +ena_free_irqs(struct ena_adapter *adapter) { - ena_free_io_irq(adapter); ena_free_mgmnt_irq(adapter); ena_disable_msix(adapter); @@ -1926,7 +1919,6 @@ ena_free_irqs(struct ena_adapter* adapter) static void ena_disable_msix(struct ena_adapter *adapter) { - if (ENA_FLAG_ISSET(ENA_FLAG_MSIX_ENABLED, adapter)) { ENA_FLAG_CLEAR_ATOMIC(ENA_FLAG_MSIX_ENABLED, adapter); pci_release_msi(adapter->pdev); @@ -1940,7 +1932,7 @@ ena_disable_msix(struct ena_adapter *adapter) static void ena_unmask_all_io_irqs(struct ena_adapter *adapter) { - struct ena_com_io_cq* io_cq; + struct ena_com_io_cq *io_cq; struct ena_eth_io_intr_reg intr_reg; struct ena_ring *tx_ring; uint16_t ena_qid; @@ -1983,8 +1975,7 @@ ena_up_complete(struct ena_adapter *adapter) } static void -set_io_rings_size(struct ena_adapter *adapter, int new_tx_size, - int new_rx_size) +set_io_rings_size(struct ena_adapter *adapter, int new_tx_size, int new_rx_size) { int i; @@ -2027,8 +2018,7 @@ create_queues_with_size_backoff(struct ena_adapter *adapter) /* Create IO queues for Rx & Tx */ rc = ena_create_io_queues(adapter); if (unlikely(rc != 0)) { - ena_log(pdev, ERR, - "create IO queues failed\n"); + ena_log(pdev, ERR, "create IO queues failed\n"); goto err_io_que; } @@ -2060,8 +2050,8 @@ err_setup_tx: new_rx_ring_size = cur_rx_ring_size; /* - * Decrease the size of a larger queue, or decrease both if they are - * the same size. + * Decrease the size of a larger queue, or decrease both if they + * are the same size. */ if (cur_rx_ring_size <= cur_tx_ring_size) new_tx_ring_size = cur_tx_ring_size / 2; @@ -2115,13 +2105,12 @@ ena_up(struct ena_adapter *adapter) } ena_log(adapter->pdev, INFO, - "Creating %u IO queues. Rx queue size: %d, Tx queue size: %d, " - "LLQ is %s\n", + "Creating %u IO queues. Rx queue size: %d, Tx queue size: %d, LLQ is %s\n", adapter->num_io_queues, adapter->requested_rx_ring_size, adapter->requested_tx_ring_size, (adapter->ena_dev->tx_mem_queue_type == - ENA_ADMIN_PLACEMENT_POLICY_DEV) ? "ENABLED" : "DISABLED"); + ENA_ADMIN_PLACEMENT_POLICY_DEV) ? "ENABLED" : "DISABLED"); rc = create_queues_with_size_backoff(adapter); if (unlikely(rc != 0)) { @@ -2141,8 +2130,7 @@ ena_up(struct ena_adapter *adapter) ena_update_hwassist(adapter); - if_setdrvflagbits(adapter->ifp, IFF_DRV_RUNNING, - IFF_DRV_OACTIVE); + if_setdrvflagbits(adapter->ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE); ENA_FLAG_SET_ATOMIC(ENA_FLAG_DEV_UP, adapter); @@ -2259,8 +2247,8 @@ ena_ioctl(if_t ifp, u_long command, caddr_t data) case SIOCSIFFLAGS: if ((ifp->if_flags & IFF_UP) != 0) { if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0) { - if ((ifp->if_flags & (IFF_PROMISC | - IFF_ALLMULTI)) != 0) { + if ((ifp->if_flags & + (IFF_PROMISC | IFF_ALLMULTI)) != 0) { ena_log(adapter->pdev, INFO, "ioctl promisc/allmulti\n"); } @@ -2330,12 +2318,10 @@ ena_get_dev_offloads(struct ena_com_dev_get_features_ctx *feat) ENA_ADMIN_FEATURE_OFFLOAD_DESC_TX_L4_IPV6_CSUM_PART_MASK)) != 0) caps |= IFCAP_TXCSUM_IPV6; - if ((feat->offload.tx & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV4_MASK) != 0) + if ((feat->offload.tx & ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV4_MASK) != 0) caps |= IFCAP_TSO4; - if ((feat->offload.tx & - ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV6_MASK) != 0) + if ((feat->offload.tx & ENA_ADMIN_FEATURE_OFFLOAD_DESC_TSO_IPV6_MASK) != 0) caps |= IFCAP_TSO6; if ((feat->offload.rx_supported & @@ -2355,9 +2341,7 @@ ena_get_dev_offloads(struct ena_com_dev_get_features_ctx *feat) static void ena_update_host_info(struct ena_admin_host_info *host_info, if_t ifp) { - - host_info->supported_network_features[0] = - (uint32_t)if_getcapabilities(ifp); + host_info->supported_network_features[0] = (uint32_t)if_getcapabilities(ifp); } static void @@ -2408,8 +2392,8 @@ ena_setup_ifnet(device_t pdev, struct ena_adapter *adapter, if_setdev(ifp, pdev); if_setsoftc(ifp, adapter); - if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST | - IFF_KNOWSEPOCH); + if_setflags(ifp, + IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST | IFF_KNOWSEPOCH); if_setinitfn(ifp, ena_init); if_settransmitfn(ifp, ena_mq_start); if_setqflushfn(ifp, ena_qflush); @@ -2441,8 +2425,8 @@ ena_setup_ifnet(device_t pdev, struct ena_adapter *adapter, * Specify the media types supported by this adapter and register * callbacks to update media and link information */ - ifmedia_init(&adapter->media, IFM_IMASK, - ena_media_change, ena_media_status); + ifmedia_init(&adapter->media, IFM_IMASK, ena_media_change, + ena_media_status); ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); @@ -2464,17 +2448,14 @@ ena_down(struct ena_adapter *adapter) ena_log(adapter->pdev, INFO, "device is going DOWN\n"); ENA_FLAG_CLEAR_ATOMIC(ENA_FLAG_DEV_UP, adapter); - if_setdrvflagbits(adapter->ifp, IFF_DRV_OACTIVE, - IFF_DRV_RUNNING); + if_setdrvflagbits(adapter->ifp, IFF_DRV_OACTIVE, IFF_DRV_RUNNING); ena_free_io_irq(adapter); if (ENA_FLAG_ISSET(ENA_FLAG_TRIGGER_RESET, adapter)) { - rc = ena_com_dev_reset(adapter->ena_dev, - adapter->reset_reason); + rc = ena_com_dev_reset(adapter->ena_dev, adapter->reset_reason); if (unlikely(rc != 0)) - ena_log(adapter->pdev, ERR, - "Device reset failed\n"); + ena_log(adapter->pdev, ERR, "Device reset failed\n"); } ena_destroy_all_io_queues(adapter); @@ -2498,7 +2479,7 @@ ena_calc_max_io_queue_num(device_t pdev, struct ena_com_dev *ena_dev, struct ena_admin_queue_ext_feature_fields *max_queue_ext = &get_feat_ctx->max_queue_ext.max_queue_ext; io_rx_num = min_t(int, max_queue_ext->max_rx_sq_num, - max_queue_ext->max_rx_cq_num); + max_queue_ext->max_rx_cq_num); io_tx_sq_num = max_queue_ext->max_tx_sq_num; io_tx_cq_num = max_queue_ext->max_tx_cq_num; @@ -2576,7 +2557,8 @@ ena_set_queues_placement_policy(device_t pdev, struct ena_com_dev *ena_dev, rc = ena_com_config_dev_mode(ena_dev, llq, llq_default_configurations); if (unlikely(rc != 0)) { - ena_log(pdev, WARN, "Failed to configure the device mode. " + ena_log(pdev, WARN, + "Failed to configure the device mode. " "Fallback to host mode policy.\n"); ena_dev->tx_mem_queue_type = ENA_ADMIN_PLACEMENT_POLICY_HOST; } @@ -2592,11 +2574,11 @@ ena_map_llq_mem_bar(device_t pdev, struct ena_com_dev *ena_dev) /* Try to allocate resources for LLQ bar */ rid = PCIR_BAR(ENA_MEM_BAR); - adapter->memory = bus_alloc_resource_any(pdev, SYS_RES_MEMORY, - &rid, RF_ACTIVE); + adapter->memory = bus_alloc_resource_any(pdev, SYS_RES_MEMORY, &rid, + RF_ACTIVE); if (unlikely(adapter->memory == NULL)) { - ena_log(pdev, WARN, "unable to allocate LLQ bar resource. " - "Fallback to host mode policy.\n"); + ena_log(pdev, WARN, + "unable to allocate LLQ bar resource. Fallback to host mode policy.\n"); ena_dev->tx_mem_queue_type = ENA_ADMIN_PLACEMENT_POLICY_HOST; return (0); } @@ -2617,18 +2599,16 @@ ena_map_llq_mem_bar(device_t pdev, struct ena_com_dev *ena_dev) return (0); } -static inline -void set_default_llq_configurations(struct ena_llq_configurations *llq_config, - struct ena_admin_feature_llq_desc *llq) +static inline void +set_default_llq_configurations(struct ena_llq_configurations *llq_config, + struct ena_admin_feature_llq_desc *llq) { - llq_config->llq_header_location = ENA_ADMIN_INLINE_HEADER; llq_config->llq_stride_ctrl = ENA_ADMIN_MULTIPLE_DESCS_PER_ENTRY; llq_config->llq_num_decs_before_header = ENA_ADMIN_LLQ_NUM_DESCS_BEFORE_HEADER_2; - if ((llq->entry_size_ctrl_supported & - ENA_ADMIN_LIST_ENTRY_SIZE_256B) != 0 && - ena_force_large_llq_header) { + if ((llq->entry_size_ctrl_supported & ENA_ADMIN_LIST_ENTRY_SIZE_256B) != + 0 && ena_force_large_llq_header) { llq_config->llq_ring_entry_size = ENA_ADMIN_LIST_ENTRY_SIZE_256B; llq_config->llq_ring_entry_size_value = 256; @@ -2672,8 +2652,7 @@ ena_calc_io_queue_size(struct ena_calc_queue_size_ctx *ctx) } else { struct ena_admin_queue_feature_desc *max_queues = &ctx->get_feat_ctx->max_queues; - max_rx_queue_size = min_t(uint32_t, - max_queues->max_cq_depth, + max_rx_queue_size = min_t(uint32_t, max_queues->max_cq_depth, max_queues->max_sq_depth); max_tx_queue_size = max_queues->max_cq_depth; @@ -2702,9 +2681,9 @@ ena_calc_io_queue_size(struct ena_calc_queue_size_ctx *ctx) */ if (ena_force_large_llq_header) { if ((llq->entry_size_ctrl_supported & - ENA_ADMIN_LIST_ENTRY_SIZE_256B) != 0 && + ENA_ADMIN_LIST_ENTRY_SIZE_256B) != 0 && ena_dev->tx_mem_queue_type == - ENA_ADMIN_PLACEMENT_POLICY_DEV) { + ENA_ADMIN_PLACEMENT_POLICY_DEV) { max_tx_queue_size /= 2; ena_log(ctx->pdev, INFO, "Forcing large headers and decreasing maximum Tx queue size to %d\n", @@ -2757,10 +2736,9 @@ ena_config_host_info(struct ena_com_dev *ena_dev, device_t dev) strncpy(host_info->os_dist_str, osrelease, sizeof(host_info->os_dist_str) - 1); - host_info->driver_version = - (DRV_MODULE_VER_MAJOR) | - (DRV_MODULE_VER_MINOR << ENA_ADMIN_HOST_INFO_MINOR_SHIFT) | - (DRV_MODULE_VER_SUBMINOR << ENA_ADMIN_HOST_INFO_SUB_MINOR_SHIFT); + host_info->driver_version = (DRV_MODULE_VER_MAJOR) | + (DRV_MODULE_VER_MINOR << ENA_ADMIN_HOST_INFO_MINOR_SHIFT) | + (DRV_MODULE_VER_SUBMINOR << ENA_ADMIN_HOST_INFO_SUB_MINOR_SHIFT); host_info->num_cpus = mp_ncpus; host_info->driver_supported_features = ENA_ADMIN_HOST_INFO_RX_OFFSET_MASK | @@ -2786,7 +2764,7 @@ static int ena_device_init(struct ena_adapter *adapter, device_t pdev, struct ena_com_dev_get_features_ctx *get_feat_ctx, int *wd_active) { - struct ena_com_dev* ena_dev = adapter->ena_dev; + struct ena_com_dev *ena_dev = adapter->ena_dev; bool readless_supported; uint32_t aenq_groups; int dma_width; @@ -2876,7 +2854,8 @@ err_mmio_read_less: return (rc); } -static int ena_enable_msix_and_set_admin_interrupts(struct ena_adapter *adapter) +static int +ena_enable_msix_and_set_admin_interrupts(struct ena_adapter *adapter) { struct ena_com_dev *ena_dev = adapter->ena_dev; int rc; @@ -2908,8 +2887,8 @@ err_disable_msix: } /* Function called on ENA_ADMIN_KEEP_ALIVE event */ -static void ena_keep_alive_wd(void *adapter_data, - struct ena_admin_aenq_entry *aenq_e) +static void +ena_keep_alive_wd(void *adapter_data, struct ena_admin_aenq_entry *aenq_e) { struct ena_adapter *adapter = (struct ena_adapter *)adapter_data; struct ena_admin_aenq_keep_alive_desc *desc; @@ -2931,7 +2910,8 @@ static void ena_keep_alive_wd(void *adapter_data, } /* Check for keep alive expiration */ -static void check_for_missing_keep_alive(struct ena_adapter *adapter) +static void +check_for_missing_keep_alive(struct ena_adapter *adapter) { sbintime_t timestamp, time; @@ -2951,10 +2931,10 @@ static void check_for_missing_keep_alive(struct ena_adapter *adapter) } /* Check if admin queue is enabled */ -static void check_for_admin_com_state(struct ena_adapter *adapter) +static void +check_for_admin_com_state(struct ena_adapter *adapter) { - if (unlikely(ena_com_get_admin_running_state(adapter->ena_dev) == - false)) { + if (unlikely(ena_com_get_admin_running_state(adapter->ena_dev) == false)) { ena_log(adapter->pdev, ERR, "ENA admin queue is not in running state!\n"); counter_u64_add(adapter->dev_stats.admin_q_pause, 1); @@ -2974,9 +2954,11 @@ check_for_rx_interrupt_queue(struct ena_adapter *adapter, rx_ring->no_interrupt_event_cnt++; - if (rx_ring->no_interrupt_event_cnt == ENA_MAX_NO_INTERRUPT_ITERATIONS) { - ena_log(adapter->pdev, ERR, "Potential MSIX issue on Rx side " - "Queue = %d. Reset the device\n", rx_ring->qid); + if (rx_ring->no_interrupt_event_cnt == + ENA_MAX_NO_INTERRUPT_ITERATIONS) { + ena_log(adapter->pdev, ERR, + "Potential MSIX issue on Rx side Queue = %d. Reset the device\n", + rx_ring->qid); ena_trigger_reset(adapter, ENA_REGS_RESET_MISS_INTERRUPT); return (EIO); } @@ -3017,7 +2999,8 @@ check_missing_comp_in_tx_queue(struct ena_adapter *adapter, */ ena_log(pdev, ERR, "Potential MSIX issue on Tx side Queue = %d. " - "Reset the device\n", tx_ring->qid); + "Reset the device\n", + tx_ring->qid); ena_trigger_reset(adapter, ENA_REGS_RESET_MISS_INTERRUPT); return (EIO); @@ -3029,12 +3012,11 @@ check_missing_comp_in_tx_queue(struct ena_adapter *adapter, if (!tx_buf->print_once) { time_since_last_cleanup = TICKS_2_USEC(ticks - tx_ring->tx_last_cleanup_ticks); - missing_tx_comp_to = - sbttoms(adapter->missing_tx_timeout); - ena_log(pdev, WARN, "Found a Tx that wasn't " - "completed on time, qid %d, index %d." - "%d usecs have passed since last cleanup." - "Missing Tx timeout value %d msecs.\n", + missing_tx_comp_to = sbttoms( + adapter->missing_tx_timeout); + ena_log(pdev, WARN, + "Found a Tx that wasn't completed on time, qid %d, index %d." + "%d usecs have passed since last cleanup. Missing Tx timeout value %d msecs.\n", tx_ring->qid, i, time_since_last_cleanup, missing_tx_comp_to); } @@ -3134,11 +3116,12 @@ check_for_empty_rx_ring(struct ena_adapter *adapter) for (i = 0; i < adapter->num_io_queues; i++) { rx_ring = &adapter->rx_ring[i]; - refill_required = ena_com_free_q_entries(rx_ring->ena_com_io_sq); + refill_required = ena_com_free_q_entries( + rx_ring->ena_com_io_sq); if (unlikely(refill_required == (rx_ring->ring_size - 1))) { rx_ring->empty_rx_queue++; - if (rx_ring->empty_rx_queue >= EMPTY_RX_REFILL) { + if (rx_ring->empty_rx_queue >= EMPTY_RX_REFILL) { counter_u64_add(rx_ring->rx_stats.empty_rx_ring, 1); @@ -3156,8 +3139,9 @@ check_for_empty_rx_ring(struct ena_adapter *adapter) } } -static void ena_update_hints(struct ena_adapter *adapter, - struct ena_admin_ena_hw_hints *hints) +static void +ena_update_hints(struct ena_adapter *adapter, + struct ena_admin_ena_hw_hints *hints) { struct ena_com_dev *ena_dev = adapter->ena_dev; @@ -3167,8 +3151,7 @@ static void ena_update_hints(struct ena_adapter *adapter, if (hints->mmio_read_timeout) /* convert to usec */ - ena_dev->mmio_read.reg_read_to = - hints->mmio_read_timeout * 1000; + ena_dev->mmio_read.reg_read_to = hints->mmio_read_timeout * 1000; if (hints->missed_tx_completion_count_threshold_to_reset) adapter->missing_tx_threshold = @@ -3176,19 +3159,19 @@ static void ena_update_hints(struct ena_adapter *adapter, if (hints->missing_tx_completion_timeout) { if (hints->missing_tx_completion_timeout == - ENA_HW_HINTS_NO_TIMEOUT) + ENA_HW_HINTS_NO_TIMEOUT) adapter->missing_tx_timeout = ENA_HW_HINTS_NO_TIMEOUT; else - adapter->missing_tx_timeout = - SBT_1MS * hints->missing_tx_completion_timeout; + adapter->missing_tx_timeout = SBT_1MS * + hints->missing_tx_completion_timeout; } if (hints->driver_watchdog_timeout) { if (hints->driver_watchdog_timeout == ENA_HW_HINTS_NO_TIMEOUT) adapter->keep_alive_timeout = ENA_HW_HINTS_NO_TIMEOUT; else - adapter->keep_alive_timeout = - SBT_1MS * hints->driver_watchdog_timeout; + adapter->keep_alive_timeout = SBT_1MS * + hints->driver_watchdog_timeout; } } @@ -3351,7 +3334,6 @@ static int ena_device_validate_params(struct ena_adapter *adapter, struct ena_com_dev_get_features_ctx *get_feat_ctx) { - if (memcmp(get_feat_ctx->dev_attr.mac_addr, adapter->mac_addr, ETHER_ADDR_LEN) != 0) { ena_log(adapter->pdev, ERR, "Error, mac addresses differ\n"); @@ -3414,8 +3396,7 @@ ena_restore_device(struct ena_adapter *adapter) * are available. */ if ((adapter->msix_vecs - ENA_ADMIN_MSIX_VEC) < adapter->num_io_queues) - adapter->num_io_queues = - adapter->msix_vecs - ENA_ADMIN_MSIX_VEC; + adapter->num_io_queues = adapter->msix_vecs - ENA_ADMIN_MSIX_VEC; /* Re-initialize rings basic information */ ena_init_io_rings(adapter); @@ -3540,8 +3521,8 @@ ena_attach(device_t pdev) rid = PCIR_BAR(ENA_REG_BAR); adapter->memory = NULL; - adapter->registers = bus_alloc_resource_any(pdev, SYS_RES_MEMORY, - &rid, RF_ACTIVE); + adapter->registers = bus_alloc_resource_any(pdev, SYS_RES_MEMORY, &rid, + RF_ACTIVE); if (unlikely(adapter->registers == NULL)) { ena_log(pdev, ERR, "unable to allocate bus resource: registers!\n"); @@ -3567,12 +3548,12 @@ ena_attach(device_t pdev) M_WAITOK | M_ZERO); /* Store register resources */ - ((struct ena_bus*)(ena_dev->bus))->reg_bar_t = - rman_get_bustag(adapter->registers); - ((struct ena_bus*)(ena_dev->bus))->reg_bar_h = - rman_get_bushandle(adapter->registers); + ((struct ena_bus *)(ena_dev->bus))->reg_bar_t = rman_get_bustag( + adapter->registers); + ((struct ena_bus *)(ena_dev->bus))->reg_bar_h = rman_get_bushandle( + adapter->registers); - if (unlikely(((struct ena_bus*)(ena_dev->bus))->reg_bar_h == 0)) { + if (unlikely(((struct ena_bus *)(ena_dev->bus))->reg_bar_h == 0)) { ena_log(pdev, ERR, "failed to pmap registers bar\n"); rc = ENXIO; goto err_bus_free; @@ -3600,15 +3581,15 @@ ena_attach(device_t pdev) } rc = ena_set_queues_placement_policy(pdev, ena_dev, &get_feat_ctx.llq, - &llq_config); + &llq_config); if (unlikely(rc != 0)) { ena_log(pdev, ERR, "failed to set placement policy\n"); goto err_com_free; } if (ena_dev->tx_mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) - adapter->disable_meta_caching = - !!(get_feat_ctx.llq.accel_mode.u.get.supported_flags & + adapter->disable_meta_caching = !!( + get_feat_ctx.llq.accel_mode.u.get.supported_flags & BIT(ENA_ADMIN_DISABLE_META_CACHING)); adapter->keep_alive_timestamp = getsbinuptime(); @@ -3691,15 +3672,15 @@ ena_attach(device_t pdev) TASK_INIT(&adapter->reset_task, 0, ena_reset_task, adapter); adapter->reset_tq = taskqueue_create("ena_reset_enqueue", M_WAITOK | M_ZERO, taskqueue_thread_enqueue, &adapter->reset_tq); - taskqueue_start_threads(&adapter->reset_tq, 1, PI_NET, - "%s rstq", device_get_nameunit(adapter->pdev)); + taskqueue_start_threads(&adapter->reset_tq, 1, PI_NET, "%s rstq", + device_get_nameunit(adapter->pdev)); /* Initialize metrics task queue */ TASK_INIT(&adapter->metrics_task, 0, ena_metrics_task, adapter); adapter->metrics_tq = taskqueue_create("ena_metrics_enqueue", M_WAITOK | M_ZERO, taskqueue_thread_enqueue, &adapter->metrics_tq); - taskqueue_start_threads(&adapter->metrics_tq, 1, PI_NET, - "%s metricsq", device_get_nameunit(adapter->pdev)); + taskqueue_start_threads(&adapter->metrics_tq, 1, PI_NET, "%s metricsq", + device_get_nameunit(adapter->pdev)); /* Initialize statistics */ ena_alloc_counters((counter_u64_t *)&adapter->dev_stats, @@ -3871,15 +3852,15 @@ ena_update_on_link_change(void *adapter_data, } } -static void ena_notification(void *adapter_data, - struct ena_admin_aenq_entry *aenq_e) +static void +ena_notification(void *adapter_data, struct ena_admin_aenq_entry *aenq_e) { struct ena_adapter *adapter = (struct ena_adapter *)adapter_data; struct ena_admin_ena_hw_hints *hints; - ENA_WARN(aenq_e->aenq_common_desc.group != ENA_ADMIN_NOTIFICATION, adapter->ena_dev, - "Invalid group(%x) expected %x\n", aenq_e->aenq_common_desc.group, - ENA_ADMIN_NOTIFICATION); + ENA_WARN(aenq_e->aenq_common_desc.group != ENA_ADMIN_NOTIFICATION, + adapter->ena_dev, "Invalid group(%x) expected %x\n", + aenq_e->aenq_common_desc.group, ENA_ADMIN_NOTIFICATION); switch (aenq_e->aenq_common_desc.syndrome) { case ENA_ADMIN_UPDATE_HINTS: @@ -3934,16 +3915,16 @@ static struct ena_aenq_handlers aenq_handlers = { * FreeBSD Device Interface Entry Points *********************************************************************/ -static device_method_t ena_methods[] = { - /* Device interface */ - DEVMETHOD(device_probe, ena_probe), - DEVMETHOD(device_attach, ena_attach), - DEVMETHOD(device_detach, ena_detach), - DEVMETHOD_END +static device_method_t ena_methods[] = { /* Device interface */ + DEVMETHOD(device_probe, ena_probe), + DEVMETHOD(device_attach, ena_attach), + DEVMETHOD(device_detach, ena_detach), DEVMETHOD_END }; static driver_t ena_driver = { - "ena", ena_methods, sizeof(struct ena_adapter), + "ena", + ena_methods, + sizeof(struct ena_adapter), }; DRIVER_MODULE(ena, pci, ena_driver, 0, 0); diff --git a/sys/dev/ena/ena.h b/sys/dev/ena/ena.h index 43fbaad17b7..21c7f479c7e 100644 --- a/sys/dev/ena/ena.h +++ b/sys/dev/ena/ena.h @@ -58,37 +58,37 @@ #define ENA_DMA_BIT_MASK(x) ((1ULL << (x)) - 1ULL) /* 1 for AENQ + ADMIN */ -#define ENA_ADMIN_MSIX_VEC 1 -#define ENA_MAX_MSIX_VEC(io_queues) (ENA_ADMIN_MSIX_VEC + (io_queues)) +#define ENA_ADMIN_MSIX_VEC 1 +#define ENA_MAX_MSIX_VEC(io_queues) (ENA_ADMIN_MSIX_VEC + (io_queues)) -#define ENA_REG_BAR 0 -#define ENA_MEM_BAR 2 +#define ENA_REG_BAR 0 +#define ENA_MEM_BAR 2 -#define ENA_BUS_DMA_SEGS 32 +#define ENA_BUS_DMA_SEGS 32 -#define ENA_DEFAULT_BUF_RING_SIZE 4096 +#define ENA_DEFAULT_BUF_RING_SIZE 4096 -#define ENA_DEFAULT_RING_SIZE 1024 -#define ENA_MIN_RING_SIZE 256 +#define ENA_DEFAULT_RING_SIZE 1024 +#define ENA_MIN_RING_SIZE 256 /* * Refill Rx queue when number of required descriptors is above * QUEUE_SIZE / ENA_RX_REFILL_THRESH_DIVIDER or ENA_RX_REFILL_THRESH_PACKET */ -#define ENA_RX_REFILL_THRESH_DIVIDER 8 -#define ENA_RX_REFILL_THRESH_PACKET 256 +#define ENA_RX_REFILL_THRESH_DIVIDER 8 +#define ENA_RX_REFILL_THRESH_PACKET 256 -#define ENA_IRQNAME_SIZE 40 +#define ENA_IRQNAME_SIZE 40 -#define ENA_PKT_MAX_BUFS 19 +#define ENA_PKT_MAX_BUFS 19 -#define ENA_RX_RSS_TABLE_LOG_SIZE 7 -#define ENA_RX_RSS_TABLE_SIZE (1 << ENA_RX_RSS_TABLE_LOG_SIZE) +#define ENA_RX_RSS_TABLE_LOG_SIZE 7 +#define ENA_RX_RSS_TABLE_SIZE (1 << ENA_RX_RSS_TABLE_LOG_SIZE) -#define ENA_HASH_KEY_SIZE 40 +#define ENA_HASH_KEY_SIZE 40 -#define ENA_MAX_FRAME_LEN 10000 -#define ENA_MIN_FRAME_LEN 60 +#define ENA_MAX_FRAME_LEN 10000 +#define ENA_MIN_FRAME_LEN 60 #define ENA_TX_RESUME_THRESH (ENA_PKT_MAX_BUFS + 2) @@ -111,26 +111,26 @@ #define RX_IRQ_INTERVAL 20 #define TX_IRQ_INTERVAL 50 -#define ENA_MIN_MTU 128 +#define ENA_MIN_MTU 128 -#define ENA_TSO_MAXSIZE 65536 +#define ENA_TSO_MAXSIZE 65536 -#define ENA_MMIO_DISABLE_REG_READ BIT(0) +#define ENA_MMIO_DISABLE_REG_READ BIT(0) -#define ENA_TX_RING_IDX_NEXT(idx, ring_size) (((idx) + 1) & ((ring_size) - 1)) +#define ENA_TX_RING_IDX_NEXT(idx, ring_size) (((idx) + 1) & ((ring_size) - 1)) -#define ENA_RX_RING_IDX_NEXT(idx, ring_size) (((idx) + 1) & ((ring_size) - 1)) +#define ENA_RX_RING_IDX_NEXT(idx, ring_size) (((idx) + 1) & ((ring_size) - 1)) -#define ENA_IO_TXQ_IDX(q) (2 * (q)) -#define ENA_IO_RXQ_IDX(q) (2 * (q) + 1) -#define ENA_IO_TXQ_IDX_TO_COMBINED_IDX(q) ((q) / 2) -#define ENA_IO_RXQ_IDX_TO_COMBINED_IDX(q) (((q) - 1) / 2) +#define ENA_IO_TXQ_IDX(q) (2 * (q)) +#define ENA_IO_RXQ_IDX(q) (2 * (q) + 1) +#define ENA_IO_TXQ_IDX_TO_COMBINED_IDX(q) ((q) / 2) +#define ENA_IO_RXQ_IDX_TO_COMBINED_IDX(q) (((q) - 1) / 2) -#define ENA_MGMNT_IRQ_IDX 0 -#define ENA_IO_IRQ_FIRST_IDX 1 -#define ENA_IO_IRQ_IDX(q) (ENA_IO_IRQ_FIRST_IDX + (q)) +#define ENA_MGMNT_IRQ_IDX 0 +#define ENA_IO_IRQ_FIRST_IDX 1 +#define ENA_IO_IRQ_IDX(q) (ENA_IO_IRQ_FIRST_IDX + (q)) -#define ENA_MAX_NO_INTERRUPT_ITERATIONS 3 +#define ENA_MAX_NO_INTERRUPT_ITERATIONS 3 /* * ENA device should send keep alive msg every 1 sec. @@ -150,12 +150,12 @@ /* * Supported PCI vendor and devices IDs */ -#define PCI_VENDOR_ID_AMAZON 0x1d0f +#define PCI_VENDOR_ID_AMAZON 0x1d0f -#define PCI_DEV_ID_ENA_PF 0x0ec2 -#define PCI_DEV_ID_ENA_PF_RSERV0 0x1ec2 -#define PCI_DEV_ID_ENA_VF 0xec20 -#define PCI_DEV_ID_ENA_VF_RSERV0 0xec21 +#define PCI_DEV_ID_ENA_PF 0x0ec2 +#define PCI_DEV_ID_ENA_PF_RSERV0 0x1ec2 +#define PCI_DEV_ID_ENA_VF 0xec20 +#define PCI_DEV_ID_ENA_VF_RSERV0 0xec21 /* * Flags indicating current ENA driver state @@ -490,9 +490,9 @@ struct ena_adapter { enum ena_regs_reset_reason_types reset_reason; }; -#define ENA_RING_MTX_LOCK(_ring) mtx_lock(&(_ring)->ring_mtx) -#define ENA_RING_MTX_TRYLOCK(_ring) mtx_trylock(&(_ring)->ring_mtx) -#define ENA_RING_MTX_UNLOCK(_ring) mtx_unlock(&(_ring)->ring_mtx) +#define ENA_RING_MTX_LOCK(_ring) mtx_lock(&(_ring)->ring_mtx) +#define ENA_RING_MTX_TRYLOCK(_ring) mtx_trylock(&(_ring)->ring_mtx) +#define ENA_RING_MTX_UNLOCK(_ring) mtx_unlock(&(_ring)->ring_mtx) #define ENA_RING_MTX_ASSERT(_ring) \ mtx_assert(&(_ring)->ring_mtx, MA_OWNED) @@ -503,11 +503,11 @@ struct ena_adapter { #define ENA_LOCK_UNLOCK() sx_unlock(&ena_global_lock) #define ENA_LOCK_ASSERT() sx_assert(&ena_global_lock, SA_XLOCKED) -#define ENA_TIMER_INIT(_adapter) \ +#define ENA_TIMER_INIT(_adapter) \ callout_init(&(_adapter)->timer_service, true) -#define ENA_TIMER_DRAIN(_adapter) \ +#define ENA_TIMER_DRAIN(_adapter) \ callout_drain(&(_adapter)->timer_service) -#define ENA_TIMER_RESET(_adapter) \ +#define ENA_TIMER_RESET(_adapter) \ callout_reset_sbt(&(_adapter)->timer_service, SBT_1S, SBT_1S, \ ena_timer_service, (void*)(_adapter), 0) @@ -516,16 +516,6 @@ struct ena_adapter { extern struct sx ena_global_lock; -static inline int ena_mbuf_count(struct mbuf *mbuf) -{ - int count = 1; - - while ((mbuf = mbuf->m_next) != NULL) - ++count; - - return count; -} - int ena_up(struct ena_adapter *adapter); void ena_down(struct ena_adapter *adapter); int ena_restore_device(struct ena_adapter *adapter); @@ -537,6 +527,17 @@ int ena_update_queue_size(struct ena_adapter *adapter, uint32_t new_tx_size, uint32_t new_rx_size); int ena_update_io_queue_nb(struct ena_adapter *adapter, uint32_t new_num); +static inline int +ena_mbuf_count(struct mbuf *mbuf) +{ + int count = 1; + + while ((mbuf = mbuf->m_next) != NULL) + ++count; + + return count; +} + static inline void ena_trigger_reset(struct ena_adapter *adapter, enum ena_regs_reset_reason_types reset_reason) diff --git a/sys/dev/ena/ena_datapath.c b/sys/dev/ena/ena_datapath.c index 97761c86825..6a7839d4958 100644 --- a/sys/dev/ena/ena_datapath.c +++ b/sys/dev/ena/ena_datapath.c @@ -46,21 +46,21 @@ __FBSDID("$FreeBSD$"); * Static functions prototypes *********************************************************************/ -static int ena_tx_cleanup(struct ena_ring *); -static int ena_rx_cleanup(struct ena_ring *); +static int ena_tx_cleanup(struct ena_ring *); +static int ena_rx_cleanup(struct ena_ring *); static inline int ena_get_tx_req_id(struct ena_ring *tx_ring, struct ena_com_io_cq *io_cq, uint16_t *req_id); -static void ena_rx_hash_mbuf(struct ena_ring *, struct ena_com_rx_ctx *, +static void ena_rx_hash_mbuf(struct ena_ring *, struct ena_com_rx_ctx *, struct mbuf *); -static struct mbuf* ena_rx_mbuf(struct ena_ring *, struct ena_com_rx_buf_info *, +static struct mbuf *ena_rx_mbuf(struct ena_ring *, struct ena_com_rx_buf_info *, struct ena_com_rx_ctx *, uint16_t *); static inline void ena_rx_checksum(struct ena_ring *, struct ena_com_rx_ctx *, struct mbuf *); -static void ena_tx_csum(struct ena_com_tx_ctx *, struct mbuf *, bool); -static int ena_check_and_collapse_mbuf(struct ena_ring *tx_ring, +static void ena_tx_csum(struct ena_com_tx_ctx *, struct mbuf *, bool); +static int ena_check_and_collapse_mbuf(struct ena_ring *tx_ring, struct mbuf **mbuf); -static int ena_xmit_mbuf(struct ena_ring *, struct mbuf **); -static void ena_start_xmit(struct ena_ring *); +static int ena_xmit_mbuf(struct ena_ring *, struct mbuf **); +static void ena_start_xmit(struct ena_ring *); /********************************************************************* * Global functions @@ -69,12 +69,12 @@ static void ena_start_xmit(struct ena_ring *); void ena_cleanup(void *arg, int pending) { - struct ena_que *que = arg; + struct ena_que *que = arg; struct ena_adapter *adapter = que->adapter; if_t ifp = adapter->ifp; struct ena_ring *tx_ring; struct ena_ring *rx_ring; - struct ena_com_io_cq* io_cq; + struct ena_com_io_cq *io_cq; struct ena_eth_io_intr_reg intr_reg; int qid, ena_qid; int txc, rxc, i; @@ -101,13 +101,11 @@ ena_cleanup(void *arg, int pending) return; if ((txc != TX_BUDGET) && (rxc != RX_BUDGET)) - break; + break; } /* Signal that work is done and unmask interrupt */ - ena_com_update_intr_reg(&intr_reg, - RX_IRQ_INTERVAL, - TX_IRQ_INTERVAL, + ena_com_update_intr_reg(&intr_reg, RX_IRQ_INTERVAL, TX_IRQ_INTERVAL, true); counter_u64_add(tx_ring->tx_stats.unmask_interrupt_num, 1); ena_com_unmask_intr(io_cq, &intr_reg); @@ -119,8 +117,7 @@ ena_deferred_mq_start(void *arg, int pending) struct ena_ring *tx_ring = (struct ena_ring *)arg; struct ifnet *ifp = tx_ring->adapter->ifp; - while (!drbr_empty(ifp, tx_ring->br) && - tx_ring->running && + while (!drbr_empty(ifp, tx_ring->br) && tx_ring->running && (if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0) { ENA_RING_MTX_LOCK(tx_ring); ena_start_xmit(tx_ring); @@ -186,7 +183,7 @@ ena_qflush(if_t ifp) struct ena_ring *tx_ring = adapter->tx_ring; int i; - for(i = 0; i < adapter->num_io_queues; ++i, ++tx_ring) + for (i = 0; i < adapter->num_io_queues; ++i, ++tx_ring) if (!drbr_empty(ifp, tx_ring->br)) { ENA_RING_MTX_LOCK(tx_ring); drbr_flush(ifp, tx_ring->br); @@ -245,7 +242,7 @@ static int ena_tx_cleanup(struct ena_ring *tx_ring) { struct ena_adapter *adapter; - struct ena_com_io_cq* io_cq; + struct ena_com_io_cq *io_cq; uint16_t next_to_clean; uint16_t req_id; uint16_t ena_qid; @@ -283,8 +280,7 @@ ena_tx_cleanup(struct ena_ring *tx_ring) bus_dmamap_sync(adapter->tx_buf_tag, tx_info->dmamap, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(adapter->tx_buf_tag, - tx_info->dmamap); + bus_dmamap_unload(adapter->tx_buf_tag, tx_info->dmamap); ena_log_io(adapter->pdev, DBG, "tx: q %d mbuf %p completed\n", tx_ring->qid, mbuf); @@ -332,9 +328,8 @@ ena_tx_cleanup(struct ena_ring *tx_ring) ENA_TX_RESUME_THRESH); if (unlikely(!tx_ring->running && above_thresh)) { ENA_RING_MTX_LOCK(tx_ring); - above_thresh = - ena_com_sq_have_enough_space(tx_ring->ena_com_io_sq, - ENA_TX_RESUME_THRESH); + above_thresh = ena_com_sq_have_enough_space( + tx_ring->ena_com_io_sq, ENA_TX_RESUME_THRESH); if (!tx_ring->running && above_thresh) { tx_ring->running = true; counter_u64_add(tx_ring->tx_stats.queue_wakeup, 1); @@ -422,7 +417,7 @@ ena_rx_hash_mbuf(struct ena_ring *rx_ring, struct ena_com_rx_ctx *ena_rx_ctx, * @next_to_clean: ring pointer, will be updated only upon success * **/ -static struct mbuf* +static struct mbuf * ena_rx_mbuf(struct ena_ring *rx_ring, struct ena_com_rx_buf_info *ena_bufs, struct ena_com_rx_ctx *ena_rx_ctx, uint16_t *next_to_clean) { @@ -569,8 +564,8 @@ ena_rx_cleanup(struct ena_ring *rx_ring) device_t pdev; struct mbuf *mbuf; struct ena_com_rx_ctx ena_rx_ctx; - struct ena_com_io_cq* io_cq; - struct ena_com_io_sq* io_sq; + struct ena_com_io_cq *io_cq; + struct ena_com_io_sq *io_sq; enum ena_regs_reset_reason_types reset_reason; if_t ifp; uint16_t ena_qid; @@ -627,14 +622,14 @@ ena_rx_cleanup(struct ena_ring *rx_ring) if (unlikely(ena_rx_ctx.descs == 0)) break; - ena_log_io(pdev, DBG, "rx: q %d got packet from ena. " - "descs #: %d l3 proto %d l4 proto %d hash: %x\n", + ena_log_io(pdev, DBG, + "rx: q %d got packet from ena. descs #: %d l3 proto %d l4 proto %d hash: %x\n", rx_ring->qid, ena_rx_ctx.descs, ena_rx_ctx.l3_proto, ena_rx_ctx.l4_proto, ena_rx_ctx.hash); /* Receive mbuf from the ring */ - mbuf = ena_rx_mbuf(rx_ring, rx_ring->ena_bufs, - &ena_rx_ctx, &next_to_clean); + mbuf = ena_rx_mbuf(rx_ring, rx_ring->ena_bufs, &ena_rx_ctx, + &next_to_clean); bus_dmamap_sync(io_cq->cdesc_addr.mem_handle.tag, io_cq->cdesc_addr.mem_handle.map, BUS_DMASYNC_PREREAD); /* Exit if we failed to retrieve a buffer */ @@ -642,10 +637,8 @@ ena_rx_cleanup(struct ena_ring *rx_ring) for (i = 0; i < ena_rx_ctx.descs; ++i) { rx_ring->free_rx_ids[next_to_clean] = rx_ring->ena_bufs[i].req_id; - next_to_clean = - ENA_RX_RING_IDX_NEXT(next_to_clean, - rx_ring->ring_size); - + next_to_clean = ENA_RX_RING_IDX_NEXT( + next_to_clean, rx_ring->ring_size); } break; } @@ -666,7 +659,7 @@ ena_rx_cleanup(struct ena_ring *rx_ring) * should be computed by hardware. */ do_if_input = 1; - if (((ifp->if_capenable & IFCAP_LRO) != 0) && + if (((ifp->if_capenable & IFCAP_LRO) != 0) && ((mbuf->m_pkthdr.csum_flags & CSUM_IP_VALID) != 0) && (ena_rx_ctx.l4_proto == ENA_ETH_IO_L4_PROTO_TCP)) { /* @@ -677,11 +670,11 @@ ena_rx_cleanup(struct ena_ring *rx_ring) */ if ((rx_ring->lro.lro_cnt != 0) && (tcp_lro_rx(&rx_ring->lro, mbuf, 0) == 0)) - do_if_input = 0; + do_if_input = 0; } if (do_if_input != 0) { - ena_log_io(pdev, DBG, "calling if_input() with mbuf %p\n", - mbuf); + ena_log_io(pdev, DBG, + "calling if_input() with mbuf %p\n", mbuf); (*ifp->if_input)(ifp, mbuf); } @@ -873,8 +866,8 @@ ena_tx_map_mbuf(struct ena_ring *tx_ring, struct ena_tx_buffer *tx_info, * For easier maintaining of the DMA map, map the whole mbuf even if * the LLQ is used. The descriptors will be filled using the segments. */ - rc = bus_dmamap_load_mbuf_sg(adapter->tx_buf_tag, tx_info->dmamap, mbuf, - segs, &nsegs, BUS_DMA_NOWAIT); + rc = bus_dmamap_load_mbuf_sg(adapter->tx_buf_tag, + tx_info->dmamap, mbuf, segs, &nsegs, BUS_DMA_NOWAIT); if (unlikely((rc != 0) || (nsegs == 0))) { ena_log_io(adapter->pdev, WARN, "dmamap load failed! err: %d nsegs: %d\n", rc, nsegs); @@ -892,24 +885,27 @@ ena_tx_map_mbuf(struct ena_ring *tx_ring, struct ena_tx_buffer *tx_info, * First check if header fits in the mbuf. If not, copy it to * separate buffer that will be holding linearized data. */ - *header_len = min_t(uint32_t, mbuf->m_pkthdr.len, tx_ring->tx_max_header_size); + *header_len = min_t(uint32_t, mbuf->m_pkthdr.len, + tx_ring->tx_max_header_size); /* If header is in linear space, just point into mbuf's data. */ if (likely(*header_len <= mbuf_head_len)) { *push_hdr = mbuf->m_data; /* - * Otherwise, copy whole portion of header from multiple mbufs - * to intermediate buffer. + * Otherwise, copy whole portion of header from multiple + * mbufs to intermediate buffer. */ } else { - m_copydata(mbuf, 0, *header_len, tx_ring->push_buf_intermediate_buf); + m_copydata(mbuf, 0, *header_len, + tx_ring->push_buf_intermediate_buf); *push_hdr = tx_ring->push_buf_intermediate_buf; counter_u64_add(tx_ring->tx_stats.llq_buffer_copy, 1); } - ena_log_io(adapter->pdev, DBG, "mbuf: %p ""header_buf->vaddr: %p " - "push_len: %d\n", mbuf, *push_hdr, *header_len); + ena_log_io(adapter->pdev, DBG, + "mbuf: %p header_buf->vaddr: %p push_len: %d\n", + mbuf, *push_hdr, *header_len); /* If packet is fitted in LLQ header, no need for DMA segments. */ if (mbuf->m_pkthdr.len <= tx_ring->tx_max_header_size) { @@ -917,15 +913,18 @@ ena_tx_map_mbuf(struct ena_ring *tx_ring, struct ena_tx_buffer *tx_info, } else { offset = tx_ring->tx_max_header_size; /* - * As Header part is mapped to LLQ header, we can skip it and just - * map the residuum of the mbuf to DMA Segments. + * As Header part is mapped to LLQ header, we can skip + * it and just map the residuum of the mbuf to DMA + * Segments. */ while (offset > 0) { if (offset >= segs[iseg].ds_len) { offset -= segs[iseg].ds_len; } else { - ena_buf->paddr = segs[iseg].ds_addr + offset; - ena_buf->len = segs[iseg].ds_len - offset; + ena_buf->paddr = segs[iseg].ds_addr + + offset; + ena_buf->len = segs[iseg].ds_len - + offset; ena_buf++; tx_info->num_of_bufs++; offset = 0; @@ -936,12 +935,12 @@ ena_tx_map_mbuf(struct ena_ring *tx_ring, struct ena_tx_buffer *tx_info, } else { *push_hdr = NULL; /* - * header_len is just a hint for the device. Because FreeBSD is not - * giving us information about packet header length and it is not - * guaranteed that all packet headers will be in the 1st mbuf, setting - * header_len to 0 is making the device ignore this value and resolve - * header on it's own. - */ + * header_len is just a hint for the device. Because FreeBSD is + * not giving us information about packet header length and it + * is not guaranteed that all packet headers will be in the 1st + * mbuf, setting header_len to 0 is making the device ignore + * this value and resolve header on it's own. + */ *header_len = 0; } @@ -970,7 +969,7 @@ ena_xmit_mbuf(struct ena_ring *tx_ring, struct mbuf **mbuf) struct ena_tx_buffer *tx_info; struct ena_com_tx_ctx ena_tx_ctx; struct ena_com_dev *ena_dev; - struct ena_com_io_sq* io_sq; + struct ena_com_io_sq *io_sq; void *push_hdr; uint16_t next_to_use; uint16_t req_id; @@ -1139,8 +1138,7 @@ ena_start_xmit(struct ena_ring *tx_ring) drbr_advance(adapter->ifp, tx_ring->br); - if (unlikely((if_getdrvflags(adapter->ifp) & - IFF_DRV_RUNNING) == 0)) + if (unlikely((if_getdrvflags(adapter->ifp) & IFF_DRV_RUNNING) == 0)) return; tx_ring->acum_pkts++; diff --git a/sys/dev/ena/ena_datapath.h b/sys/dev/ena/ena_datapath.h index f3b721359c7..e2c543415c3 100644 --- a/sys/dev/ena/ena_datapath.h +++ b/sys/dev/ena/ena_datapath.h @@ -34,12 +34,12 @@ #ifndef ENA_TXRX_H #define ENA_TXRX_H -void ena_cleanup(void *arg, int pending); -void ena_qflush(if_t ifp); -int ena_mq_start(if_t ifp, struct mbuf *m); -void ena_deferred_mq_start(void *arg, int pending); +void ena_cleanup(void *arg, int pending); +void ena_qflush(if_t ifp); +int ena_mq_start(if_t ifp, struct mbuf *m); +void ena_deferred_mq_start(void *arg, int pending); -#define CSUM_OFFLOAD (CSUM_IP|CSUM_TCP|CSUM_UDP) -#define CSUM6_OFFLOAD (CSUM_IP6_UDP|CSUM_IP6_TCP) +#define CSUM_OFFLOAD (CSUM_IP | CSUM_TCP | CSUM_UDP) +#define CSUM6_OFFLOAD (CSUM_IP6_UDP | CSUM_IP6_TCP) #endif /* ENA_TXRX_H */ diff --git a/sys/dev/ena/ena_netmap.c b/sys/dev/ena/ena_netmap.c index da9cb8fbccb..d71e14bff96 100644 --- a/sys/dev/ena/ena_netmap.c +++ b/sys/dev/ena/ena_netmap.c @@ -58,30 +58,28 @@ static int ena_netmap_txsync(struct netmap_kring *, int); static int ena_netmap_rxsync(struct netmap_kring *, int); /* Helper functions */ -static int ena_netmap_tx_frames(struct ena_netmap_ctx *); -static int ena_netmap_tx_frame(struct ena_netmap_ctx *); +static int ena_netmap_tx_frames(struct ena_netmap_ctx *); +static int ena_netmap_tx_frame(struct ena_netmap_ctx *); static inline uint16_t ena_netmap_count_slots(struct ena_netmap_ctx *); static inline uint16_t ena_netmap_packet_len(struct netmap_slot *, u_int, uint16_t); -static int ena_netmap_copy_data(struct netmap_adapter *, - struct netmap_slot *, u_int, uint16_t, uint16_t, void *); -static int ena_netmap_map_single_slot(struct netmap_adapter *, +static int ena_netmap_copy_data(struct netmap_adapter *, struct netmap_slot *, + u_int, uint16_t, uint16_t, void *); +static int ena_netmap_map_single_slot(struct netmap_adapter *, struct netmap_slot *, bus_dma_tag_t, bus_dmamap_t, void **, uint64_t *); -static int ena_netmap_tx_map_slots(struct ena_netmap_ctx *, +static int ena_netmap_tx_map_slots(struct ena_netmap_ctx *, struct ena_tx_buffer *, void **, uint16_t *, uint16_t *); -static void ena_netmap_unmap_last_socket_chain(struct ena_netmap_ctx *, +static void ena_netmap_unmap_last_socket_chain(struct ena_netmap_ctx *, struct ena_tx_buffer *); -static void ena_netmap_tx_cleanup(struct ena_netmap_ctx *); -static uint16_t ena_netmap_tx_clean_one(struct ena_netmap_ctx *, - uint16_t); +static void ena_netmap_tx_cleanup(struct ena_netmap_ctx *); +static uint16_t ena_netmap_tx_clean_one(struct ena_netmap_ctx *, uint16_t); static inline int validate_tx_req_id(struct ena_ring *, uint16_t); static int ena_netmap_rx_frames(struct ena_netmap_ctx *); static int ena_netmap_rx_frame(struct ena_netmap_ctx *); -static int ena_netmap_rx_load_desc(struct ena_netmap_ctx *, uint16_t, - int *); +static int ena_netmap_rx_load_desc(struct ena_netmap_ctx *, uint16_t, int *); static void ena_netmap_rx_cleanup(struct ena_netmap_ctx *); -static void ena_netmap_fill_ctx(struct netmap_kring *, - struct ena_netmap_ctx *, uint16_t); +static void ena_netmap_fill_ctx(struct netmap_kring *, struct ena_netmap_ctx *, + uint16_t); int ena_netmap_attach(struct ena_adapter *adapter) @@ -106,8 +104,8 @@ ena_netmap_attach(struct ena_adapter *adapter) } int -ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, - struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info) +ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, struct ena_ring *rx_ring, + struct ena_rx_buffer *rx_info) { struct netmap_adapter *na = NA(adapter->ifp); struct netmap_kring *kring; @@ -126,12 +124,14 @@ ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, nm_i = kring->nr_hwcur; head = kring->rhead; - ena_log_nm(adapter->pdev, DBG, "nr_hwcur: %d, nr_hwtail: %d, " - "rhead: %d, rcur: %d, rtail: %d\n", kring->nr_hwcur, - kring->nr_hwtail, kring->rhead, kring->rcur, kring->rtail); + ena_log_nm(adapter->pdev, DBG, + "nr_hwcur: %d, nr_hwtail: %d, rhead: %d, rcur: %d, rtail: %d\n", + kring->nr_hwcur, kring->nr_hwtail, kring->rhead, kring->rcur, + kring->rtail); if ((nm_i == head) && rx_ring->initialized) { - ena_log_nm(adapter->pdev, ERR, "No free slots in netmap ring\n"); + ena_log_nm(adapter->pdev, ERR, + "No free slots in netmap ring\n"); return (ENOMEM); } @@ -169,8 +169,8 @@ ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, } void -ena_netmap_free_rx_slot(struct ena_adapter *adapter, - struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info) +ena_netmap_free_rx_slot(struct ena_adapter *adapter, struct ena_ring *rx_ring, + struct ena_rx_buffer *rx_info) { struct netmap_adapter *na; struct netmap_kring *kring; @@ -272,7 +272,7 @@ static int ena_netmap_reg(struct netmap_adapter *na, int onoff) { struct ifnet *ifp = na->ifp; - struct ena_adapter* adapter = ifp->if_softc; + struct ena_adapter *adapter = ifp->if_softc; device_t pdev = adapter->pdev; struct netmap_kring *kring; enum txrx t; @@ -358,13 +358,13 @@ ena_netmap_tx_frames(struct ena_netmap_ctx *ctx) while (ctx->nm_i != ctx->kring->rhead) { if ((rc = ena_netmap_tx_frame(ctx)) != 0) { /* - * When there is no empty space in Tx ring, error is - * still being returned. It should not be passed to the - * netmap, as application knows current ring state from - * netmap ring pointers. Returning error there could - * cause application to exit, but the Tx ring is commonly - * being full. - */ + * When there is no empty space in Tx ring, error is + * still being returned. It should not be passed to the + * netmap, as application knows current ring state from + * netmap ring pointers. Returning error there could + * cause application to exit, but the Tx ring is + * commonly being full. + */ if (rc == ENA_COM_NO_MEM) rc = 0; break; @@ -462,7 +462,7 @@ ena_netmap_tx_frame(struct ena_netmap_ctx *ctx) for (unsigned int i = 0; i < tx_info->num_of_bufs; i++) bus_dmamap_sync(adapter->tx_buf_tag, - tx_info->nm_info.map_seg[i], BUS_DMASYNC_PREWRITE); + tx_info->nm_info.map_seg[i], BUS_DMASYNC_PREWRITE); return (0); } @@ -604,15 +604,12 @@ ena_netmap_tx_map_slots(struct ena_netmap_ctx *ctx, return (EINVAL); } /* - * Otherwise, copy whole portion of header from multiple slots - * to intermediate buffer. + * Otherwise, copy whole portion of header from multiple + * slots to intermediate buffer. */ } else { - rc = ena_netmap_copy_data(ctx->na, - ctx->slots, - ctx->nm_i, - ctx->lim, - push_len, + rc = ena_netmap_copy_data(ctx->na, ctx->slots, + ctx->nm_i, ctx->lim, push_len, tx_ring->push_buf_intermediate_buf); if (unlikely(rc)) { ena_log_nm(adapter->pdev, ERR, @@ -631,16 +628,12 @@ ena_netmap_tx_map_slots(struct ena_netmap_ctx *ctx, slot->buf_idx, *push_hdr, push_len); /* - * If header was in linear memory space, map for the dma rest of the data - * in the first mbuf of the mbuf chain. - */ + * If header was in linear memory space, map for the dma rest of + * the data in the first mbuf of the mbuf chain. + */ if (slot_head_len > push_len) { - rc = ena_netmap_map_single_slot(ctx->na, - slot, - adapter->tx_buf_tag, - *nm_maps, - &vaddr, - &paddr); + rc = ena_netmap_map_single_slot(ctx->na, slot, + adapter->tx_buf_tag, *nm_maps, &vaddr, &paddr); if (unlikely(rc != 0)) { ena_log_nm(adapter->pdev, ERR, "DMA mapping error\n"); @@ -688,11 +681,8 @@ ena_netmap_tx_map_slots(struct ena_netmap_ctx *ctx, * Map the data and then assign it with the * offsets */ - rc = ena_netmap_map_single_slot(ctx->na, - slot, - adapter->tx_buf_tag, - *nm_maps, - &vaddr, + rc = ena_netmap_map_single_slot(ctx->na, slot, + adapter->tx_buf_tag, *nm_maps, &vaddr, &paddr); if (unlikely(rc != 0)) { ena_log_nm(adapter->pdev, ERR, @@ -724,12 +714,12 @@ ena_netmap_tx_map_slots(struct ena_netmap_ctx *ctx, } else { *push_hdr = NULL; /* - * header_len is just a hint for the device. Because netmap is - * not giving us any information about packet header length and - * it is not guaranteed that all packet headers will be in the - * 1st slot, setting header_len to 0 is making the device ignore - * this value and resolve header on it's own. - */ + * header_len is just a hint for the device. Because netmap is + * not giving us any information about packet header length and + * it is not guaranteed that all packet headers will be in the + * 1st slot, setting header_len to 0 is making the device ignore + * this value and resolve header on it's own. + */ *header_len = 0; } @@ -737,15 +727,10 @@ ena_netmap_tx_map_slots(struct ena_netmap_ctx *ctx, while (remaining_len > 0) { __builtin_prefetch(&ctx->slots[ctx->nm_i + 1]); - rc = ena_netmap_map_single_slot(ctx->na, - slot, - adapter->tx_buf_tag, - *nm_maps, - &vaddr, - &paddr); + rc = ena_netmap_map_single_slot(ctx->na, slot, + adapter->tx_buf_tag, *nm_maps, &vaddr, &paddr); if (unlikely(rc != 0)) { - ena_log_nm(adapter->pdev, ERR, - "DMA mapping error\n"); + ena_log_nm(adapter->pdev, ERR, "DMA mapping error\n"); goto error_map; } nm_maps++; @@ -928,13 +913,13 @@ ena_netmap_rx_frames(struct ena_netmap_ctx *ctx) ctx->nt = ctx->ring->next_to_clean; ctx->nm_i = ctx->kring->nr_hwtail; - while((rc = ena_netmap_rx_frame(ctx)) == ENA_NETMAP_MORE_FRAMES) { + while ((rc = ena_netmap_rx_frame(ctx)) == ENA_NETMAP_MORE_FRAMES) { frames_counter++; /* In case of multiple frames, it is not an error. */ rc = 0; if (frames_counter > ENA_MAX_FRAMES) { ena_log_nm(ctx->adapter->pdev, ERR, - "Driver is stuck in the Rx loop\n"); + "Driver is stuck in the Rx loop\n"); break; } }; @@ -976,11 +961,11 @@ ena_netmap_rx_frame(struct ena_netmap_ctx *ctx) if (unlikely(ena_rx_ctx.descs == 0)) return (ENA_NETMAP_NO_MORE_FRAMES); - ena_log_nm(ctx->adapter->pdev, DBG, + ena_log_nm(ctx->adapter->pdev, DBG, "Rx: q %d got packet from ena. descs #:" - " %d l3 proto %d l4 proto %d hash: %x\n", ctx->ring->qid, - ena_rx_ctx.descs, ena_rx_ctx.l3_proto, ena_rx_ctx.l4_proto, - ena_rx_ctx.hash); + " %d l3 proto %d l4 proto %d hash: %x\n", + ctx->ring->qid, ena_rx_ctx.descs, ena_rx_ctx.l3_proto, + ena_rx_ctx.l4_proto, ena_rx_ctx.hash); for (buf = 0; buf < ena_rx_ctx.descs; buf++) if ((rc = ena_netmap_rx_load_desc(ctx, buf, &len)) != 0) @@ -997,7 +982,7 @@ ena_netmap_rx_frame(struct ena_netmap_ctx *ctx) } bus_dmamap_sync(ctx->io_cq->cdesc_addr.mem_handle.tag, - ctx->io_cq->cdesc_addr.mem_handle.map, BUS_DMASYNC_PREREAD); + ctx->io_cq->cdesc_addr.mem_handle.map, BUS_DMASYNC_PREREAD); counter_enter(); counter_u64_add_protected(ctx->ring->rx_stats.bytes, len); @@ -1012,7 +997,7 @@ rx_clear_desc: nm = ctx->nm_i; /* Remove failed packet from ring */ - while(buf--) { + while (buf--) { ctx->slots[nm].flags = 0; ctx->slots[nm].len = 0; nm = nm_prev(nm, ctx->lim); @@ -1046,9 +1031,10 @@ ena_netmap_rx_load_desc(struct ena_netmap_ctx *ctx, uint16_t buf, int *len) ctx->slots[ctx->nm_i].len = ctx->ring->ena_bufs[buf].len; *len += ctx->slots[ctx->nm_i].len; ctx->ring->free_rx_ids[ctx->nt] = req_id; - ena_log_nm(ctx->adapter->pdev, DBG, "rx_info %p, buf_idx %d, paddr %jx, nm: %d\n", - rx_info, ctx->slots[ctx->nm_i].buf_idx, - (uintmax_t)rx_info->ena_buf.paddr, ctx->nm_i); + ena_log_nm(ctx->adapter->pdev, DBG, + "rx_info %p, buf_idx %d, paddr %jx, nm: %d\n", rx_info, + ctx->slots[ctx->nm_i].buf_idx, (uintmax_t)rx_info->ena_buf.paddr, + ctx->nm_i); ctx->nm_i = nm_next(ctx->nm_i, ctx->lim); ctx->nt = ENA_RX_RING_IDX_NEXT(ctx->nt, ctx->ring->ring_size); diff --git a/sys/dev/ena/ena_netmap.h b/sys/dev/ena/ena_netmap.h index a418e0b6317..dca4ba18a3b 100644 --- a/sys/dev/ena/ena_netmap.h +++ b/sys/dev/ena/ena_netmap.h @@ -42,19 +42,21 @@ #undef unlikely #endif /* unlikely */ -#include #include + +#include + #include -int ena_netmap_attach(struct ena_adapter *adapter); -int ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, +int ena_netmap_attach(struct ena_adapter *adapter); +int ena_netmap_alloc_rx_slot(struct ena_adapter *adapter, struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info); -void ena_netmap_free_rx_slot(struct ena_adapter *adapter, +void ena_netmap_free_rx_slot(struct ena_adapter *adapter, struct ena_ring *rx_ring, struct ena_rx_buffer *rx_info); -bool ena_rx_ring_in_netmap(struct ena_adapter *adapter, int qid); -bool ena_tx_ring_in_netmap(struct ena_adapter *adapter, int qid); -void ena_netmap_reset_rx_ring(struct ena_adapter *adapter, int qid); -void ena_netmap_reset_tx_ring(struct ena_adapter *adapter, int qid); -void ena_netmap_unload(struct ena_adapter *adapter, bus_dmamap_t map); +bool ena_rx_ring_in_netmap(struct ena_adapter *adapter, int qid); +bool ena_tx_ring_in_netmap(struct ena_adapter *adapter, int qid); +void ena_netmap_reset_rx_ring(struct ena_adapter *adapter, int qid); +void ena_netmap_reset_tx_ring(struct ena_adapter *adapter, int qid); +void ena_netmap_unload(struct ena_adapter *adapter, bus_dmamap_t map); #endif /* _ENA_NETMAP_H_ */ diff --git a/sys/dev/ena/ena_rss.c b/sys/dev/ena/ena_rss.c index 116eaa425b0..5132b0f1a36 100644 --- a/sys/dev/ena/ena_rss.c +++ b/sys/dev/ena/ena_rss.c @@ -49,7 +49,8 @@ ena_rss_key_fill(void *key, size_t size) static bool key_generated; static uint8_t default_key[ENA_HASH_KEY_SIZE]; - KASSERT(size <= ENA_HASH_KEY_SIZE, ("Requested more bytes than ENA RSS key can hold")); + KASSERT(size <= ENA_HASH_KEY_SIZE, + ("Requested more bytes than ENA RSS key can hold")); if (!key_generated) { arc4random_buf(default_key, ENA_HASH_KEY_SIZE); @@ -73,7 +74,8 @@ ena_rss_reorder_hash_key(u8 *reordered_key, const u8 *key, size_t key_size) *reordered_key++ = *key--; } -int ena_rss_set_hash(struct ena_com_dev *ena_dev, const u8 *key) +int +ena_rss_set_hash(struct ena_com_dev *ena_dev, const u8 *key) { enum ena_admin_hash_functions ena_func = ENA_ADMIN_TOEPLITZ; u8 hw_key[ENA_HASH_KEY_SIZE]; @@ -84,7 +86,8 @@ int ena_rss_set_hash(struct ena_com_dev *ena_dev, const u8 *key) ENA_HASH_KEY_SIZE, 0x0)); } -int ena_rss_get_hash_key(struct ena_com_dev *ena_dev, u8 *key) +int +ena_rss_get_hash_key(struct ena_com_dev *ena_dev, u8 *key) { u8 hw_key[ENA_HASH_KEY_SIZE]; int rc; @@ -135,8 +138,8 @@ ena_rss_init_default(struct ena_adapter *adapter) rc = ena_rss_set_hash(ena_dev, hash_key); } else #endif - rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, NULL, - ENA_HASH_KEY_SIZE, 0x0); + rc = ena_com_fill_hash_function(ena_dev, ENA_ADMIN_TOEPLITZ, + NULL, ENA_HASH_KEY_SIZE, 0x0); if (unlikely((rc != 0) && (rc != EOPNOTSUPP))) { ena_log(dev, ERR, "Cannot fill hash function\n"); goto err_rss_destroy; @@ -218,12 +221,14 @@ ena_rss_init_default_deferred(void *arg) ena_log(adapter->pdev, WARN, "WARNING: RSS was not properly initialized," " it will affect bandwidth\n"); - ENA_FLAG_CLEAR_ATOMIC(ENA_FLAG_RSS_ACTIVE, adapter); + ENA_FLAG_CLEAR_ATOMIC(ENA_FLAG_RSS_ACTIVE, + adapter); } } } } -SYSINIT(ena_rss_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_SECOND, ena_rss_init_default_deferred, NULL); +SYSINIT(ena_rss_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_SECOND, + ena_rss_init_default_deferred, NULL); int ena_rss_indir_get(struct ena_adapter *adapter, uint32_t *table) @@ -267,8 +272,7 @@ ena_rss_indir_set(struct ena_adapter *adapter, uint32_t *table) device_printf(adapter->pdev, "Writing to indirection table not supported\n"); else if (rc != 0) - device_printf(adapter->pdev, - "Cannot set indirection table\n"); + device_printf(adapter->pdev, "Cannot set indirection table\n"); return (rc); } diff --git a/sys/dev/ena/ena_rss.h b/sys/dev/ena/ena_rss.h index 42bec6fb2aa..3b9cd521ab3 100644 --- a/sys/dev/ena/ena_rss.h +++ b/sys/dev/ena/ena_rss.h @@ -44,7 +44,7 @@ #include "ena.h" -#define ENA_RX_RSS_MSG_RECORD_SZ 8 +#define ENA_RX_RSS_MSG_RECORD_SZ 8 struct ena_indir { uint32_t table[ENA_RX_RSS_TABLE_SIZE]; @@ -52,12 +52,12 @@ struct ena_indir { char sysctl_buf[ENA_RX_RSS_TABLE_SIZE * ENA_RX_RSS_MSG_RECORD_SZ]; }; -int ena_rss_set_hash(struct ena_com_dev *ena_dev, const u8 *key); -int ena_rss_get_hash_key(struct ena_com_dev *ena_dev, u8 *key); -int ena_rss_configure(struct ena_adapter *); -int ena_rss_indir_get(struct ena_adapter *adapter, uint32_t *table); -int ena_rss_indir_set(struct ena_adapter *adapter, uint32_t *table); -int ena_rss_indir_init(struct ena_adapter *adapter); +int ena_rss_set_hash(struct ena_com_dev *ena_dev, const u8 *key); +int ena_rss_get_hash_key(struct ena_com_dev *ena_dev, u8 *key); +int ena_rss_configure(struct ena_adapter *); +int ena_rss_indir_get(struct ena_adapter *adapter, uint32_t *table); +int ena_rss_indir_set(struct ena_adapter *adapter, uint32_t *table); +int ena_rss_indir_init(struct ena_adapter *adapter); static inline void ena_rss_copy_indir_buf(char *buf, uint32_t *table) @@ -65,8 +65,8 @@ ena_rss_copy_indir_buf(char *buf, uint32_t *table) int i; for (i = 0; i < ENA_RX_RSS_TABLE_SIZE; ++i) { - buf += snprintf(buf, ENA_RX_RSS_MSG_RECORD_SZ + 1, - "%s%d:%d", i == 0 ? "" : " ", i, table[i]); + buf += snprintf(buf, ENA_RX_RSS_MSG_RECORD_SZ + 1, "%s%d:%d", + i == 0 ? "" : " ", i, table[i]); } } diff --git a/sys/dev/ena/ena_sysctl.c b/sys/dev/ena/ena_sysctl.c index f333a7560aa..d9b9c7652c1 100644 --- a/sys/dev/ena/ena_sysctl.c +++ b/sys/dev/ena/ena_sysctl.c @@ -33,29 +33,29 @@ __FBSDID("$FreeBSD$"); #include "opt_rss.h" -#include "ena_sysctl.h" #include "ena_rss.h" +#include "ena_sysctl.h" -static void ena_sysctl_add_wd(struct ena_adapter *); -static void ena_sysctl_add_stats(struct ena_adapter *); -static void ena_sysctl_add_eni_metrics(struct ena_adapter *); -static void ena_sysctl_add_tuneables(struct ena_adapter *); +static void ena_sysctl_add_wd(struct ena_adapter *); +static void ena_sysctl_add_stats(struct ena_adapter *); +static void ena_sysctl_add_eni_metrics(struct ena_adapter *); +static void ena_sysctl_add_tuneables(struct ena_adapter *); /* Kernel option RSS prevents manipulation of key hash and indirection table. */ #ifndef RSS -static void ena_sysctl_add_rss(struct ena_adapter *); +static void ena_sysctl_add_rss(struct ena_adapter *); #endif -static int ena_sysctl_buf_ring_size(SYSCTL_HANDLER_ARGS); -static int ena_sysctl_rx_queue_size(SYSCTL_HANDLER_ARGS); -static int ena_sysctl_io_queues_nb(SYSCTL_HANDLER_ARGS); -static int ena_sysctl_eni_metrics_interval(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_buf_ring_size(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_rx_queue_size(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_io_queues_nb(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_eni_metrics_interval(SYSCTL_HANDLER_ARGS); #ifndef RSS -static int ena_sysctl_rss_key(SYSCTL_HANDLER_ARGS); -static int ena_sysctl_rss_indir_table(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_rss_key(SYSCTL_HANDLER_ARGS); +static int ena_sysctl_rss_indir_table(SYSCTL_HANDLER_ARGS); #endif /* Limit max ENI sample rate to be an hour. */ #define ENI_METRICS_MAX_SAMPLE_INTERVAL 3600 -#define ENA_HASH_KEY_MSG_SIZE (ENA_HASH_KEY_SIZE * 2 + 1) +#define ENA_HASH_KEY_MSG_SIZE (ENA_HASH_KEY_SIZE * 2 + 1) static SYSCTL_NODE(_hw, OID_AUTO, ena, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "ENA driver parameters"); @@ -64,8 +64,8 @@ static SYSCTL_NODE(_hw, OID_AUTO, ena, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, * Logging level for changing verbosity of the output */ int ena_log_level = ENA_INFO; -SYSCTL_INT(_hw_ena, OID_AUTO, log_level, CTLFLAG_RWTUN, - &ena_log_level, 0, "Logging level indicating verbosity of the logs"); +SYSCTL_INT(_hw_ena, OID_AUTO, log_level, CTLFLAG_RWTUN, &ena_log_level, 0, + "Logging level indicating verbosity of the logs"); SYSCTL_CONST_STRING(_hw_ena, OID_AUTO, driver_version, CTLFLAG_RD, DRV_MODULE_VERSION, "ENA driver version"); @@ -125,9 +125,8 @@ ena_sysctl_add_wd(struct ena_adapter *adapter) child = SYSCTL_CHILDREN(tree); /* Sysctl calls for Watchdog service */ - SYSCTL_ADD_INT(ctx, child, OID_AUTO, "wd_active", - CTLFLAG_RWTUN, &adapter->wd_active, 0, - "Watchdog is active"); + SYSCTL_ADD_INT(ctx, child, OID_AUTO, "wd_active", CTLFLAG_RWTUN, + &adapter->wd_active, 0, "Watchdog is active"); SYSCTL_ADD_QUAD(ctx, child, OID_AUTO, "keep_alive_timeout", CTLFLAG_RWTUN, &adapter->keep_alive_timeout, @@ -186,82 +185,68 @@ ena_sysctl_add_stats(struct ena_adapter *adapter) dev_stats = &adapter->dev_stats; admin_stats = &adapter->ena_dev->admin_queue.stats; - SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "wd_expired", - CTLFLAG_RD, &dev_stats->wd_expired, - "Watchdog expiry count"); - SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "interface_up", - CTLFLAG_RD, &dev_stats->interface_up, - "Network interface up count"); + SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "wd_expired", CTLFLAG_RD, + &dev_stats->wd_expired, "Watchdog expiry count"); + SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "interface_up", CTLFLAG_RD, + &dev_stats->interface_up, "Network interface up count"); SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "interface_down", CTLFLAG_RD, &dev_stats->interface_down, "Network interface down count"); SYSCTL_ADD_COUNTER_U64(ctx, child, OID_AUTO, "admin_q_pause", - CTLFLAG_RD, &dev_stats->admin_q_pause, - "Admin queue pauses"); + CTLFLAG_RD, &dev_stats->admin_q_pause, "Admin queue pauses"); for (i = 0; i < adapter->num_io_queues; ++i, ++tx_ring, ++rx_ring) { snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i); - queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, - namebuf, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name"); + queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf, + CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name"); queue_list = SYSCTL_CHILDREN(queue_node); adapter->que[i].oid = queue_node; #ifdef RSS /* Common stats */ - SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "cpu", - CTLFLAG_RD, &adapter->que[i].cpu, 0, "CPU affinity"); - SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "domain", - CTLFLAG_RD, &adapter->que[i].domain, 0, "NUMA domain"); + SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "cpu", CTLFLAG_RD, + &adapter->que[i].cpu, 0, "CPU affinity"); + SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "domain", CTLFLAG_RD, + &adapter->que[i].domain, 0, "NUMA domain"); #endif /* TX specific stats */ - tx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO, - "tx_ring", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX ring"); + tx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO, "tx_ring", + CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX ring"); tx_list = SYSCTL_CHILDREN(tx_node); tx_stats = &tx_ring->tx_stats; + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "count", + CTLFLAG_RD, &tx_stats->cnt, "Packets sent"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "bytes", + CTLFLAG_RD, &tx_stats->bytes, "Bytes sent"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "count", CTLFLAG_RD, - &tx_stats->cnt, "Packets sent"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "bytes", CTLFLAG_RD, - &tx_stats->bytes, "Bytes sent"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "prepare_ctx_err", CTLFLAG_RD, - &tx_stats->prepare_ctx_err, + "prepare_ctx_err", CTLFLAG_RD, &tx_stats->prepare_ctx_err, "TX buffer preparation failures"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "dma_mapping_err", CTLFLAG_RD, - &tx_stats->dma_mapping_err, "DMA mapping failures"); + "dma_mapping_err", CTLFLAG_RD, &tx_stats->dma_mapping_err, + "DMA mapping failures"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "doorbells", + CTLFLAG_RD, &tx_stats->doorbells, "Queue doorbells"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "doorbells", CTLFLAG_RD, - &tx_stats->doorbells, "Queue doorbells"); + "missing_tx_comp", CTLFLAG_RD, &tx_stats->missing_tx_comp, + "TX completions missed"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "bad_req_id", + CTLFLAG_RD, &tx_stats->bad_req_id, "Bad request id count"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "mbuf_collapses", + CTLFLAG_RD, &tx_stats->collapse, "Mbuf collapse count"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "missing_tx_comp", CTLFLAG_RD, - &tx_stats->missing_tx_comp, "TX completions missed"); + "mbuf_collapse_err", CTLFLAG_RD, &tx_stats->collapse_err, + "Mbuf collapse failures"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "queue_wakeups", + CTLFLAG_RD, &tx_stats->queue_wakeup, "Queue wakeups"); + SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "queue_stops", + CTLFLAG_RD, &tx_stats->queue_stop, "Queue stops"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "bad_req_id", CTLFLAG_RD, - &tx_stats->bad_req_id, "Bad request id count"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "mbuf_collapses", CTLFLAG_RD, - &tx_stats->collapse, - "Mbuf collapse count"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "mbuf_collapse_err", CTLFLAG_RD, - &tx_stats->collapse_err, - "Mbuf collapse failures"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "queue_wakeups", CTLFLAG_RD, - &tx_stats->queue_wakeup, "Queue wakeups"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "queue_stops", CTLFLAG_RD, - &tx_stats->queue_stop, "Queue stops"); - SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, - "llq_buffer_copy", CTLFLAG_RD, - &tx_stats->llq_buffer_copy, + "llq_buffer_copy", CTLFLAG_RD, &tx_stats->llq_buffer_copy, "Header copies for llq transaction"); SYSCTL_ADD_COUNTER_U64(ctx, tx_list, OID_AUTO, "unmask_interrupt_num", CTLFLAG_RD, @@ -269,45 +254,41 @@ ena_sysctl_add_stats(struct ena_adapter *adapter) "Unmasked interrupt count"); /* RX specific stats */ - rx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO, - "rx_ring", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX ring"); + rx_node = SYSCTL_ADD_NODE(ctx, queue_list, OID_AUTO, "rx_ring", + CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX ring"); rx_list = SYSCTL_CHILDREN(rx_node); rx_stats = &rx_ring->rx_stats; + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "count", + CTLFLAG_RD, &rx_stats->cnt, "Packets received"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "bytes", + CTLFLAG_RD, &rx_stats->bytes, "Bytes received"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "refil_partial", + CTLFLAG_RD, &rx_stats->refil_partial, + "Partial refilled mbufs"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "csum_bad", + CTLFLAG_RD, &rx_stats->csum_bad, "Bad RX checksum"); SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "count", CTLFLAG_RD, - &rx_stats->cnt, "Packets received"); + "mbuf_alloc_fail", CTLFLAG_RD, &rx_stats->mbuf_alloc_fail, + "Failed mbuf allocs"); SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "bytes", CTLFLAG_RD, - &rx_stats->bytes, "Bytes received"); + "mjum_alloc_fail", CTLFLAG_RD, &rx_stats->mjum_alloc_fail, + "Failed jumbo mbuf allocs"); SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "refil_partial", CTLFLAG_RD, - &rx_stats->refil_partial, "Partial refilled mbufs"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "csum_bad", CTLFLAG_RD, - &rx_stats->csum_bad, "Bad RX checksum"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "mbuf_alloc_fail", CTLFLAG_RD, - &rx_stats->mbuf_alloc_fail, "Failed mbuf allocs"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "mjum_alloc_fail", CTLFLAG_RD, - &rx_stats->mjum_alloc_fail, "Failed jumbo mbuf allocs"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "dma_mapping_err", CTLFLAG_RD, - &rx_stats->dma_mapping_err, "DMA mapping errors"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "bad_desc_num", CTLFLAG_RD, - &rx_stats->bad_desc_num, "Bad descriptor count"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "bad_req_id", CTLFLAG_RD, - &rx_stats->bad_req_id, "Bad request id count"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "empty_rx_ring", CTLFLAG_RD, - &rx_stats->empty_rx_ring, "RX descriptors depletion count"); - SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, - "csum_good", CTLFLAG_RD, - &rx_stats->csum_good, "Valid RX checksum calculations"); + "dma_mapping_err", CTLFLAG_RD, &rx_stats->dma_mapping_err, + "DMA mapping errors"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "bad_desc_num", + CTLFLAG_RD, &rx_stats->bad_desc_num, + "Bad descriptor count"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "bad_req_id", + CTLFLAG_RD, &rx_stats->bad_req_id, "Bad request id count"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "empty_rx_ring", + CTLFLAG_RD, &rx_stats->empty_rx_ring, + "RX descriptors depletion count"); + SYSCTL_ADD_COUNTER_U64(ctx, rx_list, OID_AUTO, "csum_good", + CTLFLAG_RD, &rx_stats->csum_good, + "Valid RX checksum calculations"); } /* Stats read from device */ @@ -574,7 +555,7 @@ ena_sysctl_rx_queue_size(SYSCTL_HANDLER_ARGS) if (error != 0 || req->newptr == NULL) goto unlock; - if (val < ENA_MIN_RING_SIZE || val > adapter->max_rx_ring_size) { + if (val < ENA_MIN_RING_SIZE || val > adapter->max_rx_ring_size) { ena_log(adapter->pdev, ERR, "Requested new Rx queue size (%u) is out of range: [%u, %u]\n", val, ENA_MIN_RING_SIZE, adapter->max_rx_ring_size); @@ -593,8 +574,8 @@ ena_sysctl_rx_queue_size(SYSCTL_HANDLER_ARGS) if (val != adapter->requested_rx_ring_size) { ena_log(adapter->pdev, INFO, - "Requested new Rx queue size: %u. Old size: %u\n", - val, adapter->requested_rx_ring_size); + "Requested new Rx queue size: %u. Old size: %u\n", val, + adapter->requested_rx_ring_size); error = ena_update_queue_size(adapter, adapter->requested_tx_ring_size, val); @@ -650,19 +631,21 @@ ena_sysctl_io_queues_nb(SYSCTL_HANDLER_ARGS) */ if (tmp > (adapter->msix_vecs - ENA_ADMIN_MSIX_VEC)) { ena_log(adapter->pdev, ERR, - "Requested number of IO queues is higher than maximum " - "allowed (%u)\n", adapter->msix_vecs - ENA_ADMIN_MSIX_VEC); + "Requested number of IO queues is higher than maximum allowed (%u)\n", + adapter->msix_vecs - ENA_ADMIN_MSIX_VEC); error = EINVAL; goto unlock; } if (tmp == adapter->num_io_queues) { ena_log(adapter->pdev, ERR, "Requested number of IO queues is equal to current value " - "(%u)\n", adapter->num_io_queues); + "(%u)\n", + adapter->num_io_queues); } else { ena_log(adapter->pdev, INFO, "Requested new number of IO queues: %u, current value: " - "%u\n", tmp, adapter->num_io_queues); + "%u\n", + tmp, adapter->num_io_queues); old_num_queues = adapter->num_io_queues; error = ena_update_io_queue_nb(adapter, tmp); @@ -713,7 +696,8 @@ ena_sysctl_eni_metrics_interval(SYSCTL_HANDLER_ARGS) bzero(&adapter->eni_metrics, sizeof(adapter->eni_metrics)); } else { ena_log(adapter->pdev, INFO, - "ENI metrics update interval is set to: %"PRIu16" seconds\n", + "ENI metrics update interval is set to: %" PRIu16 + " seconds\n", interval); } diff --git a/sys/dev/ena/ena_sysctl.h b/sys/dev/ena/ena_sysctl.h index c6059c9cba3..53bcc0ee4ca 100644 --- a/sys/dev/ena/ena_sysctl.h +++ b/sys/dev/ena/ena_sysctl.h @@ -39,8 +39,8 @@ #include "ena.h" -void ena_sysctl_add_nodes(struct ena_adapter *adapter); -void ena_sysctl_update_queue_node_nb(struct ena_adapter *adapter, int old, +void ena_sysctl_add_nodes(struct ena_adapter *adapter); +void ena_sysctl_update_queue_node_nb(struct ena_adapter *adapter, int old, int new); extern int ena_enable_9k_mbufs;