2 * ip6_flowlabel.c IPv6 flowlabel manager.
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.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
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 #include <linux/slab.h>
24 #include <linux/export.h>
25 #include <linux/pid_namespace.h>
27 #include <net/net_namespace.h>
31 #include <net/ndisc.h>
32 #include <net/protocol.h>
33 #include <net/ip6_route.h>
34 #include <net/addrconf.h>
35 #include <net/rawv6.h>
37 #include <net/transp_v6.h>
39 #include <asm/uaccess.h>
41 #define FL_MIN_LINGER 6 /* Minimal linger. It is set to 6sec specified
42 in old IPv6 RFC. Well, it was reasonable value.
44 #define FL_MAX_LINGER 150 /* Maximal linger timeout */
48 #define FL_MAX_PER_SOCK 32
49 #define FL_MAX_SIZE 4096
50 #define FL_HASH_MASK 255
51 #define FL_HASH(l) (ntohl(l)&FL_HASH_MASK)
53 static atomic_t fl_size
= ATOMIC_INIT(0);
54 static struct ip6_flowlabel __rcu
*fl_ht
[FL_HASH_MASK
+1];
56 static void ip6_fl_gc(unsigned long dummy
);
57 static DEFINE_TIMER(ip6_fl_gc_timer
, ip6_fl_gc
, 0, 0);
59 /* FL hash table lock: it protects only of GC */
61 static DEFINE_SPINLOCK(ip6_fl_lock
);
65 static DEFINE_SPINLOCK(ip6_sk_fl_lock
);
67 #define for_each_fl_rcu(hash, fl) \
68 for (fl = rcu_dereference_bh(fl_ht[(hash)]); \
70 fl = rcu_dereference_bh(fl->next))
71 #define for_each_fl_continue_rcu(fl) \
72 for (fl = rcu_dereference_bh(fl->next); \
74 fl = rcu_dereference_bh(fl->next))
76 #define for_each_sk_fl_rcu(np, sfl) \
77 for (sfl = rcu_dereference_bh(np->ipv6_fl_list); \
79 sfl = rcu_dereference_bh(sfl->next))
81 static inline struct ip6_flowlabel
*__fl_lookup(struct net
*net
, __be32 label
)
83 struct ip6_flowlabel
*fl
;
85 for_each_fl_rcu(FL_HASH(label
), fl
) {
86 if (fl
->label
== label
&& net_eq(fl
->fl_net
, net
))
92 static struct ip6_flowlabel
*fl_lookup(struct net
*net
, __be32 label
)
94 struct ip6_flowlabel
*fl
;
97 fl
= __fl_lookup(net
, label
);
98 if (fl
&& !atomic_inc_not_zero(&fl
->users
))
100 rcu_read_unlock_bh();
105 static void fl_free(struct ip6_flowlabel
*fl
)
108 if (fl
->share
== IPV6_FL_S_PROCESS
)
109 put_pid(fl
->owner
.pid
);
110 release_net(fl
->fl_net
);
116 static void fl_release(struct ip6_flowlabel
*fl
)
118 spin_lock_bh(&ip6_fl_lock
);
120 fl
->lastuse
= jiffies
;
121 if (atomic_dec_and_test(&fl
->users
)) {
122 unsigned long ttd
= fl
->lastuse
+ fl
->linger
;
123 if (time_after(ttd
, fl
->expires
))
126 if (fl
->opt
&& fl
->share
== IPV6_FL_S_EXCL
) {
127 struct ipv6_txoptions
*opt
= fl
->opt
;
131 if (!timer_pending(&ip6_fl_gc_timer
) ||
132 time_after(ip6_fl_gc_timer
.expires
, ttd
))
133 mod_timer(&ip6_fl_gc_timer
, ttd
);
135 spin_unlock_bh(&ip6_fl_lock
);
138 static void ip6_fl_gc(unsigned long dummy
)
141 unsigned long now
= jiffies
;
142 unsigned long sched
= 0;
144 spin_lock(&ip6_fl_lock
);
146 for (i
=0; i
<=FL_HASH_MASK
; i
++) {
147 struct ip6_flowlabel
*fl
;
148 struct ip6_flowlabel __rcu
**flp
;
151 while ((fl
= rcu_dereference_protected(*flp
,
152 lockdep_is_held(&ip6_fl_lock
))) != NULL
) {
153 if (atomic_read(&fl
->users
) == 0) {
154 unsigned long ttd
= fl
->lastuse
+ fl
->linger
;
155 if (time_after(ttd
, fl
->expires
))
158 if (time_after_eq(now
, ttd
)) {
161 atomic_dec(&fl_size
);
164 if (!sched
|| time_before(ttd
, sched
))
170 if (!sched
&& atomic_read(&fl_size
))
171 sched
= now
+ FL_MAX_LINGER
;
173 mod_timer(&ip6_fl_gc_timer
, sched
);
175 spin_unlock(&ip6_fl_lock
);
178 static void __net_exit
ip6_fl_purge(struct net
*net
)
182 spin_lock(&ip6_fl_lock
);
183 for (i
= 0; i
<= FL_HASH_MASK
; i
++) {
184 struct ip6_flowlabel
*fl
;
185 struct ip6_flowlabel __rcu
**flp
;
188 while ((fl
= rcu_dereference_protected(*flp
,
189 lockdep_is_held(&ip6_fl_lock
))) != NULL
) {
190 if (net_eq(fl
->fl_net
, net
) &&
191 atomic_read(&fl
->users
) == 0) {
194 atomic_dec(&fl_size
);
200 spin_unlock(&ip6_fl_lock
);
203 static struct ip6_flowlabel
*fl_intern(struct net
*net
,
204 struct ip6_flowlabel
*fl
, __be32 label
)
206 struct ip6_flowlabel
*lfl
;
208 fl
->label
= label
& IPV6_FLOWLABEL_MASK
;
210 spin_lock_bh(&ip6_fl_lock
);
213 fl
->label
= htonl(net_random())&IPV6_FLOWLABEL_MASK
;
215 lfl
= __fl_lookup(net
, fl
->label
);
222 * we dropper the ip6_fl_lock, so this entry could reappear
223 * and we need to recheck with it.
225 * OTOH no need to search the active socket first, like it is
226 * done in ipv6_flowlabel_opt - sock is locked, so new entry
227 * with the same label can only appear on another sock
229 lfl
= __fl_lookup(net
, fl
->label
);
231 atomic_inc(&lfl
->users
);
232 spin_unlock_bh(&ip6_fl_lock
);
237 fl
->lastuse
= jiffies
;
238 fl
->next
= fl_ht
[FL_HASH(fl
->label
)];
239 rcu_assign_pointer(fl_ht
[FL_HASH(fl
->label
)], fl
);
240 atomic_inc(&fl_size
);
241 spin_unlock_bh(&ip6_fl_lock
);
247 /* Socket flowlabel lists */
249 struct ip6_flowlabel
* fl6_sock_lookup(struct sock
*sk
, __be32 label
)
251 struct ipv6_fl_socklist
*sfl
;
252 struct ipv6_pinfo
*np
= inet6_sk(sk
);
254 label
&= IPV6_FLOWLABEL_MASK
;
257 for_each_sk_fl_rcu(np
, sfl
) {
258 struct ip6_flowlabel
*fl
= sfl
->fl
;
259 if (fl
->label
== label
) {
260 fl
->lastuse
= jiffies
;
261 atomic_inc(&fl
->users
);
262 rcu_read_unlock_bh();
266 rcu_read_unlock_bh();
270 EXPORT_SYMBOL_GPL(fl6_sock_lookup
);
272 void fl6_free_socklist(struct sock
*sk
)
274 struct ipv6_pinfo
*np
= inet6_sk(sk
);
275 struct ipv6_fl_socklist
*sfl
;
277 if (!rcu_access_pointer(np
->ipv6_fl_list
))
280 spin_lock_bh(&ip6_sk_fl_lock
);
281 while ((sfl
= rcu_dereference_protected(np
->ipv6_fl_list
,
282 lockdep_is_held(&ip6_sk_fl_lock
))) != NULL
) {
283 np
->ipv6_fl_list
= sfl
->next
;
284 spin_unlock_bh(&ip6_sk_fl_lock
);
289 spin_lock_bh(&ip6_sk_fl_lock
);
291 spin_unlock_bh(&ip6_sk_fl_lock
);
294 /* Service routines */
298 It is the only difficult place. flowlabel enforces equal headers
299 before and including routing header, however user may supply options
303 struct ipv6_txoptions
*fl6_merge_options(struct ipv6_txoptions
* opt_space
,
304 struct ip6_flowlabel
* fl
,
305 struct ipv6_txoptions
* fopt
)
307 struct ipv6_txoptions
* fl_opt
= fl
->opt
;
309 if (fopt
== NULL
|| fopt
->opt_flen
== 0)
312 if (fl_opt
!= NULL
) {
313 opt_space
->hopopt
= fl_opt
->hopopt
;
314 opt_space
->dst0opt
= fl_opt
->dst0opt
;
315 opt_space
->srcrt
= fl_opt
->srcrt
;
316 opt_space
->opt_nflen
= fl_opt
->opt_nflen
;
318 if (fopt
->opt_nflen
== 0)
320 opt_space
->hopopt
= NULL
;
321 opt_space
->dst0opt
= NULL
;
322 opt_space
->srcrt
= NULL
;
323 opt_space
->opt_nflen
= 0;
325 opt_space
->dst1opt
= fopt
->dst1opt
;
326 opt_space
->opt_flen
= fopt
->opt_flen
;
329 EXPORT_SYMBOL_GPL(fl6_merge_options
);
331 static unsigned long check_linger(unsigned long ttl
)
333 if (ttl
< FL_MIN_LINGER
)
334 return FL_MIN_LINGER
*HZ
;
335 if (ttl
> FL_MAX_LINGER
&& !capable(CAP_NET_ADMIN
))
340 static int fl6_renew(struct ip6_flowlabel
*fl
, unsigned long linger
, unsigned long expires
)
342 linger
= check_linger(linger
);
345 expires
= check_linger(expires
);
349 spin_lock_bh(&ip6_fl_lock
);
350 fl
->lastuse
= jiffies
;
351 if (time_before(fl
->linger
, linger
))
353 if (time_before(expires
, fl
->linger
))
354 expires
= fl
->linger
;
355 if (time_before(fl
->expires
, fl
->lastuse
+ expires
))
356 fl
->expires
= fl
->lastuse
+ expires
;
357 spin_unlock_bh(&ip6_fl_lock
);
362 static struct ip6_flowlabel
*
363 fl_create(struct net
*net
, struct sock
*sk
, struct in6_flowlabel_req
*freq
,
364 char __user
*optval
, int optlen
, int *err_p
)
366 struct ip6_flowlabel
*fl
= NULL
;
371 olen
= optlen
- CMSG_ALIGN(sizeof(*freq
));
373 if (olen
> 64 * 1024)
377 fl
= kzalloc(sizeof(*fl
), GFP_KERNEL
);
383 struct flowi6 flowi6
;
387 fl
->opt
= kmalloc(sizeof(*fl
->opt
) + olen
, GFP_KERNEL
);
391 memset(fl
->opt
, 0, sizeof(*fl
->opt
));
392 fl
->opt
->tot_len
= sizeof(*fl
->opt
) + olen
;
394 if (copy_from_user(fl
->opt
+1, optval
+CMSG_ALIGN(sizeof(*freq
)), olen
))
397 msg
.msg_controllen
= olen
;
398 msg
.msg_control
= (void*)(fl
->opt
+1);
399 memset(&flowi6
, 0, sizeof(flowi6
));
401 err
= ip6_datagram_send_ctl(net
, sk
, &msg
, &flowi6
, fl
->opt
,
402 &junk
, &junk
, &junk
);
406 if (fl
->opt
->opt_flen
)
408 if (fl
->opt
->opt_nflen
== 0) {
414 fl
->fl_net
= hold_net(net
);
415 fl
->expires
= jiffies
;
416 err
= fl6_renew(fl
, freq
->flr_linger
, freq
->flr_expires
);
419 fl
->share
= freq
->flr_share
;
420 addr_type
= ipv6_addr_type(&freq
->flr_dst
);
421 if ((addr_type
& IPV6_ADDR_MAPPED
) ||
422 addr_type
== IPV6_ADDR_ANY
) {
426 fl
->dst
= freq
->flr_dst
;
427 atomic_set(&fl
->users
, 1);
432 case IPV6_FL_S_PROCESS
:
433 fl
->owner
.pid
= get_task_pid(current
, PIDTYPE_PID
);
436 fl
->owner
.uid
= current_euid();
450 static int mem_check(struct sock
*sk
)
452 struct ipv6_pinfo
*np
= inet6_sk(sk
);
453 struct ipv6_fl_socklist
*sfl
;
454 int room
= FL_MAX_SIZE
- atomic_read(&fl_size
);
457 if (room
> FL_MAX_SIZE
- FL_MAX_PER_SOCK
)
460 for_each_sk_fl_rcu(np
, sfl
)
464 ((count
>= FL_MAX_PER_SOCK
||
465 (count
> 0 && room
< FL_MAX_SIZE
/2) || room
< FL_MAX_SIZE
/4) &&
466 !capable(CAP_NET_ADMIN
)))
472 static inline void fl_link(struct ipv6_pinfo
*np
, struct ipv6_fl_socklist
*sfl
,
473 struct ip6_flowlabel
*fl
)
475 spin_lock_bh(&ip6_sk_fl_lock
);
477 sfl
->next
= np
->ipv6_fl_list
;
478 rcu_assign_pointer(np
->ipv6_fl_list
, sfl
);
479 spin_unlock_bh(&ip6_sk_fl_lock
);
482 int ipv6_flowlabel_opt_get(struct sock
*sk
, struct in6_flowlabel_req
*freq
)
484 struct ipv6_pinfo
*np
= inet6_sk(sk
);
485 struct ipv6_fl_socklist
*sfl
;
489 for_each_sk_fl_rcu(np
, sfl
) {
490 if (sfl
->fl
->label
== (np
->flow_label
& IPV6_FLOWLABEL_MASK
)) {
491 spin_lock_bh(&ip6_fl_lock
);
492 freq
->flr_label
= sfl
->fl
->label
;
493 freq
->flr_dst
= sfl
->fl
->dst
;
494 freq
->flr_share
= sfl
->fl
->share
;
495 freq
->flr_expires
= (sfl
->fl
->expires
- jiffies
) / HZ
;
496 freq
->flr_linger
= sfl
->fl
->linger
/ HZ
;
498 spin_unlock_bh(&ip6_fl_lock
);
499 rcu_read_unlock_bh();
503 rcu_read_unlock_bh();
508 int ipv6_flowlabel_opt(struct sock
*sk
, char __user
*optval
, int optlen
)
510 int uninitialized_var(err
);
511 struct net
*net
= sock_net(sk
);
512 struct ipv6_pinfo
*np
= inet6_sk(sk
);
513 struct in6_flowlabel_req freq
;
514 struct ipv6_fl_socklist
*sfl1
=NULL
;
515 struct ipv6_fl_socklist
*sfl
;
516 struct ipv6_fl_socklist __rcu
**sflp
;
517 struct ip6_flowlabel
*fl
, *fl1
= NULL
;
520 if (optlen
< sizeof(freq
))
523 if (copy_from_user(&freq
, optval
, sizeof(freq
)))
526 switch (freq
.flr_action
) {
528 spin_lock_bh(&ip6_sk_fl_lock
);
529 for (sflp
= &np
->ipv6_fl_list
;
530 (sfl
= rcu_dereference(*sflp
))!=NULL
;
532 if (sfl
->fl
->label
== freq
.flr_label
) {
533 if (freq
.flr_label
== (np
->flow_label
&IPV6_FLOWLABEL_MASK
))
534 np
->flow_label
&= ~IPV6_FLOWLABEL_MASK
;
535 *sflp
= rcu_dereference(sfl
->next
);
536 spin_unlock_bh(&ip6_sk_fl_lock
);
542 spin_unlock_bh(&ip6_sk_fl_lock
);
545 case IPV6_FL_A_RENEW
:
547 for_each_sk_fl_rcu(np
, sfl
) {
548 if (sfl
->fl
->label
== freq
.flr_label
) {
549 err
= fl6_renew(sfl
->fl
, freq
.flr_linger
, freq
.flr_expires
);
550 rcu_read_unlock_bh();
554 rcu_read_unlock_bh();
556 if (freq
.flr_share
== IPV6_FL_S_NONE
&&
557 ns_capable(net
->user_ns
, CAP_NET_ADMIN
)) {
558 fl
= fl_lookup(net
, freq
.flr_label
);
560 err
= fl6_renew(fl
, freq
.flr_linger
, freq
.flr_expires
);
568 if (freq
.flr_label
& ~IPV6_FLOWLABEL_MASK
)
571 fl
= fl_create(net
, sk
, &freq
, optval
, optlen
, &err
);
574 sfl1
= kmalloc(sizeof(*sfl1
), GFP_KERNEL
);
576 if (freq
.flr_label
) {
579 for_each_sk_fl_rcu(np
, sfl
) {
580 if (sfl
->fl
->label
== freq
.flr_label
) {
581 if (freq
.flr_flags
&IPV6_FL_F_EXCL
) {
582 rcu_read_unlock_bh();
586 atomic_inc(&fl1
->users
);
590 rcu_read_unlock_bh();
593 fl1
= fl_lookup(net
, freq
.flr_label
);
597 if (freq
.flr_flags
&IPV6_FL_F_EXCL
)
600 if (fl1
->share
== IPV6_FL_S_EXCL
||
601 fl1
->share
!= fl
->share
||
602 ((fl1
->share
== IPV6_FL_S_PROCESS
) &&
603 (fl1
->owner
.pid
== fl
->owner
.pid
)) ||
604 ((fl1
->share
== IPV6_FL_S_USER
) &&
605 uid_eq(fl1
->owner
.uid
, fl
->owner
.uid
)))
611 if (fl
->linger
> fl1
->linger
)
612 fl1
->linger
= fl
->linger
;
613 if ((long)(fl
->expires
- fl1
->expires
) > 0)
614 fl1
->expires
= fl
->expires
;
615 fl_link(np
, sfl1
, fl1
);
625 if (!(freq
.flr_flags
&IPV6_FL_F_CREATE
))
629 if (sfl1
== NULL
|| (err
= mem_check(sk
)) != 0)
632 fl1
= fl_intern(net
, fl
, freq
.flr_label
);
636 if (!freq
.flr_label
) {
637 if (copy_to_user(&((struct in6_flowlabel_req __user
*) optval
)->flr_label
,
638 &fl
->label
, sizeof(fl
->label
))) {
639 /* Intentionally ignore fault. */
643 fl_link(np
, sfl1
, fl
);
656 #ifdef CONFIG_PROC_FS
658 struct ip6fl_iter_state
{
659 struct seq_net_private p
;
660 struct pid_namespace
*pid_ns
;
664 #define ip6fl_seq_private(seq) ((struct ip6fl_iter_state *)(seq)->private)
666 static struct ip6_flowlabel
*ip6fl_get_first(struct seq_file
*seq
)
668 struct ip6_flowlabel
*fl
= NULL
;
669 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
670 struct net
*net
= seq_file_net(seq
);
672 for (state
->bucket
= 0; state
->bucket
<= FL_HASH_MASK
; ++state
->bucket
) {
673 for_each_fl_rcu(state
->bucket
, fl
) {
674 if (net_eq(fl
->fl_net
, net
))
683 static struct ip6_flowlabel
*ip6fl_get_next(struct seq_file
*seq
, struct ip6_flowlabel
*fl
)
685 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
686 struct net
*net
= seq_file_net(seq
);
688 for_each_fl_continue_rcu(fl
) {
689 if (net_eq(fl
->fl_net
, net
))
694 if (++state
->bucket
<= FL_HASH_MASK
) {
695 for_each_fl_rcu(state
->bucket
, fl
) {
696 if (net_eq(fl
->fl_net
, net
))
707 static struct ip6_flowlabel
*ip6fl_get_idx(struct seq_file
*seq
, loff_t pos
)
709 struct ip6_flowlabel
*fl
= ip6fl_get_first(seq
);
711 while (pos
&& (fl
= ip6fl_get_next(seq
, fl
)) != NULL
)
713 return pos
? NULL
: fl
;
716 static void *ip6fl_seq_start(struct seq_file
*seq
, loff_t
*pos
)
720 return *pos
? ip6fl_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
723 static void *ip6fl_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
725 struct ip6_flowlabel
*fl
;
727 if (v
== SEQ_START_TOKEN
)
728 fl
= ip6fl_get_first(seq
);
730 fl
= ip6fl_get_next(seq
, v
);
735 static void ip6fl_seq_stop(struct seq_file
*seq
, void *v
)
738 rcu_read_unlock_bh();
741 static int ip6fl_seq_show(struct seq_file
*seq
, void *v
)
743 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
744 if (v
== SEQ_START_TOKEN
)
745 seq_printf(seq
, "%-5s %-1s %-6s %-6s %-6s %-8s %-32s %s\n",
746 "Label", "S", "Owner", "Users", "Linger", "Expires", "Dst", "Opt");
748 struct ip6_flowlabel
*fl
= v
;
750 "%05X %-1d %-6d %-6d %-6ld %-8ld %pi6 %-4d\n",
751 (unsigned int)ntohl(fl
->label
),
753 ((fl
->share
== IPV6_FL_S_PROCESS
) ?
754 pid_nr_ns(fl
->owner
.pid
, state
->pid_ns
) :
755 ((fl
->share
== IPV6_FL_S_USER
) ?
756 from_kuid_munged(seq_user_ns(seq
), fl
->owner
.uid
) :
758 atomic_read(&fl
->users
),
760 (long)(fl
->expires
- jiffies
)/HZ
,
762 fl
->opt
? fl
->opt
->opt_nflen
: 0);
767 static const struct seq_operations ip6fl_seq_ops
= {
768 .start
= ip6fl_seq_start
,
769 .next
= ip6fl_seq_next
,
770 .stop
= ip6fl_seq_stop
,
771 .show
= ip6fl_seq_show
,
774 static int ip6fl_seq_open(struct inode
*inode
, struct file
*file
)
776 struct seq_file
*seq
;
777 struct ip6fl_iter_state
*state
;
780 err
= seq_open_net(inode
, file
, &ip6fl_seq_ops
,
781 sizeof(struct ip6fl_iter_state
));
784 seq
= file
->private_data
;
785 state
= ip6fl_seq_private(seq
);
787 state
->pid_ns
= get_pid_ns(task_active_pid_ns(current
));
793 static int ip6fl_seq_release(struct inode
*inode
, struct file
*file
)
795 struct seq_file
*seq
= file
->private_data
;
796 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
797 put_pid_ns(state
->pid_ns
);
798 return seq_release_net(inode
, file
);
801 static const struct file_operations ip6fl_seq_fops
= {
802 .owner
= THIS_MODULE
,
803 .open
= ip6fl_seq_open
,
806 .release
= ip6fl_seq_release
,
809 static int __net_init
ip6_flowlabel_proc_init(struct net
*net
)
811 if (!proc_create("ip6_flowlabel", S_IRUGO
, net
->proc_net
,
817 static void __net_exit
ip6_flowlabel_proc_fini(struct net
*net
)
819 remove_proc_entry("ip6_flowlabel", net
->proc_net
);
822 static inline int ip6_flowlabel_proc_init(struct net
*net
)
826 static inline void ip6_flowlabel_proc_fini(struct net
*net
)
831 static void __net_exit
ip6_flowlabel_net_exit(struct net
*net
)
834 ip6_flowlabel_proc_fini(net
);
837 static struct pernet_operations ip6_flowlabel_net_ops
= {
838 .init
= ip6_flowlabel_proc_init
,
839 .exit
= ip6_flowlabel_net_exit
,
842 int ip6_flowlabel_init(void)
844 return register_pernet_subsys(&ip6_flowlabel_net_ops
);
847 void ip6_flowlabel_cleanup(void)
849 del_timer(&ip6_fl_gc_timer
);
850 unregister_pernet_subsys(&ip6_flowlabel_net_ops
);