URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [tags/] [linux-2.6/] [linux-2.6.24_or32_unified_v2.3/] [net/] [ipv6/] [ip6_flowlabel.c] - Blame information for rev 8

Details | Compare with Previous | View Log


/*
 *      ip6_flowlabel.c         IPv6 flowlabel manager.
 *
 *      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.
 *
 *      Authors:        Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 */
 
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/in6.h>
#include <linux/route.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
 
#include <net/net_namespace.h>
#include <net/sock.h>
 
#include <net/ipv6.h>
#include <net/ndisc.h>
#include <net/protocol.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/rawv6.h>
#include <net/icmp.h>
#include <net/transp_v6.h>
 
#include <asm/uaccess.h>
 
#define FL_MIN_LINGER   6       /* Minimal linger. It is set to 6sec specified
                                   in old IPv6 RFC. Well, it was reasonable value.
                                 */
#define FL_MAX_LINGER   60      /* Maximal linger timeout */
 
/* FL hash table */
 
#define FL_MAX_PER_SOCK 32
#define FL_MAX_SIZE     4096
#define FL_HASH_MASK    255
#define FL_HASH(l)      (ntohl(l)&FL_HASH_MASK)
 
static atomic_t fl_size = ATOMIC_INIT(0);
static struct ip6_flowlabel *fl_ht[FL_HASH_MASK+1];
 
static void ip6_fl_gc(unsigned long dummy);
static DEFINE_TIMER(ip6_fl_gc_timer, ip6_fl_gc, 0, 0);
 
/* FL hash table lock: it protects only of GC */
 
static DEFINE_RWLOCK(ip6_fl_lock);
 
/* Big socket sock */
 
static DEFINE_RWLOCK(ip6_sk_fl_lock);
 
 
static __inline__ struct ip6_flowlabel * __fl_lookup(__be32 label)
{
        struct ip6_flowlabel *fl;
 
        for (fl=fl_ht[FL_HASH(label)]; fl; fl = fl->next) {
                if (fl->label == label)
                        return fl;
        }
        return NULL;
}
 
static struct ip6_flowlabel * fl_lookup(__be32 label)
{
        struct ip6_flowlabel *fl;
 
        read_lock_bh(&ip6_fl_lock);
        fl = __fl_lookup(label);
        if (fl)
                atomic_inc(&fl->users);
        read_unlock_bh(&ip6_fl_lock);
        return fl;
}
 
 
static void fl_free(struct ip6_flowlabel *fl)
{
        if (fl)
                kfree(fl->opt);
        kfree(fl);
}
 
static void fl_release(struct ip6_flowlabel *fl)
{
        write_lock_bh(&ip6_fl_lock);
 
        fl->lastuse = jiffies;
        if (atomic_dec_and_test(&fl->users)) {
                unsigned long ttd = fl->lastuse + fl->linger;
                if (time_after(ttd, fl->expires))
                        fl->expires = ttd;
                ttd = fl->expires;
                if (fl->opt && fl->share == IPV6_FL_S_EXCL) {
                        struct ipv6_txoptions *opt = fl->opt;
                        fl->opt = NULL;
                        kfree(opt);
                }
                if (!timer_pending(&ip6_fl_gc_timer) ||
                    time_after(ip6_fl_gc_timer.expires, ttd))
                        mod_timer(&ip6_fl_gc_timer, ttd);
        }
 
        write_unlock_bh(&ip6_fl_lock);
}
 
static void ip6_fl_gc(unsigned long dummy)
{
        int i;
        unsigned long now = jiffies;
        unsigned long sched = 0;
 
        write_lock(&ip6_fl_lock);
 
        for (i=0; i<=FL_HASH_MASK; i++) {
                struct ip6_flowlabel *fl, **flp;
                flp = &fl_ht[i];
                while ((fl=*flp) != NULL) {
                        if (atomic_read(&fl->users) == 0) {
                                unsigned long ttd = fl->lastuse + fl->linger;
                                if (time_after(ttd, fl->expires))
                                        fl->expires = ttd;
                                ttd = fl->expires;
                                if (time_after_eq(now, ttd)) {
                                        *flp = fl->next;
                                        fl_free(fl);
                                        atomic_dec(&fl_size);
                                        continue;
                                }
                                if (!sched || time_before(ttd, sched))
                                        sched = ttd;
                        }
                        flp = &fl->next;
                }
        }
        if (!sched && atomic_read(&fl_size))
                sched = now + FL_MAX_LINGER;
        if (sched) {
                ip6_fl_gc_timer.expires = sched;
                add_timer(&ip6_fl_gc_timer);
        }
        write_unlock(&ip6_fl_lock);
}
 
static struct ip6_flowlabel *fl_intern(struct ip6_flowlabel *fl, __be32 label)
{
        struct ip6_flowlabel *lfl;
 
        fl->label = label & IPV6_FLOWLABEL_MASK;
 
        write_lock_bh(&ip6_fl_lock);
        if (label == 0) {
                for (;;) {
                        fl->label = htonl(net_random())&IPV6_FLOWLABEL_MASK;
                        if (fl->label) {
                                lfl = __fl_lookup(fl->label);
                                if (lfl == NULL)
                                        break;
                        }
                }
        } else {
                /*
                 * we dropper the ip6_fl_lock, so this entry could reappear
                 * and we need to recheck with it.
                 *
                 * OTOH no need to search the active socket first, like it is
                 * done in ipv6_flowlabel_opt - sock is locked, so new entry
                 * with the same label can only appear on another sock
                 */
                lfl = __fl_lookup(fl->label);
                if (lfl != NULL) {
                        atomic_inc(&lfl->users);
                        write_unlock_bh(&ip6_fl_lock);
                        return lfl;
                }
        }
 
        fl->lastuse = jiffies;
        fl->next = fl_ht[FL_HASH(fl->label)];
        fl_ht[FL_HASH(fl->label)] = fl;
        atomic_inc(&fl_size);
        write_unlock_bh(&ip6_fl_lock);
        return NULL;
}
 
 
 
/* Socket flowlabel lists */
 
struct ip6_flowlabel * fl6_sock_lookup(struct sock *sk, __be32 label)
{
        struct ipv6_fl_socklist *sfl;
        struct ipv6_pinfo *np = inet6_sk(sk);
 
        label &= IPV6_FLOWLABEL_MASK;
 
        read_lock_bh(&ip6_sk_fl_lock);
        for (sfl=np->ipv6_fl_list; sfl; sfl = sfl->next) {
                struct ip6_flowlabel *fl = sfl->fl;
                if (fl->label == label) {
                        fl->lastuse = jiffies;
                        atomic_inc(&fl->users);
                        read_unlock_bh(&ip6_sk_fl_lock);
                        return fl;
                }
        }
        read_unlock_bh(&ip6_sk_fl_lock);
        return NULL;
}
 
EXPORT_SYMBOL_GPL(fl6_sock_lookup);
 
void fl6_free_socklist(struct sock *sk)
{
        struct ipv6_pinfo *np = inet6_sk(sk);
        struct ipv6_fl_socklist *sfl;
 
        while ((sfl = np->ipv6_fl_list) != NULL) {
                np->ipv6_fl_list = sfl->next;
                fl_release(sfl->fl);
                kfree(sfl);
        }
}
 
/* Service routines */
 
 
/*
   It is the only difficult place. flowlabel enforces equal headers
   before and including routing header, however user may supply options
   following rthdr.
 */
 
struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space,
                                         struct ip6_flowlabel * fl,
                                         struct ipv6_txoptions * fopt)
{
        struct ipv6_txoptions * fl_opt = fl->opt;
 
        if (fopt == NULL || fopt->opt_flen == 0)
                return fl_opt;
 
        if (fl_opt != NULL) {
                opt_space->hopopt = fl_opt->hopopt;
                opt_space->dst0opt = fl_opt->dst0opt;
                opt_space->srcrt = fl_opt->srcrt;
                opt_space->opt_nflen = fl_opt->opt_nflen;
        } else {
                if (fopt->opt_nflen == 0)
                        return fopt;
                opt_space->hopopt = NULL;
                opt_space->dst0opt = NULL;
                opt_space->srcrt = NULL;
                opt_space->opt_nflen = 0;
        }
        opt_space->dst1opt = fopt->dst1opt;
        opt_space->opt_flen = fopt->opt_flen;
        return opt_space;
}
 
static unsigned long check_linger(unsigned long ttl)
{
        if (ttl < FL_MIN_LINGER)
                return FL_MIN_LINGER*HZ;
        if (ttl > FL_MAX_LINGER && !capable(CAP_NET_ADMIN))
                return 0;
        return ttl*HZ;
}
 
static int fl6_renew(struct ip6_flowlabel *fl, unsigned long linger, unsigned long expires)
{
        linger = check_linger(linger);
        if (!linger)
                return -EPERM;
        expires = check_linger(expires);
        if (!expires)
                return -EPERM;
        fl->lastuse = jiffies;
        if (time_before(fl->linger, linger))
                fl->linger = linger;
        if (time_before(expires, fl->linger))
                expires = fl->linger;
        if (time_before(fl->expires, fl->lastuse + expires))
                fl->expires = fl->lastuse + expires;
        return 0;
}
 
static struct ip6_flowlabel *
fl_create(struct in6_flowlabel_req *freq, char __user *optval, int optlen, int *err_p)
{
        struct ip6_flowlabel *fl;
        int olen;
        int addr_type;
        int err;
 
        err = -ENOMEM;
        fl = kzalloc(sizeof(*fl), GFP_KERNEL);
        if (fl == NULL)
                goto done;
 
        olen = optlen - CMSG_ALIGN(sizeof(*freq));
        if (olen > 0) {
                struct msghdr msg;
                struct flowi flowi;
                int junk;
 
                err = -ENOMEM;
                fl->opt = kmalloc(sizeof(*fl->opt) + olen, GFP_KERNEL);
                if (fl->opt == NULL)
                        goto done;
 
                memset(fl->opt, 0, sizeof(*fl->opt));
                fl->opt->tot_len = sizeof(*fl->opt) + olen;
                err = -EFAULT;
                if (copy_from_user(fl->opt+1, optval+CMSG_ALIGN(sizeof(*freq)), olen))
                        goto done;
 
                msg.msg_controllen = olen;
                msg.msg_control = (void*)(fl->opt+1);
                flowi.oif = 0;
 
                err = datagram_send_ctl(&msg, &flowi, fl->opt, &junk, &junk);
                if (err)
                        goto done;
                err = -EINVAL;
                if (fl->opt->opt_flen)
                        goto done;
                if (fl->opt->opt_nflen == 0) {
                        kfree(fl->opt);
                        fl->opt = NULL;
                }
        }
 
        fl->expires = jiffies;
        err = fl6_renew(fl, freq->flr_linger, freq->flr_expires);
        if (err)
                goto done;
        fl->share = freq->flr_share;
        addr_type = ipv6_addr_type(&freq->flr_dst);
        if ((addr_type&IPV6_ADDR_MAPPED)
            || addr_type == IPV6_ADDR_ANY) {
                err = -EINVAL;
                goto done;
        }
        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 = current->pid;
                break;
        case IPV6_FL_S_USER:
                fl->owner = current->euid;
                break;
        default:
                err = -EINVAL;
                goto done;
        }
        return fl;
 
done:
        fl_free(fl);
        *err_p = err;
        return NULL;
}
 
static int mem_check(struct sock *sk)
{
        struct ipv6_pinfo *np = inet6_sk(sk);
        struct ipv6_fl_socklist *sfl;
        int room = FL_MAX_SIZE - atomic_read(&fl_size);
        int count = 0;
 
        if (room > FL_MAX_SIZE - FL_MAX_PER_SOCK)
                return 0;
 
        for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next)
                count++;
 
        if (room <= 0 ||
            ((count >= FL_MAX_PER_SOCK ||
             (count > 0 && room < FL_MAX_SIZE/2) || room < FL_MAX_SIZE/4)
             && !capable(CAP_NET_ADMIN)))
                return -ENOBUFS;
 
        return 0;
}
 
static int ipv6_hdr_cmp(struct ipv6_opt_hdr *h1, struct ipv6_opt_hdr *h2)
{
        if (h1 == h2)
                return 0;
        if (h1 == NULL || h2 == NULL)
                return 1;
        if (h1->hdrlen != h2->hdrlen)
                return 1;
        return memcmp(h1+1, h2+1, ((h1->hdrlen+1)<<3) - sizeof(*h1));
}
 
static int ipv6_opt_cmp(struct ipv6_txoptions *o1, struct ipv6_txoptions *o2)
{
        if (o1 == o2)
                return 0;
        if (o1 == NULL || o2 == NULL)
                return 1;
        if (o1->opt_nflen != o2->opt_nflen)
                return 1;
        if (ipv6_hdr_cmp(o1->hopopt, o2->hopopt))
                return 1;
        if (ipv6_hdr_cmp(o1->dst0opt, o2->dst0opt))
                return 1;
        if (ipv6_hdr_cmp((struct ipv6_opt_hdr *)o1->srcrt, (struct ipv6_opt_hdr *)o2->srcrt))
                return 1;
        return 0;
}
 
static inline void fl_link(struct ipv6_pinfo *np, struct ipv6_fl_socklist *sfl,
                struct ip6_flowlabel *fl)
{
        write_lock_bh(&ip6_sk_fl_lock);
        sfl->fl = fl;
        sfl->next = np->ipv6_fl_list;
        np->ipv6_fl_list = sfl;
        write_unlock_bh(&ip6_sk_fl_lock);
}
 
int ipv6_flowlabel_opt(struct sock *sk, char __user *optval, int optlen)
{
        int err;
        struct ipv6_pinfo *np = inet6_sk(sk);
        struct in6_flowlabel_req freq;
        struct ipv6_fl_socklist *sfl1=NULL;
        struct ipv6_fl_socklist *sfl, **sflp;
        struct ip6_flowlabel *fl, *fl1 = NULL;
 
 
        if (optlen < sizeof(freq))
                return -EINVAL;
 
        if (copy_from_user(&freq, optval, sizeof(freq)))
                return -EFAULT;
 
        switch (freq.flr_action) {
        case IPV6_FL_A_PUT:
                write_lock_bh(&ip6_sk_fl_lock);
                for (sflp = &np->ipv6_fl_list; (sfl=*sflp)!=NULL; sflp = &sfl->next) {
                        if (sfl->fl->label == freq.flr_label) {
                                if (freq.flr_label == (np->flow_label&IPV6_FLOWLABEL_MASK))
                                        np->flow_label &= ~IPV6_FLOWLABEL_MASK;
                                *sflp = sfl->next;
                                write_unlock_bh(&ip6_sk_fl_lock);
                                fl_release(sfl->fl);
                                kfree(sfl);
                                return 0;
                        }
                }
                write_unlock_bh(&ip6_sk_fl_lock);
                return -ESRCH;
 
        case IPV6_FL_A_RENEW:
                read_lock_bh(&ip6_sk_fl_lock);
                for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {
                        if (sfl->fl->label == freq.flr_label) {
                                err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires);
                                read_unlock_bh(&ip6_sk_fl_lock);
                                return err;
                        }
                }
                read_unlock_bh(&ip6_sk_fl_lock);
 
                if (freq.flr_share == IPV6_FL_S_NONE && capable(CAP_NET_ADMIN)) {
                        fl = fl_lookup(freq.flr_label);
                        if (fl) {
                                err = fl6_renew(fl, freq.flr_linger, freq.flr_expires);
                                fl_release(fl);
                                return err;
                        }
                }
                return -ESRCH;
 
        case IPV6_FL_A_GET:
                if (freq.flr_label & ~IPV6_FLOWLABEL_MASK)
                        return -EINVAL;
 
                fl = fl_create(&freq, optval, optlen, &err);
                if (fl == NULL)
                        return err;
                sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);
 
                if (freq.flr_label) {
                        err = -EEXIST;
                        read_lock_bh(&ip6_sk_fl_lock);
                        for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {
                                if (sfl->fl->label == freq.flr_label) {
                                        if (freq.flr_flags&IPV6_FL_F_EXCL) {
                                                read_unlock_bh(&ip6_sk_fl_lock);
                                                goto done;
                                        }
                                        fl1 = sfl->fl;
                                        atomic_inc(&fl1->users);
                                        break;
                                }
                        }
                        read_unlock_bh(&ip6_sk_fl_lock);
 
                        if (fl1 == NULL)
                                fl1 = fl_lookup(freq.flr_label);
                        if (fl1) {
recheck:
                                err = -EEXIST;
                                if (freq.flr_flags&IPV6_FL_F_EXCL)
                                        goto release;
                                err = -EPERM;
                                if (fl1->share == IPV6_FL_S_EXCL ||
                                    fl1->share != fl->share ||
                                    fl1->owner != fl->owner)
                                        goto release;
 
                                err = -EINVAL;
                                if (!ipv6_addr_equal(&fl1->dst, &fl->dst) ||
                                    ipv6_opt_cmp(fl1->opt, fl->opt))
                                        goto release;
 
                                err = -ENOMEM;
                                if (sfl1 == NULL)
                                        goto release;
                                if (fl->linger > fl1->linger)
                                        fl1->linger = fl->linger;
                                if ((long)(fl->expires - fl1->expires) > 0)
                                        fl1->expires = fl->expires;
                                fl_link(np, sfl1, fl1);
                                fl_free(fl);
                                return 0;
 
release:
                                fl_release(fl1);
                                goto done;
                        }
                }
                err = -ENOENT;
                if (!(freq.flr_flags&IPV6_FL_F_CREATE))
                        goto done;
 
                err = -ENOMEM;
                if (sfl1 == NULL || (err = mem_check(sk)) != 0)
                        goto done;
 
                fl1 = fl_intern(fl, freq.flr_label);
                if (fl1 != NULL)
                        goto recheck;
 
                if (!freq.flr_label) {
                        if (copy_to_user(&((struct in6_flowlabel_req __user *) optval)->flr_label,
                                         &fl->label, sizeof(fl->label))) {
                                /* Intentionally ignore fault. */
                        }
                }
 
                fl_link(np, sfl1, fl);
                return 0;
 
        default:
                return -EINVAL;
        }
 
done:
        fl_free(fl);
        kfree(sfl1);
        return err;
}
 
#ifdef CONFIG_PROC_FS
 
struct ip6fl_iter_state {
        int bucket;
};
 
#define ip6fl_seq_private(seq)  ((struct ip6fl_iter_state *)(seq)->private)
 
static struct ip6_flowlabel *ip6fl_get_first(struct seq_file *seq)
{
        struct ip6_flowlabel *fl = NULL;
        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
 
        for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) {
                if (fl_ht[state->bucket]) {
                        fl = fl_ht[state->bucket];
                        break;
                }
        }
        return fl;
}
 
static struct ip6_flowlabel *ip6fl_get_next(struct seq_file *seq, struct ip6_flowlabel *fl)
{
        struct ip6fl_iter_state *state = ip6fl_seq_private(seq);
 
        fl = fl->next;
        while (!fl) {
                if (++state->bucket <= FL_HASH_MASK)
                        fl = fl_ht[state->bucket];
                else
                        break;
        }
        return fl;
}
 
static struct ip6_flowlabel *ip6fl_get_idx(struct seq_file *seq, loff_t pos)
{
        struct ip6_flowlabel *fl = ip6fl_get_first(seq);
        if (fl)
                while (pos && (fl = ip6fl_get_next(seq, fl)) != NULL)
                        --pos;
        return pos ? NULL : fl;
}
 
static void *ip6fl_seq_start(struct seq_file *seq, loff_t *pos)
{
        read_lock_bh(&ip6_fl_lock);
        return *pos ? ip6fl_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}
 
static void *ip6fl_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
        struct ip6_flowlabel *fl;
 
        if (v == SEQ_START_TOKEN)
                fl = ip6fl_get_first(seq);
        else
                fl = ip6fl_get_next(seq, v);
        ++*pos;
        return fl;
}
 
static void ip6fl_seq_stop(struct seq_file *seq, void *v)
{
        read_unlock_bh(&ip6_fl_lock);
}
 
static int ip6fl_seq_show(struct seq_file *seq, void *v)
{
        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");
        else {
                struct ip6_flowlabel *fl = v;
                seq_printf(seq,
                           "%05X %-1d %-6d %-6d %-6ld %-8ld " NIP6_SEQFMT " %-4d\n",
                           (unsigned)ntohl(fl->label),
                           fl->share,
                           (unsigned)fl->owner,
                           atomic_read(&fl->users),
                           fl->linger/HZ,
                           (long)(fl->expires - jiffies)/HZ,
                           NIP6(fl->dst),
                           fl->opt ? fl->opt->opt_nflen : 0);
        }
        return 0;
}
 
static const struct seq_operations ip6fl_seq_ops = {
        .start  =       ip6fl_seq_start,
        .next   =       ip6fl_seq_next,
        .stop   =       ip6fl_seq_stop,
        .show   =       ip6fl_seq_show,
};
 
static int ip6fl_seq_open(struct inode *inode, struct file *file)
{
        return seq_open_private(file, &ip6fl_seq_ops,
                        sizeof(struct ip6fl_iter_state));
}
 
static const struct file_operations ip6fl_seq_fops = {
        .owner          =       THIS_MODULE,
        .open           =       ip6fl_seq_open,
        .read           =       seq_read,
        .llseek         =       seq_lseek,
        .release        =       seq_release_private,
};
#endif
 
 
void ip6_flowlabel_init(void)
{
#ifdef CONFIG_PROC_FS
        proc_net_fops_create(&init_net, "ip6_flowlabel", S_IRUGO, &ip6fl_seq_fops);
#endif
}
 
void ip6_flowlabel_cleanup(void)
{
        del_timer(&ip6_fl_gc_timer);
#ifdef CONFIG_PROC_FS
        proc_net_remove(&init_net, "ip6_flowlabel");
#endif
}

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [tags/] [linux-2.6/] [linux-2.6.24_or32_unified_v2.3/] [net/] [ipv6/] [ip6_flowlabel.c] - Blame information for rev 8

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* ip6_flowlabel.c IPv6 flowlabel manager.`
3			`*`
4			`* This program is free software; you can redistribute it and/or`
5			`* modify it under the terms of the GNU General Public License`
6			`* as published by the Free Software Foundation; either version`
7			`* 2 of the License, or (at your option) any later version.`
8			`*`
9			`* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>`
10			`*/`
11
12			`#include <linux/capability.h>`
13			`#include <linux/errno.h>`
14			`#include <linux/types.h>`
15			`#include <linux/socket.h>`
16			`#include <linux/net.h>`
17			`#include <linux/netdevice.h>`
18			`#include <linux/if_arp.h>`
19			`#include <linux/in6.h>`
20			`#include <linux/route.h>`
21			`#include <linux/proc_fs.h>`
22			`#include <linux/seq_file.h>`
23
24			`#include <net/net_namespace.h>`
25			`#include <net/sock.h>`
26
27			`#include <net/ipv6.h>`
28			`#include <net/ndisc.h>`
29			`#include <net/protocol.h>`
30			`#include <net/ip6_route.h>`
31			`#include <net/addrconf.h>`
32			`#include <net/rawv6.h>`
33			`#include <net/icmp.h>`
34			`#include <net/transp_v6.h>`
35
36			`#include <asm/uaccess.h>`
37
38			`#define FL_MIN_LINGER 6 /* Minimal linger. It is set to 6sec specified`
39			`in old IPv6 RFC. Well, it was reasonable value.`
40			`*/`
41			`#define FL_MAX_LINGER 60 /* Maximal linger timeout */`
42
43			`/* FL hash table */`
44
45			`#define FL_MAX_PER_SOCK 32`
46			`#define FL_MAX_SIZE 4096`
47			`#define FL_HASH_MASK 255`
48			`#define FL_HASH(l) (ntohl(l)&FL_HASH_MASK)`
49
50			`static atomic_t fl_size = ATOMIC_INIT(0);`
51			`static struct ip6_flowlabel *fl_ht[FL_HASH_MASK+1];`
52
53			`static void ip6_fl_gc(unsigned long dummy);`
54			`static DEFINE_TIMER(ip6_fl_gc_timer, ip6_fl_gc, 0, 0);`
55
56			`/* FL hash table lock: it protects only of GC */`
57
58			`static DEFINE_RWLOCK(ip6_fl_lock);`
59
60			`/* Big socket sock */`
61
62			`static DEFINE_RWLOCK(ip6_sk_fl_lock);`
63
64
65			`static __inline__ struct ip6_flowlabel * __fl_lookup(__be32 label)`
66			`{`
67			`struct ip6_flowlabel *fl;`
68
69			`for (fl=fl_ht[FL_HASH(label)]; fl; fl = fl->next) {`
70			`if (fl->label == label)`
71			`return fl;`
72			`}`
73			`return NULL;`
74			`}`
75
76			`static struct ip6_flowlabel * fl_lookup(__be32 label)`
77			`{`
78			`struct ip6_flowlabel *fl;`
79
80			`read_lock_bh(&ip6_fl_lock);`
81			`fl = __fl_lookup(label);`
82			`if (fl)`
83			`atomic_inc(&fl->users);`
84			`read_unlock_bh(&ip6_fl_lock);`
85			`return fl;`
86			`}`
87
88
89			`static void fl_free(struct ip6_flowlabel *fl)`
90			`{`
91			`if (fl)`
92			`kfree(fl->opt);`
93			`kfree(fl);`
94			`}`
95
96			`static void fl_release(struct ip6_flowlabel *fl)`
97			`{`
98			`write_lock_bh(&ip6_fl_lock);`
99
100			`fl->lastuse = jiffies;`
101			`if (atomic_dec_and_test(&fl->users)) {`
102			`unsigned long ttd = fl->lastuse + fl->linger;`
103			`if (time_after(ttd, fl->expires))`
104			`fl->expires = ttd;`
105			`ttd = fl->expires;`
106			`if (fl->opt && fl->share == IPV6_FL_S_EXCL) {`
107			`struct ipv6_txoptions *opt = fl->opt;`
108			`fl->opt = NULL;`
109			`kfree(opt);`
110			`}`
111			`if (!timer_pending(&ip6_fl_gc_timer) \|\|`
112			`time_after(ip6_fl_gc_timer.expires, ttd))`
113			`mod_timer(&ip6_fl_gc_timer, ttd);`
114			`}`
115
116			`write_unlock_bh(&ip6_fl_lock);`
117			`}`
118
119			`static void ip6_fl_gc(unsigned long dummy)`
120			`{`
121			`int i;`
122			`unsigned long now = jiffies;`
123			`unsigned long sched = 0;`
124
125			`write_lock(&ip6_fl_lock);`
126
127			`for (i=0; i<=FL_HASH_MASK; i++) {`
128			`struct ip6_flowlabel fl, *flp;`
129			`flp = &fl_ht[i];`
130			`while ((fl=*flp) != NULL) {`
131			`if (atomic_read(&fl->users) == 0) {`
132			`unsigned long ttd = fl->lastuse + fl->linger;`
133			`if (time_after(ttd, fl->expires))`
134			`fl->expires = ttd;`
135			`ttd = fl->expires;`
136			`if (time_after_eq(now, ttd)) {`
137			`*flp = fl->next;`
138			`fl_free(fl);`
139			`atomic_dec(&fl_size);`
140			`continue;`
141			`}`
142			`if (!sched \|\| time_before(ttd, sched))`
143			`sched = ttd;`
144			`}`
145			`flp = &fl->next;`
146			`}`
147			`}`
148			`if (!sched && atomic_read(&fl_size))`
149			`sched = now + FL_MAX_LINGER;`
150			`if (sched) {`
151			`ip6_fl_gc_timer.expires = sched;`
152			`add_timer(&ip6_fl_gc_timer);`
153			`}`
154			`write_unlock(&ip6_fl_lock);`
155			`}`
156
157			`static struct ip6_flowlabel fl_intern(struct ip6_flowlabel fl, __be32 label)`
158			`{`
159			`struct ip6_flowlabel *lfl;`
160
161			`fl->label = label & IPV6_FLOWLABEL_MASK;`
162
163			`write_lock_bh(&ip6_fl_lock);`
164			`if (label == 0) {`
165			`for (;;) {`
166			`fl->label = htonl(net_random())&IPV6_FLOWLABEL_MASK;`
167			`if (fl->label) {`
168			`lfl = __fl_lookup(fl->label);`
169			`if (lfl == NULL)`
170			`break;`
171			`}`
172			`}`
173			`} else {`
174			`/*`
175			`* we dropper the ip6_fl_lock, so this entry could reappear`
176			`* and we need to recheck with it.`
177			`*`
178			`* OTOH no need to search the active socket first, like it is`
179			`* done in ipv6_flowlabel_opt - sock is locked, so new entry`
180			`* with the same label can only appear on another sock`
181			`*/`
182			`lfl = __fl_lookup(fl->label);`
183			`if (lfl != NULL) {`
184			`atomic_inc(&lfl->users);`
185			`write_unlock_bh(&ip6_fl_lock);`
186			`return lfl;`
187			`}`
188			`}`
189
190			`fl->lastuse = jiffies;`
191			`fl->next = fl_ht[FL_HASH(fl->label)];`
192			`fl_ht[FL_HASH(fl->label)] = fl;`
193			`atomic_inc(&fl_size);`
194			`write_unlock_bh(&ip6_fl_lock);`
195			`return NULL;`
196			`}`
197
198
199
200			`/* Socket flowlabel lists */`
201
202			`struct ip6_flowlabel * fl6_sock_lookup(struct sock *sk, __be32 label)`
203			`{`
204			`struct ipv6_fl_socklist *sfl;`
205			`struct ipv6_pinfo *np = inet6_sk(sk);`
206
207			`label &= IPV6_FLOWLABEL_MASK;`
208
209			`read_lock_bh(&ip6_sk_fl_lock);`
210			`for (sfl=np->ipv6_fl_list; sfl; sfl = sfl->next) {`
211			`struct ip6_flowlabel *fl = sfl->fl;`
212			`if (fl->label == label) {`
213			`fl->lastuse = jiffies;`
214			`atomic_inc(&fl->users);`
215			`read_unlock_bh(&ip6_sk_fl_lock);`
216			`return fl;`
217			`}`
218			`}`
219			`read_unlock_bh(&ip6_sk_fl_lock);`
220			`return NULL;`
221			`}`
222
223			`EXPORT_SYMBOL_GPL(fl6_sock_lookup);`
224
225			`void fl6_free_socklist(struct sock *sk)`
226			`{`
227			`struct ipv6_pinfo *np = inet6_sk(sk);`
228			`struct ipv6_fl_socklist *sfl;`
229
230			`while ((sfl = np->ipv6_fl_list) != NULL) {`
231			`np->ipv6_fl_list = sfl->next;`
232			`fl_release(sfl->fl);`
233			`kfree(sfl);`
234			`}`
235			`}`
236
237			`/* Service routines */`
238
239
240			`/*`
241			`It is the only difficult place. flowlabel enforces equal headers`
242			`before and including routing header, however user may supply options`
243			`following rthdr.`
244			`*/`
245
246			`struct ipv6_txoptions fl6_merge_options(struct ipv6_txoptions opt_space,`
247			`struct ip6_flowlabel * fl,`
248			`struct ipv6_txoptions * fopt)`
249			`{`
250			`struct ipv6_txoptions * fl_opt = fl->opt;`
251
252			`if (fopt == NULL \|\| fopt->opt_flen == 0)`
253			`return fl_opt;`
254
255			`if (fl_opt != NULL) {`
256			`opt_space->hopopt = fl_opt->hopopt;`
257			`opt_space->dst0opt = fl_opt->dst0opt;`
258			`opt_space->srcrt = fl_opt->srcrt;`
259			`opt_space->opt_nflen = fl_opt->opt_nflen;`
260			`} else {`
261			`if (fopt->opt_nflen == 0)`
262			`return fopt;`
263			`opt_space->hopopt = NULL;`
264			`opt_space->dst0opt = NULL;`
265			`opt_space->srcrt = NULL;`
266			`opt_space->opt_nflen = 0;`
267			`}`
268			`opt_space->dst1opt = fopt->dst1opt;`
269			`opt_space->opt_flen = fopt->opt_flen;`
270			`return opt_space;`
271			`}`
272
273			`static unsigned long check_linger(unsigned long ttl)`
274			`{`
275			`if (ttl < FL_MIN_LINGER)`
276			`return FL_MIN_LINGER*HZ;`
277			`if (ttl > FL_MAX_LINGER && !capable(CAP_NET_ADMIN))`
278			`return 0;`
279			`return ttl*HZ;`
280			`}`
281
282			`static int fl6_renew(struct ip6_flowlabel *fl, unsigned long linger, unsigned long expires)`
283			`{`
284			`linger = check_linger(linger);`
285			`if (!linger)`
286			`return -EPERM;`
287			`expires = check_linger(expires);`
288			`if (!expires)`
289			`return -EPERM;`
290			`fl->lastuse = jiffies;`
291			`if (time_before(fl->linger, linger))`
292			`fl->linger = linger;`
293			`if (time_before(expires, fl->linger))`
294			`expires = fl->linger;`
295			`if (time_before(fl->expires, fl->lastuse + expires))`
296			`fl->expires = fl->lastuse + expires;`
297			`return 0;`
298			`}`
299
300			`static struct ip6_flowlabel *`
301			`fl_create(struct in6_flowlabel_req freq, char __user optval, int optlen, int *err_p)`
302			`{`
303			`struct ip6_flowlabel *fl;`
304			`int olen;`
305			`int addr_type;`
306			`int err;`
307
308			`err = -ENOMEM;`
309			`fl = kzalloc(sizeof(*fl), GFP_KERNEL);`
310			`if (fl == NULL)`
311			`goto done;`
312
313			`olen = optlen - CMSG_ALIGN(sizeof(*freq));`
314			`if (olen > 0) {`
315			`struct msghdr msg;`
316			`struct flowi flowi;`
317			`int junk;`
318
319			`err = -ENOMEM;`
320			`fl->opt = kmalloc(sizeof(*fl->opt) + olen, GFP_KERNEL);`
321			`if (fl->opt == NULL)`
322			`goto done;`
323
324			`memset(fl->opt, 0, sizeof(*fl->opt));`
325			`fl->opt->tot_len = sizeof(*fl->opt) + olen;`
326			`err = -EFAULT;`
327			`if (copy_from_user(fl->opt+1, optval+CMSG_ALIGN(sizeof(*freq)), olen))`
328			`goto done;`
329
330			`msg.msg_controllen = olen;`
331			`msg.msg_control = (void*)(fl->opt+1);`
332			`flowi.oif = 0;`
333
334			`err = datagram_send_ctl(&msg, &flowi, fl->opt, &junk, &junk);`
335			`if (err)`
336			`goto done;`
337			`err = -EINVAL;`
338			`if (fl->opt->opt_flen)`
339			`goto done;`
340			`if (fl->opt->opt_nflen == 0) {`
341			`kfree(fl->opt);`
342			`fl->opt = NULL;`
343			`}`
344			`}`
345
346			`fl->expires = jiffies;`
347			`err = fl6_renew(fl, freq->flr_linger, freq->flr_expires);`
348			`if (err)`
349			`goto done;`
350			`fl->share = freq->flr_share;`
351			`addr_type = ipv6_addr_type(&freq->flr_dst);`
352			`if ((addr_type&IPV6_ADDR_MAPPED)`
353			`\|\| addr_type == IPV6_ADDR_ANY) {`
354			`err = -EINVAL;`
355			`goto done;`
356			`}`
357			`ipv6_addr_copy(&fl->dst, &freq->flr_dst);`
358			`atomic_set(&fl->users, 1);`
359			`switch (fl->share) {`
360			`case IPV6_FL_S_EXCL:`
361			`case IPV6_FL_S_ANY:`
362			`break;`
363			`case IPV6_FL_S_PROCESS:`
364			`fl->owner = current->pid;`
365			`break;`
366			`case IPV6_FL_S_USER:`
367			`fl->owner = current->euid;`
368			`break;`
369			`default:`
370			`err = -EINVAL;`
371			`goto done;`
372			`}`
373			`return fl;`
374
375			`done:`
376			`fl_free(fl);`
377			`*err_p = err;`
378			`return NULL;`
379			`}`
380
381			`static int mem_check(struct sock *sk)`
382			`{`
383			`struct ipv6_pinfo *np = inet6_sk(sk);`
384			`struct ipv6_fl_socklist *sfl;`
385			`int room = FL_MAX_SIZE - atomic_read(&fl_size);`
386			`int count = 0;`
387
388			`if (room > FL_MAX_SIZE - FL_MAX_PER_SOCK)`
389			`return 0;`
390
391			`for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next)`
392			`count++;`
393
394			`if (room <= 0 \|\|`
395			`((count >= FL_MAX_PER_SOCK \|\|`
396			`(count > 0 && room < FL_MAX_SIZE/2) \|\| room < FL_MAX_SIZE/4)`
397			`&& !capable(CAP_NET_ADMIN)))`
398			`return -ENOBUFS;`
399
400			`return 0;`
401			`}`
402
403			`static int ipv6_hdr_cmp(struct ipv6_opt_hdr h1, struct ipv6_opt_hdr h2)`
404			`{`
405			`if (h1 == h2)`
406			`return 0;`
407			`if (h1 == NULL \|\| h2 == NULL)`
408			`return 1;`
409			`if (h1->hdrlen != h2->hdrlen)`
410			`return 1;`
411			`return memcmp(h1+1, h2+1, ((h1->hdrlen+1)<<3) - sizeof(*h1));`
412			`}`
413
414			`static int ipv6_opt_cmp(struct ipv6_txoptions o1, struct ipv6_txoptions o2)`
415			`{`
416			`if (o1 == o2)`
417			`return 0;`
418			`if (o1 == NULL \|\| o2 == NULL)`
419			`return 1;`
420			`if (o1->opt_nflen != o2->opt_nflen)`
421			`return 1;`
422			`if (ipv6_hdr_cmp(o1->hopopt, o2->hopopt))`
423			`return 1;`
424			`if (ipv6_hdr_cmp(o1->dst0opt, o2->dst0opt))`
425			`return 1;`
426			`if (ipv6_hdr_cmp((struct ipv6_opt_hdr )o1->srcrt, (struct ipv6_opt_hdr )o2->srcrt))`
427			`return 1;`
428			`return 0;`
429			`}`
430
431			`static inline void fl_link(struct ipv6_pinfo np, struct ipv6_fl_socklist sfl,`
432			`struct ip6_flowlabel *fl)`
433			`{`
434			`write_lock_bh(&ip6_sk_fl_lock);`
435			`sfl->fl = fl;`
436			`sfl->next = np->ipv6_fl_list;`
437			`np->ipv6_fl_list = sfl;`
438			`write_unlock_bh(&ip6_sk_fl_lock);`
439			`}`
440
441			`int ipv6_flowlabel_opt(struct sock sk, char __user optval, int optlen)`
442			`{`
443			`int err;`
444			`struct ipv6_pinfo *np = inet6_sk(sk);`
445			`struct in6_flowlabel_req freq;`
446			`struct ipv6_fl_socklist *sfl1=NULL;`
447			`struct ipv6_fl_socklist sfl, *sflp;`
448			`struct ip6_flowlabel fl, fl1 = NULL;`
449
450
451			`if (optlen < sizeof(freq))`
452			`return -EINVAL;`
453
454			`if (copy_from_user(&freq, optval, sizeof(freq)))`
455			`return -EFAULT;`
456
457			`switch (freq.flr_action) {`
458			`case IPV6_FL_A_PUT:`
459			`write_lock_bh(&ip6_sk_fl_lock);`
460			`for (sflp = &np->ipv6_fl_list; (sfl=*sflp)!=NULL; sflp = &sfl->next) {`
461			`if (sfl->fl->label == freq.flr_label) {`
462			`if (freq.flr_label == (np->flow_label&IPV6_FLOWLABEL_MASK))`
463			`np->flow_label &= ~IPV6_FLOWLABEL_MASK;`
464			`*sflp = sfl->next;`
465			`write_unlock_bh(&ip6_sk_fl_lock);`
466			`fl_release(sfl->fl);`
467			`kfree(sfl);`
468			`return 0;`
469			`}`
470			`}`
471			`write_unlock_bh(&ip6_sk_fl_lock);`
472			`return -ESRCH;`
473
474			`case IPV6_FL_A_RENEW:`
475			`read_lock_bh(&ip6_sk_fl_lock);`
476			`for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {`
477			`if (sfl->fl->label == freq.flr_label) {`
478			`err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires);`
479			`read_unlock_bh(&ip6_sk_fl_lock);`
480			`return err;`
481			`}`
482			`}`
483			`read_unlock_bh(&ip6_sk_fl_lock);`
484
485			`if (freq.flr_share == IPV6_FL_S_NONE && capable(CAP_NET_ADMIN)) {`
486			`fl = fl_lookup(freq.flr_label);`
487			`if (fl) {`
488			`err = fl6_renew(fl, freq.flr_linger, freq.flr_expires);`
489			`fl_release(fl);`
490			`return err;`
491			`}`
492			`}`
493			`return -ESRCH;`
494
495			`case IPV6_FL_A_GET:`
496			`if (freq.flr_label & ~IPV6_FLOWLABEL_MASK)`
497			`return -EINVAL;`
498
499			`fl = fl_create(&freq, optval, optlen, &err);`
500			`if (fl == NULL)`
501			`return err;`
502			`sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);`
503
504			`if (freq.flr_label) {`
505			`err = -EEXIST;`
506			`read_lock_bh(&ip6_sk_fl_lock);`
507			`for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {`
508			`if (sfl->fl->label == freq.flr_label) {`
509			`if (freq.flr_flags&IPV6_FL_F_EXCL) {`
510			`read_unlock_bh(&ip6_sk_fl_lock);`
511			`goto done;`
512			`}`
513			`fl1 = sfl->fl;`
514			`atomic_inc(&fl1->users);`
515			`break;`
516			`}`
517			`}`
518			`read_unlock_bh(&ip6_sk_fl_lock);`
519
520			`if (fl1 == NULL)`
521			`fl1 = fl_lookup(freq.flr_label);`
522			`if (fl1) {`
523			`recheck:`
524			`err = -EEXIST;`
525			`if (freq.flr_flags&IPV6_FL_F_EXCL)`
526			`goto release;`
527			`err = -EPERM;`
528			`if (fl1->share == IPV6_FL_S_EXCL \|\|`
529			`fl1->share != fl->share \|\|`
530			`fl1->owner != fl->owner)`
531			`goto release;`
532
533			`err = -EINVAL;`
534			`if (!ipv6_addr_equal(&fl1->dst, &fl->dst) \|\|`
535			`ipv6_opt_cmp(fl1->opt, fl->opt))`
536			`goto release;`
537
538			`err = -ENOMEM;`
539			`if (sfl1 == NULL)`
540			`goto release;`
541			`if (fl->linger > fl1->linger)`
542			`fl1->linger = fl->linger;`
543			`if ((long)(fl->expires - fl1->expires) > 0)`
544			`fl1->expires = fl->expires;`
545			`fl_link(np, sfl1, fl1);`
546			`fl_free(fl);`
547			`return 0;`
548
549			`release:`
550			`fl_release(fl1);`
551			`goto done;`
552			`}`
553			`}`
554			`err = -ENOENT;`
555			`if (!(freq.flr_flags&IPV6_FL_F_CREATE))`
556			`goto done;`
557
558			`err = -ENOMEM;`
559			`if (sfl1 == NULL \|\| (err = mem_check(sk)) != 0)`
560			`goto done;`
561
562			`fl1 = fl_intern(fl, freq.flr_label);`
563			`if (fl1 != NULL)`
564			`goto recheck;`
565
566			`if (!freq.flr_label) {`
567			`if (copy_to_user(&((struct in6_flowlabel_req __user *) optval)->flr_label,`
568			`&fl->label, sizeof(fl->label))) {`
569			`/* Intentionally ignore fault. */`
570			`}`
571			`}`
572
573			`fl_link(np, sfl1, fl);`
574			`return 0;`
575
576			`default:`
577			`return -EINVAL;`
578			`}`
579
580			`done:`
581			`fl_free(fl);`
582			`kfree(sfl1);`
583			`return err;`
584			`}`
585
586			`#ifdef CONFIG_PROC_FS`
587
588			`struct ip6fl_iter_state {`
589			`int bucket;`
590			`};`
591
592			`#define ip6fl_seq_private(seq) ((struct ip6fl_iter_state *)(seq)->private)`
593
594			`static struct ip6_flowlabel ip6fl_get_first(struct seq_file seq)`
595			`{`
596			`struct ip6_flowlabel *fl = NULL;`
597			`struct ip6fl_iter_state *state = ip6fl_seq_private(seq);`
598
599			`for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) {`
600			`if (fl_ht[state->bucket]) {`
601			`fl = fl_ht[state->bucket];`
602			`break;`
603			`}`
604			`}`
605			`return fl;`
606			`}`
607
608			`static struct ip6_flowlabel ip6fl_get_next(struct seq_file seq, struct ip6_flowlabel *fl)`
609			`{`
610			`struct ip6fl_iter_state *state = ip6fl_seq_private(seq);`
611
612			`fl = fl->next;`
613			`while (!fl) {`
614			`if (++state->bucket <= FL_HASH_MASK)`
615			`fl = fl_ht[state->bucket];`
616			`else`
617			`break;`
618			`}`
619			`return fl;`
620			`}`
621
622			`static struct ip6_flowlabel ip6fl_get_idx(struct seq_file seq, loff_t pos)`
623			`{`
624			`struct ip6_flowlabel *fl = ip6fl_get_first(seq);`
625			`if (fl)`
626			`while (pos && (fl = ip6fl_get_next(seq, fl)) != NULL)`
627			`--pos;`
628			`return pos ? NULL : fl;`
629			`}`
630
631			`static void ip6fl_seq_start(struct seq_file seq, loff_t *pos)`
632			`{`
633			`read_lock_bh(&ip6_fl_lock);`
634			`return pos ? ip6fl_get_idx(seq, pos - 1) : SEQ_START_TOKEN;`
635			`}`
636
637			`static void ip6fl_seq_next(struct seq_file seq, void v, loff_t pos)`
638			`{`
639			`struct ip6_flowlabel *fl;`
640
641			`if (v == SEQ_START_TOKEN)`
642			`fl = ip6fl_get_first(seq);`
643			`else`
644			`fl = ip6fl_get_next(seq, v);`
645			`++*pos;`
646			`return fl;`
647			`}`
648
649			`static void ip6fl_seq_stop(struct seq_file seq, void v)`
650			`{`
651			`read_unlock_bh(&ip6_fl_lock);`
652			`}`
653
654			`static int ip6fl_seq_show(struct seq_file seq, void v)`
655			`{`
656			`if (v == SEQ_START_TOKEN)`
657			`seq_printf(seq, "%-5s %-1s %-6s %-6s %-6s %-8s %-32s %s\n",`
658			`"Label", "S", "Owner", "Users", "Linger", "Expires", "Dst", "Opt");`
659			`else {`
660			`struct ip6_flowlabel *fl = v;`
661			`seq_printf(seq,`
662			`"%05X %-1d %-6d %-6d %-6ld %-8ld " NIP6_SEQFMT " %-4d\n",`
663			`(unsigned)ntohl(fl->label),`
664			`fl->share,`
665			`(unsigned)fl->owner,`
666			`atomic_read(&fl->users),`
667			`fl->linger/HZ,`
668			`(long)(fl->expires - jiffies)/HZ,`
669			`NIP6(fl->dst),`
670			`fl->opt ? fl->opt->opt_nflen : 0);`
671			`}`
672			`return 0;`
673			`}`
674
675			`static const struct seq_operations ip6fl_seq_ops = {`
676			`.start = ip6fl_seq_start,`
677			`.next = ip6fl_seq_next,`
678			`.stop = ip6fl_seq_stop,`
679			`.show = ip6fl_seq_show,`
680			`};`
681
682			`static int ip6fl_seq_open(struct inode inode, struct file file)`
683			`{`
684			`return seq_open_private(file, &ip6fl_seq_ops,`
685			`sizeof(struct ip6fl_iter_state));`
686			`}`
687
688			`static const struct file_operations ip6fl_seq_fops = {`
689			`.owner = THIS_MODULE,`
690			`.open = ip6fl_seq_open,`
691			`.read = seq_read,`
692			`.llseek = seq_lseek,`
693			`.release = seq_release_private,`
694			`};`
695			`#endif`
696
697
698			`void ip6_flowlabel_init(void)`
699			`{`
700			`#ifdef CONFIG_PROC_FS`
701			`proc_net_fops_create(&init_net, "ip6_flowlabel", S_IRUGO, &ip6fl_seq_fops);`
702			`#endif`
703			`}`
704
705			`void ip6_flowlabel_cleanup(void)`
706			`{`
707			`del_timer(&ip6_fl_gc_timer);`
708			`#ifdef CONFIG_PROC_FS`
709			`proc_net_remove(&init_net, "ip6_flowlabel");`
710			`#endif`
711			`}`