7 files changed, 444 insertions, 141 deletions

diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index 4f33bbc21e7f..89809891e5ab 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -65,11 +65,10 @@ struct neighbour;
 
 struct neigh_parms
 {
+        struct net_device *dev;
         struct neigh_parms *next;
         int     (*neigh_setup)(struct neighbour *);
         struct neigh_table *tbl;
-        int     entries;
-        void    *priv;
 
         void    *sysctl_table;
 
@@ -192,7 +191,6 @@ struct neigh_table
         atomic_t                entries;
         rwlock_t                lock;
         unsigned long           last_rand;
-        struct neigh_parms      *parms_list;
         kmem_cache_t            *kmem_cachep;
         struct neigh_statistics *stats;
         struct neighbour        **hash_buckets;
@@ -252,6 +250,9 @@ extern int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
 extern int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
 extern void neigh_app_ns(struct neighbour *n);
 
+extern int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb);
+extern int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
+
 extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
 extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
 extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
new file mode 100644
index 000000000000..72fd6f5e86b1
--- /dev/null
+++ b/include/net/request_sock.h
@@ -0,0 +1,255 @@
+/*
+ * NET          Generic infrastructure for Network protocols.
+ *
+ *              Definitions for request_sock 
+ *
+ * Authors:     Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *
+ *              From code originally in include/net/tcp.h
+ *
+ *              This program is free software; you can redistribute it and/or
+ *              modify it under the terms of the GNU General Public License
+ *              as published by the Free Software Foundation; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _REQUEST_SOCK_H
+#define _REQUEST_SOCK_H
+
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <net/sock.h>
+
+struct request_sock;
+struct sk_buff;
+struct dst_entry;
+struct proto;
+
+struct request_sock_ops {
+        int             family;
+        kmem_cache_t    *slab;
+        int             obj_size;
+        int             (*rtx_syn_ack)(struct sock *sk,
+                                       struct request_sock *req,
+                                       struct dst_entry *dst);
+        void            (*send_ack)(struct sk_buff *skb,
+                                    struct request_sock *req);
+        void            (*send_reset)(struct sk_buff *skb);
+        void            (*destructor)(struct request_sock *req);
+};
+
+/* struct request_sock - mini sock to represent a connection request
+ */
+struct request_sock {
+        struct request_sock             *dl_next; /* Must be first member! */
+        u16                             mss;
+        u8                              retrans;
+        u8                              __pad;
+        /* The following two fields can be easily recomputed I think -AK */
+        u32                             window_clamp; /* window clamp at creation time */
+        u32                             rcv_wnd;          /* rcv_wnd offered first time */
+        u32                             ts_recent;
+        unsigned long                   expires;
+        struct request_sock_ops         *rsk_ops;
+        struct sock                     *sk;
+};
+
+static inline struct request_sock *reqsk_alloc(struct request_sock_ops *ops)
+{
+        struct request_sock *req = kmem_cache_alloc(ops->slab, SLAB_ATOMIC);
+
+        if (req != NULL)
+                req->rsk_ops = ops;
+
+        return req;
+}
+
+static inline void __reqsk_free(struct request_sock *req)
+{
+        kmem_cache_free(req->rsk_ops->slab, req);
+}
+
+static inline void reqsk_free(struct request_sock *req)
+{
+        req->rsk_ops->destructor(req);
+        __reqsk_free(req);
+}
+
+extern int sysctl_max_syn_backlog;
+
+/** struct listen_sock - listen state
+ *
+ * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs
+ */
+struct listen_sock {
+        u8                      max_qlen_log;
+        /* 3 bytes hole, try to use */
+        int                     qlen;
+        int                     qlen_young;
+        int                     clock_hand;
+        u32                     hash_rnd;
+        struct request_sock     *syn_table[0];
+};
+
+/** struct request_sock_queue - queue of request_socks
+ *
+ * @rskq_accept_head - FIFO head of established children
+ * @rskq_accept_tail - FIFO tail of established children
+ * @syn_wait_lock - serializer
+ *
+ * %syn_wait_lock is necessary only to avoid proc interface having to grab the main
+ * lock sock while browsing the listening hash (otherwise it's deadlock prone).
+ *
+ * This lock is acquired in read mode only from listening_get_next() seq_file
+ * op and it's acquired in write mode _only_ from code that is actively
+ * changing rskq_accept_head. All readers that are holding the master sock lock
+ * don't need to grab this lock in read mode too as rskq_accept_head. writes
+ * are always protected from the main sock lock.
+ */
+struct request_sock_queue {
+        struct request_sock     *rskq_accept_head;
+        struct request_sock     *rskq_accept_tail;
+        rwlock_t                syn_wait_lock;
+        struct listen_sock      *listen_opt;
+};
+
+extern int reqsk_queue_alloc(struct request_sock_queue *queue,
+                             const int nr_table_entries);
+
+static inline struct listen_sock *reqsk_queue_yank_listen_sk(struct request_sock_queue *queue)
+{
+        struct listen_sock *lopt;
+
+        write_lock_bh(&queue->syn_wait_lock);
+        lopt = queue->listen_opt;
+        queue->listen_opt = NULL;
+        write_unlock_bh(&queue->syn_wait_lock);
+
+        return lopt;
+}
+
+static inline void reqsk_queue_destroy(struct request_sock_queue *queue)
+{
+        kfree(reqsk_queue_yank_listen_sk(queue));
+}
+
+static inline struct request_sock *
+        reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
+{
+        struct request_sock *req = queue->rskq_accept_head;
+
+        queue->rskq_accept_head = queue->rskq_accept_head = NULL;
+        return req;
+}
+
+static inline int reqsk_queue_empty(struct request_sock_queue *queue)
+{
+        return queue->rskq_accept_head == NULL;
+}
+
+static inline void reqsk_queue_unlink(struct request_sock_queue *queue,
+                                      struct request_sock *req,
+                                      struct request_sock **prev_req)
+{
+        write_lock(&queue->syn_wait_lock);
+        *prev_req = req->dl_next;
+        write_unlock(&queue->syn_wait_lock);
+}
+
+static inline void reqsk_queue_add(struct request_sock_queue *queue,
+                                   struct request_sock *req,
+                                   struct sock *parent,
+                                   struct sock *child)
+{
+        req->sk = child;
+        sk_acceptq_added(parent);
+
+        if (queue->rskq_accept_head == NULL)
+                queue->rskq_accept_head = req;
+        else
+                queue->rskq_accept_tail->dl_next = req;
+
+        queue->rskq_accept_tail = req;
+        req->dl_next = NULL;
+}
+
+static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
+{
+        struct request_sock *req = queue->rskq_accept_head;
+
+        BUG_TRAP(req != NULL);
+
+        queue->rskq_accept_head = req->dl_next;
+        if (queue->rskq_accept_head == NULL)
+                queue->rskq_accept_tail = NULL;
+
+        return req;
+}
+
+static inline struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
+                                                 struct sock *parent)
+{
+        struct request_sock *req = reqsk_queue_remove(queue);
+        struct sock *child = req->sk;
+
+        BUG_TRAP(child != NULL);
+
+        sk_acceptq_removed(parent);
+        __reqsk_free(req);
+        return child;
+}
+
+static inline int reqsk_queue_removed(struct request_sock_queue *queue,
+                                      struct request_sock *req)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+
+        if (req->retrans == 0)
+                --lopt->qlen_young;
+
+        return --lopt->qlen;
+}
+
+static inline int reqsk_queue_added(struct request_sock_queue *queue)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+        const int prev_qlen = lopt->qlen;
+
+        lopt->qlen_young++;
+        lopt->qlen++;
+        return prev_qlen;
+}
+
+static inline int reqsk_queue_len(struct request_sock_queue *queue)
+{
+        return queue->listen_opt != NULL ? queue->listen_opt->qlen : 0;
+}
+
+static inline int reqsk_queue_len_young(struct request_sock_queue *queue)
+{
+        return queue->listen_opt->qlen_young;
+}
+
+static inline int reqsk_queue_is_full(struct request_sock_queue *queue)
+{
+        return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
+}
+
+static inline void reqsk_queue_hash_req(struct request_sock_queue *queue,
+                                        u32 hash, struct request_sock *req,
+                                        unsigned timeout)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+
+        req->expires = jiffies + timeout;
+        req->retrans = 0;
+        req->sk = NULL;
+        req->dl_next = lopt->syn_table[hash];
+
+        write_lock(&queue->syn_wait_lock);
+        lopt->syn_table[hash] = req;
+        write_unlock(&queue->syn_wait_lock);
+}
+
+#endif /* _REQUEST_SOCK_H */
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index c57504b3b518..7b97405e2dbf 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -172,4 +172,126 @@ tcf_destroy(struct tcf_proto *tp)
         kfree(tp);
 }
 
+static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
+                                       struct sk_buff_head *list)
+{
+        __skb_queue_tail(list, skb);
+        sch->qstats.backlog += skb->len;
+        sch->bstats.bytes += skb->len;
+        sch->bstats.packets++;
+
+        return NET_XMIT_SUCCESS;
+}
+
+static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
+{
+        return __qdisc_enqueue_tail(skb, sch, &sch->q);
+}
+
+static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
+                                                   struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __skb_dequeue(list);
+
+        if (likely(skb != NULL))
+                sch->qstats.backlog -= skb->len;
+
+        return skb;
+}
+
+static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
+{
+        return __qdisc_dequeue_head(sch, &sch->q);
+}
+
+static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
+                                                   struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __skb_dequeue_tail(list);
+
+        if (likely(skb != NULL))
+                sch->qstats.backlog -= skb->len;
+
+        return skb;
+}
+
+static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)
+{
+        return __qdisc_dequeue_tail(sch, &sch->q);
+}
+
+static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
+                                  struct sk_buff_head *list)
+{
+        __skb_queue_head(list, skb);
+        sch->qstats.backlog += skb->len;
+        sch->qstats.requeues++;
+
+        return NET_XMIT_SUCCESS;
+}
+
+static inline int qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch)
+{
+        return __qdisc_requeue(skb, sch, &sch->q);
+}
+
+static inline void __qdisc_reset_queue(struct Qdisc *sch,
+                                       struct sk_buff_head *list)
+{
+        /*
+         * We do not know the backlog in bytes of this list, it
+         * is up to the caller to correct it
+         */
+        skb_queue_purge(list);
+}
+
+static inline void qdisc_reset_queue(struct Qdisc *sch)
+{
+        __qdisc_reset_queue(sch, &sch->q);
+        sch->qstats.backlog = 0;
+}
+
+static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,
+                                              struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);
+
+        if (likely(skb != NULL)) {
+                unsigned int len = skb->len;
+                kfree_skb(skb);
+                return len;
+        }
+
+        return 0;
+}
+
+static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)
+{
+        return __qdisc_queue_drop(sch, &sch->q);
+}
+
+static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
+{
+        kfree_skb(skb);
+        sch->qstats.drops++;
+
+        return NET_XMIT_DROP;
+}
+
+static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)
+{
+        sch->qstats.drops++;
+
+#ifdef CONFIG_NET_CLS_POLICE
+        if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))
+                goto drop;
+
+        return NET_XMIT_SUCCESS;
+
+drop:
+#endif
+        kfree_skb(skb);
+        return NET_XMIT_DROP;
+}
+
 #endif
diff --git a/include/net/sock.h b/include/net/sock.h
index a9ef3a6a13f3..e593af5b1ecc 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -484,6 +484,8 @@ extern void sk_stream_kill_queues(struct sock *sk);
 
 extern int sk_wait_data(struct sock *sk, long *timeo);
 
+struct request_sock_ops;
+
 /* Networking protocol blocks we attach to sockets.
  * socket layer -> transport layer interface
  * transport -> network interface is defined by struct inet_proto
@@ -547,6 +549,8 @@ struct proto {
         kmem_cache_t            *slab;
         unsigned int            obj_size;
 
+        struct request_sock_ops *rsk_prot;
+
         struct module           *owner;
 
         char                    name[32];
diff --git a/include/net/tcp.h b/include/net/tcp.h
index e71f8ba3e101..f730935b824a 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -31,6 +31,7 @@
 #include <linux/cache.h>
 #include <linux/percpu.h>
 #include <net/checksum.h>
+#include <net/request_sock.h>
 #include <net/sock.h>
 #include <net/snmp.h>
 #include <net/ip.h>
@@ -563,7 +564,6 @@ static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
 #define TCP_NAGLE_PUSH          4       /* Cork is overriden for already queued data */
 
 /* sysctl variables for tcp */
-extern int sysctl_max_syn_backlog;
 extern int sysctl_tcp_timestamps;
 extern int sysctl_tcp_window_scaling;
 extern int sysctl_tcp_sack;
@@ -613,74 +613,6 @@ extern atomic_t tcp_memory_allocated;
 extern atomic_t tcp_sockets_allocated;
 extern int tcp_memory_pressure;
 
-struct open_request;
-
-struct or_calltable {
-        int  family;
-        int  (*rtx_syn_ack)     (struct sock *sk, struct open_request *req, struct dst_entry*);
-        void (*send_ack)        (struct sk_buff *skb, struct open_request *req);
-        void (*destructor)      (struct open_request *req);
-        void (*send_reset)      (struct sk_buff *skb);
-};
-
-struct tcp_v4_open_req {
-        __u32                   loc_addr;
-        __u32                   rmt_addr;
-        struct ip_options       *opt;
-};
-
-#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
-struct tcp_v6_open_req {
-        struct in6_addr         loc_addr;
-        struct in6_addr         rmt_addr;
-        struct sk_buff          *pktopts;
-        int                     iif;
-};
-#endif
-
-/* this structure is too big */
-struct open_request {
-        struct open_request     *dl_next; /* Must be first member! */
-        __u32                   rcv_isn;
-        __u32                   snt_isn;
-        __u16                   rmt_port;
-        __u16                   mss;
-        __u8                    retrans;
-        __u8                    __pad;
-        __u16   snd_wscale : 4, 
-                rcv_wscale : 4, 
-                tstamp_ok : 1,
-                sack_ok : 1,
-                wscale_ok : 1,
-                ecn_ok : 1,
-                acked : 1;
-        /* The following two fields can be easily recomputed I think -AK */
-        __u32                   window_clamp;   /* window clamp at creation time */
-        __u32                   rcv_wnd;        /* rcv_wnd offered first time */
-        __u32                   ts_recent;
-        unsigned long           expires;
-        struct or_calltable     *class;
-        struct sock             *sk;
-        union {
-                struct tcp_v4_open_req v4_req;
-#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
-                struct tcp_v6_open_req v6_req;
-#endif
-        } af;
-};
-
-/* SLAB cache for open requests. */
-extern kmem_cache_t *tcp_openreq_cachep;
-
-#define tcp_openreq_alloc()             kmem_cache_alloc(tcp_openreq_cachep, SLAB_ATOMIC)
-#define tcp_openreq_fastfree(req)       kmem_cache_free(tcp_openreq_cachep, req)
-
-static inline void tcp_openreq_free(struct open_request *req)
-{
-        req->class->destructor(req);
-        tcp_openreq_fastfree(req);
-}
-
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 #define TCP_INET_FAMILY(fam) ((fam) == AF_INET)
 #else
@@ -708,7 +640,7 @@ struct tcp_func {
 
         struct sock *           (*syn_recv_sock)        (struct sock *sk,
                                                          struct sk_buff *skb,
-                                                         struct open_request *req,
+                                                         struct request_sock *req,
                                                          struct dst_entry *dst);
     
         int                     (*remember_stamp)       (struct sock *sk);
@@ -852,8 +784,8 @@ extern enum tcp_tw_status	tcp_timewait_state_process(struct tcp_tw_bucket *tw,
                                                            unsigned len);
 
 extern struct sock *            tcp_check_req(struct sock *sk,struct sk_buff *skb,
-                                              struct open_request *req,
-                                              struct open_request **prev);
+                                              struct request_sock *req,
+                                              struct request_sock **prev);
 extern int                      tcp_child_process(struct sock *parent,
                                                   struct sock *child,
                                                   struct sk_buff *skb);
@@ -903,12 +835,12 @@ extern int			tcp_v4_conn_request(struct sock *sk,
                                                     struct sk_buff *skb);
 
 extern struct sock *            tcp_create_openreq_child(struct sock *sk,
-                                                         struct open_request *req,
+                                                         struct request_sock *req,
                                                          struct sk_buff *skb);
 
 extern struct sock *            tcp_v4_syn_recv_sock(struct sock *sk,
                                                      struct sk_buff *skb,
-                                                     struct open_request *req,
+                                                     struct request_sock *req,
                                                         struct dst_entry *dst);
 
 extern int                      tcp_v4_do_rcv(struct sock *sk,
@@ -922,7 +854,7 @@ extern int			tcp_connect(struct sock *sk);
 
 extern struct sk_buff *         tcp_make_synack(struct sock *sk,
                                                 struct dst_entry *dst,
-                                                struct open_request *req);
+                                                struct request_sock *req);
 
 extern int                      tcp_disconnect(struct sock *sk, int flags);
 
@@ -1750,99 +1682,71 @@ static inline int tcp_full_space(const struct sock *sk)
         return tcp_win_from_space(sk->sk_rcvbuf); 
 }
 
-static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req,
+static inline void tcp_acceptq_queue(struct sock *sk, struct request_sock *req,
                                          struct sock *child)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
-
-        req->sk = child;
-        sk_acceptq_added(sk);
-
-        if (!tp->accept_queue_tail) {
-                tp->accept_queue = req;
-        } else {
-                tp->accept_queue_tail->dl_next = req;
-        }
-        tp->accept_queue_tail = req;
-        req->dl_next = NULL;
+        reqsk_queue_add(&tcp_sk(sk)->accept_queue, req, sk, child);
 }
 
-struct tcp_listen_opt
-{
-        u8                      max_qlen_log;   /* log_2 of maximal queued SYNs */
-        int                     qlen;
-        int                     qlen_young;
-        int                     clock_hand;
-        u32                     hash_rnd;
-        struct open_request     *syn_table[TCP_SYNQ_HSIZE];
-};
-
 static inline void
-tcp_synq_removed(struct sock *sk, struct open_request *req)
+tcp_synq_removed(struct sock *sk, struct request_sock *req)
 {
-        struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt;
-
-        if (--lopt->qlen == 0)
+        if (reqsk_queue_removed(&tcp_sk(sk)->accept_queue, req) == 0)
                 tcp_delete_keepalive_timer(sk);
-        if (req->retrans == 0)
-                lopt->qlen_young--;
 }
 
 static inline void tcp_synq_added(struct sock *sk)
 {
-        struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt;
-
-        if (lopt->qlen++ == 0)
+        if (reqsk_queue_added(&tcp_sk(sk)->accept_queue) == 0)
                 tcp_reset_keepalive_timer(sk, TCP_TIMEOUT_INIT);
-        lopt->qlen_young++;
 }
 
 static inline int tcp_synq_len(struct sock *sk)
 {
-        return tcp_sk(sk)->listen_opt->qlen;
+        return reqsk_queue_len(&tcp_sk(sk)->accept_queue);
 }
 
 static inline int tcp_synq_young(struct sock *sk)
 {
-        return tcp_sk(sk)->listen_opt->qlen_young;
+        return reqsk_queue_len_young(&tcp_sk(sk)->accept_queue);
 }
 
 static inline int tcp_synq_is_full(struct sock *sk)
 {
-        return tcp_synq_len(sk) >> tcp_sk(sk)->listen_opt->max_qlen_log;
+        return reqsk_queue_is_full(&tcp_sk(sk)->accept_queue);
 }
 
-static inline void tcp_synq_unlink(struct tcp_sock *tp, struct open_request *req,
-                                       struct open_request **prev)
+static inline void tcp_synq_unlink(struct tcp_sock *tp, struct request_sock *req,
+                                   struct request_sock **prev)
 {
-        write_lock(&tp->syn_wait_lock);
-        *prev = req->dl_next;
-        write_unlock(&tp->syn_wait_lock);
+        reqsk_queue_unlink(&tp->accept_queue, req, prev);
 }
 
-static inline void tcp_synq_drop(struct sock *sk, struct open_request *req,
-                                     struct open_request **prev)
+static inline void tcp_synq_drop(struct sock *sk, struct request_sock *req,
+                                     struct request_sock **prev)
 {
         tcp_synq_unlink(tcp_sk(sk), req, prev);
         tcp_synq_removed(sk, req);
-        tcp_openreq_free(req);
+        reqsk_free(req);
 }
 
-static __inline__ void tcp_openreq_init(struct open_request *req,
+static __inline__ void tcp_openreq_init(struct request_sock *req,
                                         struct tcp_options_received *rx_opt,
                                         struct sk_buff *skb)
 {
+        struct inet_request_sock *ireq = inet_rsk(req);
+
         req->rcv_wnd = 0;               /* So that tcp_send_synack() knows! */
-        req->rcv_isn = TCP_SKB_CB(skb)->seq;
+        tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
         req->mss = rx_opt->mss_clamp;
         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
-        req->tstamp_ok = rx_opt->tstamp_ok;
-        req->sack_ok = rx_opt->sack_ok;
-        req->snd_wscale = rx_opt->snd_wscale;
-        req->wscale_ok = rx_opt->wscale_ok;
-        req->acked = 0;
-        req->ecn_ok = 0;
-        req->rmt_port = skb->h.th->source;
+        ireq->tstamp_ok = rx_opt->tstamp_ok;
+        ireq->sack_ok = rx_opt->sack_ok;
+        ireq->snd_wscale = rx_opt->snd_wscale;
+        ireq->wscale_ok = rx_opt->wscale_ok;
+        ireq->acked = 0;
+        ireq->ecn_ok = 0;
+        ireq->rmt_port = skb->h.th->source;
 }
 
 extern void tcp_enter_memory_pressure(void);
diff --git a/include/net/tcp_ecn.h b/include/net/tcp_ecn.h
index dc1456389a97..64980ee8c92a 100644
--- a/include/net/tcp_ecn.h
+++ b/include/net/tcp_ecn.h
@@ -2,6 +2,7 @@
 #define _NET_TCP_ECN_H_ 1
 
 #include <net/inet_ecn.h>
+#include <net/request_sock.h>
 
 #define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
 
@@ -38,9 +39,9 @@ static inline void TCP_ECN_send_syn(struct sock *sk, struct tcp_sock *tp,
 }
 
 static __inline__ void
-TCP_ECN_make_synack(struct open_request *req, struct tcphdr *th)
+TCP_ECN_make_synack(struct request_sock *req, struct tcphdr *th)
 {
-        if (req->ecn_ok)
+        if (inet_rsk(req)->ecn_ok)
                 th->ece = 1;
 }
 
@@ -111,16 +112,16 @@ static inline int TCP_ECN_rcv_ecn_echo(struct tcp_sock *tp, struct tcphdr *th)
 }
 
 static inline void TCP_ECN_openreq_child(struct tcp_sock *tp,
-                                         struct open_request *req)
+                                         struct request_sock *req)
 {
-        tp->ecn_flags = req->ecn_ok ? TCP_ECN_OK : 0;
+        tp->ecn_flags = inet_rsk(req)->ecn_ok ? TCP_ECN_OK : 0;
 }
 
 static __inline__ void
-TCP_ECN_create_request(struct open_request *req, struct tcphdr *th)
+TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th)
 {
         if (sysctl_tcp_ecn && th->ece && th->cwr)
-                req->ecn_ok = 1;
+                inet_rsk(req)->ecn_ok = 1;
 }
 
 #endif
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index d675836ba6c3..0e65e02b7a1d 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -158,6 +158,20 @@ enum {
         XFRM_STATE_DEAD
 };
 
+/* callback structure passed from either netlink or pfkey */
+struct km_event
+{
+        union {
+                u32 hard;
+                u32 proto;
+                u32 byid;
+        } data;
+
+        u32     seq;
+        u32     pid;
+        u32     event;
+};
+
 struct xfrm_type;
 struct xfrm_dst;
 struct xfrm_policy_afinfo {
@@ -179,6 +193,8 @@ struct xfrm_policy_afinfo {
 
 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
+extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
+extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
 
 #define XFRM_ACQ_EXPIRES        30
 
@@ -290,11 +306,11 @@ struct xfrm_mgr
 {
         struct list_head        list;
         char                    *id;
-        int                     (*notify)(struct xfrm_state *x, int event);
+        int                     (*notify)(struct xfrm_state *x, struct km_event *c);
         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
         struct xfrm_policy      *(*compile_policy)(u16 family, int opt, u8 *data, int len, int *dir);
         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
-        int                     (*notify_policy)(struct xfrm_policy *x, int dir, int event);
+        int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 };
 
 extern int xfrm_register_km(struct xfrm_mgr *km);
@@ -656,7 +672,7 @@ static inline int xfrm_sk_clone_policy(struct sock *sk)
         return 0;
 }
 
-extern void xfrm_policy_delete(struct xfrm_policy *pol, int dir);
+extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
 
 static inline void xfrm_sk_free_policy(struct sock *sk)
 {
@@ -817,7 +833,7 @@ extern int xfrm_state_add(struct xfrm_state *x);
 extern int xfrm_state_update(struct xfrm_state *x);
 extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family);
 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
-extern void xfrm_state_delete(struct xfrm_state *x);
+extern int xfrm_state_delete(struct xfrm_state *x);
 extern void xfrm_state_flush(u8 proto);
 extern int xfrm_replay_check(struct xfrm_state *x, u32 seq);
 extern void xfrm_replay_advance(struct xfrm_state *x, u32 seq);