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 60 /* 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
);
348 fl
->lastuse
= jiffies
;
349 if (time_before(fl
->linger
, linger
))
351 if (time_before(expires
, fl
->linger
))
352 expires
= fl
->linger
;
353 if (time_before(fl
->expires
, fl
->lastuse
+ expires
))
354 fl
->expires
= fl
->lastuse
+ expires
;
358 static struct ip6_flowlabel
*
359 fl_create(struct net
*net
, struct sock
*sk
, struct in6_flowlabel_req
*freq
,
360 char __user
*optval
, int optlen
, int *err_p
)
362 struct ip6_flowlabel
*fl
= NULL
;
367 olen
= optlen
- CMSG_ALIGN(sizeof(*freq
));
369 if (olen
> 64 * 1024)
373 fl
= kzalloc(sizeof(*fl
), GFP_KERNEL
);
379 struct flowi6 flowi6
;
383 fl
->opt
= kmalloc(sizeof(*fl
->opt
) + olen
, GFP_KERNEL
);
387 memset(fl
->opt
, 0, sizeof(*fl
->opt
));
388 fl
->opt
->tot_len
= sizeof(*fl
->opt
) + olen
;
390 if (copy_from_user(fl
->opt
+1, optval
+CMSG_ALIGN(sizeof(*freq
)), olen
))
393 msg
.msg_controllen
= olen
;
394 msg
.msg_control
= (void*)(fl
->opt
+1);
395 memset(&flowi6
, 0, sizeof(flowi6
));
397 err
= ip6_datagram_send_ctl(net
, sk
, &msg
, &flowi6
, fl
->opt
,
398 &junk
, &junk
, &junk
);
402 if (fl
->opt
->opt_flen
)
404 if (fl
->opt
->opt_nflen
== 0) {
410 fl
->fl_net
= hold_net(net
);
411 fl
->expires
= jiffies
;
412 err
= fl6_renew(fl
, freq
->flr_linger
, freq
->flr_expires
);
415 fl
->share
= freq
->flr_share
;
416 addr_type
= ipv6_addr_type(&freq
->flr_dst
);
417 if ((addr_type
& IPV6_ADDR_MAPPED
) ||
418 addr_type
== IPV6_ADDR_ANY
) {
422 fl
->dst
= freq
->flr_dst
;
423 atomic_set(&fl
->users
, 1);
428 case IPV6_FL_S_PROCESS
:
429 fl
->owner
.pid
= get_task_pid(current
, PIDTYPE_PID
);
432 fl
->owner
.uid
= current_euid();
446 static int mem_check(struct sock
*sk
)
448 struct ipv6_pinfo
*np
= inet6_sk(sk
);
449 struct ipv6_fl_socklist
*sfl
;
450 int room
= FL_MAX_SIZE
- atomic_read(&fl_size
);
453 if (room
> FL_MAX_SIZE
- FL_MAX_PER_SOCK
)
456 for_each_sk_fl_rcu(np
, sfl
)
460 ((count
>= FL_MAX_PER_SOCK
||
461 (count
> 0 && room
< FL_MAX_SIZE
/2) || room
< FL_MAX_SIZE
/4) &&
462 !capable(CAP_NET_ADMIN
)))
468 static inline void fl_link(struct ipv6_pinfo
*np
, struct ipv6_fl_socklist
*sfl
,
469 struct ip6_flowlabel
*fl
)
471 spin_lock_bh(&ip6_sk_fl_lock
);
473 sfl
->next
= np
->ipv6_fl_list
;
474 rcu_assign_pointer(np
->ipv6_fl_list
, sfl
);
475 spin_unlock_bh(&ip6_sk_fl_lock
);
478 int ipv6_flowlabel_opt(struct sock
*sk
, char __user
*optval
, int optlen
)
480 int uninitialized_var(err
);
481 struct net
*net
= sock_net(sk
);
482 struct ipv6_pinfo
*np
= inet6_sk(sk
);
483 struct in6_flowlabel_req freq
;
484 struct ipv6_fl_socklist
*sfl1
=NULL
;
485 struct ipv6_fl_socklist
*sfl
;
486 struct ipv6_fl_socklist __rcu
**sflp
;
487 struct ip6_flowlabel
*fl
, *fl1
= NULL
;
490 if (optlen
< sizeof(freq
))
493 if (copy_from_user(&freq
, optval
, sizeof(freq
)))
496 switch (freq
.flr_action
) {
498 spin_lock_bh(&ip6_sk_fl_lock
);
499 for (sflp
= &np
->ipv6_fl_list
;
500 (sfl
= rcu_dereference(*sflp
))!=NULL
;
502 if (sfl
->fl
->label
== freq
.flr_label
) {
503 if (freq
.flr_label
== (np
->flow_label
&IPV6_FLOWLABEL_MASK
))
504 np
->flow_label
&= ~IPV6_FLOWLABEL_MASK
;
505 *sflp
= rcu_dereference(sfl
->next
);
506 spin_unlock_bh(&ip6_sk_fl_lock
);
512 spin_unlock_bh(&ip6_sk_fl_lock
);
515 case IPV6_FL_A_RENEW
:
517 for_each_sk_fl_rcu(np
, sfl
) {
518 if (sfl
->fl
->label
== freq
.flr_label
) {
519 err
= fl6_renew(sfl
->fl
, freq
.flr_linger
, freq
.flr_expires
);
520 rcu_read_unlock_bh();
524 rcu_read_unlock_bh();
526 if (freq
.flr_share
== IPV6_FL_S_NONE
&&
527 ns_capable(net
->user_ns
, CAP_NET_ADMIN
)) {
528 fl
= fl_lookup(net
, freq
.flr_label
);
530 err
= fl6_renew(fl
, freq
.flr_linger
, freq
.flr_expires
);
538 if (freq
.flr_label
& ~IPV6_FLOWLABEL_MASK
)
541 fl
= fl_create(net
, sk
, &freq
, optval
, optlen
, &err
);
544 sfl1
= kmalloc(sizeof(*sfl1
), GFP_KERNEL
);
546 if (freq
.flr_label
) {
549 for_each_sk_fl_rcu(np
, sfl
) {
550 if (sfl
->fl
->label
== freq
.flr_label
) {
551 if (freq
.flr_flags
&IPV6_FL_F_EXCL
) {
552 rcu_read_unlock_bh();
556 atomic_inc(&fl1
->users
);
560 rcu_read_unlock_bh();
563 fl1
= fl_lookup(net
, freq
.flr_label
);
567 if (freq
.flr_flags
&IPV6_FL_F_EXCL
)
570 if (fl1
->share
== IPV6_FL_S_EXCL
||
571 fl1
->share
!= fl
->share
||
572 ((fl1
->share
== IPV6_FL_S_PROCESS
) &&
573 (fl1
->owner
.pid
== fl
->owner
.pid
)) ||
574 ((fl1
->share
== IPV6_FL_S_USER
) &&
575 uid_eq(fl1
->owner
.uid
, fl
->owner
.uid
)))
581 if (fl
->linger
> fl1
->linger
)
582 fl1
->linger
= fl
->linger
;
583 if ((long)(fl
->expires
- fl1
->expires
) > 0)
584 fl1
->expires
= fl
->expires
;
585 fl_link(np
, sfl1
, fl1
);
595 if (!(freq
.flr_flags
&IPV6_FL_F_CREATE
))
599 if (sfl1
== NULL
|| (err
= mem_check(sk
)) != 0)
602 fl1
= fl_intern(net
, fl
, freq
.flr_label
);
606 if (!freq
.flr_label
) {
607 if (copy_to_user(&((struct in6_flowlabel_req __user
*) optval
)->flr_label
,
608 &fl
->label
, sizeof(fl
->label
))) {
609 /* Intentionally ignore fault. */
613 fl_link(np
, sfl1
, fl
);
626 #ifdef CONFIG_PROC_FS
628 struct ip6fl_iter_state
{
629 struct seq_net_private p
;
630 struct pid_namespace
*pid_ns
;
634 #define ip6fl_seq_private(seq) ((struct ip6fl_iter_state *)(seq)->private)
636 static struct ip6_flowlabel
*ip6fl_get_first(struct seq_file
*seq
)
638 struct ip6_flowlabel
*fl
= NULL
;
639 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
640 struct net
*net
= seq_file_net(seq
);
642 for (state
->bucket
= 0; state
->bucket
<= FL_HASH_MASK
; ++state
->bucket
) {
643 for_each_fl_rcu(state
->bucket
, fl
) {
644 if (net_eq(fl
->fl_net
, net
))
653 static struct ip6_flowlabel
*ip6fl_get_next(struct seq_file
*seq
, struct ip6_flowlabel
*fl
)
655 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
656 struct net
*net
= seq_file_net(seq
);
658 for_each_fl_continue_rcu(fl
) {
659 if (net_eq(fl
->fl_net
, net
))
664 if (++state
->bucket
<= FL_HASH_MASK
) {
665 for_each_fl_rcu(state
->bucket
, fl
) {
666 if (net_eq(fl
->fl_net
, net
))
677 static struct ip6_flowlabel
*ip6fl_get_idx(struct seq_file
*seq
, loff_t pos
)
679 struct ip6_flowlabel
*fl
= ip6fl_get_first(seq
);
681 while (pos
&& (fl
= ip6fl_get_next(seq
, fl
)) != NULL
)
683 return pos
? NULL
: fl
;
686 static void *ip6fl_seq_start(struct seq_file
*seq
, loff_t
*pos
)
690 return *pos
? ip6fl_get_idx(seq
, *pos
- 1) : SEQ_START_TOKEN
;
693 static void *ip6fl_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
695 struct ip6_flowlabel
*fl
;
697 if (v
== SEQ_START_TOKEN
)
698 fl
= ip6fl_get_first(seq
);
700 fl
= ip6fl_get_next(seq
, v
);
705 static void ip6fl_seq_stop(struct seq_file
*seq
, void *v
)
708 rcu_read_unlock_bh();
711 static int ip6fl_seq_show(struct seq_file
*seq
, void *v
)
713 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
714 if (v
== SEQ_START_TOKEN
)
715 seq_printf(seq
, "%-5s %-1s %-6s %-6s %-6s %-8s %-32s %s\n",
716 "Label", "S", "Owner", "Users", "Linger", "Expires", "Dst", "Opt");
718 struct ip6_flowlabel
*fl
= v
;
720 "%05X %-1d %-6d %-6d %-6ld %-8ld %pi6 %-4d\n",
721 (unsigned int)ntohl(fl
->label
),
723 ((fl
->share
== IPV6_FL_S_PROCESS
) ?
724 pid_nr_ns(fl
->owner
.pid
, state
->pid_ns
) :
725 ((fl
->share
== IPV6_FL_S_USER
) ?
726 from_kuid_munged(seq_user_ns(seq
), fl
->owner
.uid
) :
728 atomic_read(&fl
->users
),
730 (long)(fl
->expires
- jiffies
)/HZ
,
732 fl
->opt
? fl
->opt
->opt_nflen
: 0);
737 static const struct seq_operations ip6fl_seq_ops
= {
738 .start
= ip6fl_seq_start
,
739 .next
= ip6fl_seq_next
,
740 .stop
= ip6fl_seq_stop
,
741 .show
= ip6fl_seq_show
,
744 static int ip6fl_seq_open(struct inode
*inode
, struct file
*file
)
746 struct seq_file
*seq
;
747 struct ip6fl_iter_state
*state
;
750 err
= seq_open_net(inode
, file
, &ip6fl_seq_ops
,
751 sizeof(struct ip6fl_iter_state
));
754 seq
= file
->private_data
;
755 state
= ip6fl_seq_private(seq
);
757 state
->pid_ns
= get_pid_ns(task_active_pid_ns(current
));
763 static int ip6fl_seq_release(struct inode
*inode
, struct file
*file
)
765 struct seq_file
*seq
= file
->private_data
;
766 struct ip6fl_iter_state
*state
= ip6fl_seq_private(seq
);
767 put_pid_ns(state
->pid_ns
);
768 return seq_release_net(inode
, file
);
771 static const struct file_operations ip6fl_seq_fops
= {
772 .owner
= THIS_MODULE
,
773 .open
= ip6fl_seq_open
,
776 .release
= ip6fl_seq_release
,
779 static int __net_init
ip6_flowlabel_proc_init(struct net
*net
)
781 if (!proc_create("ip6_flowlabel", S_IRUGO
, net
->proc_net
,
787 static void __net_exit
ip6_flowlabel_proc_fini(struct net
*net
)
789 remove_proc_entry("ip6_flowlabel", net
->proc_net
);
792 static inline int ip6_flowlabel_proc_init(struct net
*net
)
796 static inline void ip6_flowlabel_proc_fini(struct net
*net
)
801 static void __net_exit
ip6_flowlabel_net_exit(struct net
*net
)
804 ip6_flowlabel_proc_fini(net
);
807 static struct pernet_operations ip6_flowlabel_net_ops
= {
808 .init
= ip6_flowlabel_proc_init
,
809 .exit
= ip6_flowlabel_net_exit
,
812 int ip6_flowlabel_init(void)
814 return register_pernet_subsys(&ip6_flowlabel_net_ops
);
817 void ip6_flowlabel_cleanup(void)
819 del_timer(&ip6_fl_gc_timer
);
820 unregister_pernet_subsys(&ip6_flowlabel_net_ops
);