Upgrade libdde_linux26 layer to 2.6.32 compatibility

  * debian/patches/libdde_{addr_fix,addr_list,config,devres,dma_head,ethoc,
  ethtool,fixes,group_addr,mdio,netdev_tx_t,pci-needs_freset,pci_ids.h,phy,
  pr_cont,rcu,rculist,rx_queue,trans_start,ucast_list,workqueue}: New patches
  to upgrade the libdde_linux26 layer to 2.6.32 compatibility.

1 files changed, 429 insertions, 0 deletions

diff --git a/debian/patches/libdde_group_addr.patch b/debian/patches/libdde_group_addr.patch
new file mode 100644
index 00000000..2ea72715
--- /dev/null
+++ b/debian/patches/libdde_group_addr.patch
@@ -0,0 +1,429 @@
+commit 31278e71471399beaff9280737e52b47db4dc345
+Author: Jiri Pirko <jpirko@redhat.com>
+Date:   Wed Jun 17 01:12:19 2009 +0000
+
+    net: group address list and its count
+    
+    This patch is inspired by patch recently posted by Johannes Berg. Basically what
+    my patch does is to group list and a count of addresses into newly introduced
+    structure netdev_hw_addr_list. This brings us two benefits:
+    1) struct net_device becames a bit nicer.
+    2) in the future there will be a possibility to operate with lists independently
+       on netdevices (with exporting right functions).
+    I wanted to introduce this patch before I'll post a multicast lists conversion.
+    
+    Signed-off-by: Jiri Pirko <jpirko@redhat.com>
+    
+     drivers/net/bnx2.c              |    4 +-
+     drivers/net/e1000/e1000_main.c  |    4 +-
+     drivers/net/ixgbe/ixgbe_main.c  |    6 +-
+     drivers/net/mv643xx_eth.c       |    2 +-
+     drivers/net/niu.c               |    4 +-
+     drivers/net/virtio_net.c        |   10 ++--
+     drivers/s390/net/qeth_l2_main.c |    2 +-
+     include/linux/netdevice.h       |   17 +++--
+     net/core/dev.c                  |  130 ++++++++++++++++++--------------------
+     9 files changed, 89 insertions(+), 90 deletions(-)
+    Signed-off-by: David S. Miller <davem@davemloft.net>
+
+Index: hurd-debian/libdde_linux26/contrib/include/linux/netdevice.h
+===================================================================
+--- hurd-debian.orig/libdde_linux26/contrib/include/linux/netdevice.h	2012-04-16 00:34:46.000000000 +0000
++++ hurd-debian/libdde_linux26/contrib/include/linux/netdevice.h	2012-04-16 00:34:51.000000000 +0000
+@@ -224,6 +224,11 @@
+ 	struct rcu_head		rcu_head;
+ };
+ 
++struct netdev_hw_addr_list {
++	struct list_head	list;
++	int			count;
++};
++
+ struct hh_cache
+ {
+ 	struct hh_cache *hh_next;	/* Next entry			     */
+@@ -741,9 +746,8 @@
+ 	unsigned char		addr_len;	/* hardware address length	*/
+ 	unsigned short          dev_id;		/* for shared network cards */
+ 
+-	struct list_head	uc_list;	/* Secondary unicast mac
+-						   addresses */
+-	int			uc_count;	/* Number of installed ucasts	*/
++	struct netdev_hw_addr_list	uc;	/* Secondary unicast
++						   mac addresses */
+ 	int			uc_promisc;
+ 	spinlock_t		addr_list_lock;
+ 	struct dev_addr_list	*mc_list;	/* Multicast mac addresses	*/
+@@ -775,7 +779,8 @@
+ 						   because most packets are
+ 						   unicast) */
+ 
+-	struct list_head	dev_addr_list; /* list of device hw addresses */
++	struct netdev_hw_addr_list	dev_addrs; /* list of device
++						      hw addresses */
+ 
+ 	unsigned char		broadcast[MAX_ADDR_LEN];	/* hw bcast add	*/
+ 
+@@ -1786,11 +1791,11 @@
+ }
+ 
+ /*
+- * dev_addr_list walker. Should be used only for read access. Call with
++ * dev_addrs walker. Should be used only for read access. Call with
+  * rcu_read_lock held.
+  */
+ #define for_each_dev_addr(dev, ha) \
+-		list_for_each_entry_rcu(ha, &dev->dev_addr_list, list)
++		list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
+ 
+ /* These functions live elsewhere (drivers/net/net_init.c, but related) */
+ 
+Index: hurd-debian/libdde_linux26/lib/src/net/core/dev.c
+===================================================================
+--- hurd-debian.orig/libdde_linux26/lib/src/net/core/dev.c	2012-04-16 00:34:49.000000000 +0000
++++ hurd-debian/libdde_linux26/lib/src/net/core/dev.c	2012-04-16 00:34:51.000000000 +0000
+@@ -3377,10 +3377,10 @@
+ 		/* Unicast addresses changes may only happen under the rtnl,
+ 		 * therefore calling __dev_set_promiscuity here is safe.
+ 		 */
+-		if (dev->uc_count > 0 && !dev->uc_promisc) {
++		if (dev->uc.count > 0 && !dev->uc_promisc) {
+ 			__dev_set_promiscuity(dev, 1);
+ 			dev->uc_promisc = 1;
+-		} else if (dev->uc_count == 0 && dev->uc_promisc) {
++		} else if (dev->uc.count == 0 && dev->uc_promisc) {
+ 			__dev_set_promiscuity(dev, -1);
+ 			dev->uc_promisc = 0;
+ 		}
+@@ -3399,9 +3399,8 @@
+ 
+ /* hw addresses list handling functions */
+ 
+-static int __hw_addr_add(struct list_head *list, int *delta,
+-			 unsigned char *addr, int addr_len,
+-			 unsigned char addr_type)
++static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
++			 int addr_len, unsigned char addr_type)
+ {
+ 	struct netdev_hw_addr *ha;
+ 	int alloc_size;
+@@ -3409,7 +3408,7 @@
+ 	if (addr_len > MAX_ADDR_LEN)
+ 		return -EINVAL;
+ 
+-	list_for_each_entry(ha, list, list) {
++	list_for_each_entry(ha, &list->list, list) {
+ 		if (!memcmp(ha->addr, addr, addr_len) &&
+ 		    ha->type == addr_type) {
+ 			ha->refcount++;
+@@ -3428,9 +3427,8 @@
+ 	ha->type = addr_type;
+ 	ha->refcount = 1;
+ 	ha->synced = false;
+-	list_add_tail_rcu(&ha->list, list);
+-	if (delta)
+-		(*delta)++;
++	list_add_tail_rcu(&ha->list, &list->list);
++	list->count++;
+ 	return 0;
+ }
+ 
+@@ -3442,120 +3440,121 @@
+ 	kfree(ha);
+ }
+ 
+-static int __hw_addr_del(struct list_head *list, int *delta,
+-			 unsigned char *addr, int addr_len,
+-			 unsigned char addr_type)
++static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
++			 int addr_len, unsigned char addr_type)
+ {
+ 	struct netdev_hw_addr *ha;
+ 
+-	list_for_each_entry(ha, list, list) {
++	list_for_each_entry(ha, &list->list, list) {
+ 		if (!memcmp(ha->addr, addr, addr_len) &&
+ 		    (ha->type == addr_type || !addr_type)) {
+ 			if (--ha->refcount)
+ 				return 0;
+ 			list_del_rcu(&ha->list);
+ 			call_rcu(&ha->rcu_head, ha_rcu_free);
+-			if (delta)
+-				(*delta)--;
++			list->count--;
+ 			return 0;
+ 		}
+ 	}
+ 	return -ENOENT;
+ }
+ 
+-static int __hw_addr_add_multiple(struct list_head *to_list, int *to_delta,
+-				  struct list_head *from_list, int addr_len,
++static int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
++				  struct netdev_hw_addr_list *from_list,
++				  int addr_len,
+ 				  unsigned char addr_type)
+ {
+ 	int err;
+ 	struct netdev_hw_addr *ha, *ha2;
+ 	unsigned char type;
+ 
+-	list_for_each_entry(ha, from_list, list) {
++	list_for_each_entry(ha, &from_list->list, list) {
+ 		type = addr_type ? addr_type : ha->type;
+-		err = __hw_addr_add(to_list, to_delta, ha->addr,
+-				    addr_len, type);
++		err = __hw_addr_add(to_list, ha->addr, addr_len, type);
+ 		if (err)
+ 			goto unroll;
+ 	}
+ 	return 0;
+ 
+ unroll:
+-	list_for_each_entry(ha2, from_list, list) {
++	list_for_each_entry(ha2, &from_list->list, list) {
+ 		if (ha2 == ha)
+ 			break;
+ 		type = addr_type ? addr_type : ha2->type;
+-		__hw_addr_del(to_list, to_delta, ha2->addr,
+-			      addr_len, type);
++		__hw_addr_del(to_list, ha2->addr, addr_len, type);
+ 	}
+ 	return err;
+ }
+ 
+-static void __hw_addr_del_multiple(struct list_head *to_list, int *to_delta,
+-				   struct list_head *from_list, int addr_len,
++static void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
++				   struct netdev_hw_addr_list *from_list,
++				   int addr_len,
+ 				   unsigned char addr_type)
+ {
+ 	struct netdev_hw_addr *ha;
+ 	unsigned char type;
+ 
+-	list_for_each_entry(ha, from_list, list) {
++	list_for_each_entry(ha, &from_list->list, list) {
+ 		type = addr_type ? addr_type : ha->type;
+-		__hw_addr_del(to_list, to_delta, ha->addr,
+-			      addr_len, addr_type);
++		__hw_addr_del(to_list, ha->addr, addr_len, addr_type);
+ 	}
+ }
+ 
+-static int __hw_addr_sync(struct list_head *to_list, int *to_delta,
+-			  struct list_head *from_list, int *from_delta,
++static int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
++			  struct netdev_hw_addr_list *from_list,
+ 			  int addr_len)
+ {
+ 	int err = 0;
+ 	struct netdev_hw_addr *ha, *tmp;
+ 
+-	list_for_each_entry_safe(ha, tmp, from_list, list) {
++	list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
+ 		if (!ha->synced) {
+-			err = __hw_addr_add(to_list, to_delta, ha->addr,
++			err = __hw_addr_add(to_list, ha->addr,
+ 					    addr_len, ha->type);
+ 			if (err)
+ 				break;
+ 			ha->synced = true;
+ 			ha->refcount++;
+ 		} else if (ha->refcount == 1) {
+-			__hw_addr_del(to_list, to_delta, ha->addr,
+-				      addr_len, ha->type);
+-			__hw_addr_del(from_list, from_delta, ha->addr,
+-				      addr_len, ha->type);
++			__hw_addr_del(to_list, ha->addr, addr_len, ha->type);
++			__hw_addr_del(from_list, ha->addr, addr_len, ha->type);
+ 		}
+ 	}
+ 	return err;
+ }
+ 
+-static void __hw_addr_unsync(struct list_head *to_list, int *to_delta,
+-			     struct list_head *from_list, int *from_delta,
++static void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
++			     struct netdev_hw_addr_list *from_list,
+ 			     int addr_len)
+ {
+ 	struct netdev_hw_addr *ha, *tmp;
+ 
+-	list_for_each_entry_safe(ha, tmp, from_list, list) {
++	list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
+ 		if (ha->synced) {
+-			__hw_addr_del(to_list, to_delta, ha->addr,
++			__hw_addr_del(to_list, ha->addr,
+ 				      addr_len, ha->type);
+ 			ha->synced = false;
+-			__hw_addr_del(from_list, from_delta, ha->addr,
++			__hw_addr_del(from_list, ha->addr,
+ 				      addr_len, ha->type);
+ 		}
+ 	}
+ }
+ 
+-
+-static void __hw_addr_flush(struct list_head *list)
++static void __hw_addr_flush(struct netdev_hw_addr_list *list)
+ {
+ 	struct netdev_hw_addr *ha, *tmp;
+ 
+-	list_for_each_entry_safe(ha, tmp, list, list) {
++	list_for_each_entry_safe(ha, tmp, &list->list, list) {
+ 		list_del_rcu(&ha->list);
+ 		call_rcu(&ha->rcu_head, ha_rcu_free);
+ 	}
++	list->count = 0;
++}
++
++static void __hw_addr_init(struct netdev_hw_addr_list *list)
++{
++	INIT_LIST_HEAD(&list->list);
++	list->count = 0;
+ }
+ 
+ /* Device addresses handling functions */
+@@ -3564,7 +3563,7 @@
+ {
+ 	/* rtnl_mutex must be held here */
+ 
+-	__hw_addr_flush(&dev->dev_addr_list);
++	__hw_addr_flush(&dev->dev_addrs);
+ 	dev->dev_addr = NULL;
+ }
+ 
+@@ -3576,16 +3575,16 @@
+ 
+ 	/* rtnl_mutex must be held here */
+ 
+-	INIT_LIST_HEAD(&dev->dev_addr_list);
++	__hw_addr_init(&dev->dev_addrs);
+ 	memset(addr, 0, sizeof(addr));
+-	err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, sizeof(addr),
++	err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
+ 			    NETDEV_HW_ADDR_T_LAN);
+ 	if (!err) {
+ 		/*
+ 		 * Get the first (previously created) address from the list
+ 		 * and set dev_addr pointer to this location.
+ 		 */
+-		ha = list_first_entry(&dev->dev_addr_list,
++		ha = list_first_entry(&dev->dev_addrs.list,
+ 				      struct netdev_hw_addr, list);
+ 		dev->dev_addr = ha->addr;
+ 	}
+@@ -3610,8 +3609,7 @@
+ 
+ 	ASSERT_RTNL();
+ 
+-	err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, dev->addr_len,
+-			    addr_type);
++	err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
+ 	if (!err)
+ 		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
+ 	return err;
+@@ -3641,11 +3639,12 @@
+ 	 * We can not remove the first address from the list because
+ 	 * dev->dev_addr points to that.
+ 	 */
+-	ha = list_first_entry(&dev->dev_addr_list, struct netdev_hw_addr, list);
++	ha = list_first_entry(&dev->dev_addrs.list,
++			      struct netdev_hw_addr, list);
+ 	if (ha->addr == dev->dev_addr && ha->refcount == 1)
+ 		return -ENOENT;
+ 
+-	err = __hw_addr_del(&dev->dev_addr_list, NULL, addr, dev->addr_len,
++	err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
+ 			    addr_type);
+ 	if (!err)
+ 		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
+@@ -3673,8 +3672,7 @@
+ 
+ 	if (from_dev->addr_len != to_dev->addr_len)
+ 		return -EINVAL;
+-	err = __hw_addr_add_multiple(&to_dev->dev_addr_list, NULL,
+-				     &from_dev->dev_addr_list,
++	err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
+ 				     to_dev->addr_len, addr_type);
+ 	if (!err)
+ 		call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
+@@ -3700,15 +3698,14 @@
+ 
+ 	if (from_dev->addr_len != to_dev->addr_len)
+ 		return -EINVAL;
+-	__hw_addr_del_multiple(&to_dev->dev_addr_list, NULL,
+-			       &from_dev->dev_addr_list,
++	__hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
+ 			       to_dev->addr_len, addr_type);
+ 	call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
+ 	return 0;
+ }
+ EXPORT_SYMBOL(dev_addr_del_multiple);
+ 
+-/* unicast and multicast addresses handling functions */
++/* multicast addresses handling functions */
+ 
+ int __dev_addr_delete(struct dev_addr_list **list, int *count,
+ 		      void *addr, int alen, int glbl)
+@@ -3784,8 +3781,8 @@
+ 
+ 	ASSERT_RTNL();
+ 
+-	err = __hw_addr_del(&dev->uc_list, &dev->uc_count, addr,
+-			    dev->addr_len, NETDEV_HW_ADDR_T_UNICAST);
++	err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
++			    NETDEV_HW_ADDR_T_UNICAST);
+ 	if (!err)
+ 		__dev_set_rx_mode(dev);
+ 	return err;
+@@ -3808,8 +3805,8 @@
+ 
+ 	ASSERT_RTNL();
+ 
+-	err = __hw_addr_add(&dev->uc_list, &dev->uc_count, addr,
+-			    dev->addr_len, NETDEV_HW_ADDR_T_UNICAST);
++	err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
++			    NETDEV_HW_ADDR_T_UNICAST);
+ 	if (!err)
+ 		__dev_set_rx_mode(dev);
+ 	return err;
+@@ -3882,8 +3879,7 @@
+ 	if (to->addr_len != from->addr_len)
+ 		return -EINVAL;
+ 
+-	err = __hw_addr_sync(&to->uc_list, &to->uc_count,
+-			     &from->uc_list, &from->uc_count, to->addr_len);
++	err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
+ 	if (!err)
+ 		__dev_set_rx_mode(to);
+ 	return err;
+@@ -3906,8 +3902,7 @@
+ 	if (to->addr_len != from->addr_len)
+ 		return;
+ 
+-	__hw_addr_unsync(&to->uc_list, &to->uc_count,
+-			 &from->uc_list, &from->uc_count, to->addr_len);
++	__hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
+ 	__dev_set_rx_mode(to);
+ }
+ EXPORT_SYMBOL(dev_unicast_unsync);
+@@ -3916,15 +3911,14 @@
+ {
+ 	/* rtnl_mutex must be held here */
+ 
+-	__hw_addr_flush(&dev->uc_list);
+-	dev->uc_count = 0;
++	__hw_addr_flush(&dev->uc);
+ }
+ 
+ static void dev_unicast_init(struct net_device *dev)
+ {
+ 	/* rtnl_mutex must be held here */
+ 
+-	INIT_LIST_HEAD(&dev->uc_list);
++	__hw_addr_init(&dev->uc);
+ }
+ 
+