ibmveth: Add ethtool driver stats hooks
[linux-2.6.git] / drivers / net / ibmveth.c
index d96eb72..40cb00e 100644 (file)
@@ -47,6 +47,9 @@
 #include <linux/mm.h>
 #include <linux/ethtool.h>
 #include <linux/proc_fs.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <net/net_namespace.h>
 #include <asm/semaphore.h>
 #include <asm/hvcall.h>
 #include <asm/atomic.h>
@@ -83,7 +86,7 @@
 static int ibmveth_open(struct net_device *dev);
 static int ibmveth_close(struct net_device *dev);
 static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
-static int ibmveth_poll(struct net_device *dev, int *budget);
+static int ibmveth_poll(struct napi_struct *napi, int budget);
 static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static struct net_device_stats *ibmveth_get_stats(struct net_device *dev);
 static void ibmveth_set_multicast_list(struct net_device *dev);
@@ -97,7 +100,7 @@ static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
 static struct kobj_type ktype_veth_pool;
 
 #ifdef CONFIG_PROC_FS
-#define IBMVETH_PROC_DIR "net/ibmveth"
+#define IBMVETH_PROC_DIR "ibmveth"
 static struct proc_dir_entry *ibmveth_proc_dir;
 #endif
 
@@ -110,6 +113,28 @@ MODULE_DESCRIPTION("IBM i/pSeries Virtual Ethernet Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(ibmveth_driver_version);
 
+struct ibmveth_stat {
+       char name[ETH_GSTRING_LEN];
+       int offset;
+};
+
+#define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
+#define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
+
+struct ibmveth_stat ibmveth_stats[] = {
+       { "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) },
+       { "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) },
+       { "replenish_add_buff_failure", IBMVETH_STAT_OFF(replenish_add_buff_failure) },
+       { "replenish_add_buff_success", IBMVETH_STAT_OFF(replenish_add_buff_success) },
+       { "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) },
+       { "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) },
+       { "tx_multidesc_send", IBMVETH_STAT_OFF(tx_multidesc_send) },
+       { "tx_linearized", IBMVETH_STAT_OFF(tx_linearized) },
+       { "tx_linearize_failed", IBMVETH_STAT_OFF(tx_linearize_failed) },
+       { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
+       { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
+};
+
 /* simple methods of getting data from the current rxq entry */
 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
 {
@@ -131,6 +156,11 @@ static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
        return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
 }
 
+static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
+{
+       return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].csum_good);
+}
+
 /* setup the initial settings for a buffer pool */
 static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, u32 pool_index, u32 pool_size, u32 buff_size, u32 pool_active)
 {
@@ -480,6 +510,8 @@ static int ibmveth_open(struct net_device *netdev)
 
        ibmveth_debug_printk("open starting\n");
 
+       napi_enable(&adapter->napi);
+
        for(i = 0; i<IbmVethNumBufferPools; i++)
                rxq_entries += adapter->rx_buff_pool[i].size;
 
@@ -489,6 +521,7 @@ static int ibmveth_open(struct net_device *netdev)
        if(!adapter->buffer_list_addr || !adapter->filter_list_addr) {
                ibmveth_error_printk("unable to allocate filter or buffer list pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -498,6 +531,7 @@ static int ibmveth_open(struct net_device *netdev)
        if(!adapter->rx_queue.queue_addr) {
                ibmveth_error_printk("unable to allocate rx queue pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -514,6 +548,7 @@ static int ibmveth_open(struct net_device *netdev)
           (dma_mapping_error(adapter->rx_queue.queue_dma))) {
                ibmveth_error_printk("unable to map filter or buffer list pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -545,6 +580,7 @@ static int ibmveth_open(struct net_device *netdev)
                                     rxq_desc.desc,
                                     mac_address);
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENONET;
        }
 
@@ -555,6 +591,7 @@ static int ibmveth_open(struct net_device *netdev)
                        ibmveth_error_printk("unable to alloc pool\n");
                        adapter->rx_buff_pool[i].active = 0;
                        ibmveth_cleanup(adapter);
+                       napi_disable(&adapter->napi);
                        return -ENOMEM ;
                }
        }
@@ -567,6 +604,7 @@ static int ibmveth_open(struct net_device *netdev)
                } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
 
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return rc;
        }
 
@@ -587,6 +625,8 @@ static int ibmveth_close(struct net_device *netdev)
 
        ibmveth_debug_printk("close starting\n");
 
+       napi_disable(&adapter->napi);
+
        if (!adapter->pool_config)
                netif_stop_queue(netdev);
 
@@ -634,12 +674,163 @@ static u32 netdev_get_link(struct net_device *dev) {
        return 1;
 }
 
+static void ibmveth_set_rx_csum_flags(struct net_device *dev, u32 data)
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+
+       if (data)
+               adapter->rx_csum = 1;
+       else {
+               /*
+                * Since the ibmveth firmware interface does not have the concept of
+                * separate tx/rx checksum offload enable, if rx checksum is disabled
+                * we also have to disable tx checksum offload. Once we disable rx
+                * checksum offload, we are no longer allowed to send tx buffers that
+                * are not properly checksummed.
+                */
+               adapter->rx_csum = 0;
+               dev->features &= ~NETIF_F_IP_CSUM;
+       }
+}
+
+static void ibmveth_set_tx_csum_flags(struct net_device *dev, u32 data)
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+
+       if (data) {
+               dev->features |= NETIF_F_IP_CSUM;
+               adapter->rx_csum = 1;
+       } else
+               dev->features &= ~NETIF_F_IP_CSUM;
+}
+
+static int ibmveth_set_csum_offload(struct net_device *dev, u32 data,
+                                   void (*done) (struct net_device *, u32))
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+       union ibmveth_illan_attributes set_attr, clr_attr, ret_attr;
+       long ret;
+       int rc1 = 0, rc2 = 0;
+       int restart = 0;
+
+       if (netif_running(dev)) {
+               restart = 1;
+               adapter->pool_config = 1;
+               ibmveth_close(dev);
+               adapter->pool_config = 0;
+       }
+
+       set_attr.desc = 0;
+       clr_attr.desc = 0;
+
+       if (data)
+               set_attr.fields.tcp_csum_offload_ipv4 = 1;
+       else
+               clr_attr.fields.tcp_csum_offload_ipv4 = 1;
+
+       ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr.desc);
+
+       if (ret == H_SUCCESS && !ret_attr.fields.active_trunk &&
+           !ret_attr.fields.trunk_priority &&
+           ret_attr.fields.csum_offload_padded_pkt_support) {
+               ret = h_illan_attributes(adapter->vdev->unit_address, clr_attr.desc,
+                                        set_attr.desc, &ret_attr.desc);
+
+               if (ret != H_SUCCESS) {
+                       rc1 = -EIO;
+                       ibmveth_error_printk("unable to change checksum offload settings."
+                                            " %d rc=%ld\n", data, ret);
+
+                       ret = h_illan_attributes(adapter->vdev->unit_address,
+                                                set_attr.desc, clr_attr.desc, &ret_attr.desc);
+               } else
+                       done(dev, data);
+       } else {
+               rc1 = -EIO;
+               ibmveth_error_printk("unable to change checksum offload settings."
+                                    " %d rc=%ld ret_attr=%lx\n", data, ret, ret_attr.desc);
+       }
+
+       if (restart)
+               rc2 = ibmveth_open(dev);
+
+       return rc1 ? rc1 : rc2;
+}
+
+static int ibmveth_set_rx_csum(struct net_device *dev, u32 data)
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+
+       if ((data && adapter->rx_csum) || (!data && !adapter->rx_csum))
+               return 0;
+
+       return ibmveth_set_csum_offload(dev, data, ibmveth_set_rx_csum_flags);
+}
+
+static int ibmveth_set_tx_csum(struct net_device *dev, u32 data)
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+       int rc = 0;
+
+       if (data && (dev->features & NETIF_F_IP_CSUM))
+               return 0;
+       if (!data && !(dev->features & NETIF_F_IP_CSUM))
+               return 0;
+
+       if (data && !adapter->rx_csum)
+               rc = ibmveth_set_csum_offload(dev, data, ibmveth_set_tx_csum_flags);
+       else
+               ibmveth_set_tx_csum_flags(dev, data);
+
+       return rc;
+}
+
+static u32 ibmveth_get_rx_csum(struct net_device *dev)
+{
+       struct ibmveth_adapter *adapter = dev->priv;
+       return adapter->rx_csum;
+}
+
+static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
+{
+       int i;
+
+       if (stringset != ETH_SS_STATS)
+               return;
+
+       for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN)
+               memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN);
+}
+
+static int ibmveth_get_stats_count(struct net_device *dev)
+{
+       return ARRAY_SIZE(ibmveth_stats);
+}
+
+static void ibmveth_get_ethtool_stats(struct net_device *dev,
+                                     struct ethtool_stats *stats, u64 *data)
+{
+       int i;
+       struct ibmveth_adapter *adapter = dev->priv;
+
+       for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++)
+               data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset);
+}
+
 static const struct ethtool_ops netdev_ethtool_ops = {
        .get_drvinfo            = netdev_get_drvinfo,
        .get_settings           = netdev_get_settings,
        .get_link               = netdev_get_link,
        .get_sg                 = ethtool_op_get_sg,
        .get_tx_csum            = ethtool_op_get_tx_csum,
+       .set_tx_csum            = ibmveth_set_tx_csum,
+       .get_rx_csum            = ibmveth_get_rx_csum,
+       .set_rx_csum            = ibmveth_set_rx_csum,
+       .get_tso                        = ethtool_op_get_tso,
+       .get_ufo                        = ethtool_op_get_ufo,
+       .get_strings            = ibmveth_get_strings,
+       .get_stats_count                = ibmveth_get_stats_count,
+       .get_ethtool_stats      = ibmveth_get_ethtool_stats,
 };
 
 static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
@@ -684,6 +875,24 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                        desc[0].fields.length, DMA_TO_DEVICE);
        desc[0].fields.valid   = 1;
 
+       if (skb->ip_summed == CHECKSUM_PARTIAL &&
+           ip_hdr(skb)->protocol != IPPROTO_TCP && skb_checksum_help(skb)) {
+               ibmveth_error_printk("tx: failed to checksum packet\n");
+               tx_dropped++;
+               goto out;
+       }
+
+       if (skb->ip_summed == CHECKSUM_PARTIAL) {
+               unsigned char *buf = skb_transport_header(skb) + skb->csum_offset;
+
+               desc[0].fields.no_csum = 1;
+               desc[0].fields.csum_good = 1;
+
+               /* Need to zero out the checksum */
+               buf[0] = 0;
+               buf[1] = 0;
+       }
+
        if(dma_mapping_error(desc[0].fields.address)) {
                ibmveth_error_printk("tx: unable to map initial fragment\n");
                tx_map_failed++;
@@ -702,6 +911,10 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                frag->size, DMA_TO_DEVICE);
                desc[curfrag+1].fields.length = frag->size;
                desc[curfrag+1].fields.valid  = 1;
+               if (skb->ip_summed == CHECKSUM_PARTIAL) {
+                       desc[curfrag+1].fields.no_csum = 1;
+                       desc[curfrag+1].fields.csum_good = 1;
+               }
 
                if(dma_mapping_error(desc[curfrag+1].fields.address)) {
                        ibmveth_error_printk("tx: unable to map fragment %d\n", curfrag);
@@ -767,80 +980,72 @@ out:      spin_lock_irqsave(&adapter->stats_lock, flags);
        return 0;
 }
 
-static int ibmveth_poll(struct net_device *netdev, int *budget)
+static int ibmveth_poll(struct napi_struct *napi, int budget)
 {
-       struct ibmveth_adapter *adapter = netdev->priv;
-       int max_frames_to_process = netdev->quota;
+       struct ibmveth_adapter *adapter = container_of(napi, struct ibmveth_adapter, napi);
+       struct net_device *netdev = adapter->netdev;
        int frames_processed = 0;
-       int more_work = 1;
        unsigned long lpar_rc;
 
  restart_poll:
        do {
-               struct net_device *netdev = adapter->netdev;
+               struct sk_buff *skb;
 
-               if(ibmveth_rxq_pending_buffer(adapter)) {
-                       struct sk_buff *skb;
+               if (!ibmveth_rxq_pending_buffer(adapter))
+                       break;
 
-                       rmb();
+               rmb();
+               if (!ibmveth_rxq_buffer_valid(adapter)) {
+                       wmb(); /* suggested by larson1 */
+                       adapter->rx_invalid_buffer++;
+                       ibmveth_debug_printk("recycling invalid buffer\n");
+                       ibmveth_rxq_recycle_buffer(adapter);
+               } else {
+                       int length = ibmveth_rxq_frame_length(adapter);
+                       int offset = ibmveth_rxq_frame_offset(adapter);
+                       int csum_good = ibmveth_rxq_csum_good(adapter);
 
-                       if(!ibmveth_rxq_buffer_valid(adapter)) {
-                               wmb(); /* suggested by larson1 */
-                               adapter->rx_invalid_buffer++;
-                               ibmveth_debug_printk("recycling invalid buffer\n");
-                               ibmveth_rxq_recycle_buffer(adapter);
-                       } else {
-                               int length = ibmveth_rxq_frame_length(adapter);
-                               int offset = ibmveth_rxq_frame_offset(adapter);
-                               skb = ibmveth_rxq_get_buffer(adapter);
+                       skb = ibmveth_rxq_get_buffer(adapter);
+                       if (csum_good)
+                               skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-                               ibmveth_rxq_harvest_buffer(adapter);
+                       ibmveth_rxq_harvest_buffer(adapter);
 
-                               skb_reserve(skb, offset);
-                               skb_put(skb, length);
-                               skb->protocol = eth_type_trans(skb, netdev);
+                       skb_reserve(skb, offset);
+                       skb_put(skb, length);
+                       skb->protocol = eth_type_trans(skb, netdev);
 
-                               netif_receive_skb(skb); /* send it up */
+                       netif_receive_skb(skb); /* send it up */
 
-                               adapter->stats.rx_packets++;
-                               adapter->stats.rx_bytes += length;
-                               frames_processed++;
-                               netdev->last_rx = jiffies;
-                       }
-               } else {
-                       more_work = 0;
+                       adapter->stats.rx_packets++;
+                       adapter->stats.rx_bytes += length;
+                       frames_processed++;
+                       netdev->last_rx = jiffies;
                }
-       } while(more_work && (frames_processed < max_frames_to_process));
+       } while (frames_processed < budget);
 
        ibmveth_replenish_task(adapter);
 
-       if(more_work) {
-               /* more work to do - return that we are not done yet */
-               netdev->quota -= frames_processed;
-               *budget -= frames_processed;
-               return 1;
-       }
+       if (frames_processed < budget) {
+               /* We think we are done - reenable interrupts,
+                * then check once more to make sure we are done.
+                */
+               lpar_rc = h_vio_signal(adapter->vdev->unit_address,
+                                      VIO_IRQ_ENABLE);
 
-       /* we think we are done - reenable interrupts, then check once more to make sure we are done */
-       lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_ENABLE);
-
-       ibmveth_assert(lpar_rc == H_SUCCESS);
+               ibmveth_assert(lpar_rc == H_SUCCESS);
 
-       netif_rx_complete(netdev);
+               netif_rx_complete(netdev, napi);
 
-       if(ibmveth_rxq_pending_buffer(adapter) && netif_rx_reschedule(netdev, frames_processed))
-       {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
-               ibmveth_assert(lpar_rc == H_SUCCESS);
-               more_work = 1;
-               goto restart_poll;
+               if (ibmveth_rxq_pending_buffer(adapter) &&
+                   netif_rx_reschedule(netdev, napi)) {
+                       lpar_rc = h_vio_signal(adapter->vdev->unit_address,
+                                              VIO_IRQ_DISABLE);
+                       goto restart_poll;
+               }
        }
 
-       netdev->quota -= frames_processed;
-       *budget -= frames_processed;
-
-       /* we really are done */
-       return 0;
+       return frames_processed;
 }
 
 static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
@@ -849,10 +1054,11 @@ static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
        struct ibmveth_adapter *adapter = netdev->priv;
        unsigned long lpar_rc;
 
-       if(netif_rx_schedule_prep(netdev)) {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
+       if (netif_rx_schedule_prep(netdev, &adapter->napi)) {
+               lpar_rc = h_vio_signal(adapter->vdev->unit_address,
+                                      VIO_IRQ_DISABLE);
                ibmveth_assert(lpar_rc == H_SUCCESS);
-               __netif_rx_schedule(netdev);
+               __netif_rx_schedule(netdev, &adapter->napi);
        }
        return IRQ_HANDLED;
 }
@@ -962,8 +1168,10 @@ static void ibmveth_poll_controller(struct net_device *dev)
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
        int rc, i;
+       long ret;
        struct net_device *netdev;
-       struct ibmveth_adapter *adapter = NULL;
+       struct ibmveth_adapter *adapter;
+       union ibmveth_illan_attributes set_attr, ret_attr;
 
        unsigned char *mac_addr_p;
        unsigned int *mcastFilterSize_p;
@@ -997,7 +1205,6 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
        SET_MODULE_OWNER(netdev);
 
        adapter = netdev->priv;
-       memset(adapter, 0, sizeof(adapter));
        dev->dev.driver_data = netdev;
 
        adapter->vdev = dev;
@@ -1005,6 +1212,8 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
        adapter->mcastFilterSize= *mcastFilterSize_p;
        adapter->pool_config = 0;
 
+       netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
+
        /*      Some older boxes running PHYP non-natively have an OF that
                returns a 8-byte local-mac-address field (and the first
                2 bytes have to be ignored) while newer boxes' OF return
@@ -1021,8 +1230,6 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
 
        netdev->irq = dev->irq;
        netdev->open               = ibmveth_open;
-       netdev->poll               = ibmveth_poll;
-       netdev->weight             = 16;
        netdev->stop               = ibmveth_close;
        netdev->hard_start_xmit    = ibmveth_start_xmit;
        netdev->get_stats          = ibmveth_get_stats;
@@ -1058,6 +1265,25 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
 
        ibmveth_debug_printk("registering netdev...\n");
 
+       ret = h_illan_attributes(dev->unit_address, 0, 0, &ret_attr.desc);
+
+       if (ret == H_SUCCESS && !ret_attr.fields.active_trunk &&
+           !ret_attr.fields.trunk_priority &&
+           ret_attr.fields.csum_offload_padded_pkt_support) {
+               set_attr.desc = 0;
+               set_attr.fields.tcp_csum_offload_ipv4 = 1;
+
+               ret = h_illan_attributes(dev->unit_address, 0, set_attr.desc,
+                                        &ret_attr.desc);
+
+               if (ret == H_SUCCESS) {
+                       adapter->rx_csum = 1;
+                       netdev->features |= NETIF_F_IP_CSUM;
+               } else
+                       ret = h_illan_attributes(dev->unit_address, set_attr.desc,
+                                                0, &ret_attr.desc);
+       }
+
        rc = register_netdev(netdev);
 
        if(rc) {
@@ -1093,7 +1319,7 @@ static int __devexit ibmveth_remove(struct vio_dev *dev)
 #ifdef CONFIG_PROC_FS
 static void ibmveth_proc_register_driver(void)
 {
-       ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, NULL);
+       ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, init_net.proc_net);
        if (ibmveth_proc_dir) {
                SET_MODULE_OWNER(ibmveth_proc_dir);
        }
@@ -1101,7 +1327,7 @@ static void ibmveth_proc_register_driver(void)
 
 static void ibmveth_proc_unregister_driver(void)
 {
-       remove_proc_entry(IBMVETH_PROC_DIR, NULL);
+       remove_proc_entry(IBMVETH_PROC_DIR, init_net.proc_net);
 }
 
 static void *ibmveth_seq_start(struct seq_file *seq, loff_t *pos)
@@ -1280,24 +1506,28 @@ const char * buf, size_t count)
                        int i;
                        /* Make sure there is a buffer pool with buffers that
                           can hold a packet of the size of the MTU */
-                       for(i = 0; i<IbmVethNumBufferPools; i++) {
+                       for (i = 0; i < IbmVethNumBufferPools; i++) {
                                if (pool == &adapter->rx_buff_pool[i])
                                        continue;
                                if (!adapter->rx_buff_pool[i].active)
                                        continue;
-                               if (mtu < adapter->rx_buff_pool[i].buff_size) {
-                                       pool->active = 0;
-                                       h_free_logical_lan_buffer(adapter->
-                                                                 vdev->
-                                                                 unit_address,
-                                                                 pool->
-                                                                 buff_size);
-                               }
+                               if (mtu <= adapter->rx_buff_pool[i].buff_size)
+                                       break;
                        }
-                       if (pool->active) {
+
+                       if (i == IbmVethNumBufferPools) {
                                ibmveth_error_printk("no active pool >= MTU\n");
                                return -EPERM;
                        }
+
+                       pool->active = 0;
+                       if (netif_running(netdev)) {
+                               adapter->pool_config = 1;
+                               ibmveth_close(netdev);
+                               adapter->pool_config = 0;
+                               if ((rc = ibmveth_open(netdev)))
+                                       return rc;
+                       }
                }
        } else if (attr == &veth_num_attr) {
                if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT)