ethdev: store numa_node per device
[dpdk.git] / lib / librte_ether / rte_ethdev.c
index ab0fa59..2fd8498 100644 (file)
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  * 
- *   Copyright(c) 2010-2012 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
  *   All rights reserved.
  * 
  *   Redistribution and use in source and binary forms, with or without 
@@ -124,6 +124,7 @@ struct rte_eth_dev_callback {
        rte_eth_dev_cb_fn cb_fn;                /**< Callback address */
        void *cb_arg;                           /**< Parameter for callback */
        enum rte_eth_event_type event;          /**< Interrupt event type */
+       uint32_t active;                        /**< Callback is executing */
 };
 
 enum {
@@ -240,12 +241,96 @@ rte_eth_driver_register(struct eth_driver *eth_drv)
        rte_eal_pci_register(&eth_drv->pci_drv);
 }
 
+int
+rte_eth_dev_socket_id(uint8_t port_id)
+{
+       if (port_id >= nb_ports)
+               return -1;
+       return rte_eth_devices[port_id].pci_dev->numa_node;
+}
+
 uint8_t
 rte_eth_dev_count(void)
 {
        return (nb_ports);
 }
 
+static int
+rte_eth_dev_rx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
+{
+       uint16_t old_nb_queues = dev->data->nb_rx_queues;
+       void **rxq;
+       unsigned i;
+
+       FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release, -ENOTSUP);
+
+       if (dev->data->rx_queues == NULL) {
+               dev->data->rx_queues = rte_zmalloc("ethdev->rx_queues",
+                               sizeof(dev->data->rx_queues[0]) * nb_queues,
+                               CACHE_LINE_SIZE);
+               if (dev->data->rx_queues == NULL) {
+                       dev->data->nb_rx_queues = 0;
+                       return -(ENOMEM);
+               }
+       } else {
+               rxq = dev->data->rx_queues;
+
+               for (i = nb_queues; i < old_nb_queues; i++)
+                       (*dev->dev_ops->rx_queue_release)(rxq[i]);
+               rxq = rte_realloc(rxq, sizeof(rxq[0]) * nb_queues,
+                               CACHE_LINE_SIZE);
+               if (rxq == NULL)
+                       return -(ENOMEM);
+
+               if (nb_queues > old_nb_queues)
+                       memset(rxq + old_nb_queues, 0,
+                               sizeof(rxq[0]) * (nb_queues - old_nb_queues));
+
+               dev->data->rx_queues = rxq;
+
+       }
+       dev->data->nb_rx_queues = nb_queues;
+       return (0);
+}
+
+static int
+rte_eth_dev_tx_queue_config(struct rte_eth_dev *dev, uint16_t nb_queues)
+{
+       uint16_t old_nb_queues = dev->data->nb_tx_queues;
+       void **txq;
+       unsigned i;
+
+       FUNC_PTR_OR_ERR_RET(*dev->dev_ops->tx_queue_release, -ENOTSUP);
+
+       if (dev->data->tx_queues == NULL) {
+               dev->data->tx_queues = rte_zmalloc("ethdev->tx_queues",
+                               sizeof(dev->data->tx_queues[0]) * nb_queues,
+                               CACHE_LINE_SIZE);
+               if (dev->data->tx_queues == NULL) {
+                       dev->data->nb_tx_queues = 0;
+                       return -(ENOMEM);
+               }
+       } else {
+               txq = dev->data->tx_queues;
+
+               for (i = nb_queues; i < old_nb_queues; i++)
+                       (*dev->dev_ops->tx_queue_release)(txq[i]);
+               txq = rte_realloc(txq, sizeof(txq[0]) * nb_queues,
+                               CACHE_LINE_SIZE);
+               if (txq == NULL)
+                       return -(ENOMEM);
+
+               if (nb_queues > old_nb_queues)
+                       memset(txq + old_nb_queues, 0,
+                               sizeof(txq[0]) * (nb_queues - old_nb_queues));
+
+               dev->data->tx_queues = txq;
+
+       }
+       dev->data->nb_tx_queues = nb_queues;
+       return (0);
+}
+
 int
 rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
                      const struct rte_eth_conf *dev_conf)
@@ -316,6 +401,14 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
                                (unsigned)dev_info.max_rx_pktlen);
                        return (-EINVAL);
                }
+               else if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN) {
+                       PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
+                               " < min valid value %u\n",
+                               port_id,
+                               (unsigned)dev_conf->rxmode.max_rx_pkt_len,
+                               (unsigned)ETHER_MIN_LEN);
+                       return (-EINVAL);
+               }
        } else
                /* Use default value */
                dev->data->dev_conf.rxmode.max_rx_pkt_len = ETHER_MAX_LEN;
@@ -400,12 +493,34 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
                }
        }
 
-       diag = (*dev->dev_ops->dev_configure)(dev, nb_rx_q, nb_tx_q);
+       /*
+        * Setup new number of RX/TX queues and reconfigure device.
+        */
+       diag = rte_eth_dev_rx_queue_config(dev, nb_rx_q);
        if (diag != 0) {
-               rte_free(dev->data->rx_queues);
-               rte_free(dev->data->tx_queues);
+               PMD_DEBUG_TRACE("port%d rte_eth_dev_rx_queue_config = %d\n",
+                               port_id, diag);
+               return diag;
        }
-       return diag;
+
+       diag = rte_eth_dev_tx_queue_config(dev, nb_tx_q);
+       if (diag != 0) {
+               PMD_DEBUG_TRACE("port%d rte_eth_dev_tx_queue_config = %d\n",
+                               port_id, diag);
+               rte_eth_dev_rx_queue_config(dev, 0);
+               return diag;
+       }
+
+       diag = (*dev->dev_ops->dev_configure)(dev);
+       if (diag != 0) {
+               PMD_DEBUG_TRACE("port%d dev_configure = %d\n",
+                               port_id, diag);
+               rte_eth_dev_rx_queue_config(dev, 0);
+               rte_eth_dev_tx_queue_config(dev, 0);
+               return diag;
+       }
+
+       return 0;
 }
 
 static void
@@ -597,7 +712,7 @@ rte_eth_tx_queue_setup(uint8_t port_id, uint16_t tx_queue_id,
         * in a multi-process setup*/
        PROC_PRIMARY_OR_ERR_RET(-E_RTE_SECONDARY);
 
-       if (port_id >= nb_ports) {
+       if (port_id >= RTE_MAX_ETHPORTS || port_id >= nb_ports) {
                PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
                return (-EINVAL);
        }
@@ -887,6 +1002,118 @@ rte_eth_dev_vlan_filter(uint8_t port_id, uint16_t vlan_id, int on)
        return (0);
 }
 
+int
+rte_eth_dev_set_vlan_strip_on_queue(uint8_t port_id, uint16_t rx_queue_id, int on)
+{
+       struct rte_eth_dev *dev;
+
+       if (port_id >= nb_ports) {
+               PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+               return (-ENODEV);
+       }
+
+       dev = &rte_eth_devices[port_id];
+       if (rx_queue_id >= dev->data->nb_rx_queues) {
+               PMD_DEBUG_TRACE("Invalid rx_queue_id=%d\n", port_id);
+               return (-EINVAL);
+       }
+
+       FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_strip_queue_set, -ENOTSUP);
+       (*dev->dev_ops->vlan_strip_queue_set)(dev, rx_queue_id, on);
+
+       return (0);
+}
+
+int
+rte_eth_dev_set_vlan_ether_type(uint8_t port_id, uint16_t tpid)
+{
+       struct rte_eth_dev *dev;
+
+       if (port_id >= nb_ports) {
+               PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+               return (-ENODEV);
+       }
+
+       dev = &rte_eth_devices[port_id];
+       FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_tpid_set, -ENOTSUP);
+       (*dev->dev_ops->vlan_tpid_set)(dev, tpid);
+
+       return (0);
+}
+
+int
+rte_eth_dev_set_vlan_offload(uint8_t port_id, int offload_mask)
+{
+       struct rte_eth_dev *dev;
+       int ret = 0;
+       int mask = 0;
+       int cur, org = 0;
+       
+       if (port_id >= nb_ports) {
+               PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+               return (-ENODEV);
+       }
+
+       dev = &rte_eth_devices[port_id];
+
+       /*check which option changed by application*/
+       cur = !!(offload_mask & ETH_VLAN_STRIP_OFFLOAD);
+       org = !!(dev->data->dev_conf.rxmode.hw_vlan_strip);
+       if (cur != org){
+               dev->data->dev_conf.rxmode.hw_vlan_strip = (uint8_t)cur;
+               mask |= ETH_VLAN_STRIP_MASK;
+       }
+       
+       cur = !!(offload_mask & ETH_VLAN_FILTER_OFFLOAD);
+       org = !!(dev->data->dev_conf.rxmode.hw_vlan_filter);
+       if (cur != org){
+               dev->data->dev_conf.rxmode.hw_vlan_filter = (uint8_t)cur;
+               mask |= ETH_VLAN_FILTER_MASK;
+       }
+
+       cur = !!(offload_mask & ETH_VLAN_EXTEND_OFFLOAD);
+       org = !!(dev->data->dev_conf.rxmode.hw_vlan_extend);
+       if (cur != org){
+               dev->data->dev_conf.rxmode.hw_vlan_extend = (uint8_t)cur;
+               mask |= ETH_VLAN_EXTEND_MASK;
+       }
+
+       /*no change*/
+       if(mask == 0)
+               return ret;
+       
+       FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_offload_set, -ENOTSUP);
+       (*dev->dev_ops->vlan_offload_set)(dev, mask);
+
+       return ret;
+}
+
+int
+rte_eth_dev_get_vlan_offload(uint8_t port_id)
+{
+       struct rte_eth_dev *dev;
+       int ret = 0;
+
+       if (port_id >= nb_ports) {
+               PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+               return (-ENODEV);
+       }
+
+       dev = &rte_eth_devices[port_id];
+
+       if (dev->data->dev_conf.rxmode.hw_vlan_strip)
+               ret |= ETH_VLAN_STRIP_OFFLOAD ;
+
+       if (dev->data->dev_conf.rxmode.hw_vlan_filter)
+               ret |= ETH_VLAN_FILTER_OFFLOAD ;
+
+       if (dev->data->dev_conf.rxmode.hw_vlan_extend)
+               ret |= ETH_VLAN_EXTEND_OFFLOAD ;
+
+       return ret;
+}
+
+
 int
 rte_eth_dev_fdir_add_signature_filter(uint8_t port_id,
                                      struct rte_fdir_filter *fdir_filter,
@@ -1143,10 +1370,6 @@ rte_eth_dev_fdir_set_masks(uint8_t port_id, struct rte_fdir_masks *fdir_mask)
                return (-ENOSYS);
        }
 
-       /* IPv6 mask are not supported */
-       if (fdir_mask->src_ipv6_mask)
-               return (-ENOTSUP);
-
        FUNC_PTR_OR_ERR_RET(*dev->dev_ops->fdir_set_masks, -ENOTSUP);
        return (*dev->dev_ops->fdir_set_masks)(dev, fdir_mask);
 }
@@ -1167,13 +1390,30 @@ rte_eth_dev_flow_ctrl_set(uint8_t port_id, struct rte_eth_fc_conf *fc_conf)
        }
 
        dev = &rte_eth_devices[port_id];
-
-       /* High water, low water validation are device specific */
        FUNC_PTR_OR_ERR_RET(*dev->dev_ops->flow_ctrl_set, -ENOTSUP);
-       if  (*dev->dev_ops->flow_ctrl_set)
-               return (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf);
+       return (*dev->dev_ops->flow_ctrl_set)(dev, fc_conf);
+}
+
+int
+rte_eth_dev_priority_flow_ctrl_set(uint8_t port_id, struct rte_eth_pfc_conf *pfc_conf)
+{
+       struct rte_eth_dev *dev;
+
+       if (port_id >= nb_ports) {
+               PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
+               return (-ENODEV);
+       }
 
-       return -ENOTSUP;
+       if (pfc_conf->priority > (ETH_DCB_NUM_USER_PRIORITIES - 1)) {
+               PMD_DEBUG_TRACE("Invalid priority, only 0-7 allowed\n");
+               return (-EINVAL);
+       }
+
+       dev = &rte_eth_devices[port_id];
+       /* High water, low water validation are device specific */
+       if  (*dev->dev_ops->priority_flow_ctrl_set)
+               return (*dev->dev_ops->priority_flow_ctrl_set)(dev, pfc_conf);
+       return (-ENOTSUP);
 }
 
 int
@@ -1344,40 +1584,38 @@ rte_eth_dev_callback_register(uint8_t port_id,
                        enum rte_eth_event_type event,
                        rte_eth_dev_cb_fn cb_fn, void *cb_arg)
 {
-       int ret = -1;
        struct rte_eth_dev *dev;
-       struct rte_eth_dev_callback *user_cb = NULL;
+       struct rte_eth_dev_callback *user_cb;
 
        if (!cb_fn)
-               return -1;
+               return (-EINVAL);
        if (port_id >= nb_ports) {
                PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
-               return -1;
+               return (-EINVAL);
        }
+
        dev = &rte_eth_devices[port_id];
        rte_spinlock_lock(&rte_eth_dev_cb_lock);
+
        TAILQ_FOREACH(user_cb, &(dev->callbacks), next) {
                if (user_cb->cb_fn == cb_fn &&
                        user_cb->cb_arg == cb_arg &&
                        user_cb->event == event) {
-                       ret = 0;
-                       goto out;
+                       break;
                }
        }
-       user_cb = rte_malloc("INTR_USER_CALLBACK",
-               sizeof(struct rte_eth_dev_callback), 0);
-       if (!user_cb)
-               goto out;
-       user_cb->cb_fn = cb_fn;
-       user_cb->cb_arg = cb_arg;
-       user_cb->event = event;
-       TAILQ_INSERT_TAIL(&(dev->callbacks), user_cb, next);
-       ret = 0;
 
-out:
-       rte_spinlock_unlock(&rte_eth_dev_cb_lock);
+       /* create a new callback. */
+       if (user_cb == NULL && (user_cb = rte_zmalloc("INTR_USER_CALLBACK",
+                       sizeof(struct rte_eth_dev_callback), 0)) != NULL) {
+               user_cb->cb_fn = cb_fn;
+               user_cb->cb_arg = cb_arg;
+               user_cb->event = event;
+               TAILQ_INSERT_TAIL(&(dev->callbacks), user_cb, next);
+       }
 
-       return ret;
+       rte_spinlock_unlock(&rte_eth_dev_cb_lock);
+       return ((user_cb == NULL) ? -ENOMEM : 0);
 }
 
 int
@@ -1385,38 +1623,51 @@ rte_eth_dev_callback_unregister(uint8_t port_id,
                        enum rte_eth_event_type event,
                        rte_eth_dev_cb_fn cb_fn, void *cb_arg)
 {
-       int ret = -1;
+       int ret;
        struct rte_eth_dev *dev;
-       struct rte_eth_dev_callback *cb_lst = NULL;
+       struct rte_eth_dev_callback *cb, *next;
 
        if (!cb_fn)
-               return -1;
+               return (-EINVAL);
        if (port_id >= nb_ports) {
                PMD_DEBUG_TRACE("Invalid port_id=%d\n", port_id);
-               return -1;
+               return (-EINVAL);
        }
+
        dev = &rte_eth_devices[port_id];
        rte_spinlock_lock(&rte_eth_dev_cb_lock);
-       TAILQ_FOREACH(cb_lst, &(dev->callbacks), next) {
-               if (cb_lst->cb_fn != cb_fn || cb_lst->event != event)
+
+       ret = 0;
+       for (cb = TAILQ_FIRST(&dev->callbacks); cb != NULL; cb = next) {
+
+               next = TAILQ_NEXT(cb, next);
+
+               if (cb->cb_fn != cb_fn || cb->event != event ||
+                               (cb->cb_arg != (void *)-1 &&
+                               cb->cb_arg != cb_arg))
                        continue;
-               if (cb_lst->cb_arg == (void *)-1 ||
-                               cb_lst->cb_arg == cb_arg) {
-                       TAILQ_REMOVE(&(dev->callbacks), cb_lst, next);
-                       rte_free(cb_lst);
-                       ret = 0;
+
+               /*
+                * if this callback is not executing right now,
+                * then remove it.
+                */
+               if (cb->active == 0) {
+                       TAILQ_REMOVE(&(dev->callbacks), cb, next);
+                       rte_free(cb);
+               } else {
+                       ret = -EAGAIN;
                }
        }
 
        rte_spinlock_unlock(&rte_eth_dev_cb_lock);
-
-       return ret;
+       return (ret);
 }
 
 void
-_rte_eth_dev_callback_process(struct rte_eth_dev *dev, enum rte_eth_event_type event)
+_rte_eth_dev_callback_process(struct rte_eth_dev *dev,
+       enum rte_eth_event_type event)
 {
-       struct rte_eth_dev_callback *cb_lst = NULL;
+       struct rte_eth_dev_callback *cb_lst;
        struct rte_eth_dev_callback dev_cb;
 
        rte_spinlock_lock(&rte_eth_dev_cb_lock);
@@ -1424,11 +1675,12 @@ _rte_eth_dev_callback_process(struct rte_eth_dev *dev, enum rte_eth_event_type e
                if (cb_lst->cb_fn == NULL || cb_lst->event != event)
                        continue;
                dev_cb = *cb_lst;
+               cb_lst->active = 1;
                rte_spinlock_unlock(&rte_eth_dev_cb_lock);
                dev_cb.cb_fn(dev->data->port_id, dev_cb.event,
                                                dev_cb.cb_arg);
                rte_spinlock_lock(&rte_eth_dev_cb_lock);
+               cb_lst->active = 0;
        }
        rte_spinlock_unlock(&rte_eth_dev_cb_lock);
 }
-