mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 19:51:31 -04:00
Merge branch 'master' of /repos/git/net-next-2.6
Conflicts: net/bridge/br_device.c net/bridge/br_forward.c Signed-off-by: Patrick McHardy <[email protected]>
This commit is contained in:
Patrick McHardy
commit
1e4b105712
744 changed files with 38111 additions and 17664 deletions
|
|
@ -419,7 +419,7 @@ int inet_release(struct socket *sock)
|
|||
if (sk) {
|
||||
long timeout;
|
||||
|
||||
inet_rps_reset_flow(sk);
|
||||
sock_rps_reset_flow(sk);
|
||||
|
||||
/* Applications forget to leave groups before exiting */
|
||||
ip_mc_drop_socket(sk);
|
||||
|
|
@ -548,7 +548,7 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
|
|||
{
|
||||
DEFINE_WAIT(wait);
|
||||
|
||||
prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
|
||||
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
|
||||
|
||||
/* Basic assumption: if someone sets sk->sk_err, he _must_
|
||||
* change state of the socket from TCP_SYN_*.
|
||||
|
|
@ -561,9 +561,9 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
|
|||
lock_sock(sk);
|
||||
if (signal_pending(current) || !timeo)
|
||||
break;
|
||||
prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
|
||||
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
|
||||
}
|
||||
finish_wait(sk->sk_sleep, &wait);
|
||||
finish_wait(sk_sleep(sk), &wait);
|
||||
return timeo;
|
||||
}
|
||||
|
||||
|
|
@ -722,7 +722,7 @@ int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
|
|||
{
|
||||
struct sock *sk = sock->sk;
|
||||
|
||||
inet_rps_record_flow(sk);
|
||||
sock_rps_record_flow(sk);
|
||||
|
||||
/* We may need to bind the socket. */
|
||||
if (!inet_sk(sk)->inet_num && inet_autobind(sk))
|
||||
|
|
@ -737,7 +737,7 @@ static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
|
|||
{
|
||||
struct sock *sk = sock->sk;
|
||||
|
||||
inet_rps_record_flow(sk);
|
||||
sock_rps_record_flow(sk);
|
||||
|
||||
/* We may need to bind the socket. */
|
||||
if (!inet_sk(sk)->inet_num && inet_autobind(sk))
|
||||
|
|
@ -755,7 +755,7 @@ int inet_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
|
|||
int addr_len = 0;
|
||||
int err;
|
||||
|
||||
inet_rps_record_flow(sk);
|
||||
sock_rps_record_flow(sk);
|
||||
|
||||
err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
|
||||
flags & ~MSG_DONTWAIT, &addr_len);
|
||||
|
|
@ -1323,8 +1323,8 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
|
|||
if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
|
||||
goto out_unlock;
|
||||
|
||||
id = ntohl(*(u32 *)&iph->id);
|
||||
flush = (u16)((ntohl(*(u32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF));
|
||||
id = ntohl(*(__be32 *)&iph->id);
|
||||
flush = (u16)((ntohl(*(__be32 *)iph) ^ skb_gro_len(skb)) | (id ^ IP_DF));
|
||||
id >>= 16;
|
||||
|
||||
for (p = *head; p; p = p->next) {
|
||||
|
|
@ -1337,8 +1337,8 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
|
|||
|
||||
if ((iph->protocol ^ iph2->protocol) |
|
||||
(iph->tos ^ iph2->tos) |
|
||||
(iph->saddr ^ iph2->saddr) |
|
||||
(iph->daddr ^ iph2->daddr)) {
|
||||
((__force u32)iph->saddr ^ (__force u32)iph2->saddr) |
|
||||
((__force u32)iph->daddr ^ (__force u32)iph2->daddr)) {
|
||||
NAPI_GRO_CB(p)->same_flow = 0;
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -245,8 +245,8 @@ static void fib4_rule_flush_cache(struct fib_rules_ops *ops)
|
|||
rt_cache_flush(ops->fro_net, -1);
|
||||
}
|
||||
|
||||
static struct fib_rules_ops fib4_rules_ops_template = {
|
||||
.family = FIB_RULES_IPV4,
|
||||
static const struct fib_rules_ops __net_initdata fib4_rules_ops_template = {
|
||||
.family = AF_INET,
|
||||
.rule_size = sizeof(struct fib4_rule),
|
||||
.addr_size = sizeof(u32),
|
||||
.action = fib4_rule_action,
|
||||
|
|
|
|||
|
|
@ -209,7 +209,9 @@ static inline struct node *tnode_get_child_rcu(struct tnode *tn, unsigned int i)
|
|||
{
|
||||
struct node *ret = tnode_get_child(tn, i);
|
||||
|
||||
return rcu_dereference(ret);
|
||||
return rcu_dereference_check(ret,
|
||||
rcu_read_lock_held() ||
|
||||
lockdep_rtnl_is_held());
|
||||
}
|
||||
|
||||
static inline int tnode_child_length(const struct tnode *tn)
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
|
|||
* having to remove and re-insert us on the wait queue.
|
||||
*/
|
||||
for (;;) {
|
||||
prepare_to_wait_exclusive(sk->sk_sleep, &wait,
|
||||
prepare_to_wait_exclusive(sk_sleep(sk), &wait,
|
||||
TASK_INTERRUPTIBLE);
|
||||
release_sock(sk);
|
||||
if (reqsk_queue_empty(&icsk->icsk_accept_queue))
|
||||
|
|
@ -253,7 +253,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
|
|||
if (!timeo)
|
||||
break;
|
||||
}
|
||||
finish_wait(sk->sk_sleep, &wait);
|
||||
finish_wait(sk_sleep(sk), &wait);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ static int ip_dev_loopback_xmit(struct sk_buff *newskb)
|
|||
newskb->pkt_type = PACKET_LOOPBACK;
|
||||
newskb->ip_summed = CHECKSUM_UNNECESSARY;
|
||||
WARN_ON(!skb_dst(newskb));
|
||||
netif_rx(newskb);
|
||||
netif_rx_ni(newskb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -954,6 +954,22 @@ e_inval:
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* ip_queue_rcv_skb - Queue an skb into sock receive queue
|
||||
* @sk: socket
|
||||
* @skb: buffer
|
||||
*
|
||||
* Queues an skb into socket receive queue. If IP_CMSG_PKTINFO option
|
||||
* is not set, we drop skb dst entry now, while dst cache line is hot.
|
||||
*/
|
||||
int ip_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
|
||||
{
|
||||
if (!(inet_sk(sk)->cmsg_flags & IP_CMSG_PKTINFO))
|
||||
skb_dst_drop(skb);
|
||||
return sock_queue_rcv_skb(sk, skb);
|
||||
}
|
||||
EXPORT_SYMBOL(ip_queue_rcv_skb);
|
||||
|
||||
int ip_setsockopt(struct sock *sk, int level,
|
||||
int optname, char __user *optval, unsigned int optlen)
|
||||
{
|
||||
|
|
|
|||
110
net/ipv4/ipmr.c
110
net/ipv4/ipmr.c
|
|
@ -128,8 +128,8 @@ static int ip_mr_forward(struct net *net, struct mr_table *mrt,
|
|||
int local);
|
||||
static int ipmr_cache_report(struct mr_table *mrt,
|
||||
struct sk_buff *pkt, vifi_t vifi, int assert);
|
||||
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
||||
struct mfc_cache *c, struct rtmsg *rtm);
|
||||
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
||||
struct mfc_cache *c, struct rtmsg *rtm);
|
||||
static void ipmr_expire_process(unsigned long arg);
|
||||
|
||||
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
||||
|
|
@ -216,8 +216,8 @@ static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static struct fib_rules_ops ipmr_rules_ops_template = {
|
||||
.family = FIB_RULES_IPMR,
|
||||
static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
|
||||
.family = RTNL_FAMILY_IPMR,
|
||||
.rule_size = sizeof(struct ipmr_rule),
|
||||
.addr_size = sizeof(u32),
|
||||
.action = ipmr_rule_action,
|
||||
|
|
@ -831,7 +831,7 @@ static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
|
|||
if (ip_hdr(skb)->version == 0) {
|
||||
struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
|
||||
|
||||
if (ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
|
||||
if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
|
||||
nlh->nlmsg_len = (skb_tail_pointer(skb) -
|
||||
(u8 *)nlh);
|
||||
} else {
|
||||
|
|
@ -1772,10 +1772,10 @@ int ip_mr_input(struct sk_buff *skb)
|
|||
|
||||
vif = ipmr_find_vif(mrt, skb->dev);
|
||||
if (vif >= 0) {
|
||||
int err = ipmr_cache_unresolved(mrt, vif, skb);
|
||||
int err2 = ipmr_cache_unresolved(mrt, vif, skb);
|
||||
read_unlock(&mrt_lock);
|
||||
|
||||
return err;
|
||||
return err2;
|
||||
}
|
||||
read_unlock(&mrt_lock);
|
||||
kfree_skb(skb);
|
||||
|
|
@ -1904,9 +1904,8 @@ drop:
|
|||
}
|
||||
#endif
|
||||
|
||||
static int
|
||||
ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, struct mfc_cache *c,
|
||||
struct rtmsg *rtm)
|
||||
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
||||
struct mfc_cache *c, struct rtmsg *rtm)
|
||||
{
|
||||
int ct;
|
||||
struct rtnexthop *nhp;
|
||||
|
|
@ -1994,11 +1993,93 @@ int ipmr_get_route(struct net *net,
|
|||
|
||||
if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
|
||||
cache->mfc_flags |= MFC_NOTIFY;
|
||||
err = ipmr_fill_mroute(mrt, skb, cache, rtm);
|
||||
err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
|
||||
read_unlock(&mrt_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
||||
u32 pid, u32 seq, struct mfc_cache *c)
|
||||
{
|
||||
struct nlmsghdr *nlh;
|
||||
struct rtmsg *rtm;
|
||||
|
||||
nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
|
||||
if (nlh == NULL)
|
||||
return -EMSGSIZE;
|
||||
|
||||
rtm = nlmsg_data(nlh);
|
||||
rtm->rtm_family = RTNL_FAMILY_IPMR;
|
||||
rtm->rtm_dst_len = 32;
|
||||
rtm->rtm_src_len = 32;
|
||||
rtm->rtm_tos = 0;
|
||||
rtm->rtm_table = mrt->id;
|
||||
NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
|
||||
rtm->rtm_type = RTN_MULTICAST;
|
||||
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
|
||||
rtm->rtm_protocol = RTPROT_UNSPEC;
|
||||
rtm->rtm_flags = 0;
|
||||
|
||||
NLA_PUT_BE32(skb, RTA_SRC, c->mfc_origin);
|
||||
NLA_PUT_BE32(skb, RTA_DST, c->mfc_mcastgrp);
|
||||
|
||||
if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
|
||||
goto nla_put_failure;
|
||||
|
||||
return nlmsg_end(skb, nlh);
|
||||
|
||||
nla_put_failure:
|
||||
nlmsg_cancel(skb, nlh);
|
||||
return -EMSGSIZE;
|
||||
}
|
||||
|
||||
static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
|
||||
{
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct mr_table *mrt;
|
||||
struct mfc_cache *mfc;
|
||||
unsigned int t = 0, s_t;
|
||||
unsigned int h = 0, s_h;
|
||||
unsigned int e = 0, s_e;
|
||||
|
||||
s_t = cb->args[0];
|
||||
s_h = cb->args[1];
|
||||
s_e = cb->args[2];
|
||||
|
||||
read_lock(&mrt_lock);
|
||||
ipmr_for_each_table(mrt, net) {
|
||||
if (t < s_t)
|
||||
goto next_table;
|
||||
if (t > s_t)
|
||||
s_h = 0;
|
||||
for (h = s_h; h < MFC_LINES; h++) {
|
||||
list_for_each_entry(mfc, &mrt->mfc_cache_array[h], list) {
|
||||
if (e < s_e)
|
||||
goto next_entry;
|
||||
if (ipmr_fill_mroute(mrt, skb,
|
||||
NETLINK_CB(cb->skb).pid,
|
||||
cb->nlh->nlmsg_seq,
|
||||
mfc) < 0)
|
||||
goto done;
|
||||
next_entry:
|
||||
e++;
|
||||
}
|
||||
e = s_e = 0;
|
||||
}
|
||||
s_h = 0;
|
||||
next_table:
|
||||
t++;
|
||||
}
|
||||
done:
|
||||
read_unlock(&mrt_lock);
|
||||
|
||||
cb->args[2] = e;
|
||||
cb->args[1] = h;
|
||||
cb->args[0] = t;
|
||||
|
||||
return skb->len;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PROC_FS
|
||||
/*
|
||||
* The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
|
||||
|
|
@ -2227,9 +2308,9 @@ static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
|
|||
const struct ipmr_mfc_iter *it = seq->private;
|
||||
const struct mr_table *mrt = it->mrt;
|
||||
|
||||
seq_printf(seq, "%08lX %08lX %-3hd",
|
||||
(unsigned long) mfc->mfc_mcastgrp,
|
||||
(unsigned long) mfc->mfc_origin,
|
||||
seq_printf(seq, "%08X %08X %-3hd",
|
||||
(__force u32) mfc->mfc_mcastgrp,
|
||||
(__force u32) mfc->mfc_origin,
|
||||
mfc->mfc_parent);
|
||||
|
||||
if (it->cache != &mrt->mfc_unres_queue) {
|
||||
|
|
@ -2355,6 +2436,7 @@ int __init ip_mr_init(void)
|
|||
goto add_proto_fail;
|
||||
}
|
||||
#endif
|
||||
rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
|
||||
return 0;
|
||||
|
||||
#ifdef CONFIG_IP_PIMSM_V2
|
||||
|
|
|
|||
|
|
@ -290,7 +290,7 @@ static int raw_rcv_skb(struct sock * sk, struct sk_buff * skb)
|
|||
{
|
||||
/* Charge it to the socket. */
|
||||
|
||||
if (sock_queue_rcv_skb(sk, skb) < 0) {
|
||||
if (ip_queue_rcv_skb(sk, skb) < 0) {
|
||||
kfree_skb(skb);
|
||||
return NET_RX_DROP;
|
||||
}
|
||||
|
|
|
|||
137
net/ipv4/route.c
137
net/ipv4/route.c
|
|
@ -129,7 +129,6 @@ static int ip_rt_gc_elasticity __read_mostly = 8;
|
|||
static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
|
||||
static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
|
||||
static int ip_rt_min_advmss __read_mostly = 256;
|
||||
static int ip_rt_secret_interval __read_mostly = 10 * 60 * HZ;
|
||||
static int rt_chain_length_max __read_mostly = 20;
|
||||
|
||||
static struct delayed_work expires_work;
|
||||
|
|
@ -258,10 +257,9 @@ static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
|
|||
(__raw_get_cpu_var(rt_cache_stat).field++)
|
||||
|
||||
static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
|
||||
int genid)
|
||||
int genid)
|
||||
{
|
||||
return jhash_3words((__force u32)(__be32)(daddr),
|
||||
(__force u32)(__be32)(saddr),
|
||||
return jhash_3words((__force u32)daddr, (__force u32)saddr,
|
||||
idx, genid)
|
||||
& rt_hash_mask;
|
||||
}
|
||||
|
|
@ -378,12 +376,13 @@ static int rt_cache_seq_show(struct seq_file *seq, void *v)
|
|||
struct rtable *r = v;
|
||||
int len;
|
||||
|
||||
seq_printf(seq, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
|
||||
"%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
|
||||
seq_printf(seq, "%s\t%08X\t%08X\t%8X\t%d\t%u\t%d\t"
|
||||
"%08X\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
|
||||
r->u.dst.dev ? r->u.dst.dev->name : "*",
|
||||
(unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
|
||||
(__force u32)r->rt_dst,
|
||||
(__force u32)r->rt_gateway,
|
||||
r->rt_flags, atomic_read(&r->u.dst.__refcnt),
|
||||
r->u.dst.__use, 0, (unsigned long)r->rt_src,
|
||||
r->u.dst.__use, 0, (__force u32)r->rt_src,
|
||||
(dst_metric(&r->u.dst, RTAX_ADVMSS) ?
|
||||
(int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
|
||||
dst_metric(&r->u.dst, RTAX_WINDOW),
|
||||
|
|
@ -685,18 +684,17 @@ static inline bool rt_caching(const struct net *net)
|
|||
static inline bool compare_hash_inputs(const struct flowi *fl1,
|
||||
const struct flowi *fl2)
|
||||
{
|
||||
return (__force u32)(((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
|
||||
(fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr) |
|
||||
return ((((__force u32)fl1->nl_u.ip4_u.daddr ^ (__force u32)fl2->nl_u.ip4_u.daddr) |
|
||||
((__force u32)fl1->nl_u.ip4_u.saddr ^ (__force u32)fl2->nl_u.ip4_u.saddr) |
|
||||
(fl1->iif ^ fl2->iif)) == 0);
|
||||
}
|
||||
|
||||
static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
|
||||
{
|
||||
return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
|
||||
(fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr)) |
|
||||
return (((__force u32)fl1->nl_u.ip4_u.daddr ^ (__force u32)fl2->nl_u.ip4_u.daddr) |
|
||||
((__force u32)fl1->nl_u.ip4_u.saddr ^ (__force u32)fl2->nl_u.ip4_u.saddr) |
|
||||
(fl1->mark ^ fl2->mark) |
|
||||
(*(u16 *)&fl1->nl_u.ip4_u.tos ^
|
||||
*(u16 *)&fl2->nl_u.ip4_u.tos) |
|
||||
(*(u16 *)&fl1->nl_u.ip4_u.tos ^ *(u16 *)&fl2->nl_u.ip4_u.tos) |
|
||||
(fl1->oif ^ fl2->oif) |
|
||||
(fl1->iif ^ fl2->iif)) == 0;
|
||||
}
|
||||
|
|
@ -919,32 +917,11 @@ void rt_cache_flush_batch(void)
|
|||
rt_do_flush(!in_softirq());
|
||||
}
|
||||
|
||||
/*
|
||||
* We change rt_genid and let gc do the cleanup
|
||||
*/
|
||||
static void rt_secret_rebuild(unsigned long __net)
|
||||
{
|
||||
struct net *net = (struct net *)__net;
|
||||
rt_cache_invalidate(net);
|
||||
mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
|
||||
}
|
||||
|
||||
static void rt_secret_rebuild_oneshot(struct net *net)
|
||||
{
|
||||
del_timer_sync(&net->ipv4.rt_secret_timer);
|
||||
rt_cache_invalidate(net);
|
||||
if (ip_rt_secret_interval)
|
||||
mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
|
||||
}
|
||||
|
||||
static void rt_emergency_hash_rebuild(struct net *net)
|
||||
{
|
||||
if (net_ratelimit()) {
|
||||
if (net_ratelimit())
|
||||
printk(KERN_WARNING "Route hash chain too long!\n");
|
||||
printk(KERN_WARNING "Adjust your secret_interval!\n");
|
||||
}
|
||||
|
||||
rt_secret_rebuild_oneshot(net);
|
||||
rt_cache_invalidate(net);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -2319,8 +2296,8 @@ int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
|
|||
rcu_read_lock();
|
||||
for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
|
||||
rth = rcu_dereference(rth->u.dst.rt_next)) {
|
||||
if (((rth->fl.fl4_dst ^ daddr) |
|
||||
(rth->fl.fl4_src ^ saddr) |
|
||||
if ((((__force u32)rth->fl.fl4_dst ^ (__force u32)daddr) |
|
||||
((__force u32)rth->fl.fl4_src ^ (__force u32)saddr) |
|
||||
(rth->fl.iif ^ iif) |
|
||||
rth->fl.oif |
|
||||
(rth->fl.fl4_tos ^ tos)) == 0 &&
|
||||
|
|
@ -3102,48 +3079,6 @@ static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
static void rt_secret_reschedule(int old)
|
||||
{
|
||||
struct net *net;
|
||||
int new = ip_rt_secret_interval;
|
||||
int diff = new - old;
|
||||
|
||||
if (!diff)
|
||||
return;
|
||||
|
||||
rtnl_lock();
|
||||
for_each_net(net) {
|
||||
int deleted = del_timer_sync(&net->ipv4.rt_secret_timer);
|
||||
long time;
|
||||
|
||||
if (!new)
|
||||
continue;
|
||||
|
||||
if (deleted) {
|
||||
time = net->ipv4.rt_secret_timer.expires - jiffies;
|
||||
|
||||
if (time <= 0 || (time += diff) <= 0)
|
||||
time = 0;
|
||||
} else
|
||||
time = new;
|
||||
|
||||
mod_timer(&net->ipv4.rt_secret_timer, jiffies + time);
|
||||
}
|
||||
rtnl_unlock();
|
||||
}
|
||||
|
||||
static int ipv4_sysctl_rt_secret_interval(ctl_table *ctl, int write,
|
||||
void __user *buffer, size_t *lenp,
|
||||
loff_t *ppos)
|
||||
{
|
||||
int old = ip_rt_secret_interval;
|
||||
int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
|
||||
|
||||
rt_secret_reschedule(old);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ctl_table ipv4_route_table[] = {
|
||||
{
|
||||
.procname = "gc_thresh",
|
||||
|
|
@ -3252,13 +3187,6 @@ static ctl_table ipv4_route_table[] = {
|
|||
.mode = 0644,
|
||||
.proc_handler = proc_dointvec,
|
||||
},
|
||||
{
|
||||
.procname = "secret_interval",
|
||||
.data = &ip_rt_secret_interval,
|
||||
.maxlen = sizeof(int),
|
||||
.mode = 0644,
|
||||
.proc_handler = ipv4_sysctl_rt_secret_interval,
|
||||
},
|
||||
{ }
|
||||
};
|
||||
|
||||
|
|
@ -3337,34 +3265,15 @@ static __net_initdata struct pernet_operations sysctl_route_ops = {
|
|||
};
|
||||
#endif
|
||||
|
||||
|
||||
static __net_init int rt_secret_timer_init(struct net *net)
|
||||
static __net_init int rt_genid_init(struct net *net)
|
||||
{
|
||||
atomic_set(&net->ipv4.rt_genid,
|
||||
(int) ((num_physpages ^ (num_physpages>>8)) ^
|
||||
(jiffies ^ (jiffies >> 7))));
|
||||
|
||||
net->ipv4.rt_secret_timer.function = rt_secret_rebuild;
|
||||
net->ipv4.rt_secret_timer.data = (unsigned long)net;
|
||||
init_timer_deferrable(&net->ipv4.rt_secret_timer);
|
||||
|
||||
if (ip_rt_secret_interval) {
|
||||
net->ipv4.rt_secret_timer.expires =
|
||||
jiffies + net_random() % ip_rt_secret_interval +
|
||||
ip_rt_secret_interval;
|
||||
add_timer(&net->ipv4.rt_secret_timer);
|
||||
}
|
||||
get_random_bytes(&net->ipv4.rt_genid,
|
||||
sizeof(net->ipv4.rt_genid));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __net_exit void rt_secret_timer_exit(struct net *net)
|
||||
{
|
||||
del_timer_sync(&net->ipv4.rt_secret_timer);
|
||||
}
|
||||
|
||||
static __net_initdata struct pernet_operations rt_secret_timer_ops = {
|
||||
.init = rt_secret_timer_init,
|
||||
.exit = rt_secret_timer_exit,
|
||||
static __net_initdata struct pernet_operations rt_genid_ops = {
|
||||
.init = rt_genid_init,
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -3425,9 +3334,6 @@ int __init ip_rt_init(void)
|
|||
schedule_delayed_work(&expires_work,
|
||||
net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
|
||||
|
||||
if (register_pernet_subsys(&rt_secret_timer_ops))
|
||||
printk(KERN_ERR "Unable to setup rt_secret_timer\n");
|
||||
|
||||
if (ip_rt_proc_init())
|
||||
printk(KERN_ERR "Unable to create route proc files\n");
|
||||
#ifdef CONFIG_XFRM
|
||||
|
|
@ -3439,6 +3345,7 @@ int __init ip_rt_init(void)
|
|||
#ifdef CONFIG_SYSCTL
|
||||
register_pernet_subsys(&sysctl_route_ops);
|
||||
#endif
|
||||
register_pernet_subsys(&rt_genid_ops);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -378,7 +378,7 @@ unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
|
|||
struct sock *sk = sock->sk;
|
||||
struct tcp_sock *tp = tcp_sk(sk);
|
||||
|
||||
sock_poll_wait(file, sk->sk_sleep, wait);
|
||||
sock_poll_wait(file, sk_sleep(sk), wait);
|
||||
if (sk->sk_state == TCP_LISTEN)
|
||||
return inet_csk_listen_poll(sk);
|
||||
|
||||
|
|
@ -2298,7 +2298,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level,
|
|||
if (sock_flag(sk, SOCK_KEEPOPEN) &&
|
||||
!((1 << sk->sk_state) &
|
||||
(TCPF_CLOSE | TCPF_LISTEN))) {
|
||||
__u32 elapsed = tcp_time_stamp - tp->rcv_tstamp;
|
||||
u32 elapsed = keepalive_time_elapsed(tp);
|
||||
if (tp->keepalive_time > elapsed)
|
||||
elapsed = tp->keepalive_time - elapsed;
|
||||
else
|
||||
|
|
@ -2721,7 +2721,7 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
|
|||
struct tcphdr *th2;
|
||||
unsigned int len;
|
||||
unsigned int thlen;
|
||||
unsigned int flags;
|
||||
__be32 flags;
|
||||
unsigned int mss = 1;
|
||||
unsigned int hlen;
|
||||
unsigned int off;
|
||||
|
|
@ -2771,10 +2771,10 @@ struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
|
|||
|
||||
found:
|
||||
flush = NAPI_GRO_CB(p)->flush;
|
||||
flush |= flags & TCP_FLAG_CWR;
|
||||
flush |= (flags ^ tcp_flag_word(th2)) &
|
||||
~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH);
|
||||
flush |= th->ack_seq ^ th2->ack_seq;
|
||||
flush |= (__force int)(flags & TCP_FLAG_CWR);
|
||||
flush |= (__force int)((flags ^ tcp_flag_word(th2)) &
|
||||
~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH));
|
||||
flush |= (__force int)(th->ack_seq ^ th2->ack_seq);
|
||||
for (i = sizeof(*th); i < thlen; i += 4)
|
||||
flush |= *(u32 *)((u8 *)th + i) ^
|
||||
*(u32 *)((u8 *)th2 + i);
|
||||
|
|
@ -2795,8 +2795,9 @@ found:
|
|||
|
||||
out_check_final:
|
||||
flush = len < mss;
|
||||
flush |= flags & (TCP_FLAG_URG | TCP_FLAG_PSH | TCP_FLAG_RST |
|
||||
TCP_FLAG_SYN | TCP_FLAG_FIN);
|
||||
flush |= (__force int)(flags & (TCP_FLAG_URG | TCP_FLAG_PSH |
|
||||
TCP_FLAG_RST | TCP_FLAG_SYN |
|
||||
TCP_FLAG_FIN));
|
||||
|
||||
if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
|
||||
pp = head;
|
||||
|
|
|
|||
|
|
@ -4367,6 +4367,7 @@ static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
|
|||
if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq)
|
||||
goto drop;
|
||||
|
||||
skb_dst_drop(skb);
|
||||
__skb_pull(skb, th->doff * 4);
|
||||
|
||||
TCP_ECN_accept_cwr(tp, skb);
|
||||
|
|
|
|||
|
|
@ -1286,8 +1286,8 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
|
|||
goto drop_and_release;
|
||||
|
||||
/* Secret recipe starts with IP addresses */
|
||||
*mess++ ^= daddr;
|
||||
*mess++ ^= saddr;
|
||||
*mess++ ^= (__force u32)daddr;
|
||||
*mess++ ^= (__force u32)saddr;
|
||||
|
||||
/* plus variable length Initiator Cookie */
|
||||
c = (u8 *)mess;
|
||||
|
|
@ -1672,7 +1672,7 @@ process:
|
|||
|
||||
skb->dev = NULL;
|
||||
|
||||
inet_rps_save_rxhash(sk, skb->rxhash);
|
||||
sock_rps_save_rxhash(sk, skb->rxhash);
|
||||
|
||||
bh_lock_sock_nested(sk);
|
||||
ret = 0;
|
||||
|
|
|
|||
|
|
@ -861,7 +861,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
|
|||
th->urg_ptr = htons(tp->snd_up - tcb->seq);
|
||||
th->urg = 1;
|
||||
} else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
|
||||
th->urg_ptr = 0xFFFF;
|
||||
th->urg_ptr = htons(0xFFFF);
|
||||
th->urg = 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -888,7 +888,8 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
|
|||
tcp_event_data_sent(tp, skb, sk);
|
||||
|
||||
if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
|
||||
TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
|
||||
TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
|
||||
tcp_skb_pcount(skb));
|
||||
|
||||
err = icsk->icsk_af_ops->queue_xmit(skb);
|
||||
if (likely(err <= 0))
|
||||
|
|
@ -2485,7 +2486,7 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
|
|||
*tail-- ^= TCP_SKB_CB(skb)->seq + 1;
|
||||
|
||||
/* recommended */
|
||||
*tail-- ^= ((th->dest << 16) | th->source);
|
||||
*tail-- ^= (((__force u32)th->dest << 16) | (__force u32)th->source);
|
||||
*tail-- ^= (u32)(unsigned long)cvp; /* per sockopt */
|
||||
|
||||
sha_transform((__u32 *)&xvp->cookie_bakery[0],
|
||||
|
|
@ -2503,7 +2504,7 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
|
|||
th->window = htons(min(req->rcv_wnd, 65535U));
|
||||
tcp_options_write((__be32 *)(th + 1), tp, &opts);
|
||||
th->doff = (tcp_header_size >> 2);
|
||||
TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
|
||||
TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS, tcp_skb_pcount(skb));
|
||||
|
||||
#ifdef CONFIG_TCP_MD5SIG
|
||||
/* Okay, we have all we need - do the md5 hash if needed */
|
||||
|
|
|
|||
|
|
@ -517,7 +517,7 @@ static void tcp_keepalive_timer (unsigned long data)
|
|||
struct sock *sk = (struct sock *) data;
|
||||
struct inet_connection_sock *icsk = inet_csk(sk);
|
||||
struct tcp_sock *tp = tcp_sk(sk);
|
||||
__u32 elapsed;
|
||||
u32 elapsed;
|
||||
|
||||
/* Only process if socket is not in use. */
|
||||
bh_lock_sock(sk);
|
||||
|
|
@ -554,7 +554,7 @@ static void tcp_keepalive_timer (unsigned long data)
|
|||
if (tp->packets_out || tcp_send_head(sk))
|
||||
goto resched;
|
||||
|
||||
elapsed = tcp_time_stamp - tp->rcv_tstamp;
|
||||
elapsed = keepalive_time_elapsed(tp);
|
||||
|
||||
if (elapsed >= keepalive_time_when(tp)) {
|
||||
if (icsk->icsk_probes_out >= keepalive_probes(tp)) {
|
||||
|
|
|
|||
|
|
@ -307,13 +307,13 @@ static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
|
|||
static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
|
||||
unsigned int port)
|
||||
{
|
||||
return jhash_1word(saddr, net_hash_mix(net)) ^ port;
|
||||
return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
|
||||
}
|
||||
|
||||
int udp_v4_get_port(struct sock *sk, unsigned short snum)
|
||||
{
|
||||
unsigned int hash2_nulladdr =
|
||||
udp4_portaddr_hash(sock_net(sk), INADDR_ANY, snum);
|
||||
udp4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
|
||||
unsigned int hash2_partial =
|
||||
udp4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
|
||||
|
||||
|
|
@ -466,14 +466,14 @@ static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
|
|||
daddr, hnum, dif,
|
||||
hslot2, slot2);
|
||||
if (!result) {
|
||||
hash2 = udp4_portaddr_hash(net, INADDR_ANY, hnum);
|
||||
hash2 = udp4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
|
||||
slot2 = hash2 & udptable->mask;
|
||||
hslot2 = &udptable->hash2[slot2];
|
||||
if (hslot->count < hslot2->count)
|
||||
goto begin;
|
||||
|
||||
result = udp4_lib_lookup2(net, saddr, sport,
|
||||
INADDR_ANY, hnum, dif,
|
||||
htonl(INADDR_ANY), hnum, dif,
|
||||
hslot2, slot2);
|
||||
}
|
||||
rcu_read_unlock();
|
||||
|
|
@ -1062,10 +1062,10 @@ static unsigned int first_packet_length(struct sock *sk)
|
|||
spin_unlock_bh(&rcvq->lock);
|
||||
|
||||
if (!skb_queue_empty(&list_kill)) {
|
||||
lock_sock(sk);
|
||||
lock_sock_bh(sk);
|
||||
__skb_queue_purge(&list_kill);
|
||||
sk_mem_reclaim_partial(sk);
|
||||
release_sock(sk);
|
||||
unlock_sock_bh(sk);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
|
@ -1196,10 +1196,10 @@ out:
|
|||
return err;
|
||||
|
||||
csum_copy_err:
|
||||
lock_sock(sk);
|
||||
lock_sock_bh(sk);
|
||||
if (!skb_kill_datagram(sk, skb, flags))
|
||||
UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
|
||||
release_sock(sk);
|
||||
unlock_sock_bh(sk);
|
||||
|
||||
if (noblock)
|
||||
return -EAGAIN;
|
||||
|
|
@ -1217,7 +1217,7 @@ int udp_disconnect(struct sock *sk, int flags)
|
|||
sk->sk_state = TCP_CLOSE;
|
||||
inet->inet_daddr = 0;
|
||||
inet->inet_dport = 0;
|
||||
inet_rps_save_rxhash(sk, 0);
|
||||
sock_rps_save_rxhash(sk, 0);
|
||||
sk->sk_bound_dev_if = 0;
|
||||
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
|
||||
inet_reset_saddr(sk);
|
||||
|
|
@ -1262,9 +1262,9 @@ static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
|
|||
int rc;
|
||||
|
||||
if (inet_sk(sk)->inet_daddr)
|
||||
inet_rps_save_rxhash(sk, skb->rxhash);
|
||||
sock_rps_save_rxhash(sk, skb->rxhash);
|
||||
|
||||
rc = sock_queue_rcv_skb(sk, skb);
|
||||
rc = ip_queue_rcv_skb(sk, skb);
|
||||
if (rc < 0) {
|
||||
int is_udplite = IS_UDPLITE(sk);
|
||||
|
||||
|
|
@ -1372,6 +1372,10 @@ int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
|
|||
goto drop;
|
||||
}
|
||||
|
||||
|
||||
if (sk_rcvqueues_full(sk, skb))
|
||||
goto drop;
|
||||
|
||||
rc = 0;
|
||||
|
||||
bh_lock_sock(sk);
|
||||
|
|
@ -1620,9 +1624,9 @@ int udp_rcv(struct sk_buff *skb)
|
|||
|
||||
void udp_destroy_sock(struct sock *sk)
|
||||
{
|
||||
lock_sock(sk);
|
||||
lock_sock_bh(sk);
|
||||
udp_flush_pending_frames(sk);
|
||||
release_sock(sk);
|
||||
unlock_sock_bh(sk);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
Loading…
Reference in a new issue