Patched in Tegra support.

2 files changed, 221 insertions, 366 deletions

diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index c0353d55d56..0a4db0211da 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -67,8 +67,8 @@
 struct netlink_sock {
         /* struct sock has to be the first member of netlink_sock */
         struct sock             sk;
-        u32                     portid;
-        u32                     dst_portid;
+        u32                     pid;
+        u32                     dst_pid;
         u32                     dst_group;
         u32                     flags;
         u32                     subscriptions;
@@ -80,7 +80,6 @@ struct netlink_sock {
         struct mutex            *cb_mutex;
         struct mutex            cb_def_mutex;
         void                    (*netlink_rcv)(struct sk_buff *skb);
-        void                    (*netlink_bind)(int group);
         struct module           *module;
 };
 
@@ -104,29 +103,28 @@ static inline int netlink_is_kernel(struct sock *sk)
         return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET;
 }
 
-struct nl_portid_hash {
-        struct hlist_head       *table;
-        unsigned long           rehash_time;
+struct nl_pid_hash {
+        struct hlist_head *table;
+        unsigned long rehash_time;
 
-        unsigned int            mask;
-        unsigned int            shift;
+        unsigned int mask;
+        unsigned int shift;
 
-        unsigned int            entries;
-        unsigned int            max_shift;
+        unsigned int entries;
+        unsigned int max_shift;
 
-        u32                     rnd;
+        u32 rnd;
 };
 
 struct netlink_table {
-        struct nl_portid_hash   hash;
-        struct hlist_head       mc_list;
-        struct listeners __rcu  *listeners;
-        unsigned int            flags;
-        unsigned int            groups;
-        struct mutex            *cb_mutex;
-        struct module           *module;
-        void                    (*bind)(int group);
-        int                     registered;
+        struct nl_pid_hash hash;
+        struct hlist_head mc_list;
+        struct listeners __rcu *listeners;
+        unsigned int nl_nonroot;
+        unsigned int groups;
+        struct mutex *cb_mutex;
+        struct module *module;
+        int registered;
 };
 
 static struct netlink_table *nl_table;
@@ -134,34 +132,21 @@ static struct netlink_table *nl_table;
 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
 
 static int netlink_dump(struct sock *sk);
+static void netlink_destroy_callback(struct netlink_callback *cb);
 
 static DEFINE_RWLOCK(nl_table_lock);
 static atomic_t nl_table_users = ATOMIC_INIT(0);
 
-#define nl_deref_protected(X) rcu_dereference_protected(X, lockdep_is_held(&nl_table_lock));
-
 static ATOMIC_NOTIFIER_HEAD(netlink_chain);
 
-static inline u32 netlink_group_mask(u32 group)
+static u32 netlink_group_mask(u32 group)
 {
         return group ? 1 << (group - 1) : 0;
 }
 
-static inline struct hlist_head *nl_portid_hashfn(struct nl_portid_hash *hash, u32 portid)
-{
-        return &hash->table[jhash_1word(portid, hash->rnd) & hash->mask];
-}
-
-static void netlink_destroy_callback(struct netlink_callback *cb)
-{
-        kfree_skb(cb->skb);
-        kfree(cb);
-}
-
-static void netlink_consume_callback(struct netlink_callback *cb)
+static struct hlist_head *nl_pid_hashfn(struct nl_pid_hash *hash, u32 pid)
 {
-        consume_skb(cb->skb);
-        kfree(cb);
+        return &hash->table[jhash_1word(pid, hash->rnd) & hash->mask];
 }
 
 static void netlink_sock_destruct(struct sock *sk)
@@ -171,8 +156,6 @@ static void netlink_sock_destruct(struct sock *sk)
         if (nlk->cb) {
                 if (nlk->cb->done)
                         nlk->cb->done(nlk->cb);
-
-                module_put(nlk->cb->module);
                 netlink_destroy_callback(nlk->cb);
         }
 
@@ -243,17 +226,18 @@ netlink_unlock_table(void)
                 wake_up(&nl_table_wait);
 }
 
-static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid)
+static inline struct sock *netlink_lookup(struct net *net, int protocol,
+                                          u32 pid)
 {
-        struct nl_portid_hash *hash = &nl_table[protocol].hash;
+        struct nl_pid_hash *hash = &nl_table[protocol].hash;
         struct hlist_head *head;
         struct sock *sk;
         struct hlist_node *node;
 
         read_lock(&nl_table_lock);
-        head = nl_portid_hashfn(hash, portid);
+        head = nl_pid_hashfn(hash, pid);
         sk_for_each(sk, node, head) {
-                if (net_eq(sock_net(sk), net) && (nlk_sk(sk)->portid == portid)) {
+                if (net_eq(sock_net(sk), net) && (nlk_sk(sk)->pid == pid)) {
                         sock_hold(sk);
                         goto found;
                 }
@@ -264,7 +248,7 @@ found:
         return sk;
 }
 
-static struct hlist_head *nl_portid_hash_zalloc(size_t size)
+static inline struct hlist_head *nl_pid_hash_zalloc(size_t size)
 {
         if (size <= PAGE_SIZE)
                 return kzalloc(size, GFP_ATOMIC);
@@ -274,7 +258,7 @@ static struct hlist_head *nl_portid_hash_zalloc(size_t size)
                                          get_order(size));
 }
 
-static void nl_portid_hash_free(struct hlist_head *table, size_t size)
+static inline void nl_pid_hash_free(struct hlist_head *table, size_t size)
 {
         if (size <= PAGE_SIZE)
                 kfree(table);
@@ -282,7 +266,7 @@ static void nl_portid_hash_free(struct hlist_head *table, size_t size)
                 free_pages((unsigned long)table, get_order(size));
 }
 
-static int nl_portid_hash_rehash(struct nl_portid_hash *hash, int grow)
+static int nl_pid_hash_rehash(struct nl_pid_hash *hash, int grow)
 {
         unsigned int omask, mask, shift;
         size_t osize, size;
@@ -300,7 +284,7 @@ static int nl_portid_hash_rehash(struct nl_portid_hash *hash, int grow)
                 size *= 2;
         }
 
-        table = nl_portid_hash_zalloc(size);
+        table = nl_pid_hash_zalloc(size);
         if (!table)
                 return 0;
 
@@ -315,23 +299,23 @@ static int nl_portid_hash_rehash(struct nl_portid_hash *hash, int grow)
                 struct hlist_node *node, *tmp;
 
                 sk_for_each_safe(sk, node, tmp, &otable[i])
-                        __sk_add_node(sk, nl_portid_hashfn(hash, nlk_sk(sk)->portid));
+                        __sk_add_node(sk, nl_pid_hashfn(hash, nlk_sk(sk)->pid));
         }
 
-        nl_portid_hash_free(otable, osize);
+        nl_pid_hash_free(otable, osize);
         hash->rehash_time = jiffies + 10 * 60 * HZ;
         return 1;
 }
 
-static inline int nl_portid_hash_dilute(struct nl_portid_hash *hash, int len)
+static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len)
 {
         int avg = hash->entries >> hash->shift;
 
-        if (unlikely(avg > 1) && nl_portid_hash_rehash(hash, 1))
+        if (unlikely(avg > 1) && nl_pid_hash_rehash(hash, 1))
                 return 1;
 
         if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) {
-                nl_portid_hash_rehash(hash, 0);
+                nl_pid_hash_rehash(hash, 0);
                 return 1;
         }
 
@@ -347,11 +331,6 @@ netlink_update_listeners(struct sock *sk)
         struct hlist_node *node;
         unsigned long mask;
         unsigned int i;
-        struct listeners *listeners;
-
-        listeners = nl_deref_protected(tbl->listeners);
-        if (!listeners)
-                return;
 
         for (i = 0; i < NLGRPLONGS(tbl->groups); i++) {
                 mask = 0;
@@ -359,15 +338,15 @@ netlink_update_listeners(struct sock *sk)
                         if (i < NLGRPLONGS(nlk_sk(sk)->ngroups))
                                 mask |= nlk_sk(sk)->groups[i];
                 }
-                listeners->masks[i] = mask;
+                tbl->listeners->masks[i] = mask;
         }
         /* this function is only called with the netlink table "grabbed", which
          * makes sure updates are visible before bind or setsockopt return. */
 }
 
-static int netlink_insert(struct sock *sk, struct net *net, u32 portid)
+static int netlink_insert(struct sock *sk, struct net *net, u32 pid)
 {
-        struct nl_portid_hash *hash = &nl_table[sk->sk_protocol].hash;
+        struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
         struct hlist_head *head;
         int err = -EADDRINUSE;
         struct sock *osk;
@@ -375,10 +354,10 @@ static int netlink_insert(struct sock *sk, struct net *net, u32 portid)
         int len;
 
         netlink_table_grab();
-        head = nl_portid_hashfn(hash, portid);
+        head = nl_pid_hashfn(hash, pid);
         len = 0;
         sk_for_each(osk, node, head) {
-                if (net_eq(sock_net(osk), net) && (nlk_sk(osk)->portid == portid))
+                if (net_eq(sock_net(osk), net) && (nlk_sk(osk)->pid == pid))
                         break;
                 len++;
         }
@@ -386,17 +365,17 @@ static int netlink_insert(struct sock *sk, struct net *net, u32 portid)
                 goto err;
 
         err = -EBUSY;
-        if (nlk_sk(sk)->portid)
+        if (nlk_sk(sk)->pid)
                 goto err;
 
         err = -ENOMEM;
         if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX))
                 goto err;
 
-        if (len && nl_portid_hash_dilute(hash, len))
-                head = nl_portid_hashfn(hash, portid);
+        if (len && nl_pid_hash_dilute(hash, len))
+                head = nl_pid_hashfn(hash, pid);
         hash->entries++;
-        nlk_sk(sk)->portid = portid;
+        nlk_sk(sk)->pid = pid;
         sk_add_node(sk, head);
         err = 0;
 
@@ -436,9 +415,9 @@ static int __netlink_create(struct net *net, struct socket *sock,
         sock_init_data(sock, sk);
 
         nlk = nlk_sk(sk);
-        if (cb_mutex) {
+        if (cb_mutex)
                 nlk->cb_mutex = cb_mutex;
-        } else {
+        else {
                 nlk->cb_mutex = &nlk->cb_def_mutex;
                 mutex_init(nlk->cb_mutex);
         }
@@ -455,7 +434,6 @@ static int netlink_create(struct net *net, struct socket *sock, int protocol,
         struct module *module = NULL;
         struct mutex *cb_mutex;
         struct netlink_sock *nlk;
-        void (*bind)(int group);
         int err = 0;
 
         sock->state = SS_UNCONNECTED;
@@ -480,7 +458,6 @@ static int netlink_create(struct net *net, struct socket *sock, int protocol,
         else
                 err = -EPROTONOSUPPORT;
         cb_mutex = nl_table[protocol].cb_mutex;
-        bind = nl_table[protocol].bind;
         netlink_unlock_table();
 
         if (err < 0)
@@ -496,7 +473,6 @@ static int netlink_create(struct net *net, struct socket *sock, int protocol,
 
         nlk = nlk_sk(sock->sk);
         nlk->module = module;
-        nlk->netlink_bind = bind;
 out:
         return err;
 
@@ -527,11 +503,11 @@ static int netlink_release(struct socket *sock)
 
         skb_queue_purge(&sk->sk_write_queue);
 
-        if (nlk->portid) {
+        if (nlk->pid) {
                 struct netlink_notify n = {
                                                 .net = sock_net(sk),
                                                 .protocol = sk->sk_protocol,
-                                                .portid = nlk->portid,
+                                                .pid = nlk->pid,
                                           };
                 atomic_notifier_call_chain(&netlink_chain,
                                 NETLINK_URELEASE, &n);
@@ -543,19 +519,12 @@ static int netlink_release(struct socket *sock)
         if (netlink_is_kernel(sk)) {
                 BUG_ON(nl_table[sk->sk_protocol].registered == 0);
                 if (--nl_table[sk->sk_protocol].registered == 0) {
-                        struct listeners *old;
-
-                        old = nl_deref_protected(nl_table[sk->sk_protocol].listeners);
-                        RCU_INIT_POINTER(nl_table[sk->sk_protocol].listeners, NULL);
-                        kfree_rcu(old, rcu);
+                        kfree(nl_table[sk->sk_protocol].listeners);
                         nl_table[sk->sk_protocol].module = NULL;
-                        nl_table[sk->sk_protocol].bind = NULL;
-                        nl_table[sk->sk_protocol].flags = 0;
                         nl_table[sk->sk_protocol].registered = 0;
                 }
-        } else if (nlk->subscriptions) {
+        } else if (nlk->subscriptions)
                 netlink_update_listeners(sk);
-        }
         netlink_table_ungrab();
 
         kfree(nlk->groups);
@@ -572,24 +541,24 @@ static int netlink_autobind(struct socket *sock)
 {
         struct sock *sk = sock->sk;
         struct net *net = sock_net(sk);
-        struct nl_portid_hash *hash = &nl_table[sk->sk_protocol].hash;
+        struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
         struct hlist_head *head;
         struct sock *osk;
         struct hlist_node *node;
-        s32 portid = task_tgid_vnr(current);
+        s32 pid = task_tgid_vnr(current);
         int err;
         static s32 rover = -4097;
 
 retry:
         cond_resched();
         netlink_table_grab();
-        head = nl_portid_hashfn(hash, portid);
+        head = nl_pid_hashfn(hash, pid);
         sk_for_each(osk, node, head) {
                 if (!net_eq(sock_net(osk), net))
                         continue;
-                if (nlk_sk(osk)->portid == portid) {
-                        /* Bind collision, search negative portid values. */
-                        portid = rover--;
+                if (nlk_sk(osk)->pid == pid) {
+                        /* Bind collision, search negative pid values. */
+                        pid = rover--;
                         if (rover > -4097)
                                 rover = -4097;
                         netlink_table_ungrab();
@@ -598,7 +567,7 @@ retry:
         }
         netlink_table_ungrab();
 
-        err = netlink_insert(sk, net, portid);
+        err = netlink_insert(sk, net, pid);
         if (err == -EADDRINUSE)
                 goto retry;
 
@@ -609,10 +578,10 @@ retry:
         return err;
 }
 
-static inline int netlink_capable(const struct socket *sock, unsigned int flag)
+static inline int netlink_capable(struct socket *sock, unsigned int flag)
 {
-        return (nl_table[sock->sk->sk_protocol].flags & flag) ||
-                ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN);
+        return (nl_table[sock->sk->sk_protocol].nl_nonroot & flag) ||
+               capable(CAP_NET_ADMIN);
 }
 
 static void
@@ -669,23 +638,20 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr,
         struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
         int err;
 
-        if (addr_len < sizeof(struct sockaddr_nl))
-                return -EINVAL;
-
         if (nladdr->nl_family != AF_NETLINK)
                 return -EINVAL;
 
         /* Only superuser is allowed to listen multicasts */
         if (nladdr->nl_groups) {
-                if (!netlink_capable(sock, NL_CFG_F_NONROOT_RECV))
+                if (!netlink_capable(sock, NL_NONROOT_RECV))
                         return -EPERM;
                 err = netlink_realloc_groups(sk);
                 if (err)
                         return err;
         }
 
-        if (nlk->portid) {
-                if (nladdr->nl_pid != nlk->portid)
+        if (nlk->pid) {
+                if (nladdr->nl_pid != nlk->pid)
                         return -EINVAL;
         } else {
                 err = nladdr->nl_pid ?
@@ -706,15 +672,6 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr,
         netlink_update_listeners(sk);
         netlink_table_ungrab();
 
-        if (nlk->netlink_bind && nlk->groups[0]) {
-                int i;
-
-                for (i=0; i<nlk->ngroups; i++) {
-                        if (test_bit(i, nlk->groups))
-                                nlk->netlink_bind(i);
-                }
-        }
-
         return 0;
 }
 
@@ -731,7 +688,7 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr,
 
         if (addr->sa_family == AF_UNSPEC) {
                 sk->sk_state    = NETLINK_UNCONNECTED;
-                nlk->dst_portid = 0;
+                nlk->dst_pid    = 0;
                 nlk->dst_group  = 0;
                 return 0;
         }
@@ -739,15 +696,15 @@ static int netlink_connect(struct socket *sock, struct sockaddr *addr,
                 return -EINVAL;
 
         /* Only superuser is allowed to send multicasts */
-        if (nladdr->nl_groups && !netlink_capable(sock, NL_CFG_F_NONROOT_SEND))
+        if (nladdr->nl_groups && !netlink_capable(sock, NL_NONROOT_SEND))
                 return -EPERM;
 
-        if (!nlk->portid)
+        if (!nlk->pid)
                 err = netlink_autobind(sock);
 
         if (err == 0) {
                 sk->sk_state    = NETLINK_CONNECTED;
-                nlk->dst_portid = nladdr->nl_pid;
+                nlk->dst_pid    = nladdr->nl_pid;
                 nlk->dst_group  = ffs(nladdr->nl_groups);
         }
 
@@ -766,10 +723,10 @@ static int netlink_getname(struct socket *sock, struct sockaddr *addr,
         *addr_len = sizeof(*nladdr);
 
         if (peer) {
-                nladdr->nl_pid = nlk->dst_portid;
+                nladdr->nl_pid = nlk->dst_pid;
                 nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
         } else {
-                nladdr->nl_pid = nlk->portid;
+                nladdr->nl_pid = nlk->pid;
                 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
         }
         return 0;
@@ -788,19 +745,19 @@ static void netlink_overrun(struct sock *sk)
         atomic_inc(&sk->sk_drops);
 }
 
-static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid)
+static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid)
 {
         struct sock *sock;
         struct netlink_sock *nlk;
 
-        sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid);
+        sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, pid);
         if (!sock)
                 return ERR_PTR(-ECONNREFUSED);
 
         /* Don't bother queuing skb if kernel socket has no input function */
         nlk = nlk_sk(sock);
         if (sock->sk_state == NETLINK_CONNECTED &&
-            nlk->dst_portid != nlk_sk(ssk)->portid) {
+            nlk->dst_pid != nlk_sk(ssk)->pid) {
                 sock_put(sock);
                 return ERR_PTR(-ECONNREFUSED);
         }
@@ -873,19 +830,12 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
         return 0;
 }
 
-static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
+int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
 {
         int len = skb->len;
 
         skb_queue_tail(&sk->sk_receive_queue, skb);
         sk->sk_data_ready(sk, len);
-        return len;
-}
-
-int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
-{
-        int len = __netlink_sendskb(sk, skb);
-
         sock_put(sk);
         return len;
 }
@@ -896,7 +846,8 @@ void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
         sock_put(sk);
 }
 
-static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
+static inline struct sk_buff *netlink_trim(struct sk_buff *skb,
+                                           gfp_t allocation)
 {
         int delta;
 
@@ -910,7 +861,7 @@ static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
                 struct sk_buff *nskb = skb_clone(skb, allocation);
                 if (!nskb)
                         return skb;
-                consume_skb(skb);
+                kfree_skb(skb);
                 skb = nskb;
         }
 
@@ -920,7 +871,7 @@ static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
         return skb;
 }
 
-static void netlink_rcv_wake(struct sock *sk)
+static inline void netlink_rcv_wake(struct sock *sk)
 {
         struct netlink_sock *nlk = nlk_sk(sk);
 
@@ -930,8 +881,7 @@ static void netlink_rcv_wake(struct sock *sk)
                 wake_up_interruptible(&nlk->wait);
 }
 
-static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
-                                  struct sock *ssk)
+static inline int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb)
 {
         int ret;
         struct netlink_sock *nlk = nlk_sk(sk);
@@ -940,18 +890,15 @@ static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
         if (nlk->netlink_rcv != NULL) {
                 ret = skb->len;
                 skb_set_owner_r(skb, sk);
-                NETLINK_CB(skb).ssk = ssk;
                 nlk->netlink_rcv(skb);
-                consume_skb(skb);
-        } else {
-                kfree_skb(skb);
         }
+        kfree_skb(skb);
         sock_put(sk);
         return ret;
 }
 
 int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
-                    u32 portid, int nonblock)
+                    u32 pid, int nonblock)
 {
         struct sock *sk;
         int err;
@@ -961,13 +908,13 @@ int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
 
         timeo = sock_sndtimeo(ssk, nonblock);
 retry:
-        sk = netlink_getsockbyportid(ssk, portid);
+        sk = netlink_getsockbypid(ssk, pid);
         if (IS_ERR(sk)) {
                 kfree_skb(skb);
                 return PTR_ERR(sk);
         }
         if (netlink_is_kernel(sk))
-                return netlink_unicast_kernel(sk, skb, ssk);
+                return netlink_unicast_kernel(sk, skb);
 
         if (sk_filter(sk, skb)) {
                 err = skb->len;
@@ -996,7 +943,7 @@ int netlink_has_listeners(struct sock *sk, unsigned int group)
         rcu_read_lock();
         listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners);
 
-        if (listeners && group - 1 < nl_table[sk->sk_protocol].groups)
+        if (group - 1 < nl_table[sk->sk_protocol].groups)
                 res = test_bit(group - 1, listeners->masks);
 
         rcu_read_unlock();
@@ -1005,15 +952,17 @@ int netlink_has_listeners(struct sock *sk, unsigned int group)
 }
 EXPORT_SYMBOL_GPL(netlink_has_listeners);
 
-static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
+static inline int netlink_broadcast_deliver(struct sock *sk,
+                                            struct sk_buff *skb)
 {
         struct netlink_sock *nlk = nlk_sk(sk);
 
         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
             !test_bit(0, &nlk->state)) {
                 skb_set_owner_r(skb, sk);
-                __netlink_sendskb(sk, skb);
-                return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1);
+                skb_queue_tail(&sk->sk_receive_queue, skb);
+                sk->sk_data_ready(sk, skb->len);
+                return atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf;
         }
         return -1;
 }
@@ -1021,7 +970,7 @@ static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
 struct netlink_broadcast_data {
         struct sock *exclude_sk;
         struct net *net;
-        u32 portid;
+        u32 pid;
         u32 group;
         int failure;
         int delivery_failure;
@@ -1033,7 +982,7 @@ struct netlink_broadcast_data {
         void *tx_data;
 };
 
-static int do_one_broadcast(struct sock *sk,
+static inline int do_one_broadcast(struct sock *sk,
                                    struct netlink_broadcast_data *p)
 {
         struct netlink_sock *nlk = nlk_sk(sk);
@@ -1042,7 +991,7 @@ static int do_one_broadcast(struct sock *sk,
         if (p->exclude_sk == sk)
                 goto out;
 
-        if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
+        if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
             !test_bit(p->group - 1, nlk->groups))
                 goto out;
 
@@ -1094,7 +1043,7 @@ out:
         return 0;
 }
 
-int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,
+int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 pid,
         u32 group, gfp_t allocation,
         int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
         void *filter_data)
@@ -1108,7 +1057,7 @@ int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid
 
         info.exclude_sk = ssk;
         info.net = net;
-        info.portid = portid;
+        info.pid = pid;
         info.group = group;
         info.failure = 0;
         info.delivery_failure = 0;
@@ -1134,8 +1083,8 @@ int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid
         if (info.delivery_failure) {
                 kfree_skb(info.skb2);
                 return -ENOBUFS;
-        }
-        consume_skb(info.skb2);
+        } else
+                consume_skb(info.skb2);
 
         if (info.delivered) {
                 if (info.congested && (allocation & __GFP_WAIT))
@@ -1146,22 +1095,23 @@ int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid
 }
 EXPORT_SYMBOL(netlink_broadcast_filtered);
 
-int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid,
+int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
                       u32 group, gfp_t allocation)
 {
-        return netlink_broadcast_filtered(ssk, skb, portid, group, allocation,
+        return netlink_broadcast_filtered(ssk, skb, pid, group, allocation,
                 NULL, NULL);
 }
 EXPORT_SYMBOL(netlink_broadcast);
 
 struct netlink_set_err_data {
         struct sock *exclude_sk;
-        u32 portid;
+        u32 pid;
         u32 group;
         int code;
 };
 
-static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p)
+static inline int do_one_set_err(struct sock *sk,
+                                 struct netlink_set_err_data *p)
 {
         struct netlink_sock *nlk = nlk_sk(sk);
         int ret = 0;
@@ -1172,7 +1122,7 @@ static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p)
         if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
                 goto out;
 
-        if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
+        if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
             !test_bit(p->group - 1, nlk->groups))
                 goto out;
 
@@ -1190,14 +1140,14 @@ out:
 /**
  * netlink_set_err - report error to broadcast listeners
  * @ssk: the kernel netlink socket, as returned by netlink_kernel_create()
- * @portid: the PORTID of a process that we want to skip (if any)
+ * @pid: the PID of a process that we want to skip (if any)
  * @groups: the broadcast group that will notice the error
  * @code: error code, must be negative (as usual in kernelspace)
  *
  * This function returns the number of broadcast listeners that have set the
  * NETLINK_RECV_NO_ENOBUFS socket option.
  */
-int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code)
+int netlink_set_err(struct sock *ssk, u32 pid, u32 group, int code)
 {
         struct netlink_set_err_data info;
         struct hlist_node *node;
@@ -1205,7 +1155,7 @@ int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code)
         int ret = 0;
 
         info.exclude_sk = ssk;
-        info.portid = portid;
+        info.pid = pid;
         info.group = group;
         /* sk->sk_err wants a positive error value */
         info.code = -code;
@@ -1262,7 +1212,7 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname,
                 break;
         case NETLINK_ADD_MEMBERSHIP:
         case NETLINK_DROP_MEMBERSHIP: {
-                if (!netlink_capable(sock, NL_CFG_F_NONROOT_RECV))
+                if (!netlink_capable(sock, NL_NONROOT_RECV))
                         return -EPERM;
                 err = netlink_realloc_groups(sk);
                 if (err)
@@ -1273,10 +1223,6 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname,
                 netlink_update_socket_mc(nlk, val,
                                          optname == NETLINK_ADD_MEMBERSHIP);
                 netlink_table_ungrab();
-
-                if (nlk->netlink_bind)
-                        nlk->netlink_bind(val);
-
                 err = 0;
                 break;
         }
@@ -1292,9 +1238,8 @@ static int netlink_setsockopt(struct socket *sock, int level, int optname,
                         nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
                         clear_bit(0, &nlk->state);
                         wake_up_interruptible(&nlk->wait);
-                } else {
+                } else
                         nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
-                }
                 err = 0;
                 break;
         default:
@@ -1370,7 +1315,7 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
         struct sock *sk = sock->sk;
         struct netlink_sock *nlk = nlk_sk(sk);
         struct sockaddr_nl *addr = msg->msg_name;
-        u32 dst_portid;
+        u32 dst_pid;
         u32 dst_group;
         struct sk_buff *skb;
         int err;
@@ -1379,10 +1324,11 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
         if (msg->msg_flags&MSG_OOB)
                 return -EOPNOTSUPP;
 
-        if (NULL == siocb->scm)
+        if (NULL == siocb->scm) {
                 siocb->scm = &scm;
-
-        err = scm_send(sock, msg, siocb->scm, true);
+                memset(&scm, 0, sizeof(scm));
+        }
+        err = scm_send(sock, msg, siocb->scm);
         if (err < 0)
                 return err;
 
@@ -1390,18 +1336,17 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
                 err = -EINVAL;
                 if (addr->nl_family != AF_NETLINK)
                         goto out;
-                dst_portid = addr->nl_pid;
+                dst_pid = addr->nl_pid;
                 dst_group = ffs(addr->nl_groups);
                 err =  -EPERM;
-                if ((dst_group || dst_portid) &&
-                    !netlink_capable(sock, NL_CFG_F_NONROOT_SEND))
+                if (dst_group && !netlink_capable(sock, NL_NONROOT_SEND))
                         goto out;
         } else {
-                dst_portid = nlk->dst_portid;
+                dst_pid = nlk->dst_pid;
                 dst_group = nlk->dst_group;
         }
 
-        if (!nlk->portid) {
+        if (!nlk->pid) {
                 err = netlink_autobind(sock);
                 if (err)
                         goto out;
@@ -1415,9 +1360,9 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
         if (skb == NULL)
                 goto out;
 
-        NETLINK_CB(skb).portid  = nlk->portid;
+        NETLINK_CB(skb).pid     = nlk->pid;
         NETLINK_CB(skb).dst_group = dst_group;
-        NETLINK_CB(skb).creds   = siocb->scm->creds;
+        memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
 
         err = -EFAULT;
         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
@@ -1433,9 +1378,9 @@ static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
 
         if (dst_group) {
                 atomic_inc(&skb->users);
-                netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
+                netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
         }
-        err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);
+        err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
 
 out:
         scm_destroy(siocb->scm);
@@ -1498,7 +1443,7 @@ static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,
                 struct sockaddr_nl *addr = (struct sockaddr_nl *)msg->msg_name;
                 addr->nl_family = AF_NETLINK;
                 addr->nl_pad    = 0;
-                addr->nl_pid    = NETLINK_CB(skb).portid;
+                addr->nl_pid    = NETLINK_CB(skb).pid;
                 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
                 msg->msg_namelen = sizeof(*addr);
         }
@@ -1542,15 +1487,14 @@ static void netlink_data_ready(struct sock *sk, int len)
  */
 
 struct sock *
-__netlink_kernel_create(struct net *net, int unit, struct module *module,
-                        struct netlink_kernel_cfg *cfg)
+netlink_kernel_create(struct net *net, int unit, unsigned int groups,
+                      void (*input)(struct sk_buff *skb),
+                      struct mutex *cb_mutex, struct module *module)
 {
         struct socket *sock;
         struct sock *sk;
         struct netlink_sock *nlk;
         struct listeners *listeners = NULL;
-        struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL;
-        unsigned int groups;
 
         BUG_ON(!nl_table);
 
@@ -1572,18 +1516,16 @@ __netlink_kernel_create(struct net *net, int unit, struct module *module,
         sk = sock->sk;
         sk_change_net(sk, net);
 
-        if (!cfg || cfg->groups < 32)
+        if (groups < 32)
                 groups = 32;
-        else
-                groups = cfg->groups;
 
         listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
         if (!listeners)
                 goto out_sock_release;
 
         sk->sk_data_ready = netlink_data_ready;
-        if (cfg && cfg->input)
-                nlk_sk(sk)->netlink_rcv = cfg->input;
+        if (input)
+                nlk_sk(sk)->netlink_rcv = input;
 
         if (netlink_insert(sk, net, 0))
                 goto out_sock_release;
@@ -1597,10 +1539,6 @@ __netlink_kernel_create(struct net *net, int unit, struct module *module,
                 rcu_assign_pointer(nl_table[unit].listeners, listeners);
                 nl_table[unit].cb_mutex = cb_mutex;
                 nl_table[unit].module = module;
-                if (cfg) {
-                        nl_table[unit].bind = cfg->bind;
-                        nl_table[unit].flags = cfg->flags;
-                }
                 nl_table[unit].registered = 1;
         } else {
                 kfree(listeners);
@@ -1618,7 +1556,8 @@ out_sock_release_nosk:
         sock_release(sock);
         return NULL;
 }
-EXPORT_SYMBOL(__netlink_kernel_create);
+EXPORT_SYMBOL(netlink_kernel_create);
+
 
 void
 netlink_kernel_release(struct sock *sk)
@@ -1639,7 +1578,7 @@ int __netlink_change_ngroups(struct sock *sk, unsigned int groups)
                 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC);
                 if (!new)
                         return -ENOMEM;
-                old = nl_deref_protected(tbl->listeners);
+                old = rcu_dereference_raw(tbl->listeners);
                 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups));
                 rcu_assign_pointer(tbl->listeners, new);
 
@@ -1698,23 +1637,18 @@ void netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
         netlink_table_ungrab();
 }
 
-struct nlmsghdr *
-__nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags)
+void netlink_set_nonroot(int protocol, unsigned int flags)
 {
-        struct nlmsghdr *nlh;
-        int size = NLMSG_LENGTH(len);
+        if ((unsigned int)protocol < MAX_LINKS)
+                nl_table[protocol].nl_nonroot = flags;
+}
+EXPORT_SYMBOL(netlink_set_nonroot);
 
-        nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
-        nlh->nlmsg_type = type;
-        nlh->nlmsg_len = size;
-        nlh->nlmsg_flags = flags;
-        nlh->nlmsg_pid = portid;
-        nlh->nlmsg_seq = seq;
-        if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
-                memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
-        return nlh;
+static void netlink_destroy_callback(struct netlink_callback *cb)
+{
+        kfree_skb(cb->skb);
+        kfree(cb);
 }
-EXPORT_SYMBOL(__nlmsg_put);
 
 /*
  * It looks a bit ugly.
@@ -1751,8 +1685,10 @@ static int netlink_dump(struct sock *sk)
 
                 if (sk_filter(sk, skb))
                         kfree_skb(skb);
-                else
-                        __netlink_sendskb(sk, skb);
+                else {
+                        skb_queue_tail(&sk->sk_receive_queue, skb);
+                        sk->sk_data_ready(sk, skb->len);
+                }
                 return 0;
         }
 
@@ -1766,16 +1702,17 @@ static int netlink_dump(struct sock *sk)
 
         if (sk_filter(sk, skb))
                 kfree_skb(skb);
-        else
-                __netlink_sendskb(sk, skb);
+        else {
+                skb_queue_tail(&sk->sk_receive_queue, skb);
+                sk->sk_data_ready(sk, skb->len);
+        }
 
         if (cb->done)
                 cb->done(cb);
         nlk->cb = NULL;
         mutex_unlock(nlk->cb_mutex);
 
-        module_put(cb->module);
-        netlink_consume_callback(cb);
+        netlink_destroy_callback(cb);
         return 0;
 
 errout_skb:
@@ -1784,9 +1721,12 @@ errout_skb:
         return err;
 }
 
-int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
-                         const struct nlmsghdr *nlh,
-                         struct netlink_dump_control *control)
+int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
+                       const struct nlmsghdr *nlh,
+                       int (*dump)(struct sk_buff *skb,
+                                   struct netlink_callback *),
+                       int (*done)(struct netlink_callback *),
+                       u16 min_dump_alloc)
 {
         struct netlink_callback *cb;
         struct sock *sk;
@@ -1797,43 +1737,32 @@ int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
         if (cb == NULL)
                 return -ENOBUFS;
 
-        cb->dump = control->dump;
-        cb->done = control->done;
+        cb->dump = dump;
+        cb->done = done;
         cb->nlh = nlh;
-        cb->data = control->data;
-        cb->module = control->module;
-        cb->min_dump_alloc = control->min_dump_alloc;
+        cb->min_dump_alloc = min_dump_alloc;
         atomic_inc(&skb->users);
         cb->skb = skb;
 
-        sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid);
+        sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).pid);
         if (sk == NULL) {
                 netlink_destroy_callback(cb);
                 return -ECONNREFUSED;
         }
         nlk = nlk_sk(sk);
-
-        mutex_lock(nlk->cb_mutex);
         /* A dump is in progress... */
+        mutex_lock(nlk->cb_mutex);
         if (nlk->cb) {
                 mutex_unlock(nlk->cb_mutex);
                 netlink_destroy_callback(cb);
-                ret = -EBUSY;
-                goto out;
-        }
-        /* add reference of module which cb->dump belongs to */
-        if (!try_module_get(cb->module)) {
-                mutex_unlock(nlk->cb_mutex);
-                netlink_destroy_callback(cb);
-                ret = -EPROTONOSUPPORT;
-                goto out;
+                sock_put(sk);
+                return -EBUSY;
         }
-
         nlk->cb = cb;
         mutex_unlock(nlk->cb_mutex);
 
         ret = netlink_dump(sk);
-out:
+
         sock_put(sk);
 
         if (ret)
@@ -1844,7 +1773,7 @@ out:
          */
         return -EINTR;
 }
-EXPORT_SYMBOL(__netlink_dump_start);
+EXPORT_SYMBOL(netlink_dump_start);
 
 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
 {
@@ -1863,7 +1792,7 @@ void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
 
                 sk = netlink_lookup(sock_net(in_skb->sk),
                                     in_skb->sk->sk_protocol,
-                                    NETLINK_CB(in_skb).portid);
+                                    NETLINK_CB(in_skb).pid);
                 if (sk) {
                         sk->sk_err = ENOBUFS;
                         sk->sk_error_report(sk);
@@ -1872,12 +1801,12 @@ void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
                 return;
         }
 
-        rep = __nlmsg_put(skb, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
+        rep = __nlmsg_put(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
                           NLMSG_ERROR, payload, 0);
         errmsg = nlmsg_data(rep);
         errmsg->error = err;
         memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh));
-        netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).portid, MSG_DONTWAIT);
+        netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
 }
 EXPORT_SYMBOL(netlink_ack);
 
@@ -1927,33 +1856,33 @@ EXPORT_SYMBOL(netlink_rcv_skb);
  * nlmsg_notify - send a notification netlink message
  * @sk: netlink socket to use
  * @skb: notification message
- * @portid: destination netlink portid for reports or 0
+ * @pid: destination netlink pid for reports or 0
  * @group: destination multicast group or 0
  * @report: 1 to report back, 0 to disable
  * @flags: allocation flags
  */
-int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
+int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 pid,
                  unsigned int group, int report, gfp_t flags)
 {
         int err = 0;
 
         if (group) {
-                int exclude_portid = 0;
+                int exclude_pid = 0;
 
                 if (report) {
                         atomic_inc(&skb->users);
-                        exclude_portid = portid;
+                        exclude_pid = pid;
                 }
 
                 /* errors reported via destination sk->sk_err, but propagate
                  * delivery errors if NETLINK_BROADCAST_ERROR flag is set */
-                err = nlmsg_multicast(sk, skb, exclude_portid, group, flags);
+                err = nlmsg_multicast(sk, skb, exclude_pid, group, flags);
         }
 
         if (report) {
                 int err2;
 
-                err2 = nlmsg_unicast(sk, skb, portid);
+                err2 = nlmsg_unicast(sk, skb, pid);
                 if (!err || err == -ESRCH)
                         err = err2;
         }
@@ -1978,7 +1907,7 @@ static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
         loff_t off = 0;
 
         for (i = 0; i < MAX_LINKS; i++) {
-                struct nl_portid_hash *hash = &nl_table[i].hash;
+                struct nl_pid_hash *hash = &nl_table[i].hash;
 
                 for (j = 0; j <= hash->mask; j++) {
                         sk_for_each(s, node, &hash->table[j]) {
@@ -2026,7 +1955,7 @@ static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
         j = iter->hash_idx + 1;
 
         do {
-                struct nl_portid_hash *hash = &nl_table[i].hash;
+                struct nl_pid_hash *hash = &nl_table[i].hash;
 
                 for (; j <= hash->mask; j++) {
                         s = sk_head(&hash->table[j]);
@@ -2054,18 +1983,18 @@ static void netlink_seq_stop(struct seq_file *seq, void *v)
 
 static int netlink_seq_show(struct seq_file *seq, void *v)
 {
-        if (v == SEQ_START_TOKEN) {
+        if (v == SEQ_START_TOKEN)
                 seq_puts(seq,
                          "sk       Eth Pid    Groups   "
                          "Rmem     Wmem     Dump     Locks     Drops     Inode\n");
-        } else {
+        else {
                 struct sock *s = v;
                 struct netlink_sock *nlk = nlk_sk(s);
 
-                seq_printf(seq, "%pK %-3d %-6u %08x %-8d %-8d %pK %-8d %-8d %-8lu\n",
+                seq_printf(seq, "%pK %-3d %-6d %08x %-8d %-8d %pK %-8d %-8d %-8lu\n",
                            s,
                            s->sk_protocol,
-                           nlk->portid,
+                           nlk->pid,
                            nlk->groups ? (u32)nlk->groups[0] : 0,
                            sk_rmem_alloc_get(s),
                            sk_wmem_alloc_get(s),
@@ -2173,7 +2102,6 @@ static void __init netlink_add_usersock_entry(void)
         rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners);
         nl_table[NETLINK_USERSOCK].module = THIS_MODULE;
         nl_table[NETLINK_USERSOCK].registered = 1;
-        nl_table[NETLINK_USERSOCK].flags = NL_CFG_F_NONROOT_SEND;
 
         netlink_table_ungrab();
 }
@@ -2210,12 +2138,12 @@ static int __init netlink_proto_init(void)
         order = get_bitmask_order(min(limit, (unsigned long)UINT_MAX)) - 1;
 
         for (i = 0; i < MAX_LINKS; i++) {
-                struct nl_portid_hash *hash = &nl_table[i].hash;
+                struct nl_pid_hash *hash = &nl_table[i].hash;
 
-                hash->table = nl_portid_hash_zalloc(1 * sizeof(*hash->table));
+                hash->table = nl_pid_hash_zalloc(1 * sizeof(*hash->table));
                 if (!hash->table) {
                         while (i-- > 0)
-                                nl_portid_hash_free(nl_table[i].hash.table,
+                                nl_pid_hash_free(nl_table[i].hash.table,
                                                  1 * sizeof(*hash->table));
                         kfree(nl_table);
                         goto panic;
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index f2aabb6f410..482fa571b4e 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -33,14 +33,6 @@ void genl_unlock(void)
 }
 EXPORT_SYMBOL(genl_unlock);
 
-#ifdef CONFIG_LOCKDEP
-int lockdep_genl_is_held(void)
-{
-        return lockdep_is_held(&genl_mutex);
-}
-EXPORT_SYMBOL(lockdep_genl_is_held);
-#endif
-
 #define GENL_FAM_TAB_SIZE       16
 #define GENL_FAM_TAB_MASK       (GENL_FAM_TAB_SIZE - 1)
 
@@ -106,7 +98,7 @@ static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
 /* Of course we are going to have problems once we hit
  * 2^16 alive types, but that can only happen by year 2K
 */
-static u16 genl_generate_id(void)
+static inline u16 genl_generate_id(void)
 {
         static u16 id_gen_idx = GENL_MIN_ID;
         int i;
@@ -498,37 +490,6 @@ int genl_unregister_family(struct genl_family *family)
 }
 EXPORT_SYMBOL(genl_unregister_family);
 
-/**
- * genlmsg_put - Add generic netlink header to netlink message
- * @skb: socket buffer holding the message
- * @portid: netlink portid the message is addressed to
- * @seq: sequence number (usually the one of the sender)
- * @family: generic netlink family
- * @flags: netlink message flags
- * @cmd: generic netlink command
- *
- * Returns pointer to user specific header
- */
-void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
-                                struct genl_family *family, int flags, u8 cmd)
-{
-        struct nlmsghdr *nlh;
-        struct genlmsghdr *hdr;
-
-        nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
-                        family->hdrsize, flags);
-        if (nlh == NULL)
-                return NULL;
-
-        hdr = nlmsg_data(nlh);
-        hdr->cmd = cmd;
-        hdr->version = family->version;
-        hdr->reserved = 0;
-
-        return (char *) hdr + GENL_HDRLEN;
-}
-EXPORT_SYMBOL(genlmsg_put);
-
 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
 {
         struct genl_ops *ops;
@@ -555,7 +516,7 @@ static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                 return -EOPNOTSUPP;
 
         if ((ops->flags & GENL_ADMIN_PERM) &&
-            !capable(CAP_NET_ADMIN))
+            security_netlink_recv(skb, CAP_NET_ADMIN))
                 return -EPERM;
 
         if (nlh->nlmsg_flags & NLM_F_DUMP) {
@@ -563,13 +524,8 @@ static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                         return -EOPNOTSUPP;
 
                 genl_unlock();
-                {
-                        struct netlink_dump_control c = {
-                                .dump = ops->dumpit,
-                                .done = ops->done,
-                        };
-                        err = netlink_dump_start(net->genl_sock, skb, nlh, &c);
-                }
+                err = netlink_dump_start(net->genl_sock, skb, nlh,
+                                         ops->dumpit, ops->done, 0);
                 genl_lock();
                 return err;
         }
@@ -585,7 +541,7 @@ static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
         }
 
         info.snd_seq = nlh->nlmsg_seq;
-        info.snd_portid = NETLINK_CB(skb).portid;
+        info.snd_pid = NETLINK_CB(skb).pid;
         info.nlhdr = nlh;
         info.genlhdr = nlmsg_data(nlh);
         info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
@@ -626,21 +582,20 @@ static struct genl_family genl_ctrl = {
         .netnsok = true,
 };
 
-static int ctrl_fill_info(struct genl_family *family, u32 portid, u32 seq,
+static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
                           u32 flags, struct sk_buff *skb, u8 cmd)
 {
         void *hdr;
 
-        hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
+        hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
         if (hdr == NULL)
                 return -1;
 
-        if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
-            nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
-            nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
-            nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
-            nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
-                goto nla_put_failure;
+        NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
+        NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
+        NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
+        NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
+        NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
 
         if (!list_empty(&family->ops_list)) {
                 struct nlattr *nla_ops;
@@ -658,9 +613,8 @@ static int ctrl_fill_info(struct genl_family *family, u32 portid, u32 seq,
                         if (nest == NULL)
                                 goto nla_put_failure;
 
-                        if (nla_put_u32(skb, CTRL_ATTR_OP_ID, ops->cmd) ||
-                            nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, ops->flags))
-                                goto nla_put_failure;
+                        NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
+                        NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
 
                         nla_nest_end(skb, nest);
                 }
@@ -684,10 +638,9 @@ static int ctrl_fill_info(struct genl_family *family, u32 portid, u32 seq,
                         if (nest == NULL)
                                 goto nla_put_failure;
 
-                        if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id) ||
-                            nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
-                                           grp->name))
-                                goto nla_put_failure;
+                        NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
+                        NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
+                                       grp->name);
 
                         nla_nest_end(skb, nest);
                 }
@@ -701,7 +654,7 @@ nla_put_failure:
         return -EMSGSIZE;
 }
 
-static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 portid,
+static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
                                 u32 seq, u32 flags, struct sk_buff *skb,
                                 u8 cmd)
 {
@@ -709,13 +662,12 @@ static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 portid,
         struct nlattr *nla_grps;
         struct nlattr *nest;
 
-        hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
+        hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
         if (hdr == NULL)
                 return -1;
 
-        if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name) ||
-            nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id))
-                goto nla_put_failure;
+        NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name);
+        NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id);
 
         nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
         if (nla_grps == NULL)
@@ -725,10 +677,9 @@ static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 portid,
         if (nest == NULL)
                 goto nla_put_failure;
 
-        if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id) ||
-            nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
-                           grp->name))
-                goto nla_put_failure;
+        NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
+        NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
+                       grp->name);
 
         nla_nest_end(skb, nest);
         nla_nest_end(skb, nla_grps);
@@ -756,7 +707,7 @@ static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
                                 continue;
                         if (++n < fams_to_skip)
                                 continue;
-                        if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
+                        if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
                                            cb->nlh->nlmsg_seq, NLM_F_MULTI,
                                            skb, CTRL_CMD_NEWFAMILY) < 0)
                                 goto errout;
@@ -773,7 +724,7 @@ errout:
 }
 
 static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
-                                             u32 portid, int seq, u8 cmd)
+                                             u32 pid, int seq, u8 cmd)
 {
         struct sk_buff *skb;
         int err;
@@ -782,7 +733,7 @@ static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
         if (skb == NULL)
                 return ERR_PTR(-ENOBUFS);
 
-        err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
+        err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
         if (err < 0) {
                 nlmsg_free(skb);
                 return ERR_PTR(err);
@@ -792,7 +743,7 @@ static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
 }
 
 static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
-                                            u32 portid, int seq, u8 cmd)
+                                            u32 pid, int seq, u8 cmd)
 {
         struct sk_buff *skb;
         int err;
@@ -801,7 +752,7 @@ static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
         if (skb == NULL)
                 return ERR_PTR(-ENOBUFS);
 
-        err = ctrl_fill_mcgrp_info(grp, portid, seq, 0, skb, cmd);
+        err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd);
         if (err < 0) {
                 nlmsg_free(skb);
                 return ERR_PTR(err);
@@ -833,15 +784,6 @@ static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
 
                 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
                 res = genl_family_find_byname(name);
-#ifdef CONFIG_MODULES
-                if (res == NULL) {
-                        genl_unlock();
-                        request_module("net-pf-%d-proto-%d-family-%s",
-                                       PF_NETLINK, NETLINK_GENERIC, name);
-                        genl_lock();
-                        res = genl_family_find_byname(name);
-                }
-#endif
                 err = -ENOENT;
         }
 
@@ -853,7 +795,7 @@ static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
                 return -ENOENT;
         }
 
-        msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
+        msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq,
                                     CTRL_CMD_NEWFAMILY);
         if (IS_ERR(msg))
                 return PTR_ERR(msg);
@@ -915,14 +857,10 @@ static struct genl_multicast_group notify_grp = {
 
 static int __net_init genl_pernet_init(struct net *net)
 {
-        struct netlink_kernel_cfg cfg = {
-                .input          = genl_rcv,
-                .cb_mutex       = &genl_mutex,
-                .flags          = NL_CFG_F_NONROOT_RECV,
-        };
-
         /* we'll bump the group number right afterwards */
-        net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
+        net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, 0,
+                                               genl_rcv, &genl_mutex,
+                                               THIS_MODULE);
 
         if (!net->genl_sock && net_eq(net, &init_net))
                 panic("GENL: Cannot initialize generic netlink\n");
@@ -955,6 +893,8 @@ static int __init genl_init(void)
         if (err < 0)
                 goto problem;
 
+        netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
+
         err = register_pernet_subsys(&genl_pernet_ops);
         if (err)
                 goto problem;
@@ -971,7 +911,7 @@ problem:
 
 subsys_initcall(genl_init);
 
-static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
+static int genlmsg_mcast(struct sk_buff *skb, u32 pid, unsigned long group,
                          gfp_t flags)
 {
         struct sk_buff *tmp;
@@ -986,7 +926,7 @@ static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
                                 goto error;
                         }
                         err = nlmsg_multicast(prev->genl_sock, tmp,
-                                              portid, group, flags);
+                                              pid, group, flags);
                         if (err)
                                 goto error;
                 }
@@ -994,28 +934,15 @@ static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
                 prev = net;
         }
 
-        return nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
+        return nlmsg_multicast(prev->genl_sock, skb, pid, group, flags);
  error:
         kfree_skb(skb);
         return err;
 }
 
-int genlmsg_multicast_allns(struct sk_buff *skb, u32 portid, unsigned int group,
+int genlmsg_multicast_allns(struct sk_buff *skb, u32 pid, unsigned int group,
                             gfp_t flags)
 {
-        return genlmsg_mcast(skb, portid, group, flags);
+        return genlmsg_mcast(skb, pid, group, flags);
 }
 EXPORT_SYMBOL(genlmsg_multicast_allns);
-
-void genl_notify(struct sk_buff *skb, struct net *net, u32 portid, u32 group,
-                 struct nlmsghdr *nlh, gfp_t flags)
-{
-        struct sock *sk = net->genl_sock;
-        int report = 0;
-
-        if (nlh)
-                report = nlmsg_report(nlh);
-
-        nlmsg_notify(sk, skb, portid, group, report, flags);
-}
-EXPORT_SYMBOL(genl_notify);