[NET]: Support multiple network namespaces with netlink

[pandora-kernel.git] / net / netlink / af_netlink.c

diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 5681ce3..3029f86 100644 (file)
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -57,6 +57,7 @@
 #include <linux/selinux.h>
 #include <linux/mutex.h>
 
+#include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/scm.h>
 #include <net/netlink.h>
@@ -88,7 +89,7 @@ struct netlink_sock {
 
 static inline struct netlink_sock *nlk_sk(struct sock *sk)
 {
-       return (struct netlink_sock *)sk;
+       return container_of(sk, struct netlink_sock, sk);
 }
 
 struct nl_pid_hash {
@@ -210,7 +211,7 @@ netlink_unlock_table(void)
                wake_up(&nl_table_wait);
 }
 
-static __inline__ struct sock *netlink_lookup(int protocol, u32 pid)
+static __inline__ struct sock *netlink_lookup(struct net *net, int protocol, u32 pid)
 {
        struct nl_pid_hash *hash = &nl_table[protocol].hash;
        struct hlist_head *head;
@@ -220,7 +221,7 @@ static __inline__ struct sock *netlink_lookup(int protocol, u32 pid)
        read_lock(&nl_table_lock);
        head = nl_pid_hashfn(hash, pid);
        sk_for_each(sk, node, head) {
-               if (nlk_sk(sk)->pid == pid) {
+               if ((sk->sk_net == net) && (nlk_sk(sk)->pid == pid)) {
                        sock_hold(sk);
                        goto found;
                }
@@ -327,7 +328,7 @@ netlink_update_listeners(struct sock *sk)
         * makes sure updates are visible before bind or setsockopt return. */
 }
 
-static int netlink_insert(struct sock *sk, u32 pid)
+static int netlink_insert(struct sock *sk, struct net *net, u32 pid)
 {
        struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
        struct hlist_head *head;
@@ -340,7 +341,7 @@ static int netlink_insert(struct sock *sk, u32 pid)
        head = nl_pid_hashfn(hash, pid);
        len = 0;
        sk_for_each(osk, node, head) {
-               if (nlk_sk(osk)->pid == pid)
+               if ((osk->sk_net == net) && (nlk_sk(osk)->pid == pid))
                        break;
                len++;
        }
@@ -383,15 +384,15 @@ static struct proto netlink_proto = {
        .obj_size = sizeof(struct netlink_sock),
 };
 
-static int __netlink_create(struct socket *sock, struct mutex *cb_mutex,
-                           int protocol)
+static int __netlink_create(struct net *net, struct socket *sock,
+                           struct mutex *cb_mutex, int protocol)
 {
        struct sock *sk;
        struct netlink_sock *nlk;
 
        sock->ops = &netlink_ops;
 
-       sk = sk_alloc(PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
+       sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
        if (!sk)
                return -ENOMEM;
 
@@ -411,7 +412,7 @@ static int __netlink_create(struct socket *sock, struct mutex *cb_mutex,
        return 0;
 }
 
-static int netlink_create(struct socket *sock, int protocol)
+static int netlink_create(struct net *net, struct socket *sock, int protocol)
 {
        struct module *module = NULL;
        struct mutex *cb_mutex;
@@ -440,7 +441,7 @@ static int netlink_create(struct socket *sock, int protocol)
        cb_mutex = nl_table[protocol].cb_mutex;
        netlink_unlock_table();
 
-       if ((err = __netlink_create(sock, cb_mutex, protocol)) < 0)
+       if ((err = __netlink_create(net, sock, cb_mutex, protocol)) < 0)
                goto out_module;
 
        nlk = nlk_sk(sock->sk);
@@ -477,6 +478,7 @@ static int netlink_release(struct socket *sock)
 
        if (nlk->pid && !nlk->subscriptions) {
                struct netlink_notify n = {
+                                               .net = sk->sk_net,
                                                .protocol = sk->sk_protocol,
                                                .pid = nlk->pid,
                                          };
@@ -505,6 +507,7 @@ static int netlink_release(struct socket *sock)
 static int netlink_autobind(struct socket *sock)
 {
        struct sock *sk = sock->sk;
+       struct net *net = sk->sk_net;
        struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
        struct hlist_head *head;
        struct sock *osk;
@@ -518,6 +521,8 @@ retry:
        netlink_table_grab();
        head = nl_pid_hashfn(hash, pid);
        sk_for_each(osk, node, head) {
+               if ((osk->sk_net != net))
+                       continue;
                if (nlk_sk(osk)->pid == pid) {
                        /* Bind collision, search negative pid values. */
                        pid = rover--;
@@ -529,7 +534,7 @@ retry:
        }
        netlink_table_ungrab();
 
-       err = netlink_insert(sk, pid);
+       err = netlink_insert(sk, net, pid);
        if (err == -EADDRINUSE)
                goto retry;
 
@@ -594,6 +599,7 @@ static int netlink_realloc_groups(struct sock *sk)
 static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 {
        struct sock *sk = sock->sk;
+       struct net *net = sk->sk_net;
        struct netlink_sock *nlk = nlk_sk(sk);
        struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
        int err;
@@ -615,7 +621,7 @@ static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len
                        return -EINVAL;
        } else {
                err = nladdr->nl_pid ?
-                       netlink_insert(sk, nladdr->nl_pid) :
+                       netlink_insert(sk, net, nladdr->nl_pid) :
                        netlink_autobind(sock);
                if (err)
                        return err;
@@ -699,10 +705,12 @@ static void netlink_overrun(struct sock *sk)
 static struct sock *netlink_getsockbypid(struct sock *ssk, u32 pid)
 {
        int protocol = ssk->sk_protocol;
+       struct net *net;
        struct sock *sock;
        struct netlink_sock *nlk;
 
-       sock = netlink_lookup(protocol, pid);
+       net = ssk->sk_net;
+       sock = netlink_lookup(net, protocol, pid);
        if (!sock)
                return ERR_PTR(-ECONNREFUSED);
 
@@ -883,6 +891,7 @@ static __inline__ int netlink_broadcast_deliver(struct sock *sk, struct sk_buff
 
 struct netlink_broadcast_data {
        struct sock *exclude_sk;
+       struct net *net;
        u32 pid;
        u32 group;
        int failure;
@@ -905,6 +914,9 @@ static inline int do_one_broadcast(struct sock *sk,
            !test_bit(p->group - 1, nlk->groups))
                goto out;
 
+       if ((sk->sk_net != p->net))
+               goto out;
+
        if (p->failure) {
                netlink_overrun(sk);
                goto out;
@@ -943,6 +955,7 @@ out:
 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
                      u32 group, gfp_t allocation)
 {
+       struct net *net = ssk->sk_net;
        struct netlink_broadcast_data info;
        struct hlist_node *node;
        struct sock *sk;
@@ -950,6 +963,7 @@ int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid,
        skb = netlink_trim(skb, allocation);
 
        info.exclude_sk = ssk;
+       info.net = net;
        info.pid = pid;
        info.group = group;
        info.failure = 0;
@@ -998,6 +1012,9 @@ static inline int do_one_set_err(struct sock *sk,
        if (sk == p->exclude_sk)
                goto out;
 
+       if (sk->sk_net != p->exclude_sk->sk_net)
+               goto out;
+
        if (nlk->pid == p->pid || p->group - 1 >= nlk->ngroups ||
            !test_bit(p->group - 1, nlk->groups))
                goto out;
@@ -1300,7 +1317,7 @@ static void netlink_data_ready(struct sock *sk, int len)
  */
 
 struct sock *
-netlink_kernel_create(int unit, unsigned int groups,
+netlink_kernel_create(struct net *net, int unit, unsigned int groups,
                      void (*input)(struct sock *sk, int len),
                      struct mutex *cb_mutex, struct module *module)
 {
@@ -1317,7 +1334,7 @@ netlink_kernel_create(int unit, unsigned int groups,
        if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
                return NULL;
 
-       if (__netlink_create(sock, cb_mutex, unit) < 0)
+       if (__netlink_create(net, sock, cb_mutex, unit) < 0)
                goto out_sock_release;
 
        if (groups < 32)
@@ -1332,18 +1349,20 @@ netlink_kernel_create(int unit, unsigned int groups,
        if (input)
                nlk_sk(sk)->data_ready = input;
 
-       if (netlink_insert(sk, 0))
+       if (netlink_insert(sk, net, 0))
                goto out_sock_release;
 
        nlk = nlk_sk(sk);
        nlk->flags |= NETLINK_KERNEL_SOCKET;
 
        netlink_table_grab();
-       nl_table[unit].groups = groups;
-       nl_table[unit].listeners = listeners;
-       nl_table[unit].cb_mutex = cb_mutex;
-       nl_table[unit].module = module;
-       nl_table[unit].registered = 1;
+       if (!nl_table[unit].registered) {
+               nl_table[unit].groups = groups;
+               nl_table[unit].listeners = listeners;
+               nl_table[unit].cb_mutex = cb_mutex;
+               nl_table[unit].module = module;
+               nl_table[unit].registered = 1;
+       }
        netlink_table_ungrab();
 
        return sk;
@@ -1509,7 +1528,7 @@ int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
        atomic_inc(&skb->users);
        cb->skb = skb;
 
-       sk = netlink_lookup(ssk->sk_protocol, NETLINK_CB(skb).pid);
+       sk = netlink_lookup(ssk->sk_net, ssk->sk_protocol, NETLINK_CB(skb).pid);
        if (sk == NULL) {
                netlink_destroy_callback(cb);
                return -ECONNREFUSED;
@@ -1551,7 +1570,8 @@ void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
        if (!skb) {
                struct sock *sk;
 
-               sk = netlink_lookup(in_skb->sk->sk_protocol,
+               sk = netlink_lookup(in_skb->sk->sk_net,
+                                   in_skb->sk->sk_protocol,
                                    NETLINK_CB(in_skb).pid);
                if (sk) {
                        sk->sk_err = ENOBUFS;
@@ -1702,6 +1722,7 @@ int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 pid,
 
 #ifdef CONFIG_PROC_FS
 struct nl_seq_iter {
+       struct net *net;
        int link;
        int hash_idx;
 };
@@ -1719,6 +1740,8 @@ static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos)
 
                for (j = 0; j <= hash->mask; j++) {
                        sk_for_each(s, node, &hash->table[j]) {
+                               if (iter->net != s->sk_net)
+                                       continue;
                                if (off == pos) {
                                        iter->link = i;
                                        iter->hash_idx = j;
@@ -1748,11 +1771,14 @@ static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
        if (v == SEQ_START_TOKEN)
                return netlink_seq_socket_idx(seq, 0);
 
-       s = sk_next(v);
+       iter = seq->private;
+       s = v;
+       do {
+               s = sk_next(s);
+       } while (s && (iter->net != s->sk_net));
        if (s)
                return s;
 
-       iter = seq->private;
        i = iter->link;
        j = iter->hash_idx + 1;
 
@@ -1761,6 +1787,8 @@ static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
                for (; j <= hash->mask; j++) {
                        s = sk_head(&hash->table[j]);
+                       while (s && (iter->net != s->sk_net))
+                               s = sk_next(s);
                        if (s) {
                                iter->link = i;
                                iter->hash_idx = j;
@@ -1831,15 +1859,24 @@ static int netlink_seq_open(struct inode *inode, struct file *file)
 
        seq = file->private_data;
        seq->private = iter;
+       iter->net = get_net(PROC_NET(inode));
        return 0;
 }
 
+static int netlink_seq_release(struct inode *inode, struct file *file)
+{
+       struct seq_file *seq = file->private_data;
+       struct nl_seq_iter *iter = seq->private;
+       put_net(iter->net);
+       return seq_release_private(inode, file);
+}
+
 static const struct file_operations netlink_seq_fops = {
        .owner          = THIS_MODULE,
        .open           = netlink_seq_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
-       .release        = seq_release_private,
+       .release        = netlink_seq_release,
 };
 
 #endif
@@ -1881,6 +1918,27 @@ static struct net_proto_family netlink_family_ops = {
        .owner  = THIS_MODULE,  /* for consistency 8) */
 };
 
+static int netlink_net_init(struct net *net)
+{
+#ifdef CONFIG_PROC_FS
+       if (!proc_net_fops_create(net, "netlink", 0, &netlink_seq_fops))
+               return -ENOMEM;
+#endif
+       return 0;
+}
+
+static void netlink_net_exit(struct net *net)
+{
+#ifdef CONFIG_PROC_FS
+       proc_net_remove(net, "netlink");
+#endif
+}
+
+static struct pernet_operations netlink_net_ops = {
+       .init = netlink_net_init,
+       .exit = netlink_net_exit,
+};
+
 static int __init netlink_proto_init(void)
 {
        struct sk_buff *dummy_skb;
@@ -1926,9 +1984,7 @@ static int __init netlink_proto_init(void)
        }
 
        sock_register(&netlink_family_ops);
-#ifdef CONFIG_PROC_FS
-       proc_net_fops_create("netlink", 0, &netlink_seq_fops);
-#endif
+       register_pernet_subsys(&netlink_net_ops);
        /* The netlink device handler may be needed early. */
        rtnetlink_init();
 out: