1 files changed, 22 insertions, 58 deletions

diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index 29124b7a04c..54303945019 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -21,8 +21,6 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
-#include <linux/export.h>
-#include <linux/pid_namespace.h>
 
 #include <net/net_namespace.h>
 #include <net/sock.h>
@@ -92,8 +90,6 @@ static struct ip6_flowlabel *fl_lookup(struct net *net, __be32 label)
 static void fl_free(struct ip6_flowlabel *fl)
 {
         if (fl) {
-                if (fl->share == IPV6_FL_S_PROCESS)
-                        put_pid(fl->owner.pid);
                 release_net(fl->fl_net);
                 kfree(fl->opt);
         }
@@ -297,7 +293,6 @@ struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space,
         opt_space->opt_flen = fopt->opt_flen;
         return opt_space;
 }
-EXPORT_SYMBOL_GPL(fl6_merge_options);
 
 static unsigned long check_linger(unsigned long ttl)
 {
@@ -390,17 +385,17 @@ fl_create(struct net *net, struct sock *sk, struct in6_flowlabel_req *freq,
                 err = -EINVAL;
                 goto done;
         }
-        fl->dst = freq->flr_dst;
+        ipv6_addr_copy(&fl->dst, &freq->flr_dst);
         atomic_set(&fl->users, 1);
         switch (fl->share) {
         case IPV6_FL_S_EXCL:
         case IPV6_FL_S_ANY:
                 break;
         case IPV6_FL_S_PROCESS:
-                fl->owner.pid = get_task_pid(current, PIDTYPE_PID);
+                fl->owner = current->pid;
                 break;
         case IPV6_FL_S_USER:
-                fl->owner.uid = current_euid();
+                fl->owner = current_euid();
                 break;
         default:
                 err = -EINVAL;
@@ -436,32 +431,32 @@ static int mem_check(struct sock *sk)
         return 0;
 }
 
-static bool ipv6_hdr_cmp(struct ipv6_opt_hdr *h1, struct ipv6_opt_hdr *h2)
+static int ipv6_hdr_cmp(struct ipv6_opt_hdr *h1, struct ipv6_opt_hdr *h2)
 {
         if (h1 == h2)
-                return false;
+                return 0;
         if (h1 == NULL || h2 == NULL)
-                return true;
+                return 1;
         if (h1->hdrlen != h2->hdrlen)
-                return true;
+                return 1;
         return memcmp(h1+1, h2+1, ((h1->hdrlen+1)<<3) - sizeof(*h1));
 }
 
-static bool ipv6_opt_cmp(struct ipv6_txoptions *o1, struct ipv6_txoptions *o2)
+static int ipv6_opt_cmp(struct ipv6_txoptions *o1, struct ipv6_txoptions *o2)
 {
         if (o1 == o2)
-                return false;
+                return 0;
         if (o1 == NULL || o2 == NULL)
-                return true;
+                return 1;
         if (o1->opt_nflen != o2->opt_nflen)
-                return true;
+                return 1;
         if (ipv6_hdr_cmp(o1->hopopt, o2->hopopt))
-                return true;
+                return 1;
         if (ipv6_hdr_cmp(o1->dst0opt, o2->dst0opt))
-                return true;
+                return 1;
         if (ipv6_hdr_cmp((struct ipv6_opt_hdr *)o1->srcrt, (struct ipv6_opt_hdr *)o2->srcrt))
-                return true;
-        return false;
+                return 1;
+        return 0;
 }
 
 static inline void fl_link(struct ipv6_pinfo *np, struct ipv6_fl_socklist *sfl,
@@ -519,8 +514,7 @@ int ipv6_flowlabel_opt(struct sock *sk, char __user *optval, int optlen)
                 }
                 read_unlock_bh(&ip6_sk_fl_lock);
 
-                if (freq.flr_share == IPV6_FL_S_NONE &&
-                    ns_capable(net->user_ns, CAP_NET_ADMIN)) {
+                if (freq.flr_share == IPV6_FL_S_NONE && capable(CAP_NET_ADMIN)) {
                         fl = fl_lookup(net, freq.flr_label);
                         if (fl) {
                                 err = fl6_renew(fl, freq.flr_linger, freq.flr_expires);
@@ -565,10 +559,7 @@ recheck:
                                 err = -EPERM;
                                 if (fl1->share == IPV6_FL_S_EXCL ||
                                     fl1->share != fl->share ||
-                                    ((fl1->share == IPV6_FL_S_PROCESS) &&
-                                     (fl1->owner.pid == fl->owner.pid)) ||
-                                    ((fl1->share == IPV6_FL_S_USER) &&
-                                     uid_eq(fl1->owner.uid, fl->owner.uid)))
+                                    fl1->owner != fl->owner)
                                         goto release;
 
                                 err = -EINVAL;
@@ -628,7 +619,6 @@ done:
 
 struct ip6fl_iter_state {
         struct seq_net_private p;
-        struct pid_namespace *pid_ns;
         int bucket;
 };
 
@@ -707,7 +697,6 @@ static void ip6fl_seq_stop(struct seq_file *seq, void *v)
 
 static int ip6fl_seq_show(struct seq_file *seq, void *v)
 {
-        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
         if (v == SEQ_START_TOKEN)
                 seq_printf(seq, "%-5s %-1s %-6s %-6s %-6s %-8s %-32s %s\n",
                            "Label", "S", "Owner", "Users", "Linger", "Expires", "Dst", "Opt");
@@ -715,13 +704,9 @@ static int ip6fl_seq_show(struct seq_file *seq, void *v)
                 struct ip6_flowlabel *fl = v;
                 seq_printf(seq,
                            "%05X %-1d %-6d %-6d %-6ld %-8ld %pi6 %-4d\n",
-                           (unsigned int)ntohl(fl->label),
+                           (unsigned)ntohl(fl->label),
                            fl->share,
-                           ((fl->share == IPV6_FL_S_PROCESS) ?
-                            pid_nr_ns(fl->owner.pid, state->pid_ns) :
-                            ((fl->share == IPV6_FL_S_USER) ?
-                             from_kuid_munged(seq_user_ns(seq), fl->owner.uid) :
-                             0)),
+                           (unsigned)fl->owner,
                            atomic_read(&fl->users),
                            fl->linger/HZ,
                            (long)(fl->expires - jiffies)/HZ,
@@ -740,29 +725,8 @@ static const struct seq_operations ip6fl_seq_ops = {
 
 static int ip6fl_seq_open(struct inode *inode, struct file *file)
 {
-        struct seq_file *seq;
-        struct ip6fl_iter_state *state;
-        int err;
-
-        err = seq_open_net(inode, file, &ip6fl_seq_ops,
-                           sizeof(struct ip6fl_iter_state));
-
-        if (!err) {
-                seq = file->private_data;
-                state = ip6fl_seq_private(seq);
-                rcu_read_lock();
-                state->pid_ns = get_pid_ns(task_active_pid_ns(current));
-                rcu_read_unlock();
-        }
-        return err;
-}
-
-static int ip6fl_seq_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *seq = file->private_data;
-        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
-        put_pid_ns(state->pid_ns);
-        return seq_release_net(inode, file);
+        return seq_open_net(inode, file, &ip6fl_seq_ops,
+                            sizeof(struct ip6fl_iter_state));
 }
 
 static const struct file_operations ip6fl_seq_fops = {
@@ -770,7 +734,7 @@ static const struct file_operations ip6fl_seq_fops = {
         .open           =       ip6fl_seq_open,
         .read           =       seq_read,
         .llseek         =       seq_lseek,
-        .release        =       ip6fl_seq_release,
+        .release        =       seq_release_net,
 };
 
 static int __net_init ip6_flowlabel_proc_init(struct net *net)