* Re: [PATCH net-next-2.6] bridge: remove dev_put() in add_del_if()
From: Eric Dumazet @ 2009-11-04 19:43 UTC (permalink / raw)
To: Stephen Hemminger; +Cc: David S. Miller, Linux Netdev List
In-Reply-To: <20091104114020.5a2aef2c@nehalam>
Stephen Hemminger a écrit :
>
> As part of the general ref count purge sure.
> Acked-by: Stephen Hemminger <shemminger@vyatta.com>
>
Yes, sure... but nf_queue.c is such an abuser that I doubt we
really can make dev_put() doing the atomic_dec_test() one day...
^ permalink raw reply
* Re: [PATCH 01/25] mlx4_core: identify function as pf or vf
From: Roland Dreier @ 2009-11-04 19:45 UTC (permalink / raw)
To: Yevgeny Petrilin
Cc: linux-rdma-u79uwXL29TY76Z2rM5mHXA, netdev-u79uwXL29TY76Z2rM5mHXA,
liranl-VPRAkNaXOzVS1MOuV/RT9w, tziporet-VPRAkNaXOzVS1MOuV/RT9w
In-Reply-To: <4AF19E07.7040702-VPRAkNaXOzVS1MOuV/RT9w@public.gmane.org>
Just noticed that all the patches I looked at have:
> From: Yevgeny Petrilin <yevgenyp-VPRAkNaXOzVS1MOuV/RT9w@public.gmane.org>
but only:
> Signed-off-by: Liran Liss <liranl-VPRAkNaXOzVS1MOuV/RT9w@public.gmane.org>
I guess Liran is actually the real author? in this case, you should
add a line like:
From: Liran Liss <liranl-VPRAkNaXOzVS1MOuV/RT9w@public.gmane.org>
in the body of the email message, and add your own signed-off-by line
after Liran's (since you are in the chain of people handling the patch).
- R.
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* [PATCH net-next-2.6] netfilter: remove synchronize_net() calls in ip_queue/ip6_queue
From: Eric Dumazet @ 2009-11-04 19:47 UTC (permalink / raw)
To: Patrick McHardy; +Cc: Linux Netdev List, Netfilter Developers
nf_unregister_queue_handlers() already does a synchronize_rcu()
call, we dont need to do it again in callers.
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
net/ipv4/netfilter/ip_queue.c | 2 +-
net/ipv6/netfilter/ip6_queue.c | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index c156db2..9811a45 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -622,7 +622,7 @@ cleanup_netlink_notifier:
static void __exit ip_queue_fini(void)
{
nf_unregister_queue_handlers(&nfqh);
- synchronize_net();
+
ipq_flush(NULL, 0);
#ifdef CONFIG_SYSCTL
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index 1cf3f0c..a82016f 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -625,7 +625,7 @@ cleanup_netlink_notifier:
static void __exit ip6_queue_fini(void)
{
nf_unregister_queue_handlers(&nfqh);
- synchronize_net();
+
ipq_flush(NULL, 0);
#ifdef CONFIG_SYSCTL
^ permalink raw reply related
* Re: [PATCH 16/25] mlx4_core: boot sriov
From: Roland Dreier @ 2009-11-04 19:55 UTC (permalink / raw)
To: Yevgeny Petrilin; +Cc: linux-rdma, netdev, liranl, tziporet
In-Reply-To: <4AF19E5D.1060806@mellanox.co.il>
> + /* Detect if this device is a virtual function */
> + switch (id->device) {
> + case 0x6341:
> + case 0x634b:
> + case 0x6733:
> + case 0x673d:
> + case 0x6369:
> + case 0x6751:
> + case 0x6765:
This isn't be maintainable or sane. How about using driver_data in the
PCI device table?
> +#ifdef CONFIG_PCI_IOV
> + if (sr_iov) {
Can we avoid a lot of these ifdefs by just doing
#else
#define sr_iov 0
#endif /* CONFIG_PCI_IOV */
at the beginning and letting the IOV code be optimized away?
- R.
^ permalink raw reply
* [PATCH net-next-2.6] netlabel: remove dev_put() calls
From: Eric Dumazet @ 2009-11-04 20:03 UTC (permalink / raw)
To: David S. Miller; +Cc: Linux Netdev List
Use dev_get_by_name_rcu() to avoid dev_put() calls,
in sections already inside a rcu_read_lock()
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
net/netlabel/netlabel_unlabeled.c | 6 ++----
1 files changed, 2 insertions(+), 4 deletions(-)
diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
index fb357f0..3dfe2ba 100644
--- a/net/netlabel/netlabel_unlabeled.c
+++ b/net/netlabel/netlabel_unlabeled.c
@@ -472,13 +472,12 @@ int netlbl_unlhsh_add(struct net *net,
rcu_read_lock();
if (dev_name != NULL) {
- dev = dev_get_by_name(net, dev_name);
+ dev = dev_get_by_name_rcu(net, dev_name);
if (dev == NULL) {
ret_val = -ENODEV;
goto unlhsh_add_return;
}
ifindex = dev->ifindex;
- dev_put(dev);
iface = netlbl_unlhsh_search_iface(ifindex);
} else {
ifindex = 0;
@@ -737,13 +736,12 @@ int netlbl_unlhsh_remove(struct net *net,
rcu_read_lock();
if (dev_name != NULL) {
- dev = dev_get_by_name(net, dev_name);
+ dev = dev_get_by_name_rcu(net, dev_name);
if (dev == NULL) {
ret_val = -ENODEV;
goto unlhsh_remove_return;
}
iface = netlbl_unlhsh_search_iface(dev->ifindex);
- dev_put(dev);
} else
iface = rcu_dereference(netlbl_unlhsh_def);
if (iface == NULL) {
^ permalink raw reply related
* Re: [PATCH 19/25] mlx4: Randomizing mac addresses for slaves
From: Roland Dreier @ 2009-11-04 20:04 UTC (permalink / raw)
To: Yevgeny Petrilin
Cc: linux-rdma-u79uwXL29TY76Z2rM5mHXA, netdev-u79uwXL29TY76Z2rM5mHXA,
liranl-VPRAkNaXOzVS1MOuV/RT9w, tziporet-VPRAkNaXOzVS1MOuV/RT9w
In-Reply-To: <4AF19E69.8070605-VPRAkNaXOzVS1MOuV/RT9w@public.gmane.org>
> +#define MLX4_MAC_HEAD 0x2c9000000ULL
> + random_ether_addr(rand_mac);
> + caps->def_mac[i] = MLX4_MAC_HEAD | rand_mac[0] |
> + ((u64)(rand_mac[1]) << 8) | ((u64)(rand_mac[2]) << 16);
Is this a good idea? You're basically choosing 24 random bits within
your OUI... seems the chance of collision with another MAC used on the
same network is high enough that it could easily happen in practice on a
moderately big network. Can you pick a reserved range or something?
Also I'm not sure if there's much point in using random_ether_addr if
you're going to override the high order part anyway, since
random_ether_addr just makes sure it doesn't pick a multicast address.
- R.
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH net-next-2.6] netfilter: remove synchronize_net() calls in ip_queue/ip6_queue
From: Patrick McHardy @ 2009-11-04 20:15 UTC (permalink / raw)
To: Eric Dumazet; +Cc: Linux Netdev List, Netfilter Developers
In-Reply-To: <4AF1DA57.8080202@gmail.com>
Eric Dumazet wrote:
> nf_unregister_queue_handlers() already does a synchronize_rcu()
> call, we dont need to do it again in callers.
Applied, thanks Eric.
^ permalink raw reply
* [PATCH] appletalk/ddp.c: Neaten checksum function
From: Joe Perches @ 2009-11-04 20:26 UTC (permalink / raw)
To: netdev; +Cc: Arnaldo Carvalho de Melo, David S. Miller
atalk_sum_partial can now use the rol16 function in bitops.h
Signed-off-by: Joe Perches <joe@perches.com>
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index abe3801..e6903db 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -922,13 +922,8 @@ static unsigned long atalk_sum_partial(const unsigned char *data,
{
/* This ought to be unwrapped neatly. I'll trust gcc for now */
while (len--) {
- sum += *data;
- sum <<= 1;
- if (sum & 0x10000) {
- sum++;
- sum &= 0xffff;
- }
- data++;
+ sum += *data++;
+ sum = rol16(sum, 1);
}
return sum;
}
^ permalink raw reply related
* test
From: Simon Kirby @ 2009-11-04 20:27 UTC (permalink / raw)
To: netdev, Wensong Zhang, Julian Anastasov
[-- Attachment #1: Type: text/plain, Size: 1191 bytes --]
Hello!
I was noticing a significant amount of what seems/seemed to be
destination lists with multiple entries with the lblcr LVS algorithm.
While tracking it down, I think I stumbled over a mistake. In
ip_vs_lblcr_full_check(), it appears the time check logic is reversed:
for (i=0, j=tbl->rover; i<IP_VS_LBLCR_TAB_SIZE; i++) {
j = (j + 1) & IP_VS_LBLCR_TAB_MASK;
write_lock(&svc->sched_lock);
list_for_each_entry_safe(en, nxt, &tbl->bucket[j], list) {
if (time_after(en->lastuse+sysctl_ip_vs_lblcr_expiration,
now))
continue;
ip_vs_lblcr_free(en);
atomic_dec(&tbl->entries);
}
write_unlock(&svc->sched_lock);
}
Shouldn't this be "time_before"? It seems that it currently nukes all
recently-used entries every time this function is called, which seems to
be every 30 minutes, rather than removing the not-recently-used ones.
If my reading is correct, this patch should fix it. Am I missing
something?
Cheers,
Simon-
[-- Attachment #2: lblcr+full_check_time_fix.patch --]
[-- Type: text/x-diff, Size: 535 bytes --]
diff --git a/net/netfilter/ipvs/ip_vs_lblcr.c b/net/netfilter/ipvs/ip_vs_lblcr.c
index 715b57f..937743f 100644
--- a/net/netfilter/ipvs/ip_vs_lblcr.c
+++ b/net/netfilter/ipvs/ip_vs_lblcr.c
@@ -432,7 +432,7 @@ static inline void ip_vs_lblcr_full_check(struct ip_vs_service *svc)
write_lock(&svc->sched_lock);
list_for_each_entry_safe(en, nxt, &tbl->bucket[j], list) {
- if (time_after(en->lastuse+sysctl_ip_vs_lblcr_expiration,
+ if (time_before(en->lastuse+sysctl_ip_vs_lblcr_expiration,
now))
continue;
^ permalink raw reply related
* [PATCH] rose: device refcount leak
From: Eric Dumazet @ 2009-11-04 20:31 UTC (permalink / raw)
To: David S. Miller, Linux Netdev List
While hunting dev_put() for net-next-2.6, I found a device refcount
leak in ROSE, ioctl(SIOCADDRT) error path.
Fix is to not touch device refcount, as we hold RTNL
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
net/rose/rose_route.c | 16 ++++++----------
1 files changed, 6 insertions(+), 10 deletions(-)
diff --git a/net/rose/rose_route.c b/net/rose/rose_route.c
index 9478d9b..c55a543 100644
--- a/net/rose/rose_route.c
+++ b/net/rose/rose_route.c
@@ -578,18 +578,18 @@ static int rose_clear_routes(void)
/*
* Check that the device given is a valid AX.25 interface that is "up".
+ * called whith RTNL
*/
-static struct net_device *rose_ax25_dev_get(char *devname)
+static struct net_device *rose_ax25_dev_find(char *devname)
{
struct net_device *dev;
- if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
+ if ((dev = __dev_get_by_name(&init_net, devname)) == NULL)
return NULL;
if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
return dev;
- dev_put(dev);
return NULL;
}
@@ -720,27 +720,23 @@ int rose_rt_ioctl(unsigned int cmd, void __user *arg)
case SIOCADDRT:
if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
return -EFAULT;
- if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
+ if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
return -EINVAL;
- if (rose_dev_exists(&rose_route.address)) { /* Can't add routes to ourself */
- dev_put(dev);
+ if (rose_dev_exists(&rose_route.address)) /* Can't add routes to ourself */
return -EINVAL;
- }
if (rose_route.mask > 10) /* Mask can't be more than 10 digits */
return -EINVAL;
if (rose_route.ndigis > AX25_MAX_DIGIS)
return -EINVAL;
err = rose_add_node(&rose_route, dev);
- dev_put(dev);
return err;
case SIOCDELRT:
if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
return -EFAULT;
- if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
+ if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
return -EINVAL;
err = rose_del_node(&rose_route, dev);
- dev_put(dev);
return err;
case SIOCRSCLRRT:
^ permalink raw reply related
* [RFC] [PATCH] udp: optimize lookup of UDP sockets to by including destination address in the hash key
From: Lucian Adrian Grijincu @ 2009-11-04 21:03 UTC (permalink / raw)
To: netdev; +Cc: Octavian Purdila
[-- Attachment #1: Type: text/plain, Size: 3466 bytes --]
Hi,
Before you look at the patch attached: I know it's not the prettiest of patches sent here. It's a work-in-progress and is ugly and incomplete (for example IPv6 is not properly updated to benefit this patch and may even be as buggy as hell right now).
I'm sending it here to ask for an opinion on the approach.
The current approach uses one single hash to lookup UDP sockets.
The key to the hash is calculated based on the port only.
This works well if there aren't many sockets bound to the same port, but becomes a linear linked list search for a setup with many UPD packets bound to the same port, which does not scale much.
In this patch the hashtable lookup key takes into consideration the address the socket is bound to too.
This will lead to better distribution for setup where there are many UDP sockets bound to the same port but different IP addresses.
There's a subtle bug lurking here: because some sockets may be bound to INADDR_ANY when checking whether a given UPD port is already taken one must search two buckets:
* one with the key computed from the port and for the IP address of the socket
* one with the key computed from the port and INADDR_ANY
Now if the address by which we must do the lookup is INADDR_ANY there's another problem: we can't just search it's own bucket and the bucket for INADDR_ANY (the same bucket twice) like above because there might be a socket bound to a specific address and the port we're trying to bind to.
In this case we could search the whole hash (which would take forever) or use another hash that is computed based on the port only (which this patch does).
There are other things to look after: when modifying the hashes we must take spin_locks or spin_lock_bhs. Because we now have two hashtables and one hashtable might be searched twice locks must be taken in the proper order.
I ran the attached UDP tester: it's a program that binds to a lot of UDP sockets and if run as a sender it sends lots of datagrams to the receiver which will just count the number of packets recevied.
== Performance stats ==
I ran this on a 2.6.31 with and without the patch on two powerpc single core processors connected directly by 100Mbps ethernet.
* nsocks = number of IPv4 bound sockets
* ndgrams = number of datagrams sent by each socket
* payloadlen = the lenght of the UPD message sent
* send_time = how many second did the sending operation take?
* recv_dgrams = how many datagrams were successfully received?
1. nsocks=512 ndgrams=2000 payloadlen=1
- without patch:
* send_time = 27s to 31s
* recv_dgrams = 550 to 850
- with patch:
* send_time = 35s to 36s
* recv_dgrams = 507000 to 516000
2. nsocks=512 ndgrams=4000 payloadlen=1
- without patch:
* send_time = 53s to 60s
* recv_dgrams = 650 to 1100
- with patch:
* send_time = ~70s
* recv_dgrams = 1010000 to 1034000
3. nsocks=512 ndgrams=4000 payloadlen=1000
- without patch:
* send_time = ~74s
* recv_dgrams = 650
- with patch:
* send_time = ~88s
* recv_dgrams = 995000
4. nsocks=256 ndgrams=2000 payloadlen=1
- without patch:
* send_time = 13s
* recv_dgrams = 370 to 720
- with patch:
* send_time = 17s
* recv_dgrams = 267000
As you can see this has a hit on total send time, but the number of received packets increases by two orders of magnitude.
I'd like hear your opinion about this approach.
If you'd like to test this, I'll be happy to port it to net-next and provide the patch.
--
Lucian
[-- Attachment #2: upd-two-sock-hashes-v1.patch --]
[-- Type: text/x-patch, Size: 24696 bytes --]
--- arch/powerpc/configs/ixia_ppc750_defconfig
+++ arch/powerpc/configs/ixia_ppc750_defconfig
@@ -1,7 +1,7 @@
#
# Automatically generated make config: don't edit
-# Linux kernel version: 2.6.31-rc5
-# Thu Aug 13 17:15:17 2009
+# Linux kernel version: 2.6.31
+# Mon Nov 2 22:05:36 2009
#
# CONFIG_PPC64 is not set
@@ -287,6 +287,7 @@
#
# Networking options
#
+CONFIG_NETDEV_HASHBITS=10
# CONFIG_NET_SYSCTL_DEV is not set
CONFIG_PACKET=y
CONFIG_PACKET_MMAP=y
--- include/linux/udp.h
+++ include/linux/udp.h
@@ -45,7 +45,7 @@
return (struct udphdr *)skb_transport_header(skb);
}
-#define UDP_HTABLE_SIZE 128
+#define UDP_HTABLE_SIZE (1 << CONFIG_NETDEV_HASHBITS)
static inline int udp_hashfn(struct net *net, const unsigned num)
{
--- include/net/sock.h
+++ include/net/sock.h
@@ -173,6 +173,7 @@
* @skc_bound_rx_dev_if: bound rx device index if != 0
* @skc_bound_tx_dev_if: bound tx device index if != 0
* @skc_bind_node: bind hash linkage for various protocol lookup tables
+ * @skc_nulls_bind_node: bind hash linkage for UDP/UDP-Lite protocol
* @skc_prot: protocol handlers inside a network family
* @skc_net: reference to the network namespace of this socket
*
@@ -195,7 +196,10 @@
unsigned char skc_reuse;
int skc_bound_rx_dev_if;
int skc_bound_tx_dev_if;
- struct hlist_node skc_bind_node;
+ union {
+ struct hlist_node skc_bind_node;
+ struct hlist_nulls_node skc_nulls_bind_node;
+ };
struct proto *skc_prot;
#ifdef CONFIG_NET_NS
struct net *skc_net;
@@ -287,6 +291,7 @@
#define sk_bound_rx_dev_if __sk_common.skc_bound_rx_dev_if
#define sk_bound_tx_dev_if __sk_common.skc_bound_tx_dev_if
#define sk_bind_node __sk_common.skc_bind_node
+#define sk_nulls_bind_node __sk_common.skc_nulls_bind_node
#define sk_prot __sk_common.skc_prot
#define sk_net __sk_common.skc_net
#define sk_vlanprio __sk_common.skc_vlanprio
@@ -495,6 +500,11 @@
return 0;
}
+static __inline__ void __sk_nulls_del_bind_node_init_rcu(struct sock *sk)
+{
+ hlist_nulls_del_init_rcu(&sk->sk_nulls_bind_node);
+}
+
static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
{
int rc = __sk_nulls_del_node_init_rcu(sk);
@@ -523,6 +533,11 @@
hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
}
+static __inline__ void __sk_nulls_add_bind_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
+{
+ hlist_nulls_add_head_rcu(&sk->sk_nulls_bind_node, list);
+}
+
static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
{
sock_hold(sk);
@@ -559,6 +574,8 @@
hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
#define sk_for_each_bound(__sk, node, list) \
hlist_for_each_entry(__sk, node, list, sk_bind_node)
+#define sk_nulls_for_each_bound(__sk, node, list) \
+ hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_bind_node)
/* Sock flags */
enum sock_flags {
--- include/net/udp.h
+++ include/net/udp.h
@@ -55,7 +55,8 @@
spinlock_t lock;
} __attribute__((aligned(2 * sizeof(long))));
struct udp_table {
- struct udp_hslot hash[UDP_HTABLE_SIZE];
+ struct udp_hslot hash[UDP_HTABLE_SIZE]; /* pair hash */
+ struct udp_hslot port_hash[UDP_HTABLE_SIZE]; /* port hash */
};
extern struct udp_table udp_table;
extern void udp_table_init(struct udp_table *);
@@ -117,7 +118,11 @@
BUG();
}
+extern void __udp_lib_hash(struct sock *sk);
+extern void __udp_lib_unhash(struct sock *sk);
extern void udp_lib_unhash(struct sock *sk);
+extern void udp_lock_hashes_bh(struct net *net, struct sock *sk, __u16 num);
+extern void udp_unlock_hashes_bh(struct net *net, struct sock *sk, __u16 num);
static inline void udp_lib_close(struct sock *sk, long timeout)
{
--- net/Kconfig
+++ net/Kconfig
@@ -25,6 +25,13 @@
menu "Networking options"
+config NETDEV_HASHBITS
+ int "Network device hash size (10 => 1024, 14 => 16384)"
+ range 10 20
+ default 10
+ help
+ Select network device hash size as a power of 2.
+
config NET_SYSCTL_DEV
bool "Per device sysctl entries"
default y
--- net/ipv4/datagram.c
+++ net/ipv4/datagram.c
@@ -19,6 +19,7 @@
#include <net/sock.h>
#include <net/route.h>
#include <net/tcp_states.h>
+#include <net/udp.h>
int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
@@ -62,8 +63,13 @@
}
if (!inet->saddr)
inet->saddr = rt->rt_src; /* Update source address */
- if (!inet->rcv_saddr)
+ if (!inet->rcv_saddr) {
inet->rcv_saddr = rt->rt_src;
+ udp_lock_hashes_bh(sock_net(sk), sk, inet_sk(sk)->num);
+ __udp_lib_unhash(sk);
+ __udp_lib_hash(sk);
+ udp_unlock_hashes_bh(sock_net(sk), sk, inet_sk(sk)->num);
+ }
inet->daddr = rt->rt_dst;
inet->dport = usin->sin_port;
sk->sk_state = TCP_ESTABLISHED;
--- net/ipv4/udp.c
+++ net/ipv4/udp.c
@@ -122,17 +122,84 @@
#define PORTS_PER_CHAIN (65536 / UDP_HTABLE_SIZE)
-static int udp_lib_lport_inuse(struct net *net, __u16 num,
- const struct udp_hslot *hslot,
- unsigned long *bitmap,
- struct sock *sk,
- int (*saddr_comp)(const struct sock *sk1,
- const struct sock *sk2))
+
+static inline int is_rcv_saddr_any(const struct sock *sk)
+{
+ switch (sk->sk_family) {
+ case PF_INET:
+ return inet_sk(sk)->rcv_saddr == 0;
+ case PF_INET6:
+ return ipv6_addr_any(&inet6_sk(sk)->rcv_saddr);
+ }
+ WARN(1, "unrecognised sk->sk_family in is_rcv_saddr_any");
+ return 0;
+}
+
+static inline u32 udp_v4_addr_hashfn(struct net * net, const u32 laddr, u16 snum)
+{
+ u32 key;
+ snum += net_hash_mix(net);
+ if (laddr == 0)
+ key = snum;
+ else
+ key = jhash2(&laddr, 1, snum);
+
+ return key & (UDP_HTABLE_SIZE - 1);
+}
+
+static inline u32 udp_v6_addr_hashfn(struct net * net, const struct in6_addr *laddr, u16 snum)
+{
+ u32 key;
+ snum += net_hash_mix(net);
+ if (ipv6_addr_any(laddr))
+ key = snum;
+ else if (ipv6_addr_type(laddr) == IPV6_ADDR_MAPPED)
+ key = jhash2(&laddr->s6_addr32[3], 1, snum);
+ else
+ key = jhash2(laddr->s6_addr32, 4, snum);
+
+ return key & (UDP_HTABLE_SIZE - 1);
+}
+
+static int udp_saddr_hashfn(struct net * net, struct sock *sk, u16 snum)
+{
+ switch (sk->sk_family) {
+ case PF_INET:
+ return udp_v4_addr_hashfn(net, inet_sk(sk)->rcv_saddr, snum);
+ case PF_INET6:
+ return udp_v6_addr_hashfn(net, &inet6_sk(sk)->rcv_saddr, snum);
+ }
+ WARN(1, "unrecognised sk->sk_family in is_rcv_saddr_any");
+ return 0;
+}
+
+static int udp_addr_any_hashfn(struct net * net, struct sock *sk, u16 snum)
+{
+ switch (sk->sk_family) {
+ case PF_INET:
+ return udp_v4_addr_hashfn(net, INADDR_ANY, snum);
+ case PF_INET6:
+ return udp_v6_addr_hashfn(net, &in6addr_any, snum);
+ }
+ WARN(1, "unrecognised sk->sk_family in is_rcv_saddr_any");
+ return 0;
+}
+
+
+
+
+
+static int __udp_lib_lport_inuse_port(struct net *net, __u16 num,
+ const struct udp_hslot *hslot,
+ unsigned long *bitmap,
+ struct sock *sk,
+ int (*saddr_comp)(const struct sock *sk1,
+ const struct sock *sk2))
{
struct sock *sk2;
struct hlist_nulls_node *node;
- sk_nulls_for_each(sk2, node, &hslot->head)
+ sk_nulls_for_each_bound(sk2, node, &hslot->head)
if (net_eq(sock_net(sk2), net) &&
sk2 != sk &&
(bitmap || sk2->sk_hash == num) &&
@@ -149,6 +216,215 @@
return 0;
}
+static int __udp_lib_lport_inuse_pair(struct net *net, __u16 num,
+ const struct udp_hslot *hslot,
+ struct sock *sk,
+ int (*saddr_comp)(const struct sock *sk1,
+ const struct sock *sk2))
+{
+ struct sock *sk2;
+ struct hlist_nulls_node *node;
+
+ sk_nulls_for_each(sk2, node, &hslot->head)
+ if (net_eq(sock_net(sk2), net) &&
+ sk2 != sk &&
+ sk2->sk_hash == num &&
+ (!sk2->sk_reuse || !sk->sk_reuse) &&
+ (!sk2->sk_bound_rx_dev_if || !sk->sk_bound_rx_dev_if
+ || sk2->sk_bound_rx_dev_if == sk->sk_bound_rx_dev_if) &&
+ (*saddr_comp)(sk, sk2))
+ return 1;
+ return 0;
+}
+
+
+static inline void __udp_lock_pair_hashes(struct udp_table *udptable,
+ int pair_key, int pair_addrany_key)
+{
+ /*
+ - because pair_key might be equal to pair_addrany_key, make sure
+ you never take the same lock twice!
+
+ - between pair_hash(addr) and pair_hash(addrany) take first the
+ one with the smallest key.
+ */
+ if (pair_key == pair_addrany_key) {
+ spin_lock(&udptable->hash[pair_key].lock);
+ } else if (pair_key < pair_addrany_key) {
+ spin_lock(&udptable->hash[pair_key].lock);
+ spin_lock(&udptable->hash[pair_addrany_key].lock);
+ } else {
+ spin_lock(&udptable->hash[pair_addrany_key].lock);
+ spin_lock(&udptable->hash[pair_key].lock);
+ }
+}
+
+static inline void __udp_unlock_pair_hashes(struct udp_table *udptable,
+ int pair_key, int pair_addrany_key)
+{
+ if (pair_key == pair_addrany_key) {
+ spin_unlock(&udptable->hash[pair_key].lock);
+ } else if (pair_key < pair_addrany_key) {
+ spin_unlock(&udptable->hash[pair_addrany_key].lock);
+ spin_unlock(&udptable->hash[pair_key].lock);
+ } else {
+ spin_unlock(&udptable->hash[pair_key].lock);
+ spin_unlock(&udptable->hash[pair_addrany_key].lock);
+ }
+}
+
+
+static inline void __udp_lock_pair_hashes_bh(struct udp_table *udptable,
+ int pair_key, int pair_addrany_key)
+{
+ local_bh_disable();
+ __udp_lock_pair_hashes(udptable, pair_key, pair_addrany_key);
+}
+
+static inline void __udp_unlock_pair_hashes_bh(struct udp_table *udptable,
+ int pair_key, int pair_addrany_key)
+{
+ __udp_unlock_pair_hashes(udptable, pair_key, pair_addrany_key);
+ local_bh_enable();
+}
+
+
+static inline void __udp_lock_hashes(struct udp_table *udptable, int port_key,
+ int pair_key, int pair_addrany_key)
+{
+ /* To avoid deadlocks we need to always take the locks in order:
+ - port_hash lock *before* the pair_hash locks.
+ This is needed because searching in a port hash is done by setting
+ bits in a bitmap for each port found in the hash and then iterating
+ over all possible ports that could be in that hash and searching
+ for any that could be in it but isn't (which means it's free).
+ After finding such a port we lock it's pair hashes too.
+ */
+ spin_lock(&udptable->port_hash[port_key].lock);
+ __udp_lock_pair_hashes(udptable, pair_key, pair_addrany_key);
+}
+
+static inline void __udp_unlock_hashes(struct udp_table *udptable, int port_key,
+ int pair_key, int pair_addrany_key)
+{
+ __udp_unlock_pair_hashes(udptable, pair_key, pair_addrany_key);
+ spin_unlock(&udptable->port_hash[port_key].lock);
+}
+
+
+static inline void __udp_lock_hashes_bh(struct udp_table *udptable, int port_key,
+ int pair_key, int pair_addrany_key)
+{
+ spin_lock_bh(&udptable->port_hash[port_key].lock);
+ __udp_lock_pair_hashes_bh(udptable, pair_key, pair_addrany_key);
+}
+static inline void __udp_unlock_hashes_bh(struct udp_table *udptable, int port_key,
+ int pair_key, int pair_addrany_key)
+{
+ __udp_unlock_pair_hashes_bh(udptable, pair_key, pair_addrany_key);
+ spin_unlock_bh(&udptable->port_hash[port_key].lock);
+}
+
+
+static inline void udp_lock_hashes(struct net *net, struct sock *sk, __u16 num)
+{
+ int port_key, pair_key, pair_addrany_key;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_saddr_hashfn(net, sk, num);
+ pair_addrany_key = udp_addr_any_hashfn(net, sk, num);
+
+ __udp_lock_hashes(udptable, port_key, pair_key, pair_addrany_key);
+}
+
+
+static inline void udp_unlock_hashes(struct net *net, struct sock *sk, __u16 num)
+{
+ int port_key, pair_key, pair_addrany_key;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_saddr_hashfn(net, sk, num);
+ pair_addrany_key = udp_addr_any_hashfn(net, sk, num);
+
+ __udp_unlock_hashes(udptable, port_key, pair_key, pair_addrany_key);
+}
+
+
+void udp_lock_hashes_bh(struct net *net, struct sock *sk, __u16 num)
+{
+ int port_key, pair_key, pair_addrany_key;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_saddr_hashfn(net, sk, num);
+ pair_addrany_key = udp_addr_any_hashfn(net, sk, num);
+
+ __udp_lock_hashes_bh(udptable, port_key, pair_key, pair_addrany_key);
+}
+
+void udp_unlock_hashes_bh(struct net *net, struct sock *sk, __u16 num)
+{
+ int port_key, pair_key, pair_addrany_key;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_saddr_hashfn(net, sk, num);
+ pair_addrany_key = udp_addr_any_hashfn(net, sk, num);
+
+ __udp_unlock_hashes_bh(udptable, port_key, pair_key, pair_addrany_key);
+}
+
+/*
+ * Find out if a given local port is already used.
+ *
+ * NOTE:
+ * - returns 0 with all hashes LOCKED if the port is not used as a local
+ * port. the caller can modify the hashes and is responsible
+ * of unlocking them
+ * - returns 1 with all hashes UNLOCKED if the port is already used.
+ */
+static int udp_lib_lport_inuse(struct net *net, __u16 num,
+ struct sock *sk,
+ int (*saddr_comp)(const struct sock *sk1,
+ const struct sock *sk2))
+{
+ int port_key, pair_key, pair_addrany_key;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_saddr_hashfn(net, sk, num);
+ pair_addrany_key = udp_addr_any_hashfn(net, sk, num);
+
+ __udp_lock_hashes_bh(udptable, port_key, pair_key, pair_addrany_key);
+
+ if (!is_rcv_saddr_any(sk)) {
+ /* We have a well-defined source address. Verify that
+ * there is no other socket which exactly matches this
+ * one. */
+ if(!__udp_lib_lport_inuse_pair(net, num,
+ &udptable->hash[pair_key],
+ sk, saddr_comp))
+ return 0;
+
+ /* there was no exact match. Verify there is no socket
+ * bound to INADDR_ANY/in6addr_any on this port. */
+ if(!__udp_lib_lport_inuse_pair(net, num,
+ &udptable->hash[pair_addrany_key],
+ sk, saddr_comp))
+ return 0;
+ } else {
+ if(!__udp_lib_lport_inuse_port(net, num,
+ &udptable->port_hash[port_key],
+ NULL, sk, saddr_comp))
+ return 0;
+ }
+
+ __udp_unlock_hashes_bh(udptable, port_key, pair_key, pair_addrany_key);
+ return 1;
+}
+
/* Defined in net/ipv4/ip_sockglue.c */
int is_reserved_port(uint16_t port);
@@ -163,7 +439,7 @@
int (*saddr_comp)(const struct sock *sk1,
const struct sock *sk2 ) )
{
- struct udp_hslot *hslot;
+ struct udp_hslot *hslot_port;
struct udp_table *udptable = sk->sk_prot->h.udp_table;
int error = 1;
struct net *net = sock_net(sk);
@@ -172,56 +448,79 @@
int low, high, remaining;
unsigned rand;
unsigned short first, last;
- DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
inet_get_local_port_range(&low, &high);
remaining = (high - low) + 1;
rand = net_random();
first = (((u64)rand * remaining) >> 32) + low;
- /*
- * force rand to be an odd multiple of UDP_HTABLE_SIZE
- */
- rand = (rand | 1) * UDP_HTABLE_SIZE;
- for (last = first + UDP_HTABLE_SIZE; first != last; first++) {
- hslot = &udptable->hash[udp_hashfn(net, first)];
- bitmap_zero(bitmap, PORTS_PER_CHAIN);
- spin_lock_bh(&hslot->lock);
- udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
- saddr_comp);
+ if (!is_rcv_saddr_any(sk)) {
+ int i;
snum = first;
+ for (i = 0; i < remaining; i++, snum++) {
+ if (snum > high)
+ snum = low;
+ if (is_reserved_port(snum))
+ continue;
+ if (!udp_lib_lport_inuse(net, snum, sk, saddr_comp))
+ goto found;
+ }
+ goto fail;
+ } else {
+ DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
+
+ /* We're bound to INADDR_ANY/in6addr_any. Make sure this port
+ * isn't being used by a conflicting socket. */
+
/*
- * Iterate on all possible values of snum for this hash.
- * Using steps of an odd multiple of UDP_HTABLE_SIZE
- * give us randomization and full range coverage.
+ * force rand to be an odd multiple of UDP_HTABLE_SIZE
*/
- do {
- if (low <= snum && snum <= high &&
- !test_bit(snum / UDP_HTABLE_SIZE, bitmap) &&
- !is_reserved_port(snum))
- goto found;
- snum += rand;
- } while (snum != first);
- spin_unlock_bh(&hslot->lock);
+ rand = (rand | 1) * UDP_HTABLE_SIZE;
+ for (last = first + UDP_HTABLE_SIZE; first != last; first++) {
+ bitmap_zero(bitmap, PORTS_PER_CHAIN);
+
+ hslot_port = &udptable->port_hash[udp_hashfn(net, first)];
+ spin_lock_bh(&hslot_port->lock);
+
+ __udp_lib_lport_inuse_port(net, snum, hslot_port,
+ bitmap, sk, saddr_comp);
+
+ snum = first;
+ /*
+ * Iterate on all possible values of snum for this hash.
+ * Using steps of an odd multiple of UDP_HTABLE_SIZE
+ * give us randomization and full range coverage.
+ */
+ do {
+ if (low <= snum && snum <= high &&
+ !test_bit(snum / UDP_HTABLE_SIZE, bitmap) &&
+ !is_reserved_port(snum)) {
+ /* we only have the port hash lock.
+ Before updating the hashes we
+ must take the pair locks too. */
+ __udp_lock_pair_hashes_bh(udptable,
+ udp_saddr_hashfn(net, sk, snum),
+ udp_addr_any_hashfn(net, sk, snum));
+ goto found;
+ }
+ snum += rand;
+ } while (snum != first);
+ spin_unlock_bh(&hslot_port->lock);
+ }
+ goto fail;
}
- goto fail;
} else {
- hslot = &udptable->hash[udp_hashfn(net, snum)];
- spin_lock_bh(&hslot->lock);
- if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk, saddr_comp))
- goto fail_unlock;
+ if (udp_lib_lport_inuse(net, snum, sk, saddr_comp))
+ goto fail;
}
found:
inet_sk(sk)->num = snum;
sk->sk_hash = snum;
- if (sk_unhashed(sk)) {
- sk_nulls_add_node_rcu(sk, &hslot->head);
- sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
- }
+ __udp_lib_unhash(sk);
+ __udp_lib_hash(sk);
+ udp_unlock_hashes_bh(net, sk, snum);
error = 0;
-fail_unlock:
- spin_unlock_bh(&hslot->lock);
fail:
return error;
}
@@ -278,24 +577,42 @@
/* UDP is nearly always wildcards out the wazoo, it makes no sense to try
* harder than this. -DaveM
*/
-static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
+static struct sock *__udp4_lib_lookup_addr(struct net *net, __be32 saddr,
__be16 sport, __be32 daddr, __be16 dport,
- int dif, struct udp_table *udptable)
+ int dif, struct udp_table *udptable, __be32 haddr)
{
struct sock *sk, *result;
struct hlist_nulls_node *node;
unsigned short hnum = ntohs(dport);
- unsigned int hash = udp_hashfn(net, hnum);
- struct udp_hslot *hslot = &udptable->hash[hash];
+ unsigned int hash;
+ struct udp_hslot *hslot;
int score, badness;
- rcu_read_lock();
+ hash = udp_v4_addr_hashfn(net, haddr, hnum);
+ hslot = &udptable->hash[hash];
begin:
result = NULL;
badness = -1;
sk_nulls_for_each_rcu(sk, node, &hslot->head) {
score = compute_score(sk, net, saddr, hnum, sport,
daddr, dport, dif);
+
+ /* Computed score can't be greater than 9,
+ * so we should just break upon reaching it.
+ *
+ * XXX: Test if this does indeed speed things up in our case:
+ * many udp slots bounded on the same port and on different
+ * addresses. If all sk are distributed evenly and the
+ * hashtable size is sufficiently large the lists should be
+ * small and this check should not have a visible
+ * performance impact. On the other hand, if this does
+ * improve things we should inspect the above suppositions.
+ */
+ if (score == 9) {
+ result = sk;
+ badness = score;
+ goto out;
+ }
if (score > badness) {
result = sk;
badness = score;
@@ -306,9 +623,11 @@
* not the expected one, we must restart lookup.
* We probably met an item that was moved to another chain.
*/
- if (get_nulls_value(node) != hash)
+ if (get_nulls_value(node) != hash) {
goto begin;
+ }
+out:
if (result) {
if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
result = NULL;
@@ -318,10 +637,26 @@
goto begin;
}
}
+ return result;
+}
+
+static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
+ __be16 sport, __be32 daddr, __be16 dport,
+ int dif, struct udp_table *udptable)
+{
+ struct sock *result;
+ rcu_read_lock();
+ result = __udp4_lib_lookup_addr(net, saddr, sport, daddr, dport,
+ dif, udptable, daddr);
+ if (!result) {
+ result = __udp4_lib_lookup_addr(net, saddr, sport, daddr, dport,
+ dif, udptable, INADDR_ANY);
+ }
rcu_read_unlock();
return result;
}
+
static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
__be16 sport, __be16 dport,
struct udp_table *udptable)
@@ -1001,19 +1336,35 @@
return 0;
}
+
+void __udp_lib_hash(struct sock *sk)
+{
+ int pair_key, port_key;
+ u16 snum = inet_sk(sk)->num;
+ struct udp_table *udptable = sk->sk_prot->h.udp_table;
+
+ port_key = udp_hashfn(sock_net(sk), snum);
+ pair_key = udp_saddr_hashfn(sock_net(sk), sk, snum);
+
+ sk_nulls_add_node_rcu(sk, &udptable->hash[pair_key].head);
+ __sk_nulls_add_bind_node_rcu(sk, &udptable->port_hash[port_key].head);
+ sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
+}
+
+void __udp_lib_unhash(struct sock *sk)
+{
+ if (sk_nulls_del_node_init_rcu(sk)) {
+ inet_sk(sk)->num = 0;
+ __sk_nulls_del_bind_node_init_rcu(sk);
+ sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
+ }
+}
void udp_lib_unhash(struct sock *sk)
{
if (sk_hashed(sk)) {
- struct udp_table *udptable = sk->sk_prot->h.udp_table;
- unsigned int hash = udp_hashfn(sock_net(sk), sk->sk_hash);
- struct udp_hslot *hslot = &udptable->hash[hash];
-
- spin_lock_bh(&hslot->lock);
- if (sk_nulls_del_node_init_rcu(sk)) {
- inet_sk(sk)->num = 0;
- sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
- }
- spin_unlock_bh(&hslot->lock);
+ udp_lock_hashes_bh(sock_net(sk), sk, sk->sk_hash);
+ __udp_lib_unhash(sk);
+ udp_unlock_hashes_bh(sock_net(sk), sk, sk->sk_hash);
}
}
EXPORT_SYMBOL(udp_lib_unhash);
@@ -1149,6 +1500,31 @@
return -1;
}
+static void __udp4_lib_mcast_deliver_hslot(struct net *net, struct sk_buff *skb,
+ struct udphdr *uh, __be32 saddr,
+ __be32 daddr, struct udp_hslot *hslot)
+{
+ struct sock *sk;
+ int dif;
+
+ sk = sk_nulls_head(&hslot->head);
+ dif = skb->dev->ifindex;
+ sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
+ while (sk) {
+ struct sk_buff *skb1 = skb_clone(skb, GFP_ATOMIC);
+ if (skb1) {
+ int ret = udp_queue_rcv_skb(sk, skb1);
+ if (ret > 0)
+ /* we should probably re-process instead
+ * of dropping packets here. */
+ kfree_skb(skb1);
+ }
+
+ sk = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
+ daddr, uh->source, saddr, dif);
+ }
+}
+
/*
* Multicasts and broadcasts go to each listener.
*
@@ -1160,38 +1536,23 @@
__be32 saddr, __be32 daddr,
struct udp_table *udptable)
{
- struct sock *sk;
- struct udp_hslot *hslot = &udptable->hash[udp_hashfn(net, ntohs(uh->dest))];
- int dif;
+ int port_key, pair_key, pair_addrany_key;
+ u16 num = ntohs(uh->dest);
- spin_lock(&hslot->lock);
- sk = sk_nulls_head(&hslot->head);
- dif = skb->dev->ifindex;
- sk = udp_v4_mcast_next(net, sk, uh->dest, daddr, uh->source, saddr, dif);
- if (sk) {
- struct sock *sknext = NULL;
+ port_key = udp_hashfn(net, num);
+ pair_key = udp_v4_addr_hashfn(net, daddr, num);
+ pair_addrany_key = udp_v4_addr_hashfn(net, INADDR_ANY, num);
- do {
- struct sk_buff *skb1 = skb;
+ __udp_lock_hashes(udptable, port_key, pair_key, pair_addrany_key);
+
+ __udp4_lib_mcast_deliver_hslot(net, skb, uh, saddr, daddr,
+ &udptable->hash[pair_key]);
+ if (pair_key != pair_addrany_key)
+ __udp4_lib_mcast_deliver_hslot(net, skb, uh, saddr, daddr,
+ &udptable->hash[pair_addrany_key]);
- sknext = udp_v4_mcast_next(net, sk_nulls_next(sk), uh->dest,
- daddr, uh->source, saddr,
- dif);
- if (sknext)
- skb1 = skb_clone(skb, GFP_ATOMIC);
-
- if (skb1) {
- int ret = udp_queue_rcv_skb(sk, skb1);
- if (ret > 0)
- /* we should probably re-process instead
- * of dropping packets here. */
- kfree_skb(skb1);
- }
- sk = sknext;
- } while (sknext);
- } else
- consume_skb(skb);
- spin_unlock(&hslot->lock);
+ __udp_unlock_hashes(udptable, port_key, pair_key, pair_addrany_key);
+ consume_skb(skb);
return 0;
}
@@ -1797,6 +2158,9 @@
for (i = 0; i < UDP_HTABLE_SIZE; i++) {
INIT_HLIST_NULLS_HEAD(&table->hash[i].head, i);
spin_lock_init(&table->hash[i].lock);
+
+ INIT_HLIST_NULLS_HEAD(&table->port_hash[i].head, i);
+ spin_lock_init(&table->port_hash[i].lock);
}
}
[-- Attachment #3: stressbind.c --]
[-- Type: text/x-csrc, Size: 11692 bytes --]
/*
* Creates a configurable number of UDP sockets with IPv4 and IPv6 addresses.
*
* If run as receiver: counts the number of UDP datagrams received.
* - binds on all addresses on a given port and connects the socket to the
* corresponding IP address and port.
* - Afterwars, if epolls and count the corectly received datagrams.
* - not knowing when to stop listening it must be killed with CTRL+C (or
* other killing signel). On the first CTRL+C received prints the number of
* received datagrams; on the second CTRL+C received it exit()s.
*
* If run as sender: sends a configurable number of UDP datagrams to the
* receiver and prints the number of second passed.
* - binds on all addresses on a given port and connects the socket to the
* corresponding IP address and port.
* - epolls for a free sending slot and send a new datagram to the receiver.
* - at end prints the time it took to send all the datagrams.
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <time.h>
#include <signal.h>
struct timespec tp;
struct epoll_data_t {
int fd;
int count;
int disabled;
};
static void start_timer(struct timespec *tp)
{
int rc = clock_gettime(CLOCK_REALTIME, tp);
if (rc != 0) {
perror("clock_realtime err in start_timer");
}
}
static void end_timer(struct timespec *pold, const char * msg)
{
int rc;
long unsigned dsec, dnsec;
struct timespec now;
rc = clock_gettime(CLOCK_REALTIME, &now);
if (rc != 0) {
perror("clock_realtime err in end_timer");
}
if (now.tv_nsec < pold->tv_nsec) {
dnsec = pold->tv_nsec - now.tv_nsec;
dsec = now.tv_sec - pold->tv_sec - 1;
} else {
dnsec = now.tv_nsec - pold->tv_nsec;
dsec = now.tv_sec - pold->tv_sec;
}
printf(">>> %s: %lu s %lu ns \n", msg, dsec, dnsec);
}
static struct in_addr * make_ip4_addrs(int count, int suffix)
{
int i = 0;
char str[INET6_ADDRSTRLEN];
struct in_addr * ret = malloc(sizeof(struct in_addr) * count);
for(i = 0; i < count; i++) {
snprintf(str, INET6_ADDRSTRLEN, "1.%d.%d.%d",
(i & 0xFF00) >> 8, i & 0xFF, suffix);
int s = inet_pton(AF_INET, str, &ret[i]);
if (s <= 0) {
if (s == 0)
fprintf(stderr, "ipv4 Not in presentation format");
else
perror("inet_pton");
exit(EXIT_FAILURE);
}
}
return ret;
}
static struct in6_addr * make_ip6_addrs(int count, int suffix)
{
int i = 0;
char str[INET6_ADDRSTRLEN];
struct in6_addr * ret = malloc(sizeof(struct in6_addr) * count);
for(i = 0; i < count; i++) {
snprintf(str, INET6_ADDRSTRLEN, "1::%x:%x:%x",
(i / 0x10000), (i & 0xFFFF), suffix);
int s = inet_pton(AF_INET6, str, &ret[i]);
if (s <= 0) {
if (s == 0)
fprintf(stderr, "ipv6 Not in presentation format");
else
perror("inet_pton");
exit(EXIT_FAILURE);
}
}
return ret;
}
static int * make_sockets_(int count, int type)
{
int i = 0;
int * ret = malloc(sizeof(int)*count);
for (i = 0; i < count; i++) {
ret[i] = socket(type, SOCK_DGRAM, 0);
if (ret[i] < 0) {
perror("make_ipv4_sockets socket() failed");
exit(EXIT_FAILURE);
}
}
return ret;
}
static int * make_ip4_sockets(int count)
{
return make_sockets_(count, AF_INET);
}
static int * make_ip6_sockets(int count)
{
return make_sockets_(count, AF_INET6);
}
static void print_ip_err(void * in_addr, int addr_type)
{
char str[INET6_ADDRSTRLEN];
if (inet_ntop(addr_type, in_addr, str, INET6_ADDRSTRLEN) == NULL) {
perror("inet_ntop");
exit(EXIT_FAILURE);
}
fprintf(stderr, "failed for addr: %s\n", str);
}
static void for_all_set_sockopt(int * s, int count, int level, int optname, int val)
{
int i = 0;
int rc;
for (i = 0; i < count; i++) {
rc = setsockopt(s[i], level, optname, (int[]){val}, sizeof(int));
if (rc != 0) {
perror("setsockopt");
exit(EXIT_FAILURE);
}
}
}
static void for_all_set_reuseaddr(int * s, int count)
{
for_all_set_sockopt(s, count, SOL_SOCKET, SO_REUSEADDR, 1);
}
static void for_all_set_rcvbuf(int * s, int count, int size)
{
for_all_set_sockopt(s, count, SOL_SOCKET, SO_RCVBUF, size);
}
static void for_all_set_sndbuf(int * s, int count, int size)
{
for_all_set_sockopt(s, count, SOL_SOCKET, SO_SNDBUF, size);
}
static void for_all_set_nonblocking(int * s, int count)
{
int rc, i;
for (i = 0; i < count; i++) {
rc = fcntl(s[i], F_SETFL, O_NONBLOCK);
if (rc != 0) {
fprintf(stderr, "i = %d\n", i);
perror("fcntl O_NONBLOCK");
exit(EXIT_FAILURE);
}
}
}
static void for_all_set_ipv6only(int * s, int count)
{
for_all_set_sockopt(s, count, IPPROTO_IPV6, IPV6_V6ONLY, 1);
}
static void for_all_bind_or_connect_ip4(int * s, struct in_addr * ip4, int count, int port,
int (*f)(int sockfd, const struct sockaddr *addr,
socklen_t addrlen))
{
int i, rc;
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
for (i = 0; i < count; i++) {
sin.sin_addr = ip4[i];
rc = f(s[i], (struct sockaddr*)&sin, sizeof(sin));
if (rc != 0) {
if (f == bind)
perror("bind ipv4");
else
perror("connect ipv4");
fprintf(stderr, "i = %d\n", i);
print_ip_err(&ip4[i], AF_INET);
exit(EXIT_FAILURE);
}
}
}
static void for_all_bind_or_connect_ip6(int * s, struct in6_addr * ip6, int count, int port,
int (*f)(int sockfd, const struct sockaddr *addr,
socklen_t addrlen))
{
int i, rc;
struct sockaddr_in6 sin6;
sin6.sin6_family = AF_INET6;
sin6.sin6_port = htons(port);
for (i = 0; i < count; i++) {
sin6.sin6_addr = ip6[i];
rc = f(s[i], (struct sockaddr*)&sin6, sizeof(sin6));
if (rc != 0) {
if (f == bind)
perror("bind ipv6");
else
perror("connect ipv6");
fprintf(stderr, "i = %d\n", i);
print_ip_err(&ip6[i], AF_INET6);
exit(EXIT_FAILURE);
}
}
}
static void for_all_bind_ip4(int * s, struct in_addr * ip4, int count, int port)
{
for_all_bind_or_connect_ip4(s, ip4, count, port, bind);
}
static void for_all_bind_ip6(int * s, struct in6_addr * ip6, int count, int port)
{
for_all_bind_or_connect_ip6(s, ip6, count, port, bind);
}
static void for_all_connect_ip4(int * s, struct in_addr * ip4, int count, int port)
{
for_all_bind_or_connect_ip4(s, ip4, count, port, connect);
}
static void for_all_connect_ip6(int * s, struct in6_addr * ip6, int count, int port)
{
for_all_bind_or_connect_ip6(s, ip6, count, port, connect);
}
static struct epoll_data_t * for_all_add_to_epoll(int *s, int count, int epollfd, int is_sender)
{
int rc;
int i;
struct epoll_event ev;
struct epoll_data_t * data = calloc(count, sizeof(struct epoll_data_t));
ev.events = EPOLLET;
if (is_sender)
ev.events |= EPOLLOUT;
else
ev.events |= EPOLLIN;
for (i = 0; i < count; i++) {
data[i].fd = s[i];
ev.data.ptr = &data[i];
rc = epoll_ctl(epollfd, EPOLL_CTL_ADD, s[i], &ev);
if (rc == -1) {
fprintf(stderr, "i = %d\n", i);
perror("epoll_ctl: conn_sock");
exit(EXIT_FAILURE);
}
}
return data;
}
static void remove_from_epoll(int epollfd, int fd, struct epoll_event * ev)
{
int rc;
//printf("removing from epoll fd %d\n", fd);
rc = epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, ev);
if (rc != 0)
perror("epoll_ctl EPOLL_CTL_DEL");
}
static void disable_epoll_event_type(int epollfd, int fd, int event_type, struct epoll_event * ev)
{
int rc;
//printf("disabling event %d on fd=%d\n", event_type, fd);
ev->events &= ~event_type;
rc = epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, ev);
if (rc != 0)
perror("epoll_ctl EPOLL_CTL_MOD");
}
static int handle_events(int epollfd, int fds_in_epoll, int is_sender, int max_packets, int datalen)
{
char * databuf = malloc(datalen);
struct epoll_event * events = malloc(sizeof(struct epoll_event) * fds_in_epoll);
int todo = fds_in_epoll;
int total = 0;
for (;todo;) {
int i, nfds;
nfds = epoll_wait(epollfd, events, fds_in_epoll, -1);
if (nfds == -1) {
if (errno == EINTR) {
printf("signal interrupted epoll_wait: total= %d\n", total);
continue;
}
perror("epoll_wait");
exit(EXIT_FAILURE);
}
for (i = 0; i < nfds; i++) {
int fd, rc;
struct epoll_event *ev = &events[i];
struct epoll_data_t *ed = ev->data.ptr;
fd = ed->fd;
if (ev->events & (EPOLLERR | EPOLLHUP)) {
remove_from_epoll(epollfd, fd, ev);
todo--;
continue;
}
if (ev->events & EPOLLIN) {
rc = recv(fd, databuf, datalen, 0);
if (rc == -1) {
//if (errno != ECONNREFUSED)
perror("recv");
continue;
}
}
if (ev->events & EPOLLOUT) {
rc = send(fd, databuf, datalen, 0);
if (rc == -1) {
//if (errno != ECONNREFUSED)
perror("send");
continue;
}
}
if (total == 0)
start_timer(&tp);
total ++;
ed->count ++;
if (ed->count == max_packets) {
remove_from_epoll(epollfd, fd, ev);
todo--;
}
}
}
free(events);
return total;
}
static int signal_was_delivered = 0;
static void handler(int unused)
{
if (!signal_was_delivered)
signal_was_delivered = 1;
else
exit(0);
}
static void add_signal()
{
signal(SIGINT, handler);
}
#define stoi atoi
int main(int argc, char * argv[])
{
int port = 1212;
if (argc < 8) {
printf("Usage: %s nr_interfaces4 nr_interfaces6 my_last_suffix their_last_suffix [s|r] max_packets datalen [recvsize]\n", argv[0]);
exit(EXIT_FAILURE);
}
int count4 = stoi(argv[1]);
int count6 = stoi(argv[2]);
int my_suffix = stoi(argv[3]);
int their_suffix = stoi(argv[4]);
int is_sender = argv[5][0] == 's';
int max_packets = stoi(argv[6]);
int datalen = stoi(argv[7]);
int recvsize = -1;
if (argc >= 8)
recvsize = stoi(argv[8]);
add_signal();
printf("args = count4=%d count6=%d my_suffix=%d their_suffix=%d is_sender=%d max_packets=%d datalen=%d recvsize=%d\n",
count4, count6, my_suffix, their_suffix, is_sender, max_packets, datalen, recvsize);
int epollfd;
struct in_addr * ip4_src = make_ip4_addrs(count4, my_suffix);
struct in6_addr * ip6_src = make_ip6_addrs(count6, my_suffix);
struct in_addr * ip4_dst = make_ip4_addrs(count4, their_suffix);
struct in6_addr * ip6_dst = make_ip6_addrs(count6, their_suffix);
struct epoll_data_t *ep_data_ip4, *ep_data_ip6;
int * s4 = make_ip4_sockets(count4);
int * s6 = make_ip6_sockets(count6);
int total = 0;
for_all_set_reuseaddr(s4, count4);
for_all_set_reuseaddr(s6, count6);
if (recvsize != -1) {
for_all_set_rcvbuf(s4, count4, recvsize);
for_all_set_rcvbuf(s6, count6, recvsize);
}
//for_all_set_sndbuf(s4, count4, 1);
//for_all_set_sndbuf(s6, count6, 1);
start_timer(&tp);
for_all_bind_ip6(s6, ip6_src, count6, port);
for_all_bind_ip4(s4, ip4_src, count4, port);
end_timer(&tp, "bound IPv4 and IPv6");
start_timer(&tp);
for_all_connect_ip4(s4, ip4_dst, count4, port);
for_all_connect_ip6(s6, ip6_dst, count6, port);
end_timer(&tp, "connected IPv4 and IPv6");
free(ip4_src); free(ip6_src);
free(ip4_dst); free(ip6_dst);
for_all_set_nonblocking(s4, count4);
for_all_set_nonblocking(s6, count6);
printf("done builing sockets.\n");
epollfd = epoll_create(count4+count6);
if (epollfd == -1) {
perror("epoll_create");
exit(EXIT_FAILURE);
}
ep_data_ip4 = for_all_add_to_epoll(s4, count4, epollfd, is_sender);
ep_data_ip6 = for_all_add_to_epoll(s6, count6, epollfd, is_sender);
printf("done builing epoll.\n");
total = handle_events(epollfd, count4 + count6, is_sender, max_packets, datalen);
end_timer(&tp, "handled all events");
free(ep_data_ip4); free(ep_data_ip6);
free(s4); free(s6);
printf("done total= %d\n", total);
return 0;
}
^ permalink raw reply
* [PATCH net-next-2.6] sctp: ipv6: avoid touching device refcount
From: Eric Dumazet @ 2009-11-04 21:06 UTC (permalink / raw)
To: David S. Miller; +Cc: Linux Netdev List
Avoid touching device refcount in sctp/ipv6, thanks to RCU
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
net/sctp/ipv6.c | 19 +++++++++++--------
1 files changed, 11 insertions(+), 8 deletions(-)
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index bb280e6..7691527 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -837,15 +837,16 @@ static int sctp_inet6_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
if (type & IPV6_ADDR_LINKLOCAL) {
if (!addr->v6.sin6_scope_id)
return 0;
- dev = dev_get_by_index(&init_net, addr->v6.sin6_scope_id);
- if (!dev)
- return 0;
- if (!ipv6_chk_addr(&init_net, &addr->v6.sin6_addr,
+ rcu_read_lock();
+ dev = dev_get_by_index_rcu(&init_net,
+ addr->v6.sin6_scope_id);
+ if (!dev ||
+ !ipv6_chk_addr(&init_net, &addr->v6.sin6_addr,
dev, 0)) {
- dev_put(dev);
+ rcu_read_unlock();
return 0;
}
- dev_put(dev);
+ rcu_read_unlock();
} else if (type == IPV6_ADDR_MAPPED) {
if (!opt->v4mapped)
return 0;
@@ -873,10 +874,12 @@ static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
if (type & IPV6_ADDR_LINKLOCAL) {
if (!addr->v6.sin6_scope_id)
return 0;
- dev = dev_get_by_index(&init_net, addr->v6.sin6_scope_id);
+ rcu_read_lock();
+ dev = dev_get_by_index_rcu(&init_net,
+ addr->v6.sin6_scope_id);
+ rcu_read_unlock();
if (!dev)
return 0;
- dev_put(dev);
}
af = opt->pf->af;
}
^ permalink raw reply related
* Re: pull request: wireless-next-2.6 2009-10-28
From: Ivo van Doorn @ 2009-11-04 21:17 UTC (permalink / raw)
To: Jiri Kosina
Cc: Pavel Machek, Luis Correia, John W. Linville, Ingo Molnar,
Johannes Berg, Jarek Poplawski, Bartlomiej Zolnierkiewicz,
Pekka Enberg, David Miller, linux-wireless-u79uwXL29TY76Z2rM5mHXA,
netdev-u79uwXL29TY76Z2rM5mHXA,
linux-kernel-u79uwXL29TY76Z2rM5mHXA
In-Reply-To: <alpine.LRH.2.00.0911041403480.31913-1ReQVI26iDCaZKY3DrU6dA@public.gmane.org>
On Wednesday 04 November 2009, Jiri Kosina wrote:
> On Mon, 2 Nov 2009, Pavel Machek wrote:
>
> > > I've searched on my GMail archives and the only patch Bart has
> > > provided so far for the rt2x00 project is this:
> > >
> > > [PATCH] MAINTAINERS: rt2x00 list is moderated
> > >
> > > Which, while technically correct, adds nothing to the project.
> > >
> > > So, I will personally continue to ignore Bart's comments, regards and
> > > rants, until he provides patches for rt2x00 that actually make the
> > > driver better.
> >
> > Well, he provided review feedback... he should be thanked for that,
> > not flamed for it.
>
> He has actually written real patches (and quite non-trivial both in amount
> and in functionality), see
>
> http://lkml.org/lkml/2009/11/3/372
Please look at the TIMESTAMP of the mail you refer to, and the TIMESTAMP
of the mail from Luis. And then you can make assumptions about the text...
> But yes, he got flamed for this for some odd reason. I got the impression
> that the community around rt2x00 doesn't like (or understand) the way how
> opensource development happens.
Well you mean the open source development where non-contributors
complain that the contributors work too slowly? Well if that is the way
things should go, then I don't want to be part of such idiocy. Perhaps
that is the policy in some companies which try to import it into the
Open Source world...
Ivo
--
To unsubscribe from this list: send the line "unsubscribe linux-wireless" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [RFC] [PATCH] udp: optimize lookup of UDP sockets to by including destination address in the hash key
From: Eric Dumazet @ 2009-11-04 21:30 UTC (permalink / raw)
To: Lucian Adrian Grijincu; +Cc: netdev, Octavian Purdila
In-Reply-To: <4AF1EC18.9090106@ixiacom.com>
Lucian Adrian Grijincu a écrit :
> Hi,
>
> Before you look at the patch attached: I know it's not the prettiest of patches sent here. It's a work-in-progress and is ugly and incomplete (for example IPv6 is not properly updated to benefit this patch and may even be as buggy as hell right now).
> I'm sending it here to ask for an opinion on the approach.
>
> The current approach uses one single hash to lookup UDP sockets.
> The key to the hash is calculated based on the port only.
> This works well if there aren't many sockets bound to the same port, but becomes a linear linked list search for a setup with many UPD packets bound to the same port, which does not scale much.
>
> In this patch the hashtable lookup key takes into consideration the address the socket is bound to too.
> This will lead to better distribution for setup where there are many UDP sockets bound to the same port but different IP addresses.
>
> There's a subtle bug lurking here: because some sockets may be bound to INADDR_ANY when checking whether a given UPD port is already taken one must search two buckets:
> * one with the key computed from the port and for the IP address of the socket
> * one with the key computed from the port and INADDR_ANY
>
> Now if the address by which we must do the lookup is INADDR_ANY there's another problem: we can't just search it's own bucket and the bucket for INADDR_ANY (the same bucket twice) like above because there might be a socket bound to a specific address and the port we're trying to bind to.
>
> In this case we could search the whole hash (which would take forever) or use another hash that is computed based on the port only (which this patch does).
>
> There are other things to look after: when modifying the hashes we must take spin_locks or spin_lock_bhs. Because we now have two hashtables and one hashtable might be searched twice locks must be taken in the proper order.
>
> I ran the attached UDP tester: it's a program that binds to a lot of UDP sockets and if run as a sender it sends lots of datagrams to the receiver which will just count the number of packets recevied.
>
>
>
> == Performance stats ==
> I ran this on a 2.6.31 with and without the patch on two powerpc single core processors connected directly by 100Mbps ethernet.
>
> * nsocks = number of IPv4 bound sockets
> * ndgrams = number of datagrams sent by each socket
> * payloadlen = the lenght of the UPD message sent
> * send_time = how many second did the sending operation take?
> * recv_dgrams = how many datagrams were successfully received?
>
>
> 1. nsocks=512 ndgrams=2000 payloadlen=1
> - without patch:
> * send_time = 27s to 31s
> * recv_dgrams = 550 to 850
> - with patch:
> * send_time = 35s to 36s
> * recv_dgrams = 507000 to 516000
>
> 2. nsocks=512 ndgrams=4000 payloadlen=1
> - without patch:
> * send_time = 53s to 60s
> * recv_dgrams = 650 to 1100
> - with patch:
> * send_time = ~70s
> * recv_dgrams = 1010000 to 1034000
>
> 3. nsocks=512 ndgrams=4000 payloadlen=1000
> - without patch:
> * send_time = ~74s
> * recv_dgrams = 650
> - with patch:
> * send_time = ~88s
> * recv_dgrams = 995000
>
> 4. nsocks=256 ndgrams=2000 payloadlen=1
> - without patch:
> * send_time = 13s
> * recv_dgrams = 370 to 720
> - with patch:
> * send_time = 17s
> * recv_dgrams = 267000
>
>
> As you can see this has a hit on total send time, but the number of received packets increases by two orders of magnitude.
>
> I'd like hear your opinion about this approach.
> If you'd like to test this, I'll be happy to port it to net-next and provide the patch.
>
>
I knew someone would do this kind of patch one day, I tried it one year ago :)
First of all, you are mixing several things in this patch.
Dont do this, its not possible for us to correctly review such complex patch.
Then, your patch is not based on net-next-2.6, and you really need to work on this tree.
Then, if you had worked on net-next-2.6, you whould have noticed UDP hash tables
are now dynamically sized at boot.
An admin can even force a 65536 slots hash table for heavy duty UDP servers.
Then, last point : Say I have a machine with 65000 udp sockets bound to a different port,
and a 65536 slots hash table, (sane values in fact, in order to have best performances),
then your two phase lookup will be slower than the one-phase current lookup (two cache misses
instead of one)
So your patch seems to solve a pathological case (where many udp sockets are
bounded to a particular port, but on many different IPs), and slow down 99%
of other uses.
Thanks
^ permalink raw reply
* [PATCH net-next-2.6] net_cls: Use __dev_get_by_index()
From: Eric Dumazet @ 2009-11-04 21:32 UTC (permalink / raw)
To: David S. Miller; +Cc: Linux Netdev List
We hold RTNL in tc_dump_tfilter(), we can avoid dev_hold()/dev_put()
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
net/sched/cls_api.c | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 7cf6c0f..c024da7 100644
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -404,6 +404,7 @@ static int tcf_node_dump(struct tcf_proto *tp, unsigned long n,
a->cb->nlh->nlmsg_seq, NLM_F_MULTI, RTM_NEWTFILTER);
}
+/* called with RTNL */
static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
{
struct net *net = sock_net(skb->sk);
@@ -422,7 +423,7 @@ static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
if (cb->nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*tcm)))
return skb->len;
- if ((dev = dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
+ if ((dev = __dev_get_by_index(&init_net, tcm->tcm_ifindex)) == NULL)
return skb->len;
if (!tcm->tcm_parent)
@@ -484,7 +485,6 @@ errout:
if (cl)
cops->put(q, cl);
out:
- dev_put(dev);
return skb->len;
}
^ permalink raw reply related
* Re: [PATCH 19/25] mlx4: Randomizing mac addresses for slaves
From: Or Gerlitz @ 2009-11-04 21:33 UTC (permalink / raw)
To: Roland Dreier; +Cc: Yevgeny Petrilin, linux-rdma, netdev, liranl, tziporet
In-Reply-To: <adar5seys3e.fsf@cisco.com>
On Wed, Nov 4, 2009 at 10:04 PM, Roland Dreier <rdreier@cisco.com> wrote:
>> +#define MLX4_MAC_HEAD 0x2c9000000ULL
> Is this a good idea? You're basically choosing 24 random bits within your OUI...
> seems the chance of collision with another MAC used on the same network is
> high enough that it could easily happen in practice on a moderately big network.
yes, this has been brought by Stephen and others on this last back on
September 11th, this year @
http://marc.info/?l=linux-netdev&m=125263488409128
> Can you pick a reserved range or something?
Using different OUI for the VF device wouldn't help either I think,
since the #VF becomes fairly big even on a modest side cluster with
(say) a VM consuming VF per 1-2 cores.
Or.
^ permalink raw reply
* [PATCH 2.6.33/1 01/12] wimax/i2400m/usb: remove unnecessary power management primitive in i2400m
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Oliver Neukum
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Oliver Neukum <oliver@neukum.org>
This patch removes an unneeded power management primitive.
Power management is automatically enabled as probe ends.
Signed-off-by: Oliver Neukum <oliver@neukum.org>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/usb.c | 1 -
1 files changed, 0 insertions(+), 1 deletions(-)
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index 7eadd11..bfa45f5 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -415,7 +415,6 @@ int i2400mu_probe(struct usb_interface *iface,
#ifdef CONFIG_PM
iface->needs_remote_wakeup = 1; /* autosuspend (15s delay) */
device_init_wakeup(dev, 1);
- usb_autopm_enable(i2400mu->usb_iface);
usb_dev->autosuspend_delay = 15 * HZ;
usb_dev->autosuspend_disabled = 0;
#endif
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 02/12] wimax/i2400m: fix the bootmode RX deadlock in SDIO driver
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Cindy H Kao
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Cindy H Kao <cindy.h.kao@intel.com>
i2400ms_bus_bm_wait_for_ack() causes a race condition. It happens
because this function clears i2400ms->bm_ack_size before waiting for
an interrupt, which is set by the interrupt service routine i2400ms_rx()
to indicate reception and size of received data; thus, if the interrupt
came right before the clearing/waiting, it is lost.
The fix is clear the bm_ack_size to -EINPROGRESS before we are enabling
the RX interrupt configuration in i2400ms_rx_setup(). Then everytime
when the interrupt service routine i2400ms_rx() is invoked during bootmode,
bm_ack_size is updated with the actual rx_size and it is cleared to
-EINPROGRESS again after the RX data is handled.
Signed-off-by: Cindy H Kao <cindy.h.kao@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/sdio-fw.c | 8 ++++----
drivers/net/wimax/i2400m/sdio-rx.c | 7 +++++++
2 files changed, 11 insertions(+), 4 deletions(-)
diff --git a/drivers/net/wimax/i2400m/sdio-fw.c b/drivers/net/wimax/i2400m/sdio-fw.c
index 7d6ec0f..c8dc538 100644
--- a/drivers/net/wimax/i2400m/sdio-fw.c
+++ b/drivers/net/wimax/i2400m/sdio-fw.c
@@ -177,10 +177,6 @@ ssize_t i2400ms_bus_bm_wait_for_ack(struct i2400m *i2400m,
d_fnstart(5, dev, "(i2400m %p ack %p size %zu)\n",
i2400m, ack, ack_size);
- spin_lock(&i2400m->rx_lock);
- i2400ms->bm_ack_size = -EINPROGRESS;
- spin_unlock(&i2400m->rx_lock);
-
result = wait_event_timeout(i2400ms->bm_wfa_wq,
i2400ms->bm_ack_size != -EINPROGRESS,
2 * HZ);
@@ -199,6 +195,10 @@ ssize_t i2400ms_bus_bm_wait_for_ack(struct i2400m *i2400m,
size = min(ack_size, i2400ms->bm_ack_size);
memcpy(ack, i2400m->bm_ack_buf, size);
}
+ /*
+ * Remember always to clear the bm_ack_size to -EINPROGRESS
+ * after the RX data is processed
+ */
i2400ms->bm_ack_size = -EINPROGRESS;
spin_unlock(&i2400m->rx_lock);
diff --git a/drivers/net/wimax/i2400m/sdio-rx.c b/drivers/net/wimax/i2400m/sdio-rx.c
index 321bead..f6ca51a 100644
--- a/drivers/net/wimax/i2400m/sdio-rx.c
+++ b/drivers/net/wimax/i2400m/sdio-rx.c
@@ -234,6 +234,13 @@ int i2400ms_rx_setup(struct i2400ms *i2400ms)
init_waitqueue_head(&i2400ms->bm_wfa_wq);
spin_lock(&i2400m->rx_lock);
i2400ms->bm_wait_result = -EINPROGRESS;
+ /*
+ * Before we are about to enable the RX interrupt, make sure
+ * bm_ack_size is cleared to -EINPROGRESS which indicates
+ * no RX interrupt happened yet or the previous interrupt
+ * has been handled, we are ready to take the new interrupt
+ */
+ i2400ms->bm_ack_size = -EINPROGRESS;
spin_unlock(&i2400m->rx_lock);
sdio_claim_host(func);
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 05/12] wimax: misplaced parenthesis
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Roel Kluin
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Roel Kluin <roel.kluin@gmail.com>
Fix misplaced parenthesis
Signed-off-by: Roel Kluin <roel.kluin@gmail.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/tx.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/drivers/net/wimax/i2400m/tx.c b/drivers/net/wimax/i2400m/tx.c
index fa16ccf..8c20802 100644
--- a/drivers/net/wimax/i2400m/tx.c
+++ b/drivers/net/wimax/i2400m/tx.c
@@ -310,7 +310,7 @@ size_t __i2400m_tx_tail_room(struct i2400m *i2400m)
size_t tail_room;
size_t tx_in;
- if (unlikely(i2400m->tx_in) == 0)
+ if (unlikely(i2400m->tx_in == 0))
return I2400M_TX_BUF_SIZE;
tx_in = i2400m->tx_in % I2400M_TX_BUF_SIZE;
tail_room = I2400M_TX_BUF_SIZE - tx_in;
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 08/12] wimax/i2400m: Ensure boot mode cmd and ack buffers are alloc'd before first message
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Dirk Brandewie <dirk.j.brandewie@intel.com>
The change to the SDIO boot mode RX chain could try to use the cmd and
ack buffers befor they were allocated. USB does not have the problem
but both were changed for consistency's sake.
Signed-off-by: Dirk Brandewie <dirk.j.brandewie@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/driver.c | 54 +++++++++++++++++++++++++++---------
drivers/net/wimax/i2400m/i2400m.h | 2 +
drivers/net/wimax/i2400m/sdio.c | 14 +++++++++
drivers/net/wimax/i2400m/usb.c | 8 +++++
4 files changed, 64 insertions(+), 14 deletions(-)
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index 304f044..20d574c 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -619,6 +619,46 @@ EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle);
/**
+ * i2400m_bm_buf_alloc - Alloc the command and ack buffers for boot mode
+ *
+ * Get the buffers needed to deal with boot mode messages. These
+ * buffers need to be allocated before the sdio recieve irq is setup.
+ */
+int i2400m_bm_buf_alloc(struct i2400m *i2400m)
+{
+ int result;
+
+ result = -ENOMEM;
+ i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
+ if (i2400m->bm_cmd_buf == NULL)
+ goto error_bm_cmd_kzalloc;
+ i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);
+ if (i2400m->bm_ack_buf == NULL)
+ goto error_bm_ack_buf_kzalloc;
+ return 0;
+
+error_bm_ack_buf_kzalloc:
+ kfree(i2400m->bm_cmd_buf);
+error_bm_cmd_kzalloc:
+ return result;
+}
+EXPORT_SYMBOL_GPL(i2400m_bm_buf_alloc);
+
+/**
+ * i2400m_bm_buf_free - Free boot mode command and ack buffers.
+ *
+ * Free the command and ack buffers
+ *
+ */
+void i2400m_bm_buf_free(struct i2400m *i2400m)
+{
+ kfree(i2400m->bm_ack_buf);
+ kfree(i2400m->bm_cmd_buf);
+ return;
+}
+EXPORT_SYMBOL_GPL(i2400m_bm_buf_free
+);
+/**
* i2400m_setup - bus-generic setup function for the i2400m device
*
* @i2400m: device descriptor (bus-specific parts have been initialized)
@@ -645,16 +685,6 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
snprintf(wimax_dev->name, sizeof(wimax_dev->name),
"i2400m-%s:%s", dev->bus->name, dev_name(dev));
- i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
- if (i2400m->bm_cmd_buf == NULL) {
- dev_err(dev, "cannot allocate USB command buffer\n");
- goto error_bm_cmd_kzalloc;
- }
- i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);
- if (i2400m->bm_ack_buf == NULL) {
- dev_err(dev, "cannot allocate USB ack buffer\n");
- goto error_bm_ack_buf_kzalloc;
- }
result = i2400m_bootrom_init(i2400m, bm_flags);
if (result < 0) {
dev_err(dev, "read mac addr: bootrom init "
@@ -713,10 +743,6 @@ error_dev_start:
error_register_netdev:
error_read_mac_addr:
error_bootrom_init:
- kfree(i2400m->bm_ack_buf);
-error_bm_ack_buf_kzalloc:
- kfree(i2400m->bm_cmd_buf);
-error_bm_cmd_kzalloc:
d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);
return result;
}
diff --git a/drivers/net/wimax/i2400m/i2400m.h b/drivers/net/wimax/i2400m/i2400m.h
index 60330f3..a6e59f1 100644
--- a/drivers/net/wimax/i2400m/i2400m.h
+++ b/drivers/net/wimax/i2400m/i2400m.h
@@ -725,6 +725,8 @@ void i2400m_put(struct i2400m *i2400m)
}
extern int i2400m_dev_reset_handle(struct i2400m *);
+extern int i2400m_bm_buf_alloc(struct i2400m *i2400m);
+extern void i2400m_bm_buf_free(struct i2400m *i2400m);
/*
* _setup()/_release() are called by the probe/disconnect functions of
diff --git a/drivers/net/wimax/i2400m/sdio.c b/drivers/net/wimax/i2400m/sdio.c
index c67b026..a68232a 100644
--- a/drivers/net/wimax/i2400m/sdio.c
+++ b/drivers/net/wimax/i2400m/sdio.c
@@ -451,6 +451,18 @@ int i2400ms_probe(struct sdio_func *func,
goto error_func_enable;
}
+ /*
+ * Before we are enabling the device interrupt register, make
+ * sure the buffer used during bootmode operation is setup so
+ * when the first D2H data interrupt comes, the memory is
+ * available for copying the D2H data.
+ */
+ result = i2400m_bm_buf_alloc(i2400m);
+ if (result < 0) {
+ dev_err(dev, "cannot allocate SDIO bootmode buffer\n");
+ goto error_bootmode_buf_setup;
+ }
+
result = i2400ms_rx_setup(i2400ms);
if (result < 0)
goto error_rx_setup;
@@ -474,6 +486,8 @@ error_debugfs_add:
error_setup:
i2400ms_rx_release(i2400ms);
error_rx_setup:
+ i2400m_bm_buf_free(i2400m);
+error_bootmode_buf_setup:
sdio_claim_host(func);
sdio_disable_func(func);
sdio_release_host(func);
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index bfa45f5..49d7554 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -419,6 +419,12 @@ int i2400mu_probe(struct usb_interface *iface,
usb_dev->autosuspend_disabled = 0;
#endif
+ result = i2400m_bm_buf_alloc(i2400m);
+ if (result < 0) {
+ dev_err(dev, "cannot allocate USB bootmode buffer\n");
+ goto error_bm_buf_alloc;
+ }
+
result = i2400m_setup(i2400m, I2400M_BRI_MAC_REINIT);
if (result < 0) {
dev_err(dev, "cannot setup device: %d\n", result);
@@ -434,6 +440,8 @@ int i2400mu_probe(struct usb_interface *iface,
error_debugfs_add:
i2400m_release(i2400m);
error_setup:
+ i2400m_bm_buf_free(i2400m);
+error_bm_buf_alloc:
usb_set_intfdata(iface, NULL);
usb_put_dev(i2400mu->usb_dev);
free_netdev(net_dev);
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 09/12] wimax/i2400m: Make boot retries a BUS-specific parameter
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Cindy H Kao
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Dirk Brandewie <dirk.j.brandewie@intel.com>
In i2400m-based devices, the driver's bootloader will retry to load
the firmware when things go wrong. The driver currently has a constant
(I2400M_BOOT_RETRIES) which governs the max number of tries.
However, different SKUs of the same hardware may admit or require
different numbers of retries due to it's particulars, so it is made a
BUS specific parameter and different values are assigned for 5x50
devices versus the 3200 ones.
Signed-off-by: Dirk Brandewie <dirk.j.brandewie@intel.com>
Signed-off-by: Cindy H Kao <cindy.h.kao@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/fw.c | 2 +-
drivers/net/wimax/i2400m/i2400m-sdio.h | 1 +
drivers/net/wimax/i2400m/i2400m-usb.h | 1 +
drivers/net/wimax/i2400m/i2400m.h | 3 ---
drivers/net/wimax/i2400m/sdio.c | 2 +-
drivers/net/wimax/i2400m/usb.c | 2 +-
6 files changed, 5 insertions(+), 6 deletions(-)
diff --git a/drivers/net/wimax/i2400m/fw.c b/drivers/net/wimax/i2400m/fw.c
index e81750e..55bd69e 100644
--- a/drivers/net/wimax/i2400m/fw.c
+++ b/drivers/net/wimax/i2400m/fw.c
@@ -602,7 +602,7 @@ int i2400m_bootrom_init(struct i2400m *i2400m, enum i2400m_bri flags)
struct device *dev = i2400m_dev(i2400m);
struct i2400m_bootrom_header *cmd;
struct i2400m_bootrom_header ack;
- int count = I2400M_BOOT_RETRIES;
+ int count = i2400m->bus_bm_retries;
int ack_timeout_cnt = 1;
BUILD_BUG_ON(sizeof(*cmd) != sizeof(i2400m_NBOOT_BARKER));
diff --git a/drivers/net/wimax/i2400m/i2400m-sdio.h b/drivers/net/wimax/i2400m/i2400m-sdio.h
index 9c4e318..66884eb 100644
--- a/drivers/net/wimax/i2400m/i2400m-sdio.h
+++ b/drivers/net/wimax/i2400m/i2400m-sdio.h
@@ -67,6 +67,7 @@
/* Host-Device interface for SDIO */
enum {
+ I2400M_SDIO_BOOT_RETRIES = 3,
I2400MS_BLK_SIZE = 256,
I2400MS_PL_SIZE_MAX = 0x3E00,
diff --git a/drivers/net/wimax/i2400m/i2400m-usb.h b/drivers/net/wimax/i2400m/i2400m-usb.h
index 6f76558..79c3753 100644
--- a/drivers/net/wimax/i2400m/i2400m-usb.h
+++ b/drivers/net/wimax/i2400m/i2400m-usb.h
@@ -137,6 +137,7 @@ static inline int edc_inc(struct edc *edc, u16 max_err, u16 timeframe)
/* Host-Device interface for USB */
enum {
+ I2400M_USB_BOOT_RETRIES = 3,
I2400MU_MAX_NOTIFICATION_LEN = 256,
I2400MU_BLK_SIZE = 16,
I2400MU_PL_SIZE_MAX = 0x3EFF,
diff --git a/drivers/net/wimax/i2400m/i2400m.h b/drivers/net/wimax/i2400m/i2400m.h
index a6e59f1..73b4e6a 100644
--- a/drivers/net/wimax/i2400m/i2400m.h
+++ b/drivers/net/wimax/i2400m/i2400m.h
@@ -148,9 +148,6 @@
/* Misc constants */
enum {
- /* Firmware uploading */
- I2400M_BOOT_RETRIES = 3,
- I3200_BOOT_RETRIES = 3,
/* Size of the Boot Mode Command buffer */
I2400M_BM_CMD_BUF_SIZE = 16 * 1024,
I2400M_BM_ACK_BUF_SIZE = 256,
diff --git a/drivers/net/wimax/i2400m/sdio.c b/drivers/net/wimax/i2400m/sdio.c
index a68232a..1429608 100644
--- a/drivers/net/wimax/i2400m/sdio.c
+++ b/drivers/net/wimax/i2400m/sdio.c
@@ -430,7 +430,7 @@ int i2400ms_probe(struct sdio_func *func,
i2400m->bus_reset = i2400ms_bus_reset;
/* The iwmc3200-wimax sometimes requires the driver to try
* hard when we paint it into a corner. */
- i2400m->bus_bm_retries = I3200_BOOT_RETRIES;
+ i2400m->bus_bm_retries = I2400M_SDIO_BOOT_RETRIES;
i2400m->bus_bm_cmd_send = i2400ms_bus_bm_cmd_send;
i2400m->bus_bm_wait_for_ack = i2400ms_bus_bm_wait_for_ack;
i2400m->bus_fw_names = i2400ms_bus_fw_names;
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index 49d7554..8f7b16a 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -406,7 +406,7 @@ int i2400mu_probe(struct usb_interface *iface,
i2400m->bus_dev_stop = i2400mu_bus_dev_stop;
i2400m->bus_tx_kick = i2400mu_bus_tx_kick;
i2400m->bus_reset = i2400mu_bus_reset;
- i2400m->bus_bm_retries = I2400M_BOOT_RETRIES;
+ i2400m->bus_bm_retries = I2400M_USB_BOOT_RETRIES;
i2400m->bus_bm_cmd_send = i2400mu_bus_bm_cmd_send;
i2400m->bus_bm_wait_for_ack = i2400mu_bus_bm_wait_for_ack;
i2400m->bus_fw_names = i2400mu_bus_fw_names;
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 00/12] WiMAX patches for 2.6.33 (batch #1)
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax
[this series of patches has been split in four batches as it was too
long; the grouping is just sequential as they are not really
related, except for dependencies].
Misc fixes: add minimal ethtool support, silly typo fixes, and
dwelve in a set of bad SDIO subdriver's boot-mode interactions with
the hardware timings and ways it managed to corner itself into a
deadlock.
Please pull from:
git://git.kernel.org/pub/scm/linux/kernel/git/inaky/wimax.git
Patches follow for ease of review.
Cindy H Kao (4):
wimax/i2400m: fix the bootmode RX deadlock in SDIO driver
wimax/iwmc3200: overwrite SDIO IOR timeout value to avoid platform
hang
wimax/iwmc3200: don't disable the SDIO function if enable fails
wimax/iwmc3200: increase wait time before enable retry
Dan Williams (1):
i2400m: minimal ethtool support
Dirk Brandewie (3):
wimax/i2400m: Update comments to talk about SDIO reset and not USB.
wimax/i2400m: Ensure boot mode cmd and ack buffers are alloc'd before
first message
wimax/i2400m: Make boot retries a BUS-specific parameter
Inaky Perez-Gonzalez (1):
wimax: indicate initial SW rfkill state is "blocked"
Oliver Neukum (1):
wimax/i2400m/usb: remove unnecessary power management primitive in
i2400m
Roel Kluin (2):
i2400m: keep index within ms_to_errno[]
wimax: misplaced parenthesis
drivers/net/wimax/i2400m/control.c | 2 +-
drivers/net/wimax/i2400m/driver.c | 54 +++++++++++++++++++++++--------
drivers/net/wimax/i2400m/fw.c | 2 +-
drivers/net/wimax/i2400m/i2400m-sdio.h | 5 ++-
drivers/net/wimax/i2400m/i2400m-usb.h | 1 +
drivers/net/wimax/i2400m/i2400m.h | 5 +--
drivers/net/wimax/i2400m/netdev.c | 18 ++++++++++
drivers/net/wimax/i2400m/sdio-fw.c | 8 ++--
drivers/net/wimax/i2400m/sdio-rx.c | 7 ++++
drivers/net/wimax/i2400m/sdio.c | 38 +++++++++++++++++-----
drivers/net/wimax/i2400m/tx.c | 2 +-
drivers/net/wimax/i2400m/usb.c | 11 +++++-
net/wimax/op-rfkill.c | 1 +
13 files changed, 118 insertions(+), 36 deletions(-)
^ permalink raw reply
* [PATCH 2.6.33/1 11/12] wimax/iwmc3200: don't disable the SDIO function if enable fails
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Cindy H Kao
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Cindy H Kao <cindy.h.kao@intel.com>
In the iwmc3200, disabling the WiMAX SDIO function when enable fails
would possibly result in a device reset triggered by the iwmc3200's
top controller since it monitors the bus reset activities from each
SDIO function. In any case, the disable makes no sense; if the enable
fails, it should not be disabled.
Thus we remove the unecessary sdio_disable_func() in
i2400ms_enable_function().
Signed-off-by: Cindy H Kao <cindy.h.kao@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/sdio.c | 1 -
1 files changed, 0 insertions(+), 1 deletions(-)
diff --git a/drivers/net/wimax/i2400m/sdio.c b/drivers/net/wimax/i2400m/sdio.c
index 0d64d16..9d6046f 100644
--- a/drivers/net/wimax/i2400m/sdio.c
+++ b/drivers/net/wimax/i2400m/sdio.c
@@ -130,7 +130,6 @@ int i2400ms_enable_function(struct sdio_func *func)
goto function_enabled;
}
d_printf(2, dev, "SDIO function failed to enable: %d\n", err);
- sdio_disable_func(func);
sdio_release_host(func);
msleep(I2400MS_INIT_SLEEP_INTERVAL);
}
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 10/12] wimax/iwmc3200: overwrite SDIO IOR timeout value to avoid platform hang
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Cindy H Kao
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Cindy H Kao <cindy.h.kao@intel.com>
The default SDIO IOE wait timeout returned from iwmc3200-wimax's CCCR
is not efficient. This inefficiency will actually cause problems on
Moorestown platforms (system hang).
This is a sillicon bug that requires a software patch to by
overwritting func->enable_timeout. The new value I2400MS_IOR_TIMEOUT
is recommended and verified from the system integration results.
Future sillicon releases will have this default value corrected in the
future.
Signed-off-by: Cindy H Kao <cindy.h.kao@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/i2400m-sdio.h | 2 ++
drivers/net/wimax/i2400m/sdio.c | 8 ++++++++
2 files changed, 10 insertions(+), 0 deletions(-)
diff --git a/drivers/net/wimax/i2400m/i2400m-sdio.h b/drivers/net/wimax/i2400m/i2400m-sdio.h
index 66884eb..cfaedfa 100644
--- a/drivers/net/wimax/i2400m/i2400m-sdio.h
+++ b/drivers/net/wimax/i2400m/i2400m-sdio.h
@@ -81,6 +81,8 @@ enum {
I2400MS_INIT_SLEEP_INTERVAL = 10,
/* How long to wait for the device to settle after reset */
I2400MS_SETTLE_TIME = 40,
+ /* The number of msec to wait for IOR after sending IOE */
+ IWMC3200_IOR_TIMEOUT = 10,
};
diff --git a/drivers/net/wimax/i2400m/sdio.c b/drivers/net/wimax/i2400m/sdio.c
index 1429608..0d64d16 100644
--- a/drivers/net/wimax/i2400m/sdio.c
+++ b/drivers/net/wimax/i2400m/sdio.c
@@ -115,6 +115,14 @@ int i2400ms_enable_function(struct sdio_func *func)
err = -ENODEV;
while (err != 0 && time_before64(get_jiffies_64(), timeout)) {
sdio_claim_host(func);
+ /*
+ * There is a sillicon bug on the IWMC3200, where the
+ * IOE timeout will cause problems on Moorestown
+ * platforms (system hang). We explicitly overwrite
+ * func->enable_timeout here to work around the issue.
+ */
+ if (func->device == SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX)
+ func->enable_timeout = IWMC3200_IOR_TIMEOUT;
err = sdio_enable_func(func);
if (0 == err) {
sdio_release_host(func);
--
1.6.2.5
^ permalink raw reply related
* [PATCH 2.6.33/1 12/12] wimax/iwmc3200: increase wait time before enable retry
From: Inaky Perez-Gonzalez @ 2009-11-04 21:39 UTC (permalink / raw)
To: netdev, wimax; +Cc: Cindy H Kao
In-Reply-To: <cover.1257370735.git.inaky@linux.intel.com>
From: Cindy H Kao <cindy.h.kao@intel.com>
When trying to enable the iwmc3200 WiMAX SDIO function, we loop
waiting for the top controller to be up and running (at which point we
can succesfully enable the function). Between each try we wait for
I2400MS_INIT_SLEEP_INTERVAL ms.
Integration tests have found the current value of 10ms to be too
short; it was upped to 100ms to give more time to the top controller
to be ready.
Signed-off-by: Cindy H Kao <cindy.h.kao@intel.com>
Signed-off-by: Inaky Perez-Gonzalez <inaky@linux.intel.com>
---
drivers/net/wimax/i2400m/i2400m-sdio.h | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/drivers/net/wimax/i2400m/i2400m-sdio.h b/drivers/net/wimax/i2400m/i2400m-sdio.h
index cfaedfa..18218a2 100644
--- a/drivers/net/wimax/i2400m/i2400m-sdio.h
+++ b/drivers/net/wimax/i2400m/i2400m-sdio.h
@@ -78,7 +78,7 @@ enum {
I2400MS_INTR_GET_SIZE_ADDR = 0x2C,
/* The number of ticks to wait for the device to signal that
* it is ready */
- I2400MS_INIT_SLEEP_INTERVAL = 10,
+ I2400MS_INIT_SLEEP_INTERVAL = 100,
/* How long to wait for the device to settle after reset */
I2400MS_SETTLE_TIME = 40,
/* The number of msec to wait for IOR after sending IOE */
--
1.6.2.5
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox