xref: /openbmc/linux/net/ipv6/addrconf.c (revision 360a9887c8c01a715b2b4b131f7c7462f7cce576)
1 /*
2  *	IPv6 Address [auto]configuration
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
8  *
9  *	This program is free software; you can redistribute it and/or
10  *      modify it under the terms of the GNU General Public License
11  *      as published by the Free Software Foundation; either version
12  *      2 of the License, or (at your option) any later version.
13  */
14 
15 /*
16  *	Changes:
17  *
18  *	Janos Farkas			:	delete timer on ifdown
19  *	<chexum@bankinf.banki.hu>
20  *	Andi Kleen			:	kill double kfree on module
21  *						unload.
22  *	Maciej W. Rozycki		:	FDDI support
23  *	sekiya@USAGI			:	Don't send too many RS
24  *						packets.
25  *	yoshfuji@USAGI			:       Fixed interval between DAD
26  *						packets.
27  *	YOSHIFUJI Hideaki @USAGI	:	improved accuracy of
28  *						address validation timer.
29  *	YOSHIFUJI Hideaki @USAGI	:	Privacy Extensions (RFC3041)
30  *						support.
31  *	Yuji SEKIYA @USAGI		:	Don't assign a same IPv6
32  *						address on a same interface.
33  *	YOSHIFUJI Hideaki @USAGI	:	ARCnet support
34  *	YOSHIFUJI Hideaki @USAGI	:	convert /proc/net/if_inet6 to
35  *						seq_file.
36  *	YOSHIFUJI Hideaki @USAGI	:	improved source address
37  *						selection; consider scope,
38  *						status etc.
39  */
40 
41 #define pr_fmt(fmt) "IPv6: " fmt
42 
43 #include <linux/errno.h>
44 #include <linux/types.h>
45 #include <linux/kernel.h>
46 #include <linux/sched/signal.h>
47 #include <linux/socket.h>
48 #include <linux/sockios.h>
49 #include <linux/net.h>
50 #include <linux/inet.h>
51 #include <linux/in6.h>
52 #include <linux/netdevice.h>
53 #include <linux/if_addr.h>
54 #include <linux/if_arp.h>
55 #include <linux/if_arcnet.h>
56 #include <linux/if_infiniband.h>
57 #include <linux/route.h>
58 #include <linux/inetdevice.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #ifdef CONFIG_SYSCTL
62 #include <linux/sysctl.h>
63 #endif
64 #include <linux/capability.h>
65 #include <linux/delay.h>
66 #include <linux/notifier.h>
67 #include <linux/string.h>
68 #include <linux/hash.h>
69 
70 #include <net/net_namespace.h>
71 #include <net/sock.h>
72 #include <net/snmp.h>
73 
74 #include <net/6lowpan.h>
75 #include <net/firewire.h>
76 #include <net/ipv6.h>
77 #include <net/protocol.h>
78 #include <net/ndisc.h>
79 #include <net/ip6_route.h>
80 #include <net/addrconf.h>
81 #include <net/tcp.h>
82 #include <net/ip.h>
83 #include <net/netlink.h>
84 #include <net/pkt_sched.h>
85 #include <net/l3mdev.h>
86 #include <linux/if_tunnel.h>
87 #include <linux/rtnetlink.h>
88 #include <linux/netconf.h>
89 #include <linux/random.h>
90 #include <linux/uaccess.h>
91 #include <asm/unaligned.h>
92 
93 #include <linux/proc_fs.h>
94 #include <linux/seq_file.h>
95 #include <linux/export.h>
96 
97 #define	INFINITY_LIFE_TIME	0xFFFFFFFF
98 
99 #define IPV6_MAX_STRLEN \
100 	sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
101 
102 static inline u32 cstamp_delta(unsigned long cstamp)
103 {
104 	return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
105 }
106 
107 static inline s32 rfc3315_s14_backoff_init(s32 irt)
108 {
109 	/* multiply 'initial retransmission time' by 0.9 .. 1.1 */
110 	u64 tmp = (900000 + prandom_u32() % 200001) * (u64)irt;
111 	do_div(tmp, 1000000);
112 	return (s32)tmp;
113 }
114 
115 static inline s32 rfc3315_s14_backoff_update(s32 rt, s32 mrt)
116 {
117 	/* multiply 'retransmission timeout' by 1.9 .. 2.1 */
118 	u64 tmp = (1900000 + prandom_u32() % 200001) * (u64)rt;
119 	do_div(tmp, 1000000);
120 	if ((s32)tmp > mrt) {
121 		/* multiply 'maximum retransmission time' by 0.9 .. 1.1 */
122 		tmp = (900000 + prandom_u32() % 200001) * (u64)mrt;
123 		do_div(tmp, 1000000);
124 	}
125 	return (s32)tmp;
126 }
127 
128 #ifdef CONFIG_SYSCTL
129 static int addrconf_sysctl_register(struct inet6_dev *idev);
130 static void addrconf_sysctl_unregister(struct inet6_dev *idev);
131 #else
132 static inline int addrconf_sysctl_register(struct inet6_dev *idev)
133 {
134 	return 0;
135 }
136 
137 static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
138 {
139 }
140 #endif
141 
142 static void ipv6_regen_rndid(struct inet6_dev *idev);
143 static void ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
144 
145 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
146 static int ipv6_count_addresses(const struct inet6_dev *idev);
147 static int ipv6_generate_stable_address(struct in6_addr *addr,
148 					u8 dad_count,
149 					const struct inet6_dev *idev);
150 
151 #define IN6_ADDR_HSIZE_SHIFT	8
152 #define IN6_ADDR_HSIZE		(1 << IN6_ADDR_HSIZE_SHIFT)
153 /*
154  *	Configured unicast address hash table
155  */
156 static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
157 static DEFINE_SPINLOCK(addrconf_hash_lock);
158 
159 static void addrconf_verify(void);
160 static void addrconf_verify_rtnl(void);
161 static void addrconf_verify_work(struct work_struct *);
162 
163 static struct workqueue_struct *addrconf_wq;
164 static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
165 
166 static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
167 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
168 
169 static void addrconf_type_change(struct net_device *dev,
170 				 unsigned long event);
171 static int addrconf_ifdown(struct net_device *dev, int how);
172 
173 static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
174 						  int plen,
175 						  const struct net_device *dev,
176 						  u32 flags, u32 noflags);
177 
178 static void addrconf_dad_start(struct inet6_ifaddr *ifp);
179 static void addrconf_dad_work(struct work_struct *w);
180 static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
181 				   bool send_na);
182 static void addrconf_dad_run(struct inet6_dev *idev);
183 static void addrconf_rs_timer(struct timer_list *t);
184 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
185 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
186 
187 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
188 				struct prefix_info *pinfo);
189 
190 static struct ipv6_devconf ipv6_devconf __read_mostly = {
191 	.forwarding		= 0,
192 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
193 	.mtu6			= IPV6_MIN_MTU,
194 	.accept_ra		= 1,
195 	.accept_redirects	= 1,
196 	.autoconf		= 1,
197 	.force_mld_version	= 0,
198 	.mldv1_unsolicited_report_interval = 10 * HZ,
199 	.mldv2_unsolicited_report_interval = HZ,
200 	.dad_transmits		= 1,
201 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
202 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
203 	.rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
204 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
205 	.use_tempaddr		= 0,
206 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
207 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
208 	.regen_max_retry	= REGEN_MAX_RETRY,
209 	.max_desync_factor	= MAX_DESYNC_FACTOR,
210 	.max_addresses		= IPV6_MAX_ADDRESSES,
211 	.accept_ra_defrtr	= 1,
212 	.accept_ra_from_local	= 0,
213 	.accept_ra_min_hop_limit= 1,
214 	.accept_ra_pinfo	= 1,
215 #ifdef CONFIG_IPV6_ROUTER_PREF
216 	.accept_ra_rtr_pref	= 1,
217 	.rtr_probe_interval	= 60 * HZ,
218 #ifdef CONFIG_IPV6_ROUTE_INFO
219 	.accept_ra_rt_info_min_plen = 0,
220 	.accept_ra_rt_info_max_plen = 0,
221 #endif
222 #endif
223 	.proxy_ndp		= 0,
224 	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
225 	.disable_ipv6		= 0,
226 	.accept_dad		= 0,
227 	.suppress_frag_ndisc	= 1,
228 	.accept_ra_mtu		= 1,
229 	.stable_secret		= {
230 		.initialized = false,
231 	},
232 	.use_oif_addrs_only	= 0,
233 	.ignore_routes_with_linkdown = 0,
234 	.keep_addr_on_down	= 0,
235 	.seg6_enabled		= 0,
236 #ifdef CONFIG_IPV6_SEG6_HMAC
237 	.seg6_require_hmac	= 0,
238 #endif
239 	.enhanced_dad           = 1,
240 	.addr_gen_mode		= IN6_ADDR_GEN_MODE_EUI64,
241 	.disable_policy		= 0,
242 };
243 
244 static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
245 	.forwarding		= 0,
246 	.hop_limit		= IPV6_DEFAULT_HOPLIMIT,
247 	.mtu6			= IPV6_MIN_MTU,
248 	.accept_ra		= 1,
249 	.accept_redirects	= 1,
250 	.autoconf		= 1,
251 	.force_mld_version	= 0,
252 	.mldv1_unsolicited_report_interval = 10 * HZ,
253 	.mldv2_unsolicited_report_interval = HZ,
254 	.dad_transmits		= 1,
255 	.rtr_solicits		= MAX_RTR_SOLICITATIONS,
256 	.rtr_solicit_interval	= RTR_SOLICITATION_INTERVAL,
257 	.rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
258 	.rtr_solicit_delay	= MAX_RTR_SOLICITATION_DELAY,
259 	.use_tempaddr		= 0,
260 	.temp_valid_lft		= TEMP_VALID_LIFETIME,
261 	.temp_prefered_lft	= TEMP_PREFERRED_LIFETIME,
262 	.regen_max_retry	= REGEN_MAX_RETRY,
263 	.max_desync_factor	= MAX_DESYNC_FACTOR,
264 	.max_addresses		= IPV6_MAX_ADDRESSES,
265 	.accept_ra_defrtr	= 1,
266 	.accept_ra_from_local	= 0,
267 	.accept_ra_min_hop_limit= 1,
268 	.accept_ra_pinfo	= 1,
269 #ifdef CONFIG_IPV6_ROUTER_PREF
270 	.accept_ra_rtr_pref	= 1,
271 	.rtr_probe_interval	= 60 * HZ,
272 #ifdef CONFIG_IPV6_ROUTE_INFO
273 	.accept_ra_rt_info_min_plen = 0,
274 	.accept_ra_rt_info_max_plen = 0,
275 #endif
276 #endif
277 	.proxy_ndp		= 0,
278 	.accept_source_route	= 0,	/* we do not accept RH0 by default. */
279 	.disable_ipv6		= 0,
280 	.accept_dad		= 1,
281 	.suppress_frag_ndisc	= 1,
282 	.accept_ra_mtu		= 1,
283 	.stable_secret		= {
284 		.initialized = false,
285 	},
286 	.use_oif_addrs_only	= 0,
287 	.ignore_routes_with_linkdown = 0,
288 	.keep_addr_on_down	= 0,
289 	.seg6_enabled		= 0,
290 #ifdef CONFIG_IPV6_SEG6_HMAC
291 	.seg6_require_hmac	= 0,
292 #endif
293 	.enhanced_dad           = 1,
294 	.addr_gen_mode		= IN6_ADDR_GEN_MODE_EUI64,
295 	.disable_policy		= 0,
296 };
297 
298 /* Check if link is ready: is it up and is a valid qdisc available */
299 static inline bool addrconf_link_ready(const struct net_device *dev)
300 {
301 	return netif_oper_up(dev) && !qdisc_tx_is_noop(dev);
302 }
303 
304 static void addrconf_del_rs_timer(struct inet6_dev *idev)
305 {
306 	if (del_timer(&idev->rs_timer))
307 		__in6_dev_put(idev);
308 }
309 
310 static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
311 {
312 	if (cancel_delayed_work(&ifp->dad_work))
313 		__in6_ifa_put(ifp);
314 }
315 
316 static void addrconf_mod_rs_timer(struct inet6_dev *idev,
317 				  unsigned long when)
318 {
319 	if (!timer_pending(&idev->rs_timer))
320 		in6_dev_hold(idev);
321 	mod_timer(&idev->rs_timer, jiffies + when);
322 }
323 
324 static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
325 				   unsigned long delay)
326 {
327 	in6_ifa_hold(ifp);
328 	if (mod_delayed_work(addrconf_wq, &ifp->dad_work, delay))
329 		in6_ifa_put(ifp);
330 }
331 
332 static int snmp6_alloc_dev(struct inet6_dev *idev)
333 {
334 	int i;
335 
336 	idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
337 	if (!idev->stats.ipv6)
338 		goto err_ip;
339 
340 	for_each_possible_cpu(i) {
341 		struct ipstats_mib *addrconf_stats;
342 		addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
343 		u64_stats_init(&addrconf_stats->syncp);
344 	}
345 
346 
347 	idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
348 					GFP_KERNEL);
349 	if (!idev->stats.icmpv6dev)
350 		goto err_icmp;
351 	idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
352 					   GFP_KERNEL);
353 	if (!idev->stats.icmpv6msgdev)
354 		goto err_icmpmsg;
355 
356 	return 0;
357 
358 err_icmpmsg:
359 	kfree(idev->stats.icmpv6dev);
360 err_icmp:
361 	free_percpu(idev->stats.ipv6);
362 err_ip:
363 	return -ENOMEM;
364 }
365 
366 static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
367 {
368 	struct inet6_dev *ndev;
369 	int err = -ENOMEM;
370 
371 	ASSERT_RTNL();
372 
373 	if (dev->mtu < IPV6_MIN_MTU)
374 		return ERR_PTR(-EINVAL);
375 
376 	ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
377 	if (!ndev)
378 		return ERR_PTR(err);
379 
380 	rwlock_init(&ndev->lock);
381 	ndev->dev = dev;
382 	INIT_LIST_HEAD(&ndev->addr_list);
383 	timer_setup(&ndev->rs_timer, addrconf_rs_timer, 0);
384 	memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
385 
386 	if (ndev->cnf.stable_secret.initialized)
387 		ndev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
388 	else
389 		ndev->cnf.addr_gen_mode = ipv6_devconf_dflt.addr_gen_mode;
390 
391 	ndev->cnf.mtu6 = dev->mtu;
392 	ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
393 	if (!ndev->nd_parms) {
394 		kfree(ndev);
395 		return ERR_PTR(err);
396 	}
397 	if (ndev->cnf.forwarding)
398 		dev_disable_lro(dev);
399 	/* We refer to the device */
400 	dev_hold(dev);
401 
402 	if (snmp6_alloc_dev(ndev) < 0) {
403 		netdev_dbg(dev, "%s: cannot allocate memory for statistics\n",
404 			   __func__);
405 		neigh_parms_release(&nd_tbl, ndev->nd_parms);
406 		dev_put(dev);
407 		kfree(ndev);
408 		return ERR_PTR(err);
409 	}
410 
411 	if (snmp6_register_dev(ndev) < 0) {
412 		netdev_dbg(dev, "%s: cannot create /proc/net/dev_snmp6/%s\n",
413 			   __func__, dev->name);
414 		goto err_release;
415 	}
416 
417 	/* One reference from device. */
418 	refcount_set(&ndev->refcnt, 1);
419 
420 	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
421 		ndev->cnf.accept_dad = -1;
422 
423 #if IS_ENABLED(CONFIG_IPV6_SIT)
424 	if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
425 		pr_info("%s: Disabled Multicast RS\n", dev->name);
426 		ndev->cnf.rtr_solicits = 0;
427 	}
428 #endif
429 
430 	INIT_LIST_HEAD(&ndev->tempaddr_list);
431 	ndev->desync_factor = U32_MAX;
432 	if ((dev->flags&IFF_LOOPBACK) ||
433 	    dev->type == ARPHRD_TUNNEL ||
434 	    dev->type == ARPHRD_TUNNEL6 ||
435 	    dev->type == ARPHRD_SIT ||
436 	    dev->type == ARPHRD_NONE) {
437 		ndev->cnf.use_tempaddr = -1;
438 	} else
439 		ipv6_regen_rndid(ndev);
440 
441 	ndev->token = in6addr_any;
442 
443 	if (netif_running(dev) && addrconf_link_ready(dev))
444 		ndev->if_flags |= IF_READY;
445 
446 	ipv6_mc_init_dev(ndev);
447 	ndev->tstamp = jiffies;
448 	err = addrconf_sysctl_register(ndev);
449 	if (err) {
450 		ipv6_mc_destroy_dev(ndev);
451 		snmp6_unregister_dev(ndev);
452 		goto err_release;
453 	}
454 	/* protected by rtnl_lock */
455 	rcu_assign_pointer(dev->ip6_ptr, ndev);
456 
457 	/* Join interface-local all-node multicast group */
458 	ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
459 
460 	/* Join all-node multicast group */
461 	ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
462 
463 	/* Join all-router multicast group if forwarding is set */
464 	if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
465 		ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
466 
467 	return ndev;
468 
469 err_release:
470 	neigh_parms_release(&nd_tbl, ndev->nd_parms);
471 	ndev->dead = 1;
472 	in6_dev_finish_destroy(ndev);
473 	return ERR_PTR(err);
474 }
475 
476 static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
477 {
478 	struct inet6_dev *idev;
479 
480 	ASSERT_RTNL();
481 
482 	idev = __in6_dev_get(dev);
483 	if (!idev) {
484 		idev = ipv6_add_dev(dev);
485 		if (IS_ERR(idev))
486 			return NULL;
487 	}
488 
489 	if (dev->flags&IFF_UP)
490 		ipv6_mc_up(idev);
491 	return idev;
492 }
493 
494 static int inet6_netconf_msgsize_devconf(int type)
495 {
496 	int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
497 		    + nla_total_size(4);	/* NETCONFA_IFINDEX */
498 	bool all = false;
499 
500 	if (type == NETCONFA_ALL)
501 		all = true;
502 
503 	if (all || type == NETCONFA_FORWARDING)
504 		size += nla_total_size(4);
505 #ifdef CONFIG_IPV6_MROUTE
506 	if (all || type == NETCONFA_MC_FORWARDING)
507 		size += nla_total_size(4);
508 #endif
509 	if (all || type == NETCONFA_PROXY_NEIGH)
510 		size += nla_total_size(4);
511 
512 	if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
513 		size += nla_total_size(4);
514 
515 	return size;
516 }
517 
518 static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
519 				      struct ipv6_devconf *devconf, u32 portid,
520 				      u32 seq, int event, unsigned int flags,
521 				      int type)
522 {
523 	struct nlmsghdr  *nlh;
524 	struct netconfmsg *ncm;
525 	bool all = false;
526 
527 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
528 			flags);
529 	if (!nlh)
530 		return -EMSGSIZE;
531 
532 	if (type == NETCONFA_ALL)
533 		all = true;
534 
535 	ncm = nlmsg_data(nlh);
536 	ncm->ncm_family = AF_INET6;
537 
538 	if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
539 		goto nla_put_failure;
540 
541 	if (!devconf)
542 		goto out;
543 
544 	if ((all || type == NETCONFA_FORWARDING) &&
545 	    nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
546 		goto nla_put_failure;
547 #ifdef CONFIG_IPV6_MROUTE
548 	if ((all || type == NETCONFA_MC_FORWARDING) &&
549 	    nla_put_s32(skb, NETCONFA_MC_FORWARDING,
550 			devconf->mc_forwarding) < 0)
551 		goto nla_put_failure;
552 #endif
553 	if ((all || type == NETCONFA_PROXY_NEIGH) &&
554 	    nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
555 		goto nla_put_failure;
556 
557 	if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
558 	    nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
559 			devconf->ignore_routes_with_linkdown) < 0)
560 		goto nla_put_failure;
561 
562 out:
563 	nlmsg_end(skb, nlh);
564 	return 0;
565 
566 nla_put_failure:
567 	nlmsg_cancel(skb, nlh);
568 	return -EMSGSIZE;
569 }
570 
571 void inet6_netconf_notify_devconf(struct net *net, int event, int type,
572 				  int ifindex, struct ipv6_devconf *devconf)
573 {
574 	struct sk_buff *skb;
575 	int err = -ENOBUFS;
576 
577 	skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_KERNEL);
578 	if (!skb)
579 		goto errout;
580 
581 	err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
582 					 event, 0, type);
583 	if (err < 0) {
584 		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
585 		WARN_ON(err == -EMSGSIZE);
586 		kfree_skb(skb);
587 		goto errout;
588 	}
589 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_KERNEL);
590 	return;
591 errout:
592 	rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
593 }
594 
595 static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
596 	[NETCONFA_IFINDEX]	= { .len = sizeof(int) },
597 	[NETCONFA_FORWARDING]	= { .len = sizeof(int) },
598 	[NETCONFA_PROXY_NEIGH]	= { .len = sizeof(int) },
599 	[NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN]	= { .len = sizeof(int) },
600 };
601 
602 static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
603 				     struct nlmsghdr *nlh,
604 				     struct netlink_ext_ack *extack)
605 {
606 	struct net *net = sock_net(in_skb->sk);
607 	struct nlattr *tb[NETCONFA_MAX+1];
608 	struct inet6_dev *in6_dev = NULL;
609 	struct net_device *dev = NULL;
610 	struct netconfmsg *ncm;
611 	struct sk_buff *skb;
612 	struct ipv6_devconf *devconf;
613 	int ifindex;
614 	int err;
615 
616 	err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
617 			  devconf_ipv6_policy, extack);
618 	if (err < 0)
619 		return err;
620 
621 	if (!tb[NETCONFA_IFINDEX])
622 		return -EINVAL;
623 
624 	err = -EINVAL;
625 	ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
626 	switch (ifindex) {
627 	case NETCONFA_IFINDEX_ALL:
628 		devconf = net->ipv6.devconf_all;
629 		break;
630 	case NETCONFA_IFINDEX_DEFAULT:
631 		devconf = net->ipv6.devconf_dflt;
632 		break;
633 	default:
634 		dev = dev_get_by_index(net, ifindex);
635 		if (!dev)
636 			return -EINVAL;
637 		in6_dev = in6_dev_get(dev);
638 		if (!in6_dev)
639 			goto errout;
640 		devconf = &in6_dev->cnf;
641 		break;
642 	}
643 
644 	err = -ENOBUFS;
645 	skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
646 	if (!skb)
647 		goto errout;
648 
649 	err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
650 					 NETLINK_CB(in_skb).portid,
651 					 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
652 					 NETCONFA_ALL);
653 	if (err < 0) {
654 		/* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
655 		WARN_ON(err == -EMSGSIZE);
656 		kfree_skb(skb);
657 		goto errout;
658 	}
659 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
660 errout:
661 	if (in6_dev)
662 		in6_dev_put(in6_dev);
663 	if (dev)
664 		dev_put(dev);
665 	return err;
666 }
667 
668 static int inet6_netconf_dump_devconf(struct sk_buff *skb,
669 				      struct netlink_callback *cb)
670 {
671 	struct net *net = sock_net(skb->sk);
672 	int h, s_h;
673 	int idx, s_idx;
674 	struct net_device *dev;
675 	struct inet6_dev *idev;
676 	struct hlist_head *head;
677 
678 	s_h = cb->args[0];
679 	s_idx = idx = cb->args[1];
680 
681 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
682 		idx = 0;
683 		head = &net->dev_index_head[h];
684 		rcu_read_lock();
685 		cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
686 			  net->dev_base_seq;
687 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
688 			if (idx < s_idx)
689 				goto cont;
690 			idev = __in6_dev_get(dev);
691 			if (!idev)
692 				goto cont;
693 
694 			if (inet6_netconf_fill_devconf(skb, dev->ifindex,
695 						       &idev->cnf,
696 						       NETLINK_CB(cb->skb).portid,
697 						       cb->nlh->nlmsg_seq,
698 						       RTM_NEWNETCONF,
699 						       NLM_F_MULTI,
700 						       NETCONFA_ALL) < 0) {
701 				rcu_read_unlock();
702 				goto done;
703 			}
704 			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
705 cont:
706 			idx++;
707 		}
708 		rcu_read_unlock();
709 	}
710 	if (h == NETDEV_HASHENTRIES) {
711 		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
712 					       net->ipv6.devconf_all,
713 					       NETLINK_CB(cb->skb).portid,
714 					       cb->nlh->nlmsg_seq,
715 					       RTM_NEWNETCONF, NLM_F_MULTI,
716 					       NETCONFA_ALL) < 0)
717 			goto done;
718 		else
719 			h++;
720 	}
721 	if (h == NETDEV_HASHENTRIES + 1) {
722 		if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
723 					       net->ipv6.devconf_dflt,
724 					       NETLINK_CB(cb->skb).portid,
725 					       cb->nlh->nlmsg_seq,
726 					       RTM_NEWNETCONF, NLM_F_MULTI,
727 					       NETCONFA_ALL) < 0)
728 			goto done;
729 		else
730 			h++;
731 	}
732 done:
733 	cb->args[0] = h;
734 	cb->args[1] = idx;
735 
736 	return skb->len;
737 }
738 
739 #ifdef CONFIG_SYSCTL
740 static void dev_forward_change(struct inet6_dev *idev)
741 {
742 	struct net_device *dev;
743 	struct inet6_ifaddr *ifa;
744 
745 	if (!idev)
746 		return;
747 	dev = idev->dev;
748 	if (idev->cnf.forwarding)
749 		dev_disable_lro(dev);
750 	if (dev->flags & IFF_MULTICAST) {
751 		if (idev->cnf.forwarding) {
752 			ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
753 			ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
754 			ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
755 		} else {
756 			ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
757 			ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
758 			ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
759 		}
760 	}
761 
762 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
763 		if (ifa->flags&IFA_F_TENTATIVE)
764 			continue;
765 		if (idev->cnf.forwarding)
766 			addrconf_join_anycast(ifa);
767 		else
768 			addrconf_leave_anycast(ifa);
769 	}
770 	inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
771 				     NETCONFA_FORWARDING,
772 				     dev->ifindex, &idev->cnf);
773 }
774 
775 
776 static void addrconf_forward_change(struct net *net, __s32 newf)
777 {
778 	struct net_device *dev;
779 	struct inet6_dev *idev;
780 
781 	for_each_netdev(net, dev) {
782 		idev = __in6_dev_get(dev);
783 		if (idev) {
784 			int changed = (!idev->cnf.forwarding) ^ (!newf);
785 			idev->cnf.forwarding = newf;
786 			if (changed)
787 				dev_forward_change(idev);
788 		}
789 	}
790 }
791 
792 static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
793 {
794 	struct net *net;
795 	int old;
796 
797 	if (!rtnl_trylock())
798 		return restart_syscall();
799 
800 	net = (struct net *)table->extra2;
801 	old = *p;
802 	*p = newf;
803 
804 	if (p == &net->ipv6.devconf_dflt->forwarding) {
805 		if ((!newf) ^ (!old))
806 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
807 						     NETCONFA_FORWARDING,
808 						     NETCONFA_IFINDEX_DEFAULT,
809 						     net->ipv6.devconf_dflt);
810 		rtnl_unlock();
811 		return 0;
812 	}
813 
814 	if (p == &net->ipv6.devconf_all->forwarding) {
815 		int old_dflt = net->ipv6.devconf_dflt->forwarding;
816 
817 		net->ipv6.devconf_dflt->forwarding = newf;
818 		if ((!newf) ^ (!old_dflt))
819 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
820 						     NETCONFA_FORWARDING,
821 						     NETCONFA_IFINDEX_DEFAULT,
822 						     net->ipv6.devconf_dflt);
823 
824 		addrconf_forward_change(net, newf);
825 		if ((!newf) ^ (!old))
826 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
827 						     NETCONFA_FORWARDING,
828 						     NETCONFA_IFINDEX_ALL,
829 						     net->ipv6.devconf_all);
830 	} else if ((!newf) ^ (!old))
831 		dev_forward_change((struct inet6_dev *)table->extra1);
832 	rtnl_unlock();
833 
834 	if (newf)
835 		rt6_purge_dflt_routers(net);
836 	return 1;
837 }
838 
839 static void addrconf_linkdown_change(struct net *net, __s32 newf)
840 {
841 	struct net_device *dev;
842 	struct inet6_dev *idev;
843 
844 	for_each_netdev(net, dev) {
845 		idev = __in6_dev_get(dev);
846 		if (idev) {
847 			int changed = (!idev->cnf.ignore_routes_with_linkdown) ^ (!newf);
848 
849 			idev->cnf.ignore_routes_with_linkdown = newf;
850 			if (changed)
851 				inet6_netconf_notify_devconf(dev_net(dev),
852 							     RTM_NEWNETCONF,
853 							     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
854 							     dev->ifindex,
855 							     &idev->cnf);
856 		}
857 	}
858 }
859 
860 static int addrconf_fixup_linkdown(struct ctl_table *table, int *p, int newf)
861 {
862 	struct net *net;
863 	int old;
864 
865 	if (!rtnl_trylock())
866 		return restart_syscall();
867 
868 	net = (struct net *)table->extra2;
869 	old = *p;
870 	*p = newf;
871 
872 	if (p == &net->ipv6.devconf_dflt->ignore_routes_with_linkdown) {
873 		if ((!newf) ^ (!old))
874 			inet6_netconf_notify_devconf(net,
875 						     RTM_NEWNETCONF,
876 						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
877 						     NETCONFA_IFINDEX_DEFAULT,
878 						     net->ipv6.devconf_dflt);
879 		rtnl_unlock();
880 		return 0;
881 	}
882 
883 	if (p == &net->ipv6.devconf_all->ignore_routes_with_linkdown) {
884 		net->ipv6.devconf_dflt->ignore_routes_with_linkdown = newf;
885 		addrconf_linkdown_change(net, newf);
886 		if ((!newf) ^ (!old))
887 			inet6_netconf_notify_devconf(net,
888 						     RTM_NEWNETCONF,
889 						     NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
890 						     NETCONFA_IFINDEX_ALL,
891 						     net->ipv6.devconf_all);
892 	}
893 	rtnl_unlock();
894 
895 	return 1;
896 }
897 
898 #endif
899 
900 /* Nobody refers to this ifaddr, destroy it */
901 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
902 {
903 	WARN_ON(!hlist_unhashed(&ifp->addr_lst));
904 
905 #ifdef NET_REFCNT_DEBUG
906 	pr_debug("%s\n", __func__);
907 #endif
908 
909 	in6_dev_put(ifp->idev);
910 
911 	if (cancel_delayed_work(&ifp->dad_work))
912 		pr_notice("delayed DAD work was pending while freeing ifa=%p\n",
913 			  ifp);
914 
915 	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
916 		pr_warn("Freeing alive inet6 address %p\n", ifp);
917 		return;
918 	}
919 
920 	kfree_rcu(ifp, rcu);
921 }
922 
923 static void
924 ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
925 {
926 	struct list_head *p;
927 	int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
928 
929 	/*
930 	 * Each device address list is sorted in order of scope -
931 	 * global before linklocal.
932 	 */
933 	list_for_each(p, &idev->addr_list) {
934 		struct inet6_ifaddr *ifa
935 			= list_entry(p, struct inet6_ifaddr, if_list);
936 		if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
937 			break;
938 	}
939 
940 	list_add_tail_rcu(&ifp->if_list, p);
941 }
942 
943 static u32 inet6_addr_hash(const struct net *net, const struct in6_addr *addr)
944 {
945 	u32 val = ipv6_addr_hash(addr) ^ net_hash_mix(net);
946 
947 	return hash_32(val, IN6_ADDR_HSIZE_SHIFT);
948 }
949 
950 static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
951 			       struct net_device *dev, unsigned int hash)
952 {
953 	struct inet6_ifaddr *ifp;
954 
955 	hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
956 		if (!net_eq(dev_net(ifp->idev->dev), net))
957 			continue;
958 		if (ipv6_addr_equal(&ifp->addr, addr)) {
959 			if (!dev || ifp->idev->dev == dev)
960 				return true;
961 		}
962 	}
963 	return false;
964 }
965 
966 static int ipv6_add_addr_hash(struct net_device *dev, struct inet6_ifaddr *ifa)
967 {
968 	unsigned int hash = inet6_addr_hash(dev_net(dev), &ifa->addr);
969 	int err = 0;
970 
971 	spin_lock(&addrconf_hash_lock);
972 
973 	/* Ignore adding duplicate addresses on an interface */
974 	if (ipv6_chk_same_addr(dev_net(dev), &ifa->addr, dev, hash)) {
975 		netdev_dbg(dev, "ipv6_add_addr: already assigned\n");
976 		err = -EEXIST;
977 	} else {
978 		hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
979 	}
980 
981 	spin_unlock(&addrconf_hash_lock);
982 
983 	return err;
984 }
985 
986 /* On success it returns ifp with increased reference count */
987 
988 static struct inet6_ifaddr *
989 ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
990 	      const struct in6_addr *peer_addr, int pfxlen,
991 	      int scope, u32 flags, u32 valid_lft, u32 prefered_lft,
992 	      bool can_block, struct netlink_ext_ack *extack)
993 {
994 	gfp_t gfp_flags = can_block ? GFP_KERNEL : GFP_ATOMIC;
995 	struct net *net = dev_net(idev->dev);
996 	struct inet6_ifaddr *ifa = NULL;
997 	struct fib6_info *f6i = NULL;
998 	int err = 0;
999 	int addr_type = ipv6_addr_type(addr);
1000 
1001 	if (addr_type == IPV6_ADDR_ANY ||
1002 	    addr_type & IPV6_ADDR_MULTICAST ||
1003 	    (!(idev->dev->flags & IFF_LOOPBACK) &&
1004 	     addr_type & IPV6_ADDR_LOOPBACK))
1005 		return ERR_PTR(-EADDRNOTAVAIL);
1006 
1007 	if (idev->dead) {
1008 		err = -ENODEV;			/*XXX*/
1009 		goto out;
1010 	}
1011 
1012 	if (idev->cnf.disable_ipv6) {
1013 		err = -EACCES;
1014 		goto out;
1015 	}
1016 
1017 	/* validator notifier needs to be blocking;
1018 	 * do not call in atomic context
1019 	 */
1020 	if (can_block) {
1021 		struct in6_validator_info i6vi = {
1022 			.i6vi_addr = *addr,
1023 			.i6vi_dev = idev,
1024 			.extack = extack,
1025 		};
1026 
1027 		err = inet6addr_validator_notifier_call_chain(NETDEV_UP, &i6vi);
1028 		err = notifier_to_errno(err);
1029 		if (err < 0)
1030 			goto out;
1031 	}
1032 
1033 	ifa = kzalloc(sizeof(*ifa), gfp_flags);
1034 	if (!ifa) {
1035 		err = -ENOBUFS;
1036 		goto out;
1037 	}
1038 
1039 	f6i = addrconf_f6i_alloc(net, idev, addr, false, gfp_flags);
1040 	if (IS_ERR(f6i)) {
1041 		err = PTR_ERR(f6i);
1042 		f6i = NULL;
1043 		goto out;
1044 	}
1045 
1046 	if (net->ipv6.devconf_all->disable_policy ||
1047 	    idev->cnf.disable_policy)
1048 		f6i->dst_nopolicy = true;
1049 
1050 	neigh_parms_data_state_setall(idev->nd_parms);
1051 
1052 	ifa->addr = *addr;
1053 	if (peer_addr)
1054 		ifa->peer_addr = *peer_addr;
1055 
1056 	spin_lock_init(&ifa->lock);
1057 	INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
1058 	INIT_HLIST_NODE(&ifa->addr_lst);
1059 	ifa->scope = scope;
1060 	ifa->prefix_len = pfxlen;
1061 	ifa->flags = flags;
1062 	/* No need to add the TENTATIVE flag for addresses with NODAD */
1063 	if (!(flags & IFA_F_NODAD))
1064 		ifa->flags |= IFA_F_TENTATIVE;
1065 	ifa->valid_lft = valid_lft;
1066 	ifa->prefered_lft = prefered_lft;
1067 	ifa->cstamp = ifa->tstamp = jiffies;
1068 	ifa->tokenized = false;
1069 
1070 	ifa->rt = f6i;
1071 
1072 	ifa->idev = idev;
1073 	in6_dev_hold(idev);
1074 
1075 	/* For caller */
1076 	refcount_set(&ifa->refcnt, 1);
1077 
1078 	rcu_read_lock_bh();
1079 
1080 	err = ipv6_add_addr_hash(idev->dev, ifa);
1081 	if (err < 0) {
1082 		rcu_read_unlock_bh();
1083 		goto out;
1084 	}
1085 
1086 	write_lock(&idev->lock);
1087 
1088 	/* Add to inet6_dev unicast addr list. */
1089 	ipv6_link_dev_addr(idev, ifa);
1090 
1091 	if (ifa->flags&IFA_F_TEMPORARY) {
1092 		list_add(&ifa->tmp_list, &idev->tempaddr_list);
1093 		in6_ifa_hold(ifa);
1094 	}
1095 
1096 	in6_ifa_hold(ifa);
1097 	write_unlock(&idev->lock);
1098 
1099 	rcu_read_unlock_bh();
1100 
1101 	inet6addr_notifier_call_chain(NETDEV_UP, ifa);
1102 out:
1103 	if (unlikely(err < 0)) {
1104 		fib6_info_release(f6i);
1105 
1106 		if (ifa) {
1107 			if (ifa->idev)
1108 				in6_dev_put(ifa->idev);
1109 			kfree(ifa);
1110 		}
1111 		ifa = ERR_PTR(err);
1112 	}
1113 
1114 	return ifa;
1115 }
1116 
1117 enum cleanup_prefix_rt_t {
1118 	CLEANUP_PREFIX_RT_NOP,    /* no cleanup action for prefix route */
1119 	CLEANUP_PREFIX_RT_DEL,    /* delete the prefix route */
1120 	CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */
1121 };
1122 
1123 /*
1124  * Check, whether the prefix for ifp would still need a prefix route
1125  * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_*
1126  * constants.
1127  *
1128  * 1) we don't purge prefix if address was not permanent.
1129  *    prefix is managed by its own lifetime.
1130  * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE.
1131  * 3) if there are no addresses, delete prefix.
1132  * 4) if there are still other permanent address(es),
1133  *    corresponding prefix is still permanent.
1134  * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE,
1135  *    don't purge the prefix, assume user space is managing it.
1136  * 6) otherwise, update prefix lifetime to the
1137  *    longest valid lifetime among the corresponding
1138  *    addresses on the device.
1139  *    Note: subsequent RA will update lifetime.
1140  **/
1141 static enum cleanup_prefix_rt_t
1142 check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires)
1143 {
1144 	struct inet6_ifaddr *ifa;
1145 	struct inet6_dev *idev = ifp->idev;
1146 	unsigned long lifetime;
1147 	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL;
1148 
1149 	*expires = jiffies;
1150 
1151 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
1152 		if (ifa == ifp)
1153 			continue;
1154 		if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr,
1155 				       ifp->prefix_len))
1156 			continue;
1157 		if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE))
1158 			return CLEANUP_PREFIX_RT_NOP;
1159 
1160 		action = CLEANUP_PREFIX_RT_EXPIRE;
1161 
1162 		spin_lock(&ifa->lock);
1163 
1164 		lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
1165 		/*
1166 		 * Note: Because this address is
1167 		 * not permanent, lifetime <
1168 		 * LONG_MAX / HZ here.
1169 		 */
1170 		if (time_before(*expires, ifa->tstamp + lifetime * HZ))
1171 			*expires = ifa->tstamp + lifetime * HZ;
1172 		spin_unlock(&ifa->lock);
1173 	}
1174 
1175 	return action;
1176 }
1177 
1178 static void
1179 cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt)
1180 {
1181 	struct fib6_info *f6i;
1182 
1183 	f6i = addrconf_get_prefix_route(&ifp->addr,
1184 				       ifp->prefix_len,
1185 				       ifp->idev->dev,
1186 				       0, RTF_GATEWAY | RTF_DEFAULT);
1187 	if (f6i) {
1188 		if (del_rt)
1189 			ip6_del_rt(dev_net(ifp->idev->dev), f6i);
1190 		else {
1191 			if (!(f6i->fib6_flags & RTF_EXPIRES))
1192 				fib6_set_expires(f6i, expires);
1193 			fib6_info_release(f6i);
1194 		}
1195 	}
1196 }
1197 
1198 
1199 /* This function wants to get referenced ifp and releases it before return */
1200 
1201 static void ipv6_del_addr(struct inet6_ifaddr *ifp)
1202 {
1203 	int state;
1204 	enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
1205 	unsigned long expires;
1206 
1207 	ASSERT_RTNL();
1208 
1209 	spin_lock_bh(&ifp->lock);
1210 	state = ifp->state;
1211 	ifp->state = INET6_IFADDR_STATE_DEAD;
1212 	spin_unlock_bh(&ifp->lock);
1213 
1214 	if (state == INET6_IFADDR_STATE_DEAD)
1215 		goto out;
1216 
1217 	spin_lock_bh(&addrconf_hash_lock);
1218 	hlist_del_init_rcu(&ifp->addr_lst);
1219 	spin_unlock_bh(&addrconf_hash_lock);
1220 
1221 	write_lock_bh(&ifp->idev->lock);
1222 
1223 	if (ifp->flags&IFA_F_TEMPORARY) {
1224 		list_del(&ifp->tmp_list);
1225 		if (ifp->ifpub) {
1226 			in6_ifa_put(ifp->ifpub);
1227 			ifp->ifpub = NULL;
1228 		}
1229 		__in6_ifa_put(ifp);
1230 	}
1231 
1232 	if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
1233 		action = check_cleanup_prefix_route(ifp, &expires);
1234 
1235 	list_del_rcu(&ifp->if_list);
1236 	__in6_ifa_put(ifp);
1237 
1238 	write_unlock_bh(&ifp->idev->lock);
1239 
1240 	addrconf_del_dad_work(ifp);
1241 
1242 	ipv6_ifa_notify(RTM_DELADDR, ifp);
1243 
1244 	inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
1245 
1246 	if (action != CLEANUP_PREFIX_RT_NOP) {
1247 		cleanup_prefix_route(ifp, expires,
1248 			action == CLEANUP_PREFIX_RT_DEL);
1249 	}
1250 
1251 	/* clean up prefsrc entries */
1252 	rt6_remove_prefsrc(ifp);
1253 out:
1254 	in6_ifa_put(ifp);
1255 }
1256 
1257 static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp,
1258 				struct inet6_ifaddr *ift,
1259 				bool block)
1260 {
1261 	struct inet6_dev *idev = ifp->idev;
1262 	struct in6_addr addr, *tmpaddr;
1263 	unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
1264 	unsigned long regen_advance;
1265 	int tmp_plen;
1266 	int ret = 0;
1267 	u32 addr_flags;
1268 	unsigned long now = jiffies;
1269 	long max_desync_factor;
1270 	s32 cnf_temp_preferred_lft;
1271 
1272 	write_lock_bh(&idev->lock);
1273 	if (ift) {
1274 		spin_lock_bh(&ift->lock);
1275 		memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
1276 		spin_unlock_bh(&ift->lock);
1277 		tmpaddr = &addr;
1278 	} else {
1279 		tmpaddr = NULL;
1280 	}
1281 retry:
1282 	in6_dev_hold(idev);
1283 	if (idev->cnf.use_tempaddr <= 0) {
1284 		write_unlock_bh(&idev->lock);
1285 		pr_info("%s: use_tempaddr is disabled\n", __func__);
1286 		in6_dev_put(idev);
1287 		ret = -1;
1288 		goto out;
1289 	}
1290 	spin_lock_bh(&ifp->lock);
1291 	if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
1292 		idev->cnf.use_tempaddr = -1;	/*XXX*/
1293 		spin_unlock_bh(&ifp->lock);
1294 		write_unlock_bh(&idev->lock);
1295 		pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
1296 			__func__);
1297 		in6_dev_put(idev);
1298 		ret = -1;
1299 		goto out;
1300 	}
1301 	in6_ifa_hold(ifp);
1302 	memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
1303 	ipv6_try_regen_rndid(idev, tmpaddr);
1304 	memcpy(&addr.s6_addr[8], idev->rndid, 8);
1305 	age = (now - ifp->tstamp) / HZ;
1306 
1307 	regen_advance = idev->cnf.regen_max_retry *
1308 			idev->cnf.dad_transmits *
1309 			NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ;
1310 
1311 	/* recalculate max_desync_factor each time and update
1312 	 * idev->desync_factor if it's larger
1313 	 */
1314 	cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft);
1315 	max_desync_factor = min_t(__u32,
1316 				  idev->cnf.max_desync_factor,
1317 				  cnf_temp_preferred_lft - regen_advance);
1318 
1319 	if (unlikely(idev->desync_factor > max_desync_factor)) {
1320 		if (max_desync_factor > 0) {
1321 			get_random_bytes(&idev->desync_factor,
1322 					 sizeof(idev->desync_factor));
1323 			idev->desync_factor %= max_desync_factor;
1324 		} else {
1325 			idev->desync_factor = 0;
1326 		}
1327 	}
1328 
1329 	tmp_valid_lft = min_t(__u32,
1330 			      ifp->valid_lft,
1331 			      idev->cnf.temp_valid_lft + age);
1332 	tmp_prefered_lft = cnf_temp_preferred_lft + age -
1333 			    idev->desync_factor;
1334 	tmp_prefered_lft = min_t(__u32, ifp->prefered_lft, tmp_prefered_lft);
1335 	tmp_plen = ifp->prefix_len;
1336 	tmp_tstamp = ifp->tstamp;
1337 	spin_unlock_bh(&ifp->lock);
1338 
1339 	write_unlock_bh(&idev->lock);
1340 
1341 	/* A temporary address is created only if this calculated Preferred
1342 	 * Lifetime is greater than REGEN_ADVANCE time units.  In particular,
1343 	 * an implementation must not create a temporary address with a zero
1344 	 * Preferred Lifetime.
1345 	 * Use age calculation as in addrconf_verify to avoid unnecessary
1346 	 * temporary addresses being generated.
1347 	 */
1348 	age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
1349 	if (tmp_prefered_lft <= regen_advance + age) {
1350 		in6_ifa_put(ifp);
1351 		in6_dev_put(idev);
1352 		ret = -1;
1353 		goto out;
1354 	}
1355 
1356 	addr_flags = IFA_F_TEMPORARY;
1357 	/* set in addrconf_prefix_rcv() */
1358 	if (ifp->flags & IFA_F_OPTIMISTIC)
1359 		addr_flags |= IFA_F_OPTIMISTIC;
1360 
1361 	ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
1362 			    ipv6_addr_scope(&addr), addr_flags,
1363 			    tmp_valid_lft, tmp_prefered_lft, block, NULL);
1364 	if (IS_ERR(ift)) {
1365 		in6_ifa_put(ifp);
1366 		in6_dev_put(idev);
1367 		pr_info("%s: retry temporary address regeneration\n", __func__);
1368 		tmpaddr = &addr;
1369 		write_lock_bh(&idev->lock);
1370 		goto retry;
1371 	}
1372 
1373 	spin_lock_bh(&ift->lock);
1374 	ift->ifpub = ifp;
1375 	ift->cstamp = now;
1376 	ift->tstamp = tmp_tstamp;
1377 	spin_unlock_bh(&ift->lock);
1378 
1379 	addrconf_dad_start(ift);
1380 	in6_ifa_put(ift);
1381 	in6_dev_put(idev);
1382 out:
1383 	return ret;
1384 }
1385 
1386 /*
1387  *	Choose an appropriate source address (RFC3484)
1388  */
1389 enum {
1390 	IPV6_SADDR_RULE_INIT = 0,
1391 	IPV6_SADDR_RULE_LOCAL,
1392 	IPV6_SADDR_RULE_SCOPE,
1393 	IPV6_SADDR_RULE_PREFERRED,
1394 #ifdef CONFIG_IPV6_MIP6
1395 	IPV6_SADDR_RULE_HOA,
1396 #endif
1397 	IPV6_SADDR_RULE_OIF,
1398 	IPV6_SADDR_RULE_LABEL,
1399 	IPV6_SADDR_RULE_PRIVACY,
1400 	IPV6_SADDR_RULE_ORCHID,
1401 	IPV6_SADDR_RULE_PREFIX,
1402 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1403 	IPV6_SADDR_RULE_NOT_OPTIMISTIC,
1404 #endif
1405 	IPV6_SADDR_RULE_MAX
1406 };
1407 
1408 struct ipv6_saddr_score {
1409 	int			rule;
1410 	int			addr_type;
1411 	struct inet6_ifaddr	*ifa;
1412 	DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
1413 	int			scopedist;
1414 	int			matchlen;
1415 };
1416 
1417 struct ipv6_saddr_dst {
1418 	const struct in6_addr *addr;
1419 	int ifindex;
1420 	int scope;
1421 	int label;
1422 	unsigned int prefs;
1423 };
1424 
1425 static inline int ipv6_saddr_preferred(int type)
1426 {
1427 	if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1428 		return 1;
1429 	return 0;
1430 }
1431 
1432 static bool ipv6_use_optimistic_addr(struct net *net,
1433 				     struct inet6_dev *idev)
1434 {
1435 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1436 	if (!idev)
1437 		return false;
1438 	if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
1439 		return false;
1440 	if (!net->ipv6.devconf_all->use_optimistic && !idev->cnf.use_optimistic)
1441 		return false;
1442 
1443 	return true;
1444 #else
1445 	return false;
1446 #endif
1447 }
1448 
1449 static bool ipv6_allow_optimistic_dad(struct net *net,
1450 				      struct inet6_dev *idev)
1451 {
1452 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1453 	if (!idev)
1454 		return false;
1455 	if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
1456 		return false;
1457 
1458 	return true;
1459 #else
1460 	return false;
1461 #endif
1462 }
1463 
1464 static int ipv6_get_saddr_eval(struct net *net,
1465 			       struct ipv6_saddr_score *score,
1466 			       struct ipv6_saddr_dst *dst,
1467 			       int i)
1468 {
1469 	int ret;
1470 
1471 	if (i <= score->rule) {
1472 		switch (i) {
1473 		case IPV6_SADDR_RULE_SCOPE:
1474 			ret = score->scopedist;
1475 			break;
1476 		case IPV6_SADDR_RULE_PREFIX:
1477 			ret = score->matchlen;
1478 			break;
1479 		default:
1480 			ret = !!test_bit(i, score->scorebits);
1481 		}
1482 		goto out;
1483 	}
1484 
1485 	switch (i) {
1486 	case IPV6_SADDR_RULE_INIT:
1487 		/* Rule 0: remember if hiscore is not ready yet */
1488 		ret = !!score->ifa;
1489 		break;
1490 	case IPV6_SADDR_RULE_LOCAL:
1491 		/* Rule 1: Prefer same address */
1492 		ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
1493 		break;
1494 	case IPV6_SADDR_RULE_SCOPE:
1495 		/* Rule 2: Prefer appropriate scope
1496 		 *
1497 		 *      ret
1498 		 *       ^
1499 		 *    -1 |  d 15
1500 		 *    ---+--+-+---> scope
1501 		 *       |
1502 		 *       |             d is scope of the destination.
1503 		 *  B-d  |  \
1504 		 *       |   \      <- smaller scope is better if
1505 		 *  B-15 |    \        if scope is enough for destination.
1506 		 *       |             ret = B - scope (-1 <= scope >= d <= 15).
1507 		 * d-C-1 | /
1508 		 *       |/         <- greater is better
1509 		 *   -C  /             if scope is not enough for destination.
1510 		 *      /|             ret = scope - C (-1 <= d < scope <= 15).
1511 		 *
1512 		 * d - C - 1 < B -15 (for all -1 <= d <= 15).
1513 		 * C > d + 14 - B >= 15 + 14 - B = 29 - B.
1514 		 * Assume B = 0 and we get C > 29.
1515 		 */
1516 		ret = __ipv6_addr_src_scope(score->addr_type);
1517 		if (ret >= dst->scope)
1518 			ret = -ret;
1519 		else
1520 			ret -= 128;	/* 30 is enough */
1521 		score->scopedist = ret;
1522 		break;
1523 	case IPV6_SADDR_RULE_PREFERRED:
1524 	    {
1525 		/* Rule 3: Avoid deprecated and optimistic addresses */
1526 		u8 avoid = IFA_F_DEPRECATED;
1527 
1528 		if (!ipv6_use_optimistic_addr(net, score->ifa->idev))
1529 			avoid |= IFA_F_OPTIMISTIC;
1530 		ret = ipv6_saddr_preferred(score->addr_type) ||
1531 		      !(score->ifa->flags & avoid);
1532 		break;
1533 	    }
1534 #ifdef CONFIG_IPV6_MIP6
1535 	case IPV6_SADDR_RULE_HOA:
1536 	    {
1537 		/* Rule 4: Prefer home address */
1538 		int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
1539 		ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1540 		break;
1541 	    }
1542 #endif
1543 	case IPV6_SADDR_RULE_OIF:
1544 		/* Rule 5: Prefer outgoing interface */
1545 		ret = (!dst->ifindex ||
1546 		       dst->ifindex == score->ifa->idev->dev->ifindex);
1547 		break;
1548 	case IPV6_SADDR_RULE_LABEL:
1549 		/* Rule 6: Prefer matching label */
1550 		ret = ipv6_addr_label(net,
1551 				      &score->ifa->addr, score->addr_type,
1552 				      score->ifa->idev->dev->ifindex) == dst->label;
1553 		break;
1554 	case IPV6_SADDR_RULE_PRIVACY:
1555 	    {
1556 		/* Rule 7: Prefer public address
1557 		 * Note: prefer temporary address if use_tempaddr >= 2
1558 		 */
1559 		int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
1560 				!!(dst->prefs & IPV6_PREFER_SRC_TMP) :
1561 				score->ifa->idev->cnf.use_tempaddr >= 2;
1562 		ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1563 		break;
1564 	    }
1565 	case IPV6_SADDR_RULE_ORCHID:
1566 		/* Rule 8-: Prefer ORCHID vs ORCHID or
1567 		 *	    non-ORCHID vs non-ORCHID
1568 		 */
1569 		ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
1570 			ipv6_addr_orchid(dst->addr));
1571 		break;
1572 	case IPV6_SADDR_RULE_PREFIX:
1573 		/* Rule 8: Use longest matching prefix */
1574 		ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
1575 		if (ret > score->ifa->prefix_len)
1576 			ret = score->ifa->prefix_len;
1577 		score->matchlen = ret;
1578 		break;
1579 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1580 	case IPV6_SADDR_RULE_NOT_OPTIMISTIC:
1581 		/* Optimistic addresses still have lower precedence than other
1582 		 * preferred addresses.
1583 		 */
1584 		ret = !(score->ifa->flags & IFA_F_OPTIMISTIC);
1585 		break;
1586 #endif
1587 	default:
1588 		ret = 0;
1589 	}
1590 
1591 	if (ret)
1592 		__set_bit(i, score->scorebits);
1593 	score->rule = i;
1594 out:
1595 	return ret;
1596 }
1597 
1598 static int __ipv6_dev_get_saddr(struct net *net,
1599 				struct ipv6_saddr_dst *dst,
1600 				struct inet6_dev *idev,
1601 				struct ipv6_saddr_score *scores,
1602 				int hiscore_idx)
1603 {
1604 	struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx];
1605 
1606 	list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) {
1607 		int i;
1608 
1609 		/*
1610 		 * - Tentative Address (RFC2462 section 5.4)
1611 		 *  - A tentative address is not considered
1612 		 *    "assigned to an interface" in the traditional
1613 		 *    sense, unless it is also flagged as optimistic.
1614 		 * - Candidate Source Address (section 4)
1615 		 *  - In any case, anycast addresses, multicast
1616 		 *    addresses, and the unspecified address MUST
1617 		 *    NOT be included in a candidate set.
1618 		 */
1619 		if ((score->ifa->flags & IFA_F_TENTATIVE) &&
1620 		    (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1621 			continue;
1622 
1623 		score->addr_type = __ipv6_addr_type(&score->ifa->addr);
1624 
1625 		if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
1626 			     score->addr_type & IPV6_ADDR_MULTICAST)) {
1627 			net_dbg_ratelimited("ADDRCONF: unspecified / multicast address assigned as unicast address on %s",
1628 					    idev->dev->name);
1629 			continue;
1630 		}
1631 
1632 		score->rule = -1;
1633 		bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
1634 
1635 		for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
1636 			int minihiscore, miniscore;
1637 
1638 			minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i);
1639 			miniscore = ipv6_get_saddr_eval(net, score, dst, i);
1640 
1641 			if (minihiscore > miniscore) {
1642 				if (i == IPV6_SADDR_RULE_SCOPE &&
1643 				    score->scopedist > 0) {
1644 					/*
1645 					 * special case:
1646 					 * each remaining entry
1647 					 * has too small (not enough)
1648 					 * scope, because ifa entries
1649 					 * are sorted by their scope
1650 					 * values.
1651 					 */
1652 					goto out;
1653 				}
1654 				break;
1655 			} else if (minihiscore < miniscore) {
1656 				swap(hiscore, score);
1657 				hiscore_idx = 1 - hiscore_idx;
1658 
1659 				/* restore our iterator */
1660 				score->ifa = hiscore->ifa;
1661 
1662 				break;
1663 			}
1664 		}
1665 	}
1666 out:
1667 	return hiscore_idx;
1668 }
1669 
1670 static int ipv6_get_saddr_master(struct net *net,
1671 				 const struct net_device *dst_dev,
1672 				 const struct net_device *master,
1673 				 struct ipv6_saddr_dst *dst,
1674 				 struct ipv6_saddr_score *scores,
1675 				 int hiscore_idx)
1676 {
1677 	struct inet6_dev *idev;
1678 
1679 	idev = __in6_dev_get(dst_dev);
1680 	if (idev)
1681 		hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
1682 						   scores, hiscore_idx);
1683 
1684 	idev = __in6_dev_get(master);
1685 	if (idev)
1686 		hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
1687 						   scores, hiscore_idx);
1688 
1689 	return hiscore_idx;
1690 }
1691 
1692 int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1693 		       const struct in6_addr *daddr, unsigned int prefs,
1694 		       struct in6_addr *saddr)
1695 {
1696 	struct ipv6_saddr_score scores[2], *hiscore;
1697 	struct ipv6_saddr_dst dst;
1698 	struct inet6_dev *idev;
1699 	struct net_device *dev;
1700 	int dst_type;
1701 	bool use_oif_addr = false;
1702 	int hiscore_idx = 0;
1703 	int ret = 0;
1704 
1705 	dst_type = __ipv6_addr_type(daddr);
1706 	dst.addr = daddr;
1707 	dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
1708 	dst.scope = __ipv6_addr_src_scope(dst_type);
1709 	dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1710 	dst.prefs = prefs;
1711 
1712 	scores[hiscore_idx].rule = -1;
1713 	scores[hiscore_idx].ifa = NULL;
1714 
1715 	rcu_read_lock();
1716 
1717 	/* Candidate Source Address (section 4)
1718 	 *  - multicast and link-local destination address,
1719 	 *    the set of candidate source address MUST only
1720 	 *    include addresses assigned to interfaces
1721 	 *    belonging to the same link as the outgoing
1722 	 *    interface.
1723 	 * (- For site-local destination addresses, the
1724 	 *    set of candidate source addresses MUST only
1725 	 *    include addresses assigned to interfaces
1726 	 *    belonging to the same site as the outgoing
1727 	 *    interface.)
1728 	 *  - "It is RECOMMENDED that the candidate source addresses
1729 	 *    be the set of unicast addresses assigned to the
1730 	 *    interface that will be used to send to the destination
1731 	 *    (the 'outgoing' interface)." (RFC 6724)
1732 	 */
1733 	if (dst_dev) {
1734 		idev = __in6_dev_get(dst_dev);
1735 		if ((dst_type & IPV6_ADDR_MULTICAST) ||
1736 		    dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||
1737 		    (idev && idev->cnf.use_oif_addrs_only)) {
1738 			use_oif_addr = true;
1739 		}
1740 	}
1741 
1742 	if (use_oif_addr) {
1743 		if (idev)
1744 			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1745 	} else {
1746 		const struct net_device *master;
1747 		int master_idx = 0;
1748 
1749 		/* if dst_dev exists and is enslaved to an L3 device, then
1750 		 * prefer addresses from dst_dev and then the master over
1751 		 * any other enslaved devices in the L3 domain.
1752 		 */
1753 		master = l3mdev_master_dev_rcu(dst_dev);
1754 		if (master) {
1755 			master_idx = master->ifindex;
1756 
1757 			hiscore_idx = ipv6_get_saddr_master(net, dst_dev,
1758 							    master, &dst,
1759 							    scores, hiscore_idx);
1760 
1761 			if (scores[hiscore_idx].ifa)
1762 				goto out;
1763 		}
1764 
1765 		for_each_netdev_rcu(net, dev) {
1766 			/* only consider addresses on devices in the
1767 			 * same L3 domain
1768 			 */
1769 			if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1770 				continue;
1771 			idev = __in6_dev_get(dev);
1772 			if (!idev)
1773 				continue;
1774 			hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1775 		}
1776 	}
1777 
1778 out:
1779 	hiscore = &scores[hiscore_idx];
1780 	if (!hiscore->ifa)
1781 		ret = -EADDRNOTAVAIL;
1782 	else
1783 		*saddr = hiscore->ifa->addr;
1784 
1785 	rcu_read_unlock();
1786 	return ret;
1787 }
1788 EXPORT_SYMBOL(ipv6_dev_get_saddr);
1789 
1790 int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1791 		      u32 banned_flags)
1792 {
1793 	struct inet6_ifaddr *ifp;
1794 	int err = -EADDRNOTAVAIL;
1795 
1796 	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
1797 		if (ifp->scope > IFA_LINK)
1798 			break;
1799 		if (ifp->scope == IFA_LINK &&
1800 		    !(ifp->flags & banned_flags)) {
1801 			*addr = ifp->addr;
1802 			err = 0;
1803 			break;
1804 		}
1805 	}
1806 	return err;
1807 }
1808 
1809 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1810 		    u32 banned_flags)
1811 {
1812 	struct inet6_dev *idev;
1813 	int err = -EADDRNOTAVAIL;
1814 
1815 	rcu_read_lock();
1816 	idev = __in6_dev_get(dev);
1817 	if (idev) {
1818 		read_lock_bh(&idev->lock);
1819 		err = __ipv6_get_lladdr(idev, addr, banned_flags);
1820 		read_unlock_bh(&idev->lock);
1821 	}
1822 	rcu_read_unlock();
1823 	return err;
1824 }
1825 
1826 static int ipv6_count_addresses(const struct inet6_dev *idev)
1827 {
1828 	const struct inet6_ifaddr *ifp;
1829 	int cnt = 0;
1830 
1831 	rcu_read_lock();
1832 	list_for_each_entry_rcu(ifp, &idev->addr_list, if_list)
1833 		cnt++;
1834 	rcu_read_unlock();
1835 	return cnt;
1836 }
1837 
1838 int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1839 		  const struct net_device *dev, int strict)
1840 {
1841 	return ipv6_chk_addr_and_flags(net, addr, dev, !dev,
1842 				       strict, IFA_F_TENTATIVE);
1843 }
1844 EXPORT_SYMBOL(ipv6_chk_addr);
1845 
1846 /* device argument is used to find the L3 domain of interest. If
1847  * skip_dev_check is set, then the ifp device is not checked against
1848  * the passed in dev argument. So the 2 cases for addresses checks are:
1849  *   1. does the address exist in the L3 domain that dev is part of
1850  *      (skip_dev_check = true), or
1851  *
1852  *   2. does the address exist on the specific device
1853  *      (skip_dev_check = false)
1854  */
1855 int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
1856 			    const struct net_device *dev, bool skip_dev_check,
1857 			    int strict, u32 banned_flags)
1858 {
1859 	unsigned int hash = inet6_addr_hash(net, addr);
1860 	const struct net_device *l3mdev;
1861 	struct inet6_ifaddr *ifp;
1862 	u32 ifp_flags;
1863 
1864 	rcu_read_lock();
1865 
1866 	l3mdev = l3mdev_master_dev_rcu(dev);
1867 	if (skip_dev_check)
1868 		dev = NULL;
1869 
1870 	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1871 		if (!net_eq(dev_net(ifp->idev->dev), net))
1872 			continue;
1873 
1874 		if (l3mdev_master_dev_rcu(ifp->idev->dev) != l3mdev)
1875 			continue;
1876 
1877 		/* Decouple optimistic from tentative for evaluation here.
1878 		 * Ban optimistic addresses explicitly, when required.
1879 		 */
1880 		ifp_flags = (ifp->flags&IFA_F_OPTIMISTIC)
1881 			    ? (ifp->flags&~IFA_F_TENTATIVE)
1882 			    : ifp->flags;
1883 		if (ipv6_addr_equal(&ifp->addr, addr) &&
1884 		    !(ifp_flags&banned_flags) &&
1885 		    (!dev || ifp->idev->dev == dev ||
1886 		     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1887 			rcu_read_unlock();
1888 			return 1;
1889 		}
1890 	}
1891 
1892 	rcu_read_unlock();
1893 	return 0;
1894 }
1895 EXPORT_SYMBOL(ipv6_chk_addr_and_flags);
1896 
1897 
1898 /* Compares an address/prefix_len with addresses on device @dev.
1899  * If one is found it returns true.
1900  */
1901 bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
1902 	const unsigned int prefix_len, struct net_device *dev)
1903 {
1904 	const struct inet6_ifaddr *ifa;
1905 	const struct inet6_dev *idev;
1906 	bool ret = false;
1907 
1908 	rcu_read_lock();
1909 	idev = __in6_dev_get(dev);
1910 	if (idev) {
1911 		list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1912 			ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
1913 			if (ret)
1914 				break;
1915 		}
1916 	}
1917 	rcu_read_unlock();
1918 
1919 	return ret;
1920 }
1921 EXPORT_SYMBOL(ipv6_chk_custom_prefix);
1922 
1923 int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1924 {
1925 	const struct inet6_ifaddr *ifa;
1926 	const struct inet6_dev *idev;
1927 	int	onlink;
1928 
1929 	onlink = 0;
1930 	rcu_read_lock();
1931 	idev = __in6_dev_get(dev);
1932 	if (idev) {
1933 		list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1934 			onlink = ipv6_prefix_equal(addr, &ifa->addr,
1935 						   ifa->prefix_len);
1936 			if (onlink)
1937 				break;
1938 		}
1939 	}
1940 	rcu_read_unlock();
1941 	return onlink;
1942 }
1943 EXPORT_SYMBOL(ipv6_chk_prefix);
1944 
1945 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1946 				     struct net_device *dev, int strict)
1947 {
1948 	unsigned int hash = inet6_addr_hash(net, addr);
1949 	struct inet6_ifaddr *ifp, *result = NULL;
1950 
1951 	rcu_read_lock();
1952 	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1953 		if (!net_eq(dev_net(ifp->idev->dev), net))
1954 			continue;
1955 		if (ipv6_addr_equal(&ifp->addr, addr)) {
1956 			if (!dev || ifp->idev->dev == dev ||
1957 			    !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1958 				result = ifp;
1959 				in6_ifa_hold(ifp);
1960 				break;
1961 			}
1962 		}
1963 	}
1964 	rcu_read_unlock();
1965 
1966 	return result;
1967 }
1968 
1969 /* Gets referenced address, destroys ifaddr */
1970 
1971 static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
1972 {
1973 	if (dad_failed)
1974 		ifp->flags |= IFA_F_DADFAILED;
1975 
1976 	if (ifp->flags&IFA_F_TEMPORARY) {
1977 		struct inet6_ifaddr *ifpub;
1978 		spin_lock_bh(&ifp->lock);
1979 		ifpub = ifp->ifpub;
1980 		if (ifpub) {
1981 			in6_ifa_hold(ifpub);
1982 			spin_unlock_bh(&ifp->lock);
1983 			ipv6_create_tempaddr(ifpub, ifp, true);
1984 			in6_ifa_put(ifpub);
1985 		} else {
1986 			spin_unlock_bh(&ifp->lock);
1987 		}
1988 		ipv6_del_addr(ifp);
1989 	} else if (ifp->flags&IFA_F_PERMANENT || !dad_failed) {
1990 		spin_lock_bh(&ifp->lock);
1991 		addrconf_del_dad_work(ifp);
1992 		ifp->flags |= IFA_F_TENTATIVE;
1993 		if (dad_failed)
1994 			ifp->flags &= ~IFA_F_OPTIMISTIC;
1995 		spin_unlock_bh(&ifp->lock);
1996 		if (dad_failed)
1997 			ipv6_ifa_notify(0, ifp);
1998 		in6_ifa_put(ifp);
1999 	} else {
2000 		ipv6_del_addr(ifp);
2001 	}
2002 }
2003 
2004 static int addrconf_dad_end(struct inet6_ifaddr *ifp)
2005 {
2006 	int err = -ENOENT;
2007 
2008 	spin_lock_bh(&ifp->lock);
2009 	if (ifp->state == INET6_IFADDR_STATE_DAD) {
2010 		ifp->state = INET6_IFADDR_STATE_POSTDAD;
2011 		err = 0;
2012 	}
2013 	spin_unlock_bh(&ifp->lock);
2014 
2015 	return err;
2016 }
2017 
2018 void addrconf_dad_failure(struct sk_buff *skb, struct inet6_ifaddr *ifp)
2019 {
2020 	struct inet6_dev *idev = ifp->idev;
2021 	struct net *net = dev_net(ifp->idev->dev);
2022 
2023 	if (addrconf_dad_end(ifp)) {
2024 		in6_ifa_put(ifp);
2025 		return;
2026 	}
2027 
2028 	net_info_ratelimited("%s: IPv6 duplicate address %pI6c used by %pM detected!\n",
2029 			     ifp->idev->dev->name, &ifp->addr, eth_hdr(skb)->h_source);
2030 
2031 	spin_lock_bh(&ifp->lock);
2032 
2033 	if (ifp->flags & IFA_F_STABLE_PRIVACY) {
2034 		int scope = ifp->scope;
2035 		u32 flags = ifp->flags;
2036 		struct in6_addr new_addr;
2037 		struct inet6_ifaddr *ifp2;
2038 		u32 valid_lft, preferred_lft;
2039 		int pfxlen = ifp->prefix_len;
2040 		int retries = ifp->stable_privacy_retry + 1;
2041 
2042 		if (retries > net->ipv6.sysctl.idgen_retries) {
2043 			net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n",
2044 					     ifp->idev->dev->name);
2045 			goto errdad;
2046 		}
2047 
2048 		new_addr = ifp->addr;
2049 		if (ipv6_generate_stable_address(&new_addr, retries,
2050 						 idev))
2051 			goto errdad;
2052 
2053 		valid_lft = ifp->valid_lft;
2054 		preferred_lft = ifp->prefered_lft;
2055 
2056 		spin_unlock_bh(&ifp->lock);
2057 
2058 		if (idev->cnf.max_addresses &&
2059 		    ipv6_count_addresses(idev) >=
2060 		    idev->cnf.max_addresses)
2061 			goto lock_errdad;
2062 
2063 		net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n",
2064 				     ifp->idev->dev->name);
2065 
2066 		ifp2 = ipv6_add_addr(idev, &new_addr, NULL, pfxlen,
2067 				     scope, flags, valid_lft,
2068 				     preferred_lft, false, NULL);
2069 		if (IS_ERR(ifp2))
2070 			goto lock_errdad;
2071 
2072 		spin_lock_bh(&ifp2->lock);
2073 		ifp2->stable_privacy_retry = retries;
2074 		ifp2->state = INET6_IFADDR_STATE_PREDAD;
2075 		spin_unlock_bh(&ifp2->lock);
2076 
2077 		addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
2078 		in6_ifa_put(ifp2);
2079 lock_errdad:
2080 		spin_lock_bh(&ifp->lock);
2081 	}
2082 
2083 errdad:
2084 	/* transition from _POSTDAD to _ERRDAD */
2085 	ifp->state = INET6_IFADDR_STATE_ERRDAD;
2086 	spin_unlock_bh(&ifp->lock);
2087 
2088 	addrconf_mod_dad_work(ifp, 0);
2089 	in6_ifa_put(ifp);
2090 }
2091 
2092 /* Join to solicited addr multicast group.
2093  * caller must hold RTNL */
2094 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
2095 {
2096 	struct in6_addr maddr;
2097 
2098 	if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
2099 		return;
2100 
2101 	addrconf_addr_solict_mult(addr, &maddr);
2102 	ipv6_dev_mc_inc(dev, &maddr);
2103 }
2104 
2105 /* caller must hold RTNL */
2106 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
2107 {
2108 	struct in6_addr maddr;
2109 
2110 	if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
2111 		return;
2112 
2113 	addrconf_addr_solict_mult(addr, &maddr);
2114 	__ipv6_dev_mc_dec(idev, &maddr);
2115 }
2116 
2117 /* caller must hold RTNL */
2118 static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
2119 {
2120 	struct in6_addr addr;
2121 
2122 	if (ifp->prefix_len >= 127) /* RFC 6164 */
2123 		return;
2124 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
2125 	if (ipv6_addr_any(&addr))
2126 		return;
2127 	__ipv6_dev_ac_inc(ifp->idev, &addr);
2128 }
2129 
2130 /* caller must hold RTNL */
2131 static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
2132 {
2133 	struct in6_addr addr;
2134 
2135 	if (ifp->prefix_len >= 127) /* RFC 6164 */
2136 		return;
2137 	ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
2138 	if (ipv6_addr_any(&addr))
2139 		return;
2140 	__ipv6_dev_ac_dec(ifp->idev, &addr);
2141 }
2142 
2143 static int addrconf_ifid_6lowpan(u8 *eui, struct net_device *dev)
2144 {
2145 	switch (dev->addr_len) {
2146 	case ETH_ALEN:
2147 		memcpy(eui, dev->dev_addr, 3);
2148 		eui[3] = 0xFF;
2149 		eui[4] = 0xFE;
2150 		memcpy(eui + 5, dev->dev_addr + 3, 3);
2151 		break;
2152 	case EUI64_ADDR_LEN:
2153 		memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN);
2154 		eui[0] ^= 2;
2155 		break;
2156 	default:
2157 		return -1;
2158 	}
2159 
2160 	return 0;
2161 }
2162 
2163 static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
2164 {
2165 	union fwnet_hwaddr *ha;
2166 
2167 	if (dev->addr_len != FWNET_ALEN)
2168 		return -1;
2169 
2170 	ha = (union fwnet_hwaddr *)dev->dev_addr;
2171 
2172 	memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
2173 	eui[0] ^= 2;
2174 	return 0;
2175 }
2176 
2177 static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
2178 {
2179 	/* XXX: inherit EUI-64 from other interface -- yoshfuji */
2180 	if (dev->addr_len != ARCNET_ALEN)
2181 		return -1;
2182 	memset(eui, 0, 7);
2183 	eui[7] = *(u8 *)dev->dev_addr;
2184 	return 0;
2185 }
2186 
2187 static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
2188 {
2189 	if (dev->addr_len != INFINIBAND_ALEN)
2190 		return -1;
2191 	memcpy(eui, dev->dev_addr + 12, 8);
2192 	eui[0] |= 2;
2193 	return 0;
2194 }
2195 
2196 static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
2197 {
2198 	if (addr == 0)
2199 		return -1;
2200 	eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
2201 		  ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
2202 		  ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
2203 		  ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
2204 		  ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
2205 		  ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
2206 	eui[1] = 0;
2207 	eui[2] = 0x5E;
2208 	eui[3] = 0xFE;
2209 	memcpy(eui + 4, &addr, 4);
2210 	return 0;
2211 }
2212 
2213 static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
2214 {
2215 	if (dev->priv_flags & IFF_ISATAP)
2216 		return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2217 	return -1;
2218 }
2219 
2220 static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
2221 {
2222 	return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2223 }
2224 
2225 static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev)
2226 {
2227 	memcpy(eui, dev->perm_addr, 3);
2228 	memcpy(eui + 5, dev->perm_addr + 3, 3);
2229 	eui[3] = 0xFF;
2230 	eui[4] = 0xFE;
2231 	eui[0] ^= 2;
2232 	return 0;
2233 }
2234 
2235 static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
2236 {
2237 	switch (dev->type) {
2238 	case ARPHRD_ETHER:
2239 	case ARPHRD_FDDI:
2240 		return addrconf_ifid_eui48(eui, dev);
2241 	case ARPHRD_ARCNET:
2242 		return addrconf_ifid_arcnet(eui, dev);
2243 	case ARPHRD_INFINIBAND:
2244 		return addrconf_ifid_infiniband(eui, dev);
2245 	case ARPHRD_SIT:
2246 		return addrconf_ifid_sit(eui, dev);
2247 	case ARPHRD_IPGRE:
2248 	case ARPHRD_TUNNEL:
2249 		return addrconf_ifid_gre(eui, dev);
2250 	case ARPHRD_6LOWPAN:
2251 		return addrconf_ifid_6lowpan(eui, dev);
2252 	case ARPHRD_IEEE1394:
2253 		return addrconf_ifid_ieee1394(eui, dev);
2254 	case ARPHRD_TUNNEL6:
2255 	case ARPHRD_IP6GRE:
2256 		return addrconf_ifid_ip6tnl(eui, dev);
2257 	}
2258 	return -1;
2259 }
2260 
2261 static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
2262 {
2263 	int err = -1;
2264 	struct inet6_ifaddr *ifp;
2265 
2266 	read_lock_bh(&idev->lock);
2267 	list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
2268 		if (ifp->scope > IFA_LINK)
2269 			break;
2270 		if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
2271 			memcpy(eui, ifp->addr.s6_addr+8, 8);
2272 			err = 0;
2273 			break;
2274 		}
2275 	}
2276 	read_unlock_bh(&idev->lock);
2277 	return err;
2278 }
2279 
2280 /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
2281 static void ipv6_regen_rndid(struct inet6_dev *idev)
2282 {
2283 regen:
2284 	get_random_bytes(idev->rndid, sizeof(idev->rndid));
2285 	idev->rndid[0] &= ~0x02;
2286 
2287 	/*
2288 	 * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
2289 	 * check if generated address is not inappropriate
2290 	 *
2291 	 *  - Reserved subnet anycast (RFC 2526)
2292 	 *	11111101 11....11 1xxxxxxx
2293 	 *  - ISATAP (RFC4214) 6.1
2294 	 *	00-00-5E-FE-xx-xx-xx-xx
2295 	 *  - value 0
2296 	 *  - XXX: already assigned to an address on the device
2297 	 */
2298 	if (idev->rndid[0] == 0xfd &&
2299 	    (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
2300 	    (idev->rndid[7]&0x80))
2301 		goto regen;
2302 	if ((idev->rndid[0]|idev->rndid[1]) == 0) {
2303 		if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
2304 			goto regen;
2305 		if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
2306 			goto regen;
2307 	}
2308 }
2309 
2310 static void  ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
2311 {
2312 	if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
2313 		ipv6_regen_rndid(idev);
2314 }
2315 
2316 /*
2317  *	Add prefix route.
2318  */
2319 
2320 static void
2321 addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
2322 		      unsigned long expires, u32 flags, gfp_t gfp_flags)
2323 {
2324 	struct fib6_config cfg = {
2325 		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
2326 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
2327 		.fc_ifindex = dev->ifindex,
2328 		.fc_expires = expires,
2329 		.fc_dst_len = plen,
2330 		.fc_flags = RTF_UP | flags,
2331 		.fc_nlinfo.nl_net = dev_net(dev),
2332 		.fc_protocol = RTPROT_KERNEL,
2333 		.fc_type = RTN_UNICAST,
2334 	};
2335 
2336 	cfg.fc_dst = *pfx;
2337 
2338 	/* Prevent useless cloning on PtP SIT.
2339 	   This thing is done here expecting that the whole
2340 	   class of non-broadcast devices need not cloning.
2341 	 */
2342 #if IS_ENABLED(CONFIG_IPV6_SIT)
2343 	if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
2344 		cfg.fc_flags |= RTF_NONEXTHOP;
2345 #endif
2346 
2347 	ip6_route_add(&cfg, gfp_flags, NULL);
2348 }
2349 
2350 
2351 static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
2352 						  int plen,
2353 						  const struct net_device *dev,
2354 						  u32 flags, u32 noflags)
2355 {
2356 	struct fib6_node *fn;
2357 	struct fib6_info *rt = NULL;
2358 	struct fib6_table *table;
2359 	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX;
2360 
2361 	table = fib6_get_table(dev_net(dev), tb_id);
2362 	if (!table)
2363 		return NULL;
2364 
2365 	rcu_read_lock();
2366 	fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0, true);
2367 	if (!fn)
2368 		goto out;
2369 
2370 	for_each_fib6_node_rt_rcu(fn) {
2371 		if (rt->fib6_nh.nh_dev->ifindex != dev->ifindex)
2372 			continue;
2373 		if ((rt->fib6_flags & flags) != flags)
2374 			continue;
2375 		if ((rt->fib6_flags & noflags) != 0)
2376 			continue;
2377 		fib6_info_hold(rt);
2378 		break;
2379 	}
2380 out:
2381 	rcu_read_unlock();
2382 	return rt;
2383 }
2384 
2385 
2386 /* Create "default" multicast route to the interface */
2387 
2388 static void addrconf_add_mroute(struct net_device *dev)
2389 {
2390 	struct fib6_config cfg = {
2391 		.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL,
2392 		.fc_metric = IP6_RT_PRIO_ADDRCONF,
2393 		.fc_ifindex = dev->ifindex,
2394 		.fc_dst_len = 8,
2395 		.fc_flags = RTF_UP,
2396 		.fc_type = RTN_UNICAST,
2397 		.fc_nlinfo.nl_net = dev_net(dev),
2398 	};
2399 
2400 	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
2401 
2402 	ip6_route_add(&cfg, GFP_ATOMIC, NULL);
2403 }
2404 
2405 static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
2406 {
2407 	struct inet6_dev *idev;
2408 
2409 	ASSERT_RTNL();
2410 
2411 	idev = ipv6_find_idev(dev);
2412 	if (!idev)
2413 		return ERR_PTR(-ENOBUFS);
2414 
2415 	if (idev->cnf.disable_ipv6)
2416 		return ERR_PTR(-EACCES);
2417 
2418 	/* Add default multicast route */
2419 	if (!(dev->flags & IFF_LOOPBACK) && !netif_is_l3_master(dev))
2420 		addrconf_add_mroute(dev);
2421 
2422 	return idev;
2423 }
2424 
2425 static void manage_tempaddrs(struct inet6_dev *idev,
2426 			     struct inet6_ifaddr *ifp,
2427 			     __u32 valid_lft, __u32 prefered_lft,
2428 			     bool create, unsigned long now)
2429 {
2430 	u32 flags;
2431 	struct inet6_ifaddr *ift;
2432 
2433 	read_lock_bh(&idev->lock);
2434 	/* update all temporary addresses in the list */
2435 	list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) {
2436 		int age, max_valid, max_prefered;
2437 
2438 		if (ifp != ift->ifpub)
2439 			continue;
2440 
2441 		/* RFC 4941 section 3.3:
2442 		 * If a received option will extend the lifetime of a public
2443 		 * address, the lifetimes of temporary addresses should
2444 		 * be extended, subject to the overall constraint that no
2445 		 * temporary addresses should ever remain "valid" or "preferred"
2446 		 * for a time longer than (TEMP_VALID_LIFETIME) or
2447 		 * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively.
2448 		 */
2449 		age = (now - ift->cstamp) / HZ;
2450 		max_valid = idev->cnf.temp_valid_lft - age;
2451 		if (max_valid < 0)
2452 			max_valid = 0;
2453 
2454 		max_prefered = idev->cnf.temp_prefered_lft -
2455 			       idev->desync_factor - age;
2456 		if (max_prefered < 0)
2457 			max_prefered = 0;
2458 
2459 		if (valid_lft > max_valid)
2460 			valid_lft = max_valid;
2461 
2462 		if (prefered_lft > max_prefered)
2463 			prefered_lft = max_prefered;
2464 
2465 		spin_lock(&ift->lock);
2466 		flags = ift->flags;
2467 		ift->valid_lft = valid_lft;
2468 		ift->prefered_lft = prefered_lft;
2469 		ift->tstamp = now;
2470 		if (prefered_lft > 0)
2471 			ift->flags &= ~IFA_F_DEPRECATED;
2472 
2473 		spin_unlock(&ift->lock);
2474 		if (!(flags&IFA_F_TENTATIVE))
2475 			ipv6_ifa_notify(0, ift);
2476 	}
2477 
2478 	if ((create || list_empty(&idev->tempaddr_list)) &&
2479 	    idev->cnf.use_tempaddr > 0) {
2480 		/* When a new public address is created as described
2481 		 * in [ADDRCONF], also create a new temporary address.
2482 		 * Also create a temporary address if it's enabled but
2483 		 * no temporary address currently exists.
2484 		 */
2485 		read_unlock_bh(&idev->lock);
2486 		ipv6_create_tempaddr(ifp, NULL, false);
2487 	} else {
2488 		read_unlock_bh(&idev->lock);
2489 	}
2490 }
2491 
2492 static bool is_addr_mode_generate_stable(struct inet6_dev *idev)
2493 {
2494 	return idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY ||
2495 	       idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM;
2496 }
2497 
2498 int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev,
2499 				 const struct prefix_info *pinfo,
2500 				 struct inet6_dev *in6_dev,
2501 				 const struct in6_addr *addr, int addr_type,
2502 				 u32 addr_flags, bool sllao, bool tokenized,
2503 				 __u32 valid_lft, u32 prefered_lft)
2504 {
2505 	struct inet6_ifaddr *ifp = ipv6_get_ifaddr(net, addr, dev, 1);
2506 	int create = 0, update_lft = 0;
2507 
2508 	if (!ifp && valid_lft) {
2509 		int max_addresses = in6_dev->cnf.max_addresses;
2510 
2511 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2512 		if ((net->ipv6.devconf_all->optimistic_dad ||
2513 		     in6_dev->cnf.optimistic_dad) &&
2514 		    !net->ipv6.devconf_all->forwarding && sllao)
2515 			addr_flags |= IFA_F_OPTIMISTIC;
2516 #endif
2517 
2518 		/* Do not allow to create too much of autoconfigured
2519 		 * addresses; this would be too easy way to crash kernel.
2520 		 */
2521 		if (!max_addresses ||
2522 		    ipv6_count_addresses(in6_dev) < max_addresses)
2523 			ifp = ipv6_add_addr(in6_dev, addr, NULL,
2524 					    pinfo->prefix_len,
2525 					    addr_type&IPV6_ADDR_SCOPE_MASK,
2526 					    addr_flags, valid_lft,
2527 					    prefered_lft, false, NULL);
2528 
2529 		if (IS_ERR_OR_NULL(ifp))
2530 			return -1;
2531 
2532 		create = 1;
2533 		spin_lock_bh(&ifp->lock);
2534 		ifp->flags |= IFA_F_MANAGETEMPADDR;
2535 		ifp->cstamp = jiffies;
2536 		ifp->tokenized = tokenized;
2537 		spin_unlock_bh(&ifp->lock);
2538 		addrconf_dad_start(ifp);
2539 	}
2540 
2541 	if (ifp) {
2542 		u32 flags;
2543 		unsigned long now;
2544 		u32 stored_lft;
2545 
2546 		/* update lifetime (RFC2462 5.5.3 e) */
2547 		spin_lock_bh(&ifp->lock);
2548 		now = jiffies;
2549 		if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
2550 			stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
2551 		else
2552 			stored_lft = 0;
2553 		if (!create && stored_lft) {
2554 			const u32 minimum_lft = min_t(u32,
2555 				stored_lft, MIN_VALID_LIFETIME);
2556 			valid_lft = max(valid_lft, minimum_lft);
2557 
2558 			/* RFC4862 Section 5.5.3e:
2559 			 * "Note that the preferred lifetime of the
2560 			 *  corresponding address is always reset to
2561 			 *  the Preferred Lifetime in the received
2562 			 *  Prefix Information option, regardless of
2563 			 *  whether the valid lifetime is also reset or
2564 			 *  ignored."
2565 			 *
2566 			 * So we should always update prefered_lft here.
2567 			 */
2568 			update_lft = 1;
2569 		}
2570 
2571 		if (update_lft) {
2572 			ifp->valid_lft = valid_lft;
2573 			ifp->prefered_lft = prefered_lft;
2574 			ifp->tstamp = now;
2575 			flags = ifp->flags;
2576 			ifp->flags &= ~IFA_F_DEPRECATED;
2577 			spin_unlock_bh(&ifp->lock);
2578 
2579 			if (!(flags&IFA_F_TENTATIVE))
2580 				ipv6_ifa_notify(0, ifp);
2581 		} else
2582 			spin_unlock_bh(&ifp->lock);
2583 
2584 		manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
2585 				 create, now);
2586 
2587 		in6_ifa_put(ifp);
2588 		addrconf_verify();
2589 	}
2590 
2591 	return 0;
2592 }
2593 EXPORT_SYMBOL_GPL(addrconf_prefix_rcv_add_addr);
2594 
2595 void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
2596 {
2597 	struct prefix_info *pinfo;
2598 	__u32 valid_lft;
2599 	__u32 prefered_lft;
2600 	int addr_type, err;
2601 	u32 addr_flags = 0;
2602 	struct inet6_dev *in6_dev;
2603 	struct net *net = dev_net(dev);
2604 
2605 	pinfo = (struct prefix_info *) opt;
2606 
2607 	if (len < sizeof(struct prefix_info)) {
2608 		netdev_dbg(dev, "addrconf: prefix option too short\n");
2609 		return;
2610 	}
2611 
2612 	/*
2613 	 *	Validation checks ([ADDRCONF], page 19)
2614 	 */
2615 
2616 	addr_type = ipv6_addr_type(&pinfo->prefix);
2617 
2618 	if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
2619 		return;
2620 
2621 	valid_lft = ntohl(pinfo->valid);
2622 	prefered_lft = ntohl(pinfo->prefered);
2623 
2624 	if (prefered_lft > valid_lft) {
2625 		net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
2626 		return;
2627 	}
2628 
2629 	in6_dev = in6_dev_get(dev);
2630 
2631 	if (!in6_dev) {
2632 		net_dbg_ratelimited("addrconf: device %s not configured\n",
2633 				    dev->name);
2634 		return;
2635 	}
2636 
2637 	/*
2638 	 *	Two things going on here:
2639 	 *	1) Add routes for on-link prefixes
2640 	 *	2) Configure prefixes with the auto flag set
2641 	 */
2642 
2643 	if (pinfo->onlink) {
2644 		struct fib6_info *rt;
2645 		unsigned long rt_expires;
2646 
2647 		/* Avoid arithmetic overflow. Really, we could
2648 		 * save rt_expires in seconds, likely valid_lft,
2649 		 * but it would require division in fib gc, that it
2650 		 * not good.
2651 		 */
2652 		if (HZ > USER_HZ)
2653 			rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
2654 		else
2655 			rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
2656 
2657 		if (addrconf_finite_timeout(rt_expires))
2658 			rt_expires *= HZ;
2659 
2660 		rt = addrconf_get_prefix_route(&pinfo->prefix,
2661 					       pinfo->prefix_len,
2662 					       dev,
2663 					       RTF_ADDRCONF | RTF_PREFIX_RT,
2664 					       RTF_GATEWAY | RTF_DEFAULT);
2665 
2666 		if (rt) {
2667 			/* Autoconf prefix route */
2668 			if (valid_lft == 0) {
2669 				ip6_del_rt(net, rt);
2670 				rt = NULL;
2671 			} else if (addrconf_finite_timeout(rt_expires)) {
2672 				/* not infinity */
2673 				fib6_set_expires(rt, jiffies + rt_expires);
2674 			} else {
2675 				fib6_clean_expires(rt);
2676 			}
2677 		} else if (valid_lft) {
2678 			clock_t expires = 0;
2679 			int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
2680 			if (addrconf_finite_timeout(rt_expires)) {
2681 				/* not infinity */
2682 				flags |= RTF_EXPIRES;
2683 				expires = jiffies_to_clock_t(rt_expires);
2684 			}
2685 			addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2686 					      dev, expires, flags, GFP_ATOMIC);
2687 		}
2688 		fib6_info_release(rt);
2689 	}
2690 
2691 	/* Try to figure out our local address for this prefix */
2692 
2693 	if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2694 		struct in6_addr addr;
2695 		bool tokenized = false, dev_addr_generated = false;
2696 
2697 		if (pinfo->prefix_len == 64) {
2698 			memcpy(&addr, &pinfo->prefix, 8);
2699 
2700 			if (!ipv6_addr_any(&in6_dev->token)) {
2701 				read_lock_bh(&in6_dev->lock);
2702 				memcpy(addr.s6_addr + 8,
2703 				       in6_dev->token.s6_addr + 8, 8);
2704 				read_unlock_bh(&in6_dev->lock);
2705 				tokenized = true;
2706 			} else if (is_addr_mode_generate_stable(in6_dev) &&
2707 				   !ipv6_generate_stable_address(&addr, 0,
2708 								 in6_dev)) {
2709 				addr_flags |= IFA_F_STABLE_PRIVACY;
2710 				goto ok;
2711 			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
2712 				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
2713 				goto put;
2714 			} else {
2715 				dev_addr_generated = true;
2716 			}
2717 			goto ok;
2718 		}
2719 		net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
2720 				    pinfo->prefix_len);
2721 		goto put;
2722 
2723 ok:
2724 		err = addrconf_prefix_rcv_add_addr(net, dev, pinfo, in6_dev,
2725 						   &addr, addr_type,
2726 						   addr_flags, sllao,
2727 						   tokenized, valid_lft,
2728 						   prefered_lft);
2729 		if (err)
2730 			goto put;
2731 
2732 		/* Ignore error case here because previous prefix add addr was
2733 		 * successful which will be notified.
2734 		 */
2735 		ndisc_ops_prefix_rcv_add_addr(net, dev, pinfo, in6_dev, &addr,
2736 					      addr_type, addr_flags, sllao,
2737 					      tokenized, valid_lft,
2738 					      prefered_lft,
2739 					      dev_addr_generated);
2740 	}
2741 	inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2742 put:
2743 	in6_dev_put(in6_dev);
2744 }
2745 
2746 /*
2747  *	Set destination address.
2748  *	Special case for SIT interfaces where we create a new "virtual"
2749  *	device.
2750  */
2751 int addrconf_set_dstaddr(struct net *net, void __user *arg)
2752 {
2753 	struct in6_ifreq ireq;
2754 	struct net_device *dev;
2755 	int err = -EINVAL;
2756 
2757 	rtnl_lock();
2758 
2759 	err = -EFAULT;
2760 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2761 		goto err_exit;
2762 
2763 	dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2764 
2765 	err = -ENODEV;
2766 	if (!dev)
2767 		goto err_exit;
2768 
2769 #if IS_ENABLED(CONFIG_IPV6_SIT)
2770 	if (dev->type == ARPHRD_SIT) {
2771 		const struct net_device_ops *ops = dev->netdev_ops;
2772 		struct ifreq ifr;
2773 		struct ip_tunnel_parm p;
2774 
2775 		err = -EADDRNOTAVAIL;
2776 		if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
2777 			goto err_exit;
2778 
2779 		memset(&p, 0, sizeof(p));
2780 		p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
2781 		p.iph.saddr = 0;
2782 		p.iph.version = 4;
2783 		p.iph.ihl = 5;
2784 		p.iph.protocol = IPPROTO_IPV6;
2785 		p.iph.ttl = 64;
2786 		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
2787 
2788 		if (ops->ndo_do_ioctl) {
2789 			mm_segment_t oldfs = get_fs();
2790 
2791 			set_fs(KERNEL_DS);
2792 			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
2793 			set_fs(oldfs);
2794 		} else
2795 			err = -EOPNOTSUPP;
2796 
2797 		if (err == 0) {
2798 			err = -ENOBUFS;
2799 			dev = __dev_get_by_name(net, p.name);
2800 			if (!dev)
2801 				goto err_exit;
2802 			err = dev_open(dev);
2803 		}
2804 	}
2805 #endif
2806 
2807 err_exit:
2808 	rtnl_unlock();
2809 	return err;
2810 }
2811 
2812 static int ipv6_mc_config(struct sock *sk, bool join,
2813 			  const struct in6_addr *addr, int ifindex)
2814 {
2815 	int ret;
2816 
2817 	ASSERT_RTNL();
2818 
2819 	lock_sock(sk);
2820 	if (join)
2821 		ret = ipv6_sock_mc_join(sk, ifindex, addr);
2822 	else
2823 		ret = ipv6_sock_mc_drop(sk, ifindex, addr);
2824 	release_sock(sk);
2825 
2826 	return ret;
2827 }
2828 
2829 /*
2830  *	Manual configuration of address on an interface
2831  */
2832 static int inet6_addr_add(struct net *net, int ifindex,
2833 			  const struct in6_addr *pfx,
2834 			  const struct in6_addr *peer_pfx,
2835 			  unsigned int plen, __u32 ifa_flags,
2836 			  __u32 prefered_lft, __u32 valid_lft,
2837 			  struct netlink_ext_ack *extack)
2838 {
2839 	struct inet6_ifaddr *ifp;
2840 	struct inet6_dev *idev;
2841 	struct net_device *dev;
2842 	unsigned long timeout;
2843 	clock_t expires;
2844 	int scope;
2845 	u32 flags;
2846 
2847 	ASSERT_RTNL();
2848 
2849 	if (plen > 128)
2850 		return -EINVAL;
2851 
2852 	/* check the lifetime */
2853 	if (!valid_lft || prefered_lft > valid_lft)
2854 		return -EINVAL;
2855 
2856 	if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64)
2857 		return -EINVAL;
2858 
2859 	dev = __dev_get_by_index(net, ifindex);
2860 	if (!dev)
2861 		return -ENODEV;
2862 
2863 	idev = addrconf_add_dev(dev);
2864 	if (IS_ERR(idev))
2865 		return PTR_ERR(idev);
2866 
2867 	if (ifa_flags & IFA_F_MCAUTOJOIN) {
2868 		int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2869 					 true, pfx, ifindex);
2870 
2871 		if (ret < 0)
2872 			return ret;
2873 	}
2874 
2875 	scope = ipv6_addr_scope(pfx);
2876 
2877 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
2878 	if (addrconf_finite_timeout(timeout)) {
2879 		expires = jiffies_to_clock_t(timeout * HZ);
2880 		valid_lft = timeout;
2881 		flags = RTF_EXPIRES;
2882 	} else {
2883 		expires = 0;
2884 		flags = 0;
2885 		ifa_flags |= IFA_F_PERMANENT;
2886 	}
2887 
2888 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
2889 	if (addrconf_finite_timeout(timeout)) {
2890 		if (timeout == 0)
2891 			ifa_flags |= IFA_F_DEPRECATED;
2892 		prefered_lft = timeout;
2893 	}
2894 
2895 	ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
2896 			    valid_lft, prefered_lft, true, extack);
2897 
2898 	if (!IS_ERR(ifp)) {
2899 		if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
2900 			addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
2901 					      expires, flags, GFP_KERNEL);
2902 		}
2903 
2904 		/* Send a netlink notification if DAD is enabled and
2905 		 * optimistic flag is not set
2906 		 */
2907 		if (!(ifp->flags & (IFA_F_OPTIMISTIC | IFA_F_NODAD)))
2908 			ipv6_ifa_notify(0, ifp);
2909 		/*
2910 		 * Note that section 3.1 of RFC 4429 indicates
2911 		 * that the Optimistic flag should not be set for
2912 		 * manually configured addresses
2913 		 */
2914 		addrconf_dad_start(ifp);
2915 		if (ifa_flags & IFA_F_MANAGETEMPADDR)
2916 			manage_tempaddrs(idev, ifp, valid_lft, prefered_lft,
2917 					 true, jiffies);
2918 		in6_ifa_put(ifp);
2919 		addrconf_verify_rtnl();
2920 		return 0;
2921 	} else if (ifa_flags & IFA_F_MCAUTOJOIN) {
2922 		ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2923 			       false, pfx, ifindex);
2924 	}
2925 
2926 	return PTR_ERR(ifp);
2927 }
2928 
2929 static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
2930 			  const struct in6_addr *pfx, unsigned int plen)
2931 {
2932 	struct inet6_ifaddr *ifp;
2933 	struct inet6_dev *idev;
2934 	struct net_device *dev;
2935 
2936 	if (plen > 128)
2937 		return -EINVAL;
2938 
2939 	dev = __dev_get_by_index(net, ifindex);
2940 	if (!dev)
2941 		return -ENODEV;
2942 
2943 	idev = __in6_dev_get(dev);
2944 	if (!idev)
2945 		return -ENXIO;
2946 
2947 	read_lock_bh(&idev->lock);
2948 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
2949 		if (ifp->prefix_len == plen &&
2950 		    ipv6_addr_equal(pfx, &ifp->addr)) {
2951 			in6_ifa_hold(ifp);
2952 			read_unlock_bh(&idev->lock);
2953 
2954 			if (!(ifp->flags & IFA_F_TEMPORARY) &&
2955 			    (ifa_flags & IFA_F_MANAGETEMPADDR))
2956 				manage_tempaddrs(idev, ifp, 0, 0, false,
2957 						 jiffies);
2958 			ipv6_del_addr(ifp);
2959 			addrconf_verify_rtnl();
2960 			if (ipv6_addr_is_multicast(pfx)) {
2961 				ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2962 					       false, pfx, dev->ifindex);
2963 			}
2964 			return 0;
2965 		}
2966 	}
2967 	read_unlock_bh(&idev->lock);
2968 	return -EADDRNOTAVAIL;
2969 }
2970 
2971 
2972 int addrconf_add_ifaddr(struct net *net, void __user *arg)
2973 {
2974 	struct in6_ifreq ireq;
2975 	int err;
2976 
2977 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2978 		return -EPERM;
2979 
2980 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2981 		return -EFAULT;
2982 
2983 	rtnl_lock();
2984 	err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
2985 			     ireq.ifr6_prefixlen, IFA_F_PERMANENT,
2986 			     INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL);
2987 	rtnl_unlock();
2988 	return err;
2989 }
2990 
2991 int addrconf_del_ifaddr(struct net *net, void __user *arg)
2992 {
2993 	struct in6_ifreq ireq;
2994 	int err;
2995 
2996 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2997 		return -EPERM;
2998 
2999 	if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
3000 		return -EFAULT;
3001 
3002 	rtnl_lock();
3003 	err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
3004 			     ireq.ifr6_prefixlen);
3005 	rtnl_unlock();
3006 	return err;
3007 }
3008 
3009 static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
3010 		     int plen, int scope)
3011 {
3012 	struct inet6_ifaddr *ifp;
3013 
3014 	ifp = ipv6_add_addr(idev, addr, NULL, plen,
3015 			    scope, IFA_F_PERMANENT,
3016 			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME,
3017 			    true, NULL);
3018 	if (!IS_ERR(ifp)) {
3019 		spin_lock_bh(&ifp->lock);
3020 		ifp->flags &= ~IFA_F_TENTATIVE;
3021 		spin_unlock_bh(&ifp->lock);
3022 		rt_genid_bump_ipv6(dev_net(idev->dev));
3023 		ipv6_ifa_notify(RTM_NEWADDR, ifp);
3024 		in6_ifa_put(ifp);
3025 	}
3026 }
3027 
3028 #if IS_ENABLED(CONFIG_IPV6_SIT)
3029 static void sit_add_v4_addrs(struct inet6_dev *idev)
3030 {
3031 	struct in6_addr addr;
3032 	struct net_device *dev;
3033 	struct net *net = dev_net(idev->dev);
3034 	int scope, plen;
3035 	u32 pflags = 0;
3036 
3037 	ASSERT_RTNL();
3038 
3039 	memset(&addr, 0, sizeof(struct in6_addr));
3040 	memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
3041 
3042 	if (idev->dev->flags&IFF_POINTOPOINT) {
3043 		addr.s6_addr32[0] = htonl(0xfe800000);
3044 		scope = IFA_LINK;
3045 		plen = 64;
3046 	} else {
3047 		scope = IPV6_ADDR_COMPATv4;
3048 		plen = 96;
3049 		pflags |= RTF_NONEXTHOP;
3050 	}
3051 
3052 	if (addr.s6_addr32[3]) {
3053 		add_addr(idev, &addr, plen, scope);
3054 		addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags,
3055 				      GFP_ATOMIC);
3056 		return;
3057 	}
3058 
3059 	for_each_netdev(net, dev) {
3060 		struct in_device *in_dev = __in_dev_get_rtnl(dev);
3061 		if (in_dev && (dev->flags & IFF_UP)) {
3062 			struct in_ifaddr *ifa;
3063 
3064 			int flag = scope;
3065 
3066 			for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
3067 
3068 				addr.s6_addr32[3] = ifa->ifa_local;
3069 
3070 				if (ifa->ifa_scope == RT_SCOPE_LINK)
3071 					continue;
3072 				if (ifa->ifa_scope >= RT_SCOPE_HOST) {
3073 					if (idev->dev->flags&IFF_POINTOPOINT)
3074 						continue;
3075 					flag |= IFA_HOST;
3076 				}
3077 
3078 				add_addr(idev, &addr, plen, flag);
3079 				addrconf_prefix_route(&addr, plen, idev->dev, 0,
3080 						      pflags, GFP_ATOMIC);
3081 			}
3082 		}
3083 	}
3084 }
3085 #endif
3086 
3087 static void init_loopback(struct net_device *dev)
3088 {
3089 	struct inet6_dev  *idev;
3090 
3091 	/* ::1 */
3092 
3093 	ASSERT_RTNL();
3094 
3095 	idev = ipv6_find_idev(dev);
3096 	if (!idev) {
3097 		pr_debug("%s: add_dev failed\n", __func__);
3098 		return;
3099 	}
3100 
3101 	add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
3102 }
3103 
3104 void addrconf_add_linklocal(struct inet6_dev *idev,
3105 			    const struct in6_addr *addr, u32 flags)
3106 {
3107 	struct inet6_ifaddr *ifp;
3108 	u32 addr_flags = flags | IFA_F_PERMANENT;
3109 
3110 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
3111 	if ((dev_net(idev->dev)->ipv6.devconf_all->optimistic_dad ||
3112 	     idev->cnf.optimistic_dad) &&
3113 	    !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
3114 		addr_flags |= IFA_F_OPTIMISTIC;
3115 #endif
3116 
3117 	ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
3118 			    INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, true, NULL);
3119 	if (!IS_ERR(ifp)) {
3120 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev,
3121 				      0, 0, GFP_ATOMIC);
3122 		addrconf_dad_start(ifp);
3123 		in6_ifa_put(ifp);
3124 	}
3125 }
3126 EXPORT_SYMBOL_GPL(addrconf_add_linklocal);
3127 
3128 static bool ipv6_reserved_interfaceid(struct in6_addr address)
3129 {
3130 	if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0)
3131 		return true;
3132 
3133 	if (address.s6_addr32[2] == htonl(0x02005eff) &&
3134 	    ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000)))
3135 		return true;
3136 
3137 	if (address.s6_addr32[2] == htonl(0xfdffffff) &&
3138 	    ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80)))
3139 		return true;
3140 
3141 	return false;
3142 }
3143 
3144 static int ipv6_generate_stable_address(struct in6_addr *address,
3145 					u8 dad_count,
3146 					const struct inet6_dev *idev)
3147 {
3148 	static DEFINE_SPINLOCK(lock);
3149 	static __u32 digest[SHA_DIGEST_WORDS];
3150 	static __u32 workspace[SHA_WORKSPACE_WORDS];
3151 
3152 	static union {
3153 		char __data[SHA_MESSAGE_BYTES];
3154 		struct {
3155 			struct in6_addr secret;
3156 			__be32 prefix[2];
3157 			unsigned char hwaddr[MAX_ADDR_LEN];
3158 			u8 dad_count;
3159 		} __packed;
3160 	} data;
3161 
3162 	struct in6_addr secret;
3163 	struct in6_addr temp;
3164 	struct net *net = dev_net(idev->dev);
3165 
3166 	BUILD_BUG_ON(sizeof(data.__data) != sizeof(data));
3167 
3168 	if (idev->cnf.stable_secret.initialized)
3169 		secret = idev->cnf.stable_secret.secret;
3170 	else if (net->ipv6.devconf_dflt->stable_secret.initialized)
3171 		secret = net->ipv6.devconf_dflt->stable_secret.secret;
3172 	else
3173 		return -1;
3174 
3175 retry:
3176 	spin_lock_bh(&lock);
3177 
3178 	sha_init(digest);
3179 	memset(&data, 0, sizeof(data));
3180 	memset(workspace, 0, sizeof(workspace));
3181 	memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len);
3182 	data.prefix[0] = address->s6_addr32[0];
3183 	data.prefix[1] = address->s6_addr32[1];
3184 	data.secret = secret;
3185 	data.dad_count = dad_count;
3186 
3187 	sha_transform(digest, data.__data, workspace);
3188 
3189 	temp = *address;
3190 	temp.s6_addr32[2] = (__force __be32)digest[0];
3191 	temp.s6_addr32[3] = (__force __be32)digest[1];
3192 
3193 	spin_unlock_bh(&lock);
3194 
3195 	if (ipv6_reserved_interfaceid(temp)) {
3196 		dad_count++;
3197 		if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
3198 			return -1;
3199 		goto retry;
3200 	}
3201 
3202 	*address = temp;
3203 	return 0;
3204 }
3205 
3206 static void ipv6_gen_mode_random_init(struct inet6_dev *idev)
3207 {
3208 	struct ipv6_stable_secret *s = &idev->cnf.stable_secret;
3209 
3210 	if (s->initialized)
3211 		return;
3212 	s = &idev->cnf.stable_secret;
3213 	get_random_bytes(&s->secret, sizeof(s->secret));
3214 	s->initialized = true;
3215 }
3216 
3217 static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
3218 {
3219 	struct in6_addr addr;
3220 
3221 	/* no link local addresses on L3 master devices */
3222 	if (netif_is_l3_master(idev->dev))
3223 		return;
3224 
3225 	ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
3226 
3227 	switch (idev->cnf.addr_gen_mode) {
3228 	case IN6_ADDR_GEN_MODE_RANDOM:
3229 		ipv6_gen_mode_random_init(idev);
3230 		/* fallthrough */
3231 	case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:
3232 		if (!ipv6_generate_stable_address(&addr, 0, idev))
3233 			addrconf_add_linklocal(idev, &addr,
3234 					       IFA_F_STABLE_PRIVACY);
3235 		else if (prefix_route)
3236 			addrconf_prefix_route(&addr, 64, idev->dev,
3237 					      0, 0, GFP_KERNEL);
3238 		break;
3239 	case IN6_ADDR_GEN_MODE_EUI64:
3240 		/* addrconf_add_linklocal also adds a prefix_route and we
3241 		 * only need to care about prefix routes if ipv6_generate_eui64
3242 		 * couldn't generate one.
3243 		 */
3244 		if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
3245 			addrconf_add_linklocal(idev, &addr, 0);
3246 		else if (prefix_route)
3247 			addrconf_prefix_route(&addr, 64, idev->dev,
3248 					      0, 0, GFP_ATOMIC);
3249 		break;
3250 	case IN6_ADDR_GEN_MODE_NONE:
3251 	default:
3252 		/* will not add any link local address */
3253 		break;
3254 	}
3255 }
3256 
3257 static void addrconf_dev_config(struct net_device *dev)
3258 {
3259 	struct inet6_dev *idev;
3260 
3261 	ASSERT_RTNL();
3262 
3263 	if ((dev->type != ARPHRD_ETHER) &&
3264 	    (dev->type != ARPHRD_FDDI) &&
3265 	    (dev->type != ARPHRD_ARCNET) &&
3266 	    (dev->type != ARPHRD_INFINIBAND) &&
3267 	    (dev->type != ARPHRD_IEEE1394) &&
3268 	    (dev->type != ARPHRD_TUNNEL6) &&
3269 	    (dev->type != ARPHRD_6LOWPAN) &&
3270 	    (dev->type != ARPHRD_IP6GRE) &&
3271 	    (dev->type != ARPHRD_IPGRE) &&
3272 	    (dev->type != ARPHRD_TUNNEL) &&
3273 	    (dev->type != ARPHRD_NONE)) {
3274 		/* Alas, we support only Ethernet autoconfiguration. */
3275 		return;
3276 	}
3277 
3278 	idev = addrconf_add_dev(dev);
3279 	if (IS_ERR(idev))
3280 		return;
3281 
3282 	/* this device type has no EUI support */
3283 	if (dev->type == ARPHRD_NONE &&
3284 	    idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64)
3285 		idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM;
3286 
3287 	addrconf_addr_gen(idev, false);
3288 }
3289 
3290 #if IS_ENABLED(CONFIG_IPV6_SIT)
3291 static void addrconf_sit_config(struct net_device *dev)
3292 {
3293 	struct inet6_dev *idev;
3294 
3295 	ASSERT_RTNL();
3296 
3297 	/*
3298 	 * Configure the tunnel with one of our IPv4
3299 	 * addresses... we should configure all of
3300 	 * our v4 addrs in the tunnel
3301 	 */
3302 
3303 	idev = ipv6_find_idev(dev);
3304 	if (!idev) {
3305 		pr_debug("%s: add_dev failed\n", __func__);
3306 		return;
3307 	}
3308 
3309 	if (dev->priv_flags & IFF_ISATAP) {
3310 		addrconf_addr_gen(idev, false);
3311 		return;
3312 	}
3313 
3314 	sit_add_v4_addrs(idev);
3315 
3316 	if (dev->flags&IFF_POINTOPOINT)
3317 		addrconf_add_mroute(dev);
3318 }
3319 #endif
3320 
3321 #if IS_ENABLED(CONFIG_NET_IPGRE)
3322 static void addrconf_gre_config(struct net_device *dev)
3323 {
3324 	struct inet6_dev *idev;
3325 
3326 	ASSERT_RTNL();
3327 
3328 	idev = ipv6_find_idev(dev);
3329 	if (!idev) {
3330 		pr_debug("%s: add_dev failed\n", __func__);
3331 		return;
3332 	}
3333 
3334 	addrconf_addr_gen(idev, true);
3335 	if (dev->flags & IFF_POINTOPOINT)
3336 		addrconf_add_mroute(dev);
3337 }
3338 #endif
3339 
3340 static int fixup_permanent_addr(struct net *net,
3341 				struct inet6_dev *idev,
3342 				struct inet6_ifaddr *ifp)
3343 {
3344 	/* !fib6_node means the host route was removed from the
3345 	 * FIB, for example, if 'lo' device is taken down. In that
3346 	 * case regenerate the host route.
3347 	 */
3348 	if (!ifp->rt || !ifp->rt->fib6_node) {
3349 		struct fib6_info *f6i, *prev;
3350 
3351 		f6i = addrconf_f6i_alloc(net, idev, &ifp->addr, false,
3352 					 GFP_ATOMIC);
3353 		if (IS_ERR(f6i))
3354 			return PTR_ERR(f6i);
3355 
3356 		/* ifp->rt can be accessed outside of rtnl */
3357 		spin_lock(&ifp->lock);
3358 		prev = ifp->rt;
3359 		ifp->rt = f6i;
3360 		spin_unlock(&ifp->lock);
3361 
3362 		fib6_info_release(prev);
3363 	}
3364 
3365 	if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
3366 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
3367 				      idev->dev, 0, 0, GFP_ATOMIC);
3368 	}
3369 
3370 	if (ifp->state == INET6_IFADDR_STATE_PREDAD)
3371 		addrconf_dad_start(ifp);
3372 
3373 	return 0;
3374 }
3375 
3376 static void addrconf_permanent_addr(struct net *net, struct net_device *dev)
3377 {
3378 	struct inet6_ifaddr *ifp, *tmp;
3379 	struct inet6_dev *idev;
3380 
3381 	idev = __in6_dev_get(dev);
3382 	if (!idev)
3383 		return;
3384 
3385 	write_lock_bh(&idev->lock);
3386 
3387 	list_for_each_entry_safe(ifp, tmp, &idev->addr_list, if_list) {
3388 		if ((ifp->flags & IFA_F_PERMANENT) &&
3389 		    fixup_permanent_addr(net, idev, ifp) < 0) {
3390 			write_unlock_bh(&idev->lock);
3391 			in6_ifa_hold(ifp);
3392 			ipv6_del_addr(ifp);
3393 			write_lock_bh(&idev->lock);
3394 
3395 			net_info_ratelimited("%s: Failed to add prefix route for address %pI6c; dropping\n",
3396 					     idev->dev->name, &ifp->addr);
3397 		}
3398 	}
3399 
3400 	write_unlock_bh(&idev->lock);
3401 }
3402 
3403 static int addrconf_notify(struct notifier_block *this, unsigned long event,
3404 			   void *ptr)
3405 {
3406 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3407 	struct netdev_notifier_changeupper_info *info;
3408 	struct inet6_dev *idev = __in6_dev_get(dev);
3409 	struct net *net = dev_net(dev);
3410 	int run_pending = 0;
3411 	int err;
3412 
3413 	switch (event) {
3414 	case NETDEV_REGISTER:
3415 		if (!idev && dev->mtu >= IPV6_MIN_MTU) {
3416 			idev = ipv6_add_dev(dev);
3417 			if (IS_ERR(idev))
3418 				return notifier_from_errno(PTR_ERR(idev));
3419 		}
3420 		break;
3421 
3422 	case NETDEV_CHANGEMTU:
3423 		/* if MTU under IPV6_MIN_MTU stop IPv6 on this interface. */
3424 		if (dev->mtu < IPV6_MIN_MTU) {
3425 			addrconf_ifdown(dev, dev != net->loopback_dev);
3426 			break;
3427 		}
3428 
3429 		if (idev) {
3430 			rt6_mtu_change(dev, dev->mtu);
3431 			idev->cnf.mtu6 = dev->mtu;
3432 			break;
3433 		}
3434 
3435 		/* allocate new idev */
3436 		idev = ipv6_add_dev(dev);
3437 		if (IS_ERR(idev))
3438 			break;
3439 
3440 		/* device is still not ready */
3441 		if (!(idev->if_flags & IF_READY))
3442 			break;
3443 
3444 		run_pending = 1;
3445 
3446 		/* fall through */
3447 
3448 	case NETDEV_UP:
3449 	case NETDEV_CHANGE:
3450 		if (dev->flags & IFF_SLAVE)
3451 			break;
3452 
3453 		if (idev && idev->cnf.disable_ipv6)
3454 			break;
3455 
3456 		if (event == NETDEV_UP) {
3457 			/* restore routes for permanent addresses */
3458 			addrconf_permanent_addr(net, dev);
3459 
3460 			if (!addrconf_link_ready(dev)) {
3461 				/* device is not ready yet. */
3462 				pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
3463 					dev->name);
3464 				break;
3465 			}
3466 
3467 			if (!idev && dev->mtu >= IPV6_MIN_MTU)
3468 				idev = ipv6_add_dev(dev);
3469 
3470 			if (!IS_ERR_OR_NULL(idev)) {
3471 				idev->if_flags |= IF_READY;
3472 				run_pending = 1;
3473 			}
3474 		} else if (event == NETDEV_CHANGE) {
3475 			if (!addrconf_link_ready(dev)) {
3476 				/* device is still not ready. */
3477 				rt6_sync_down_dev(dev, event);
3478 				break;
3479 			}
3480 
3481 			if (idev) {
3482 				if (idev->if_flags & IF_READY) {
3483 					/* device is already configured -
3484 					 * but resend MLD reports, we might
3485 					 * have roamed and need to update
3486 					 * multicast snooping switches
3487 					 */
3488 					ipv6_mc_up(idev);
3489 					rt6_sync_up(dev, RTNH_F_LINKDOWN);
3490 					break;
3491 				}
3492 				idev->if_flags |= IF_READY;
3493 			}
3494 
3495 			pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
3496 				dev->name);
3497 
3498 			run_pending = 1;
3499 		}
3500 
3501 		switch (dev->type) {
3502 #if IS_ENABLED(CONFIG_IPV6_SIT)
3503 		case ARPHRD_SIT:
3504 			addrconf_sit_config(dev);
3505 			break;
3506 #endif
3507 #if IS_ENABLED(CONFIG_NET_IPGRE)
3508 		case ARPHRD_IPGRE:
3509 			addrconf_gre_config(dev);
3510 			break;
3511 #endif
3512 		case ARPHRD_LOOPBACK:
3513 			init_loopback(dev);
3514 			break;
3515 
3516 		default:
3517 			addrconf_dev_config(dev);
3518 			break;
3519 		}
3520 
3521 		if (!IS_ERR_OR_NULL(idev)) {
3522 			if (run_pending)
3523 				addrconf_dad_run(idev);
3524 
3525 			/* Device has an address by now */
3526 			rt6_sync_up(dev, RTNH_F_DEAD);
3527 
3528 			/*
3529 			 * If the MTU changed during the interface down,
3530 			 * when the interface up, the changed MTU must be
3531 			 * reflected in the idev as well as routers.
3532 			 */
3533 			if (idev->cnf.mtu6 != dev->mtu &&
3534 			    dev->mtu >= IPV6_MIN_MTU) {
3535 				rt6_mtu_change(dev, dev->mtu);
3536 				idev->cnf.mtu6 = dev->mtu;
3537 			}
3538 			idev->tstamp = jiffies;
3539 			inet6_ifinfo_notify(RTM_NEWLINK, idev);
3540 
3541 			/*
3542 			 * If the changed mtu during down is lower than
3543 			 * IPV6_MIN_MTU stop IPv6 on this interface.
3544 			 */
3545 			if (dev->mtu < IPV6_MIN_MTU)
3546 				addrconf_ifdown(dev, dev != net->loopback_dev);
3547 		}
3548 		break;
3549 
3550 	case NETDEV_DOWN:
3551 	case NETDEV_UNREGISTER:
3552 		/*
3553 		 *	Remove all addresses from this interface.
3554 		 */
3555 		addrconf_ifdown(dev, event != NETDEV_DOWN);
3556 		break;
3557 
3558 	case NETDEV_CHANGENAME:
3559 		if (idev) {
3560 			snmp6_unregister_dev(idev);
3561 			addrconf_sysctl_unregister(idev);
3562 			err = addrconf_sysctl_register(idev);
3563 			if (err)
3564 				return notifier_from_errno(err);
3565 			err = snmp6_register_dev(idev);
3566 			if (err) {
3567 				addrconf_sysctl_unregister(idev);
3568 				return notifier_from_errno(err);
3569 			}
3570 		}
3571 		break;
3572 
3573 	case NETDEV_PRE_TYPE_CHANGE:
3574 	case NETDEV_POST_TYPE_CHANGE:
3575 		if (idev)
3576 			addrconf_type_change(dev, event);
3577 		break;
3578 
3579 	case NETDEV_CHANGEUPPER:
3580 		info = ptr;
3581 
3582 		/* flush all routes if dev is linked to or unlinked from
3583 		 * an L3 master device (e.g., VRF)
3584 		 */
3585 		if (info->upper_dev && netif_is_l3_master(info->upper_dev))
3586 			addrconf_ifdown(dev, 0);
3587 	}
3588 
3589 	return NOTIFY_OK;
3590 }
3591 
3592 /*
3593  *	addrconf module should be notified of a device going up
3594  */
3595 static struct notifier_block ipv6_dev_notf = {
3596 	.notifier_call = addrconf_notify,
3597 	.priority = ADDRCONF_NOTIFY_PRIORITY,
3598 };
3599 
3600 static void addrconf_type_change(struct net_device *dev, unsigned long event)
3601 {
3602 	struct inet6_dev *idev;
3603 	ASSERT_RTNL();
3604 
3605 	idev = __in6_dev_get(dev);
3606 
3607 	if (event == NETDEV_POST_TYPE_CHANGE)
3608 		ipv6_mc_remap(idev);
3609 	else if (event == NETDEV_PRE_TYPE_CHANGE)
3610 		ipv6_mc_unmap(idev);
3611 }
3612 
3613 static bool addr_is_local(const struct in6_addr *addr)
3614 {
3615 	return ipv6_addr_type(addr) &
3616 		(IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
3617 }
3618 
3619 static int addrconf_ifdown(struct net_device *dev, int how)
3620 {
3621 	unsigned long event = how ? NETDEV_UNREGISTER : NETDEV_DOWN;
3622 	struct net *net = dev_net(dev);
3623 	struct inet6_dev *idev;
3624 	struct inet6_ifaddr *ifa, *tmp;
3625 	int _keep_addr;
3626 	bool keep_addr;
3627 	int state, i;
3628 
3629 	ASSERT_RTNL();
3630 
3631 	rt6_disable_ip(dev, event);
3632 
3633 	idev = __in6_dev_get(dev);
3634 	if (!idev)
3635 		return -ENODEV;
3636 
3637 	/*
3638 	 * Step 1: remove reference to ipv6 device from parent device.
3639 	 *	   Do not dev_put!
3640 	 */
3641 	if (how) {
3642 		idev->dead = 1;
3643 
3644 		/* protected by rtnl_lock */
3645 		RCU_INIT_POINTER(dev->ip6_ptr, NULL);
3646 
3647 		/* Step 1.5: remove snmp6 entry */
3648 		snmp6_unregister_dev(idev);
3649 
3650 	}
3651 
3652 	/* aggregate the system setting and interface setting */
3653 	_keep_addr = net->ipv6.devconf_all->keep_addr_on_down;
3654 	if (!_keep_addr)
3655 		_keep_addr = idev->cnf.keep_addr_on_down;
3656 
3657 	/* combine the user config with event to determine if permanent
3658 	 * addresses are to be removed from address hash table
3659 	 */
3660 	keep_addr = !(how || _keep_addr <= 0 || idev->cnf.disable_ipv6);
3661 
3662 	/* Step 2: clear hash table */
3663 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3664 		struct hlist_head *h = &inet6_addr_lst[i];
3665 
3666 		spin_lock_bh(&addrconf_hash_lock);
3667 restart:
3668 		hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3669 			if (ifa->idev == idev) {
3670 				addrconf_del_dad_work(ifa);
3671 				/* combined flag + permanent flag decide if
3672 				 * address is retained on a down event
3673 				 */
3674 				if (!keep_addr ||
3675 				    !(ifa->flags & IFA_F_PERMANENT) ||
3676 				    addr_is_local(&ifa->addr)) {
3677 					hlist_del_init_rcu(&ifa->addr_lst);
3678 					goto restart;
3679 				}
3680 			}
3681 		}
3682 		spin_unlock_bh(&addrconf_hash_lock);
3683 	}
3684 
3685 	write_lock_bh(&idev->lock);
3686 
3687 	addrconf_del_rs_timer(idev);
3688 
3689 	/* Step 2: clear flags for stateless addrconf */
3690 	if (!how)
3691 		idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
3692 
3693 	/* Step 3: clear tempaddr list */
3694 	while (!list_empty(&idev->tempaddr_list)) {
3695 		ifa = list_first_entry(&idev->tempaddr_list,
3696 				       struct inet6_ifaddr, tmp_list);
3697 		list_del(&ifa->tmp_list);
3698 		write_unlock_bh(&idev->lock);
3699 		spin_lock_bh(&ifa->lock);
3700 
3701 		if (ifa->ifpub) {
3702 			in6_ifa_put(ifa->ifpub);
3703 			ifa->ifpub = NULL;
3704 		}
3705 		spin_unlock_bh(&ifa->lock);
3706 		in6_ifa_put(ifa);
3707 		write_lock_bh(&idev->lock);
3708 	}
3709 
3710 	/* re-combine the user config with event to determine if permanent
3711 	 * addresses are to be removed from the interface list
3712 	 */
3713 	keep_addr = (!how && _keep_addr > 0 && !idev->cnf.disable_ipv6);
3714 
3715 	list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) {
3716 		struct fib6_info *rt = NULL;
3717 		bool keep;
3718 
3719 		addrconf_del_dad_work(ifa);
3720 
3721 		keep = keep_addr && (ifa->flags & IFA_F_PERMANENT) &&
3722 			!addr_is_local(&ifa->addr);
3723 
3724 		write_unlock_bh(&idev->lock);
3725 		spin_lock_bh(&ifa->lock);
3726 
3727 		if (keep) {
3728 			/* set state to skip the notifier below */
3729 			state = INET6_IFADDR_STATE_DEAD;
3730 			ifa->state = INET6_IFADDR_STATE_PREDAD;
3731 			if (!(ifa->flags & IFA_F_NODAD))
3732 				ifa->flags |= IFA_F_TENTATIVE;
3733 
3734 			rt = ifa->rt;
3735 			ifa->rt = NULL;
3736 		} else {
3737 			state = ifa->state;
3738 			ifa->state = INET6_IFADDR_STATE_DEAD;
3739 		}
3740 
3741 		spin_unlock_bh(&ifa->lock);
3742 
3743 		if (rt)
3744 			ip6_del_rt(net, rt);
3745 
3746 		if (state != INET6_IFADDR_STATE_DEAD) {
3747 			__ipv6_ifa_notify(RTM_DELADDR, ifa);
3748 			inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3749 		} else {
3750 			if (idev->cnf.forwarding)
3751 				addrconf_leave_anycast(ifa);
3752 			addrconf_leave_solict(ifa->idev, &ifa->addr);
3753 		}
3754 
3755 		write_lock_bh(&idev->lock);
3756 		if (!keep) {
3757 			list_del_rcu(&ifa->if_list);
3758 			in6_ifa_put(ifa);
3759 		}
3760 	}
3761 
3762 	write_unlock_bh(&idev->lock);
3763 
3764 	/* Step 5: Discard anycast and multicast list */
3765 	if (how) {
3766 		ipv6_ac_destroy_dev(idev);
3767 		ipv6_mc_destroy_dev(idev);
3768 	} else {
3769 		ipv6_mc_down(idev);
3770 	}
3771 
3772 	idev->tstamp = jiffies;
3773 
3774 	/* Last: Shot the device (if unregistered) */
3775 	if (how) {
3776 		addrconf_sysctl_unregister(idev);
3777 		neigh_parms_release(&nd_tbl, idev->nd_parms);
3778 		neigh_ifdown(&nd_tbl, dev);
3779 		in6_dev_put(idev);
3780 	}
3781 	return 0;
3782 }
3783 
3784 static void addrconf_rs_timer(struct timer_list *t)
3785 {
3786 	struct inet6_dev *idev = from_timer(idev, t, rs_timer);
3787 	struct net_device *dev = idev->dev;
3788 	struct in6_addr lladdr;
3789 
3790 	write_lock(&idev->lock);
3791 	if (idev->dead || !(idev->if_flags & IF_READY))
3792 		goto out;
3793 
3794 	if (!ipv6_accept_ra(idev))
3795 		goto out;
3796 
3797 	/* Announcement received after solicitation was sent */
3798 	if (idev->if_flags & IF_RA_RCVD)
3799 		goto out;
3800 
3801 	if (idev->rs_probes++ < idev->cnf.rtr_solicits || idev->cnf.rtr_solicits < 0) {
3802 		write_unlock(&idev->lock);
3803 		if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3804 			ndisc_send_rs(dev, &lladdr,
3805 				      &in6addr_linklocal_allrouters);
3806 		else
3807 			goto put;
3808 
3809 		write_lock(&idev->lock);
3810 		idev->rs_interval = rfc3315_s14_backoff_update(
3811 			idev->rs_interval, idev->cnf.rtr_solicit_max_interval);
3812 		/* The wait after the last probe can be shorter */
3813 		addrconf_mod_rs_timer(idev, (idev->rs_probes ==
3814 					     idev->cnf.rtr_solicits) ?
3815 				      idev->cnf.rtr_solicit_delay :
3816 				      idev->rs_interval);
3817 	} else {
3818 		/*
3819 		 * Note: we do not support deprecated "all on-link"
3820 		 * assumption any longer.
3821 		 */
3822 		pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
3823 	}
3824 
3825 out:
3826 	write_unlock(&idev->lock);
3827 put:
3828 	in6_dev_put(idev);
3829 }
3830 
3831 /*
3832  *	Duplicate Address Detection
3833  */
3834 static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
3835 {
3836 	unsigned long rand_num;
3837 	struct inet6_dev *idev = ifp->idev;
3838 	u64 nonce;
3839 
3840 	if (ifp->flags & IFA_F_OPTIMISTIC)
3841 		rand_num = 0;
3842 	else
3843 		rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3844 
3845 	nonce = 0;
3846 	if (idev->cnf.enhanced_dad ||
3847 	    dev_net(idev->dev)->ipv6.devconf_all->enhanced_dad) {
3848 		do
3849 			get_random_bytes(&nonce, 6);
3850 		while (nonce == 0);
3851 	}
3852 	ifp->dad_nonce = nonce;
3853 	ifp->dad_probes = idev->cnf.dad_transmits;
3854 	addrconf_mod_dad_work(ifp, rand_num);
3855 }
3856 
3857 static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
3858 {
3859 	struct inet6_dev *idev = ifp->idev;
3860 	struct net_device *dev = idev->dev;
3861 	bool bump_id, notify = false;
3862 	struct net *net;
3863 
3864 	addrconf_join_solict(dev, &ifp->addr);
3865 
3866 	prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
3867 
3868 	read_lock_bh(&idev->lock);
3869 	spin_lock(&ifp->lock);
3870 	if (ifp->state == INET6_IFADDR_STATE_DEAD)
3871 		goto out;
3872 
3873 	net = dev_net(dev);
3874 	if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3875 	    (net->ipv6.devconf_all->accept_dad < 1 &&
3876 	     idev->cnf.accept_dad < 1) ||
3877 	    !(ifp->flags&IFA_F_TENTATIVE) ||
3878 	    ifp->flags & IFA_F_NODAD) {
3879 		bool send_na = false;
3880 
3881 		if (ifp->flags & IFA_F_TENTATIVE &&
3882 		    !(ifp->flags & IFA_F_OPTIMISTIC))
3883 			send_na = true;
3884 		bump_id = ifp->flags & IFA_F_TENTATIVE;
3885 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3886 		spin_unlock(&ifp->lock);
3887 		read_unlock_bh(&idev->lock);
3888 
3889 		addrconf_dad_completed(ifp, bump_id, send_na);
3890 		return;
3891 	}
3892 
3893 	if (!(idev->if_flags & IF_READY)) {
3894 		spin_unlock(&ifp->lock);
3895 		read_unlock_bh(&idev->lock);
3896 		/*
3897 		 * If the device is not ready:
3898 		 * - keep it tentative if it is a permanent address.
3899 		 * - otherwise, kill it.
3900 		 */
3901 		in6_ifa_hold(ifp);
3902 		addrconf_dad_stop(ifp, 0);
3903 		return;
3904 	}
3905 
3906 	/*
3907 	 * Optimistic nodes can start receiving
3908 	 * Frames right away
3909 	 */
3910 	if (ifp->flags & IFA_F_OPTIMISTIC) {
3911 		ip6_ins_rt(net, ifp->rt);
3912 		if (ipv6_use_optimistic_addr(net, idev)) {
3913 			/* Because optimistic nodes can use this address,
3914 			 * notify listeners. If DAD fails, RTM_DELADDR is sent.
3915 			 */
3916 			notify = true;
3917 		}
3918 	}
3919 
3920 	addrconf_dad_kick(ifp);
3921 out:
3922 	spin_unlock(&ifp->lock);
3923 	read_unlock_bh(&idev->lock);
3924 	if (notify)
3925 		ipv6_ifa_notify(RTM_NEWADDR, ifp);
3926 }
3927 
3928 static void addrconf_dad_start(struct inet6_ifaddr *ifp)
3929 {
3930 	bool begin_dad = false;
3931 
3932 	spin_lock_bh(&ifp->lock);
3933 	if (ifp->state != INET6_IFADDR_STATE_DEAD) {
3934 		ifp->state = INET6_IFADDR_STATE_PREDAD;
3935 		begin_dad = true;
3936 	}
3937 	spin_unlock_bh(&ifp->lock);
3938 
3939 	if (begin_dad)
3940 		addrconf_mod_dad_work(ifp, 0);
3941 }
3942 
3943 static void addrconf_dad_work(struct work_struct *w)
3944 {
3945 	struct inet6_ifaddr *ifp = container_of(to_delayed_work(w),
3946 						struct inet6_ifaddr,
3947 						dad_work);
3948 	struct inet6_dev *idev = ifp->idev;
3949 	bool bump_id, disable_ipv6 = false;
3950 	struct in6_addr mcaddr;
3951 
3952 	enum {
3953 		DAD_PROCESS,
3954 		DAD_BEGIN,
3955 		DAD_ABORT,
3956 	} action = DAD_PROCESS;
3957 
3958 	rtnl_lock();
3959 
3960 	spin_lock_bh(&ifp->lock);
3961 	if (ifp->state == INET6_IFADDR_STATE_PREDAD) {
3962 		action = DAD_BEGIN;
3963 		ifp->state = INET6_IFADDR_STATE_DAD;
3964 	} else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) {
3965 		action = DAD_ABORT;
3966 		ifp->state = INET6_IFADDR_STATE_POSTDAD;
3967 
3968 		if ((dev_net(idev->dev)->ipv6.devconf_all->accept_dad > 1 ||
3969 		     idev->cnf.accept_dad > 1) &&
3970 		    !idev->cnf.disable_ipv6 &&
3971 		    !(ifp->flags & IFA_F_STABLE_PRIVACY)) {
3972 			struct in6_addr addr;
3973 
3974 			addr.s6_addr32[0] = htonl(0xfe800000);
3975 			addr.s6_addr32[1] = 0;
3976 
3977 			if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
3978 			    ipv6_addr_equal(&ifp->addr, &addr)) {
3979 				/* DAD failed for link-local based on MAC */
3980 				idev->cnf.disable_ipv6 = 1;
3981 
3982 				pr_info("%s: IPv6 being disabled!\n",
3983 					ifp->idev->dev->name);
3984 				disable_ipv6 = true;
3985 			}
3986 		}
3987 	}
3988 	spin_unlock_bh(&ifp->lock);
3989 
3990 	if (action == DAD_BEGIN) {
3991 		addrconf_dad_begin(ifp);
3992 		goto out;
3993 	} else if (action == DAD_ABORT) {
3994 		in6_ifa_hold(ifp);
3995 		addrconf_dad_stop(ifp, 1);
3996 		if (disable_ipv6)
3997 			addrconf_ifdown(idev->dev, 0);
3998 		goto out;
3999 	}
4000 
4001 	if (!ifp->dad_probes && addrconf_dad_end(ifp))
4002 		goto out;
4003 
4004 	write_lock_bh(&idev->lock);
4005 	if (idev->dead || !(idev->if_flags & IF_READY)) {
4006 		write_unlock_bh(&idev->lock);
4007 		goto out;
4008 	}
4009 
4010 	spin_lock(&ifp->lock);
4011 	if (ifp->state == INET6_IFADDR_STATE_DEAD) {
4012 		spin_unlock(&ifp->lock);
4013 		write_unlock_bh(&idev->lock);
4014 		goto out;
4015 	}
4016 
4017 	if (ifp->dad_probes == 0) {
4018 		bool send_na = false;
4019 
4020 		/*
4021 		 * DAD was successful
4022 		 */
4023 
4024 		if (ifp->flags & IFA_F_TENTATIVE &&
4025 		    !(ifp->flags & IFA_F_OPTIMISTIC))
4026 			send_na = true;
4027 		bump_id = ifp->flags & IFA_F_TENTATIVE;
4028 		ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
4029 		spin_unlock(&ifp->lock);
4030 		write_unlock_bh(&idev->lock);
4031 
4032 		addrconf_dad_completed(ifp, bump_id, send_na);
4033 
4034 		goto out;
4035 	}
4036 
4037 	ifp->dad_probes--;
4038 	addrconf_mod_dad_work(ifp,
4039 			      NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME));
4040 	spin_unlock(&ifp->lock);
4041 	write_unlock_bh(&idev->lock);
4042 
4043 	/* send a neighbour solicitation for our addr */
4044 	addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
4045 	ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any,
4046 		      ifp->dad_nonce);
4047 out:
4048 	in6_ifa_put(ifp);
4049 	rtnl_unlock();
4050 }
4051 
4052 /* ifp->idev must be at least read locked */
4053 static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp)
4054 {
4055 	struct inet6_ifaddr *ifpiter;
4056 	struct inet6_dev *idev = ifp->idev;
4057 
4058 	list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
4059 		if (ifpiter->scope > IFA_LINK)
4060 			break;
4061 		if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
4062 		    (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
4063 				       IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
4064 		    IFA_F_PERMANENT)
4065 			return false;
4066 	}
4067 	return true;
4068 }
4069 
4070 static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
4071 				   bool send_na)
4072 {
4073 	struct net_device *dev = ifp->idev->dev;
4074 	struct in6_addr lladdr;
4075 	bool send_rs, send_mld;
4076 
4077 	addrconf_del_dad_work(ifp);
4078 
4079 	/*
4080 	 *	Configure the address for reception. Now it is valid.
4081 	 */
4082 
4083 	ipv6_ifa_notify(RTM_NEWADDR, ifp);
4084 
4085 	/* If added prefix is link local and we are prepared to process
4086 	   router advertisements, start sending router solicitations.
4087 	 */
4088 
4089 	read_lock_bh(&ifp->idev->lock);
4090 	send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
4091 	send_rs = send_mld &&
4092 		  ipv6_accept_ra(ifp->idev) &&
4093 		  ifp->idev->cnf.rtr_solicits != 0 &&
4094 		  (dev->flags&IFF_LOOPBACK) == 0;
4095 	read_unlock_bh(&ifp->idev->lock);
4096 
4097 	/* While dad is in progress mld report's source address is in6_addrany.
4098 	 * Resend with proper ll now.
4099 	 */
4100 	if (send_mld)
4101 		ipv6_mc_dad_complete(ifp->idev);
4102 
4103 	/* send unsolicited NA if enabled */
4104 	if (send_na &&
4105 	    (ifp->idev->cnf.ndisc_notify ||
4106 	     dev_net(dev)->ipv6.devconf_all->ndisc_notify)) {
4107 		ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifp->addr,
4108 			      /*router=*/ !!ifp->idev->cnf.forwarding,
4109 			      /*solicited=*/ false, /*override=*/ true,
4110 			      /*inc_opt=*/ true);
4111 	}
4112 
4113 	if (send_rs) {
4114 		/*
4115 		 *	If a host as already performed a random delay
4116 		 *	[...] as part of DAD [...] there is no need
4117 		 *	to delay again before sending the first RS
4118 		 */
4119 		if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
4120 			return;
4121 		ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
4122 
4123 		write_lock_bh(&ifp->idev->lock);
4124 		spin_lock(&ifp->lock);
4125 		ifp->idev->rs_interval = rfc3315_s14_backoff_init(
4126 			ifp->idev->cnf.rtr_solicit_interval);
4127 		ifp->idev->rs_probes = 1;
4128 		ifp->idev->if_flags |= IF_RS_SENT;
4129 		addrconf_mod_rs_timer(ifp->idev, ifp->idev->rs_interval);
4130 		spin_unlock(&ifp->lock);
4131 		write_unlock_bh(&ifp->idev->lock);
4132 	}
4133 
4134 	if (bump_id)
4135 		rt_genid_bump_ipv6(dev_net(dev));
4136 
4137 	/* Make sure that a new temporary address will be created
4138 	 * before this temporary address becomes deprecated.
4139 	 */
4140 	if (ifp->flags & IFA_F_TEMPORARY)
4141 		addrconf_verify_rtnl();
4142 }
4143 
4144 static void addrconf_dad_run(struct inet6_dev *idev)
4145 {
4146 	struct inet6_ifaddr *ifp;
4147 
4148 	read_lock_bh(&idev->lock);
4149 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
4150 		spin_lock(&ifp->lock);
4151 		if (ifp->flags & IFA_F_TENTATIVE &&
4152 		    ifp->state == INET6_IFADDR_STATE_DAD)
4153 			addrconf_dad_kick(ifp);
4154 		spin_unlock(&ifp->lock);
4155 	}
4156 	read_unlock_bh(&idev->lock);
4157 }
4158 
4159 #ifdef CONFIG_PROC_FS
4160 struct if6_iter_state {
4161 	struct seq_net_private p;
4162 	int bucket;
4163 	int offset;
4164 };
4165 
4166 static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
4167 {
4168 	struct if6_iter_state *state = seq->private;
4169 	struct net *net = seq_file_net(seq);
4170 	struct inet6_ifaddr *ifa = NULL;
4171 	int p = 0;
4172 
4173 	/* initial bucket if pos is 0 */
4174 	if (pos == 0) {
4175 		state->bucket = 0;
4176 		state->offset = 0;
4177 	}
4178 
4179 	for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
4180 		hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket],
4181 					 addr_lst) {
4182 			if (!net_eq(dev_net(ifa->idev->dev), net))
4183 				continue;
4184 			/* sync with offset */
4185 			if (p < state->offset) {
4186 				p++;
4187 				continue;
4188 			}
4189 			state->offset++;
4190 			return ifa;
4191 		}
4192 
4193 		/* prepare for next bucket */
4194 		state->offset = 0;
4195 		p = 0;
4196 	}
4197 	return NULL;
4198 }
4199 
4200 static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
4201 					 struct inet6_ifaddr *ifa)
4202 {
4203 	struct if6_iter_state *state = seq->private;
4204 	struct net *net = seq_file_net(seq);
4205 
4206 	hlist_for_each_entry_continue_rcu(ifa, addr_lst) {
4207 		if (!net_eq(dev_net(ifa->idev->dev), net))
4208 			continue;
4209 		state->offset++;
4210 		return ifa;
4211 	}
4212 
4213 	while (++state->bucket < IN6_ADDR_HSIZE) {
4214 		state->offset = 0;
4215 		hlist_for_each_entry_rcu(ifa,
4216 				     &inet6_addr_lst[state->bucket], addr_lst) {
4217 			if (!net_eq(dev_net(ifa->idev->dev), net))
4218 				continue;
4219 			state->offset++;
4220 			return ifa;
4221 		}
4222 	}
4223 
4224 	return NULL;
4225 }
4226 
4227 static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
4228 	__acquires(rcu)
4229 {
4230 	rcu_read_lock();
4231 	return if6_get_first(seq, *pos);
4232 }
4233 
4234 static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4235 {
4236 	struct inet6_ifaddr *ifa;
4237 
4238 	ifa = if6_get_next(seq, v);
4239 	++*pos;
4240 	return ifa;
4241 }
4242 
4243 static void if6_seq_stop(struct seq_file *seq, void *v)
4244 	__releases(rcu)
4245 {
4246 	rcu_read_unlock();
4247 }
4248 
4249 static int if6_seq_show(struct seq_file *seq, void *v)
4250 {
4251 	struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
4252 	seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
4253 		   &ifp->addr,
4254 		   ifp->idev->dev->ifindex,
4255 		   ifp->prefix_len,
4256 		   ifp->scope,
4257 		   (u8) ifp->flags,
4258 		   ifp->idev->dev->name);
4259 	return 0;
4260 }
4261 
4262 static const struct seq_operations if6_seq_ops = {
4263 	.start	= if6_seq_start,
4264 	.next	= if6_seq_next,
4265 	.show	= if6_seq_show,
4266 	.stop	= if6_seq_stop,
4267 };
4268 
4269 static int if6_seq_open(struct inode *inode, struct file *file)
4270 {
4271 	return seq_open_net(inode, file, &if6_seq_ops,
4272 			    sizeof(struct if6_iter_state));
4273 }
4274 
4275 static const struct file_operations if6_fops = {
4276 	.open		= if6_seq_open,
4277 	.read		= seq_read,
4278 	.llseek		= seq_lseek,
4279 	.release	= seq_release_net,
4280 };
4281 
4282 static int __net_init if6_proc_net_init(struct net *net)
4283 {
4284 	if (!proc_create("if_inet6", 0444, net->proc_net, &if6_fops))
4285 		return -ENOMEM;
4286 	return 0;
4287 }
4288 
4289 static void __net_exit if6_proc_net_exit(struct net *net)
4290 {
4291 	remove_proc_entry("if_inet6", net->proc_net);
4292 }
4293 
4294 static struct pernet_operations if6_proc_net_ops = {
4295 	.init = if6_proc_net_init,
4296 	.exit = if6_proc_net_exit,
4297 };
4298 
4299 int __init if6_proc_init(void)
4300 {
4301 	return register_pernet_subsys(&if6_proc_net_ops);
4302 }
4303 
4304 void if6_proc_exit(void)
4305 {
4306 	unregister_pernet_subsys(&if6_proc_net_ops);
4307 }
4308 #endif	/* CONFIG_PROC_FS */
4309 
4310 #if IS_ENABLED(CONFIG_IPV6_MIP6)
4311 /* Check if address is a home address configured on any interface. */
4312 int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
4313 {
4314 	unsigned int hash = inet6_addr_hash(net, addr);
4315 	struct inet6_ifaddr *ifp = NULL;
4316 	int ret = 0;
4317 
4318 	rcu_read_lock();
4319 	hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
4320 		if (!net_eq(dev_net(ifp->idev->dev), net))
4321 			continue;
4322 		if (ipv6_addr_equal(&ifp->addr, addr) &&
4323 		    (ifp->flags & IFA_F_HOMEADDRESS)) {
4324 			ret = 1;
4325 			break;
4326 		}
4327 	}
4328 	rcu_read_unlock();
4329 	return ret;
4330 }
4331 #endif
4332 
4333 /*
4334  *	Periodic address status verification
4335  */
4336 
4337 static void addrconf_verify_rtnl(void)
4338 {
4339 	unsigned long now, next, next_sec, next_sched;
4340 	struct inet6_ifaddr *ifp;
4341 	int i;
4342 
4343 	ASSERT_RTNL();
4344 
4345 	rcu_read_lock_bh();
4346 	now = jiffies;
4347 	next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
4348 
4349 	cancel_delayed_work(&addr_chk_work);
4350 
4351 	for (i = 0; i < IN6_ADDR_HSIZE; i++) {
4352 restart:
4353 		hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
4354 			unsigned long age;
4355 
4356 			/* When setting preferred_lft to a value not zero or
4357 			 * infinity, while valid_lft is infinity
4358 			 * IFA_F_PERMANENT has a non-infinity life time.
4359 			 */
4360 			if ((ifp->flags & IFA_F_PERMANENT) &&
4361 			    (ifp->prefered_lft == INFINITY_LIFE_TIME))
4362 				continue;
4363 
4364 			spin_lock(&ifp->lock);
4365 			/* We try to batch several events at once. */
4366 			age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
4367 
4368 			if (ifp->valid_lft != INFINITY_LIFE_TIME &&
4369 			    age >= ifp->valid_lft) {
4370 				spin_unlock(&ifp->lock);
4371 				in6_ifa_hold(ifp);
4372 				ipv6_del_addr(ifp);
4373 				goto restart;
4374 			} else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
4375 				spin_unlock(&ifp->lock);
4376 				continue;
4377 			} else if (age >= ifp->prefered_lft) {
4378 				/* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
4379 				int deprecate = 0;
4380 
4381 				if (!(ifp->flags&IFA_F_DEPRECATED)) {
4382 					deprecate = 1;
4383 					ifp->flags |= IFA_F_DEPRECATED;
4384 				}
4385 
4386 				if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
4387 				    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
4388 					next = ifp->tstamp + ifp->valid_lft * HZ;
4389 
4390 				spin_unlock(&ifp->lock);
4391 
4392 				if (deprecate) {
4393 					in6_ifa_hold(ifp);
4394 
4395 					ipv6_ifa_notify(0, ifp);
4396 					in6_ifa_put(ifp);
4397 					goto restart;
4398 				}
4399 			} else if ((ifp->flags&IFA_F_TEMPORARY) &&
4400 				   !(ifp->flags&IFA_F_TENTATIVE)) {
4401 				unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
4402 					ifp->idev->cnf.dad_transmits *
4403 					NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ;
4404 
4405 				if (age >= ifp->prefered_lft - regen_advance) {
4406 					struct inet6_ifaddr *ifpub = ifp->ifpub;
4407 					if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4408 						next = ifp->tstamp + ifp->prefered_lft * HZ;
4409 					if (!ifp->regen_count && ifpub) {
4410 						ifp->regen_count++;
4411 						in6_ifa_hold(ifp);
4412 						in6_ifa_hold(ifpub);
4413 						spin_unlock(&ifp->lock);
4414 
4415 						spin_lock(&ifpub->lock);
4416 						ifpub->regen_count = 0;
4417 						spin_unlock(&ifpub->lock);
4418 						rcu_read_unlock_bh();
4419 						ipv6_create_tempaddr(ifpub, ifp, true);
4420 						in6_ifa_put(ifpub);
4421 						in6_ifa_put(ifp);
4422 						rcu_read_lock_bh();
4423 						goto restart;
4424 					}
4425 				} else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
4426 					next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
4427 				spin_unlock(&ifp->lock);
4428 			} else {
4429 				/* ifp->prefered_lft <= ifp->valid_lft */
4430 				if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4431 					next = ifp->tstamp + ifp->prefered_lft * HZ;
4432 				spin_unlock(&ifp->lock);
4433 			}
4434 		}
4435 	}
4436 
4437 	next_sec = round_jiffies_up(next);
4438 	next_sched = next;
4439 
4440 	/* If rounded timeout is accurate enough, accept it. */
4441 	if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
4442 		next_sched = next_sec;
4443 
4444 	/* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
4445 	if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
4446 		next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
4447 
4448 	pr_debug("now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
4449 		 now, next, next_sec, next_sched);
4450 	mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
4451 	rcu_read_unlock_bh();
4452 }
4453 
4454 static void addrconf_verify_work(struct work_struct *w)
4455 {
4456 	rtnl_lock();
4457 	addrconf_verify_rtnl();
4458 	rtnl_unlock();
4459 }
4460 
4461 static void addrconf_verify(void)
4462 {
4463 	mod_delayed_work(addrconf_wq, &addr_chk_work, 0);
4464 }
4465 
4466 static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
4467 				     struct in6_addr **peer_pfx)
4468 {
4469 	struct in6_addr *pfx = NULL;
4470 
4471 	*peer_pfx = NULL;
4472 
4473 	if (addr)
4474 		pfx = nla_data(addr);
4475 
4476 	if (local) {
4477 		if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
4478 			*peer_pfx = pfx;
4479 		pfx = nla_data(local);
4480 	}
4481 
4482 	return pfx;
4483 }
4484 
4485 static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
4486 	[IFA_ADDRESS]		= { .len = sizeof(struct in6_addr) },
4487 	[IFA_LOCAL]		= { .len = sizeof(struct in6_addr) },
4488 	[IFA_CACHEINFO]		= { .len = sizeof(struct ifa_cacheinfo) },
4489 	[IFA_FLAGS]		= { .len = sizeof(u32) },
4490 };
4491 
4492 static int
4493 inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
4494 		  struct netlink_ext_ack *extack)
4495 {
4496 	struct net *net = sock_net(skb->sk);
4497 	struct ifaddrmsg *ifm;
4498 	struct nlattr *tb[IFA_MAX+1];
4499 	struct in6_addr *pfx, *peer_pfx;
4500 	u32 ifa_flags;
4501 	int err;
4502 
4503 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy,
4504 			  extack);
4505 	if (err < 0)
4506 		return err;
4507 
4508 	ifm = nlmsg_data(nlh);
4509 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4510 	if (!pfx)
4511 		return -EINVAL;
4512 
4513 	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
4514 
4515 	/* We ignore other flags so far. */
4516 	ifa_flags &= IFA_F_MANAGETEMPADDR;
4517 
4518 	return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx,
4519 			      ifm->ifa_prefixlen);
4520 }
4521 
4522 static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags,
4523 			     u32 prefered_lft, u32 valid_lft)
4524 {
4525 	u32 flags;
4526 	clock_t expires;
4527 	unsigned long timeout;
4528 	bool was_managetempaddr;
4529 	bool had_prefixroute;
4530 
4531 	ASSERT_RTNL();
4532 
4533 	if (!valid_lft || (prefered_lft > valid_lft))
4534 		return -EINVAL;
4535 
4536 	if (ifa_flags & IFA_F_MANAGETEMPADDR &&
4537 	    (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
4538 		return -EINVAL;
4539 
4540 	if (!(ifp->flags & IFA_F_TENTATIVE) || ifp->flags & IFA_F_DADFAILED)
4541 		ifa_flags &= ~IFA_F_OPTIMISTIC;
4542 
4543 	timeout = addrconf_timeout_fixup(valid_lft, HZ);
4544 	if (addrconf_finite_timeout(timeout)) {
4545 		expires = jiffies_to_clock_t(timeout * HZ);
4546 		valid_lft = timeout;
4547 		flags = RTF_EXPIRES;
4548 	} else {
4549 		expires = 0;
4550 		flags = 0;
4551 		ifa_flags |= IFA_F_PERMANENT;
4552 	}
4553 
4554 	timeout = addrconf_timeout_fixup(prefered_lft, HZ);
4555 	if (addrconf_finite_timeout(timeout)) {
4556 		if (timeout == 0)
4557 			ifa_flags |= IFA_F_DEPRECATED;
4558 		prefered_lft = timeout;
4559 	}
4560 
4561 	spin_lock_bh(&ifp->lock);
4562 	was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
4563 	had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
4564 			  !(ifp->flags & IFA_F_NOPREFIXROUTE);
4565 	ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
4566 			IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4567 			IFA_F_NOPREFIXROUTE);
4568 	ifp->flags |= ifa_flags;
4569 	ifp->tstamp = jiffies;
4570 	ifp->valid_lft = valid_lft;
4571 	ifp->prefered_lft = prefered_lft;
4572 
4573 	spin_unlock_bh(&ifp->lock);
4574 	if (!(ifp->flags&IFA_F_TENTATIVE))
4575 		ipv6_ifa_notify(0, ifp);
4576 
4577 	if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
4578 		addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
4579 				      ifp->idev->dev, expires, flags,
4580 				      GFP_KERNEL);
4581 	} else if (had_prefixroute) {
4582 		enum cleanup_prefix_rt_t action;
4583 		unsigned long rt_expires;
4584 
4585 		write_lock_bh(&ifp->idev->lock);
4586 		action = check_cleanup_prefix_route(ifp, &rt_expires);
4587 		write_unlock_bh(&ifp->idev->lock);
4588 
4589 		if (action != CLEANUP_PREFIX_RT_NOP) {
4590 			cleanup_prefix_route(ifp, rt_expires,
4591 				action == CLEANUP_PREFIX_RT_DEL);
4592 		}
4593 	}
4594 
4595 	if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
4596 		if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR))
4597 			valid_lft = prefered_lft = 0;
4598 		manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft,
4599 				 !was_managetempaddr, jiffies);
4600 	}
4601 
4602 	addrconf_verify_rtnl();
4603 
4604 	return 0;
4605 }
4606 
4607 static int
4608 inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
4609 		  struct netlink_ext_ack *extack)
4610 {
4611 	struct net *net = sock_net(skb->sk);
4612 	struct ifaddrmsg *ifm;
4613 	struct nlattr *tb[IFA_MAX+1];
4614 	struct in6_addr *pfx, *peer_pfx;
4615 	struct inet6_ifaddr *ifa;
4616 	struct net_device *dev;
4617 	struct inet6_dev *idev;
4618 	u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
4619 	u32 ifa_flags;
4620 	int err;
4621 
4622 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy,
4623 			  extack);
4624 	if (err < 0)
4625 		return err;
4626 
4627 	ifm = nlmsg_data(nlh);
4628 	pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4629 	if (!pfx)
4630 		return -EINVAL;
4631 
4632 	if (tb[IFA_CACHEINFO]) {
4633 		struct ifa_cacheinfo *ci;
4634 
4635 		ci = nla_data(tb[IFA_CACHEINFO]);
4636 		valid_lft = ci->ifa_valid;
4637 		preferred_lft = ci->ifa_prefered;
4638 	} else {
4639 		preferred_lft = INFINITY_LIFE_TIME;
4640 		valid_lft = INFINITY_LIFE_TIME;
4641 	}
4642 
4643 	dev =  __dev_get_by_index(net, ifm->ifa_index);
4644 	if (!dev)
4645 		return -ENODEV;
4646 
4647 	ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
4648 
4649 	/* We ignore other flags so far. */
4650 	ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4651 		     IFA_F_NOPREFIXROUTE | IFA_F_MCAUTOJOIN | IFA_F_OPTIMISTIC;
4652 
4653 	idev = ipv6_find_idev(dev);
4654 	if (IS_ERR(idev))
4655 		return PTR_ERR(idev);
4656 
4657 	if (!ipv6_allow_optimistic_dad(net, idev))
4658 		ifa_flags &= ~IFA_F_OPTIMISTIC;
4659 
4660 	if (ifa_flags & IFA_F_NODAD && ifa_flags & IFA_F_OPTIMISTIC) {
4661 		NL_SET_ERR_MSG(extack, "IFA_F_NODAD and IFA_F_OPTIMISTIC are mutually exclusive");
4662 		return -EINVAL;
4663 	}
4664 
4665 	ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
4666 	if (!ifa) {
4667 		/*
4668 		 * It would be best to check for !NLM_F_CREATE here but
4669 		 * userspace already relies on not having to provide this.
4670 		 */
4671 		return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
4672 				      ifm->ifa_prefixlen, ifa_flags,
4673 				      preferred_lft, valid_lft, extack);
4674 	}
4675 
4676 	if (nlh->nlmsg_flags & NLM_F_EXCL ||
4677 	    !(nlh->nlmsg_flags & NLM_F_REPLACE))
4678 		err = -EEXIST;
4679 	else
4680 		err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
4681 
4682 	in6_ifa_put(ifa);
4683 
4684 	return err;
4685 }
4686 
4687 static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
4688 			  u8 scope, int ifindex)
4689 {
4690 	struct ifaddrmsg *ifm;
4691 
4692 	ifm = nlmsg_data(nlh);
4693 	ifm->ifa_family = AF_INET6;
4694 	ifm->ifa_prefixlen = prefixlen;
4695 	ifm->ifa_flags = flags;
4696 	ifm->ifa_scope = scope;
4697 	ifm->ifa_index = ifindex;
4698 }
4699 
4700 static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
4701 			 unsigned long tstamp, u32 preferred, u32 valid)
4702 {
4703 	struct ifa_cacheinfo ci;
4704 
4705 	ci.cstamp = cstamp_delta(cstamp);
4706 	ci.tstamp = cstamp_delta(tstamp);
4707 	ci.ifa_prefered = preferred;
4708 	ci.ifa_valid = valid;
4709 
4710 	return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
4711 }
4712 
4713 static inline int rt_scope(int ifa_scope)
4714 {
4715 	if (ifa_scope & IFA_HOST)
4716 		return RT_SCOPE_HOST;
4717 	else if (ifa_scope & IFA_LINK)
4718 		return RT_SCOPE_LINK;
4719 	else if (ifa_scope & IFA_SITE)
4720 		return RT_SCOPE_SITE;
4721 	else
4722 		return RT_SCOPE_UNIVERSE;
4723 }
4724 
4725 static inline int inet6_ifaddr_msgsize(void)
4726 {
4727 	return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
4728 	       + nla_total_size(16) /* IFA_LOCAL */
4729 	       + nla_total_size(16) /* IFA_ADDRESS */
4730 	       + nla_total_size(sizeof(struct ifa_cacheinfo))
4731 	       + nla_total_size(4)  /* IFA_FLAGS */;
4732 }
4733 
4734 static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
4735 			     u32 portid, u32 seq, int event, unsigned int flags)
4736 {
4737 	struct nlmsghdr  *nlh;
4738 	u32 preferred, valid;
4739 
4740 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4741 	if (!nlh)
4742 		return -EMSGSIZE;
4743 
4744 	put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
4745 		      ifa->idev->dev->ifindex);
4746 
4747 	if (!((ifa->flags&IFA_F_PERMANENT) &&
4748 	      (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
4749 		preferred = ifa->prefered_lft;
4750 		valid = ifa->valid_lft;
4751 		if (preferred != INFINITY_LIFE_TIME) {
4752 			long tval = (jiffies - ifa->tstamp)/HZ;
4753 			if (preferred > tval)
4754 				preferred -= tval;
4755 			else
4756 				preferred = 0;
4757 			if (valid != INFINITY_LIFE_TIME) {
4758 				if (valid > tval)
4759 					valid -= tval;
4760 				else
4761 					valid = 0;
4762 			}
4763 		}
4764 	} else {
4765 		preferred = INFINITY_LIFE_TIME;
4766 		valid = INFINITY_LIFE_TIME;
4767 	}
4768 
4769 	if (!ipv6_addr_any(&ifa->peer_addr)) {
4770 		if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||
4771 		    nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0)
4772 			goto error;
4773 	} else
4774 		if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0)
4775 			goto error;
4776 
4777 	if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
4778 		goto error;
4779 
4780 	if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
4781 		goto error;
4782 
4783 	nlmsg_end(skb, nlh);
4784 	return 0;
4785 
4786 error:
4787 	nlmsg_cancel(skb, nlh);
4788 	return -EMSGSIZE;
4789 }
4790 
4791 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
4792 				u32 portid, u32 seq, int event, u16 flags)
4793 {
4794 	struct nlmsghdr  *nlh;
4795 	u8 scope = RT_SCOPE_UNIVERSE;
4796 	int ifindex = ifmca->idev->dev->ifindex;
4797 
4798 	if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
4799 		scope = RT_SCOPE_SITE;
4800 
4801 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4802 	if (!nlh)
4803 		return -EMSGSIZE;
4804 
4805 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4806 	if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 ||
4807 	    put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
4808 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4809 		nlmsg_cancel(skb, nlh);
4810 		return -EMSGSIZE;
4811 	}
4812 
4813 	nlmsg_end(skb, nlh);
4814 	return 0;
4815 }
4816 
4817 static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
4818 				u32 portid, u32 seq, int event, unsigned int flags)
4819 {
4820 	struct nlmsghdr  *nlh;
4821 	u8 scope = RT_SCOPE_UNIVERSE;
4822 	int ifindex = ifaca->aca_idev->dev->ifindex;
4823 
4824 	if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
4825 		scope = RT_SCOPE_SITE;
4826 
4827 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4828 	if (!nlh)
4829 		return -EMSGSIZE;
4830 
4831 	put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4832 	if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 ||
4833 	    put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
4834 			  INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4835 		nlmsg_cancel(skb, nlh);
4836 		return -EMSGSIZE;
4837 	}
4838 
4839 	nlmsg_end(skb, nlh);
4840 	return 0;
4841 }
4842 
4843 enum addr_type_t {
4844 	UNICAST_ADDR,
4845 	MULTICAST_ADDR,
4846 	ANYCAST_ADDR,
4847 };
4848 
4849 /* called with rcu_read_lock() */
4850 static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
4851 			  struct netlink_callback *cb, enum addr_type_t type,
4852 			  int s_ip_idx, int *p_ip_idx)
4853 {
4854 	struct ifmcaddr6 *ifmca;
4855 	struct ifacaddr6 *ifaca;
4856 	int err = 1;
4857 	int ip_idx = *p_ip_idx;
4858 
4859 	read_lock_bh(&idev->lock);
4860 	switch (type) {
4861 	case UNICAST_ADDR: {
4862 		struct inet6_ifaddr *ifa;
4863 
4864 		/* unicast address incl. temp addr */
4865 		list_for_each_entry(ifa, &idev->addr_list, if_list) {
4866 			if (++ip_idx < s_ip_idx)
4867 				continue;
4868 			err = inet6_fill_ifaddr(skb, ifa,
4869 						NETLINK_CB(cb->skb).portid,
4870 						cb->nlh->nlmsg_seq,
4871 						RTM_NEWADDR,
4872 						NLM_F_MULTI);
4873 			if (err < 0)
4874 				break;
4875 			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
4876 		}
4877 		break;
4878 	}
4879 	case MULTICAST_ADDR:
4880 		/* multicast address */
4881 		for (ifmca = idev->mc_list; ifmca;
4882 		     ifmca = ifmca->next, ip_idx++) {
4883 			if (ip_idx < s_ip_idx)
4884 				continue;
4885 			err = inet6_fill_ifmcaddr(skb, ifmca,
4886 						  NETLINK_CB(cb->skb).portid,
4887 						  cb->nlh->nlmsg_seq,
4888 						  RTM_GETMULTICAST,
4889 						  NLM_F_MULTI);
4890 			if (err < 0)
4891 				break;
4892 		}
4893 		break;
4894 	case ANYCAST_ADDR:
4895 		/* anycast address */
4896 		for (ifaca = idev->ac_list; ifaca;
4897 		     ifaca = ifaca->aca_next, ip_idx++) {
4898 			if (ip_idx < s_ip_idx)
4899 				continue;
4900 			err = inet6_fill_ifacaddr(skb, ifaca,
4901 						  NETLINK_CB(cb->skb).portid,
4902 						  cb->nlh->nlmsg_seq,
4903 						  RTM_GETANYCAST,
4904 						  NLM_F_MULTI);
4905 			if (err < 0)
4906 				break;
4907 		}
4908 		break;
4909 	default:
4910 		break;
4911 	}
4912 	read_unlock_bh(&idev->lock);
4913 	*p_ip_idx = ip_idx;
4914 	return err;
4915 }
4916 
4917 static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
4918 			   enum addr_type_t type)
4919 {
4920 	struct net *net = sock_net(skb->sk);
4921 	int h, s_h;
4922 	int idx, ip_idx;
4923 	int s_idx, s_ip_idx;
4924 	struct net_device *dev;
4925 	struct inet6_dev *idev;
4926 	struct hlist_head *head;
4927 
4928 	s_h = cb->args[0];
4929 	s_idx = idx = cb->args[1];
4930 	s_ip_idx = ip_idx = cb->args[2];
4931 
4932 	rcu_read_lock();
4933 	cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
4934 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4935 		idx = 0;
4936 		head = &net->dev_index_head[h];
4937 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
4938 			if (idx < s_idx)
4939 				goto cont;
4940 			if (h > s_h || idx > s_idx)
4941 				s_ip_idx = 0;
4942 			ip_idx = 0;
4943 			idev = __in6_dev_get(dev);
4944 			if (!idev)
4945 				goto cont;
4946 
4947 			if (in6_dump_addrs(idev, skb, cb, type,
4948 					   s_ip_idx, &ip_idx) < 0)
4949 				goto done;
4950 cont:
4951 			idx++;
4952 		}
4953 	}
4954 done:
4955 	rcu_read_unlock();
4956 	cb->args[0] = h;
4957 	cb->args[1] = idx;
4958 	cb->args[2] = ip_idx;
4959 
4960 	return skb->len;
4961 }
4962 
4963 static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
4964 {
4965 	enum addr_type_t type = UNICAST_ADDR;
4966 
4967 	return inet6_dump_addr(skb, cb, type);
4968 }
4969 
4970 static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
4971 {
4972 	enum addr_type_t type = MULTICAST_ADDR;
4973 
4974 	return inet6_dump_addr(skb, cb, type);
4975 }
4976 
4977 
4978 static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
4979 {
4980 	enum addr_type_t type = ANYCAST_ADDR;
4981 
4982 	return inet6_dump_addr(skb, cb, type);
4983 }
4984 
4985 static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4986 			     struct netlink_ext_ack *extack)
4987 {
4988 	struct net *net = sock_net(in_skb->sk);
4989 	struct ifaddrmsg *ifm;
4990 	struct nlattr *tb[IFA_MAX+1];
4991 	struct in6_addr *addr = NULL, *peer;
4992 	struct net_device *dev = NULL;
4993 	struct inet6_ifaddr *ifa;
4994 	struct sk_buff *skb;
4995 	int err;
4996 
4997 	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy,
4998 			  extack);
4999 	if (err < 0)
5000 		return err;
5001 
5002 	addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
5003 	if (!addr)
5004 		return -EINVAL;
5005 
5006 	ifm = nlmsg_data(nlh);
5007 	if (ifm->ifa_index)
5008 		dev = dev_get_by_index(net, ifm->ifa_index);
5009 
5010 	ifa = ipv6_get_ifaddr(net, addr, dev, 1);
5011 	if (!ifa) {
5012 		err = -EADDRNOTAVAIL;
5013 		goto errout;
5014 	}
5015 
5016 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
5017 	if (!skb) {
5018 		err = -ENOBUFS;
5019 		goto errout_ifa;
5020 	}
5021 
5022 	err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
5023 				nlh->nlmsg_seq, RTM_NEWADDR, 0);
5024 	if (err < 0) {
5025 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
5026 		WARN_ON(err == -EMSGSIZE);
5027 		kfree_skb(skb);
5028 		goto errout_ifa;
5029 	}
5030 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
5031 errout_ifa:
5032 	in6_ifa_put(ifa);
5033 errout:
5034 	if (dev)
5035 		dev_put(dev);
5036 	return err;
5037 }
5038 
5039 static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
5040 {
5041 	struct sk_buff *skb;
5042 	struct net *net = dev_net(ifa->idev->dev);
5043 	int err = -ENOBUFS;
5044 
5045 	skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
5046 	if (!skb)
5047 		goto errout;
5048 
5049 	err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
5050 	if (err < 0) {
5051 		/* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
5052 		WARN_ON(err == -EMSGSIZE);
5053 		kfree_skb(skb);
5054 		goto errout;
5055 	}
5056 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
5057 	return;
5058 errout:
5059 	if (err < 0)
5060 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
5061 }
5062 
5063 static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
5064 				__s32 *array, int bytes)
5065 {
5066 	BUG_ON(bytes < (DEVCONF_MAX * 4));
5067 
5068 	memset(array, 0, bytes);
5069 	array[DEVCONF_FORWARDING] = cnf->forwarding;
5070 	array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
5071 	array[DEVCONF_MTU6] = cnf->mtu6;
5072 	array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
5073 	array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
5074 	array[DEVCONF_AUTOCONF] = cnf->autoconf;
5075 	array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
5076 	array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
5077 	array[DEVCONF_RTR_SOLICIT_INTERVAL] =
5078 		jiffies_to_msecs(cnf->rtr_solicit_interval);
5079 	array[DEVCONF_RTR_SOLICIT_MAX_INTERVAL] =
5080 		jiffies_to_msecs(cnf->rtr_solicit_max_interval);
5081 	array[DEVCONF_RTR_SOLICIT_DELAY] =
5082 		jiffies_to_msecs(cnf->rtr_solicit_delay);
5083 	array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
5084 	array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] =
5085 		jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval);
5086 	array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] =
5087 		jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval);
5088 	array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
5089 	array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
5090 	array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
5091 	array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
5092 	array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
5093 	array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
5094 	array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
5095 	array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit;
5096 	array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
5097 #ifdef CONFIG_IPV6_ROUTER_PREF
5098 	array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
5099 	array[DEVCONF_RTR_PROBE_INTERVAL] =
5100 		jiffies_to_msecs(cnf->rtr_probe_interval);
5101 #ifdef CONFIG_IPV6_ROUTE_INFO
5102 	array[DEVCONF_ACCEPT_RA_RT_INFO_MIN_PLEN] = cnf->accept_ra_rt_info_min_plen;
5103 	array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
5104 #endif
5105 #endif
5106 	array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
5107 	array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
5108 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
5109 	array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
5110 	array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
5111 #endif
5112 #ifdef CONFIG_IPV6_MROUTE
5113 	array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
5114 #endif
5115 	array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
5116 	array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
5117 	array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
5118 	array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
5119 	array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
5120 	array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
5121 	array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu;
5122 	array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown;
5123 	/* we omit DEVCONF_STABLE_SECRET for now */
5124 	array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only;
5125 	array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast;
5126 	array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na;
5127 	array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down;
5128 	array[DEVCONF_SEG6_ENABLED] = cnf->seg6_enabled;
5129 #ifdef CONFIG_IPV6_SEG6_HMAC
5130 	array[DEVCONF_SEG6_REQUIRE_HMAC] = cnf->seg6_require_hmac;
5131 #endif
5132 	array[DEVCONF_ENHANCED_DAD] = cnf->enhanced_dad;
5133 	array[DEVCONF_ADDR_GEN_MODE] = cnf->addr_gen_mode;
5134 	array[DEVCONF_DISABLE_POLICY] = cnf->disable_policy;
5135 	array[DEVCONF_NDISC_TCLASS] = cnf->ndisc_tclass;
5136 }
5137 
5138 static inline size_t inet6_ifla6_size(void)
5139 {
5140 	return nla_total_size(4) /* IFLA_INET6_FLAGS */
5141 	     + nla_total_size(sizeof(struct ifla_cacheinfo))
5142 	     + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
5143 	     + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
5144 	     + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
5145 	     + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
5146 }
5147 
5148 static inline size_t inet6_if_nlmsg_size(void)
5149 {
5150 	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
5151 	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
5152 	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
5153 	       + nla_total_size(4) /* IFLA_MTU */
5154 	       + nla_total_size(4) /* IFLA_LINK */
5155 	       + nla_total_size(1) /* IFLA_OPERSTATE */
5156 	       + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
5157 }
5158 
5159 static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
5160 					int bytes)
5161 {
5162 	int i;
5163 	int pad = bytes - sizeof(u64) * ICMP6_MIB_MAX;
5164 	BUG_ON(pad < 0);
5165 
5166 	/* Use put_unaligned() because stats may not be aligned for u64. */
5167 	put_unaligned(ICMP6_MIB_MAX, &stats[0]);
5168 	for (i = 1; i < ICMP6_MIB_MAX; i++)
5169 		put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
5170 
5171 	memset(&stats[ICMP6_MIB_MAX], 0, pad);
5172 }
5173 
5174 static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
5175 					int bytes, size_t syncpoff)
5176 {
5177 	int i, c;
5178 	u64 buff[IPSTATS_MIB_MAX];
5179 	int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX;
5180 
5181 	BUG_ON(pad < 0);
5182 
5183 	memset(buff, 0, sizeof(buff));
5184 	buff[0] = IPSTATS_MIB_MAX;
5185 
5186 	for_each_possible_cpu(c) {
5187 		for (i = 1; i < IPSTATS_MIB_MAX; i++)
5188 			buff[i] += snmp_get_cpu_field64(mib, c, i, syncpoff);
5189 	}
5190 
5191 	memcpy(stats, buff, IPSTATS_MIB_MAX * sizeof(u64));
5192 	memset(&stats[IPSTATS_MIB_MAX], 0, pad);
5193 }
5194 
5195 static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
5196 			     int bytes)
5197 {
5198 	switch (attrtype) {
5199 	case IFLA_INET6_STATS:
5200 		__snmp6_fill_stats64(stats, idev->stats.ipv6, bytes,
5201 				     offsetof(struct ipstats_mib, syncp));
5202 		break;
5203 	case IFLA_INET6_ICMP6STATS:
5204 		__snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, bytes);
5205 		break;
5206 	}
5207 }
5208 
5209 static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,
5210 				  u32 ext_filter_mask)
5211 {
5212 	struct nlattr *nla;
5213 	struct ifla_cacheinfo ci;
5214 
5215 	if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
5216 		goto nla_put_failure;
5217 	ci.max_reasm_len = IPV6_MAXPLEN;
5218 	ci.tstamp = cstamp_delta(idev->tstamp);
5219 	ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
5220 	ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
5221 	if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
5222 		goto nla_put_failure;
5223 	nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
5224 	if (!nla)
5225 		goto nla_put_failure;
5226 	ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
5227 
5228 	/* XXX - MC not implemented */
5229 
5230 	if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS)
5231 		return 0;
5232 
5233 	nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
5234 	if (!nla)
5235 		goto nla_put_failure;
5236 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
5237 
5238 	nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
5239 	if (!nla)
5240 		goto nla_put_failure;
5241 	snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
5242 
5243 	nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
5244 	if (!nla)
5245 		goto nla_put_failure;
5246 
5247 	if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->cnf.addr_gen_mode))
5248 		goto nla_put_failure;
5249 
5250 	read_lock_bh(&idev->lock);
5251 	memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
5252 	read_unlock_bh(&idev->lock);
5253 
5254 	return 0;
5255 
5256 nla_put_failure:
5257 	return -EMSGSIZE;
5258 }
5259 
5260 static size_t inet6_get_link_af_size(const struct net_device *dev,
5261 				     u32 ext_filter_mask)
5262 {
5263 	if (!__in6_dev_get(dev))
5264 		return 0;
5265 
5266 	return inet6_ifla6_size();
5267 }
5268 
5269 static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
5270 			      u32 ext_filter_mask)
5271 {
5272 	struct inet6_dev *idev = __in6_dev_get(dev);
5273 
5274 	if (!idev)
5275 		return -ENODATA;
5276 
5277 	if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0)
5278 		return -EMSGSIZE;
5279 
5280 	return 0;
5281 }
5282 
5283 static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
5284 {
5285 	struct inet6_ifaddr *ifp;
5286 	struct net_device *dev = idev->dev;
5287 	bool clear_token, update_rs = false;
5288 	struct in6_addr ll_addr;
5289 
5290 	ASSERT_RTNL();
5291 
5292 	if (!token)
5293 		return -EINVAL;
5294 	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
5295 		return -EINVAL;
5296 	if (!ipv6_accept_ra(idev))
5297 		return -EINVAL;
5298 	if (idev->cnf.rtr_solicits == 0)
5299 		return -EINVAL;
5300 
5301 	write_lock_bh(&idev->lock);
5302 
5303 	BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
5304 	memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);
5305 
5306 	write_unlock_bh(&idev->lock);
5307 
5308 	clear_token = ipv6_addr_any(token);
5309 	if (clear_token)
5310 		goto update_lft;
5311 
5312 	if (!idev->dead && (idev->if_flags & IF_READY) &&
5313 	    !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
5314 			     IFA_F_OPTIMISTIC)) {
5315 		/* If we're not ready, then normal ifup will take care
5316 		 * of this. Otherwise, we need to request our rs here.
5317 		 */
5318 		ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
5319 		update_rs = true;
5320 	}
5321 
5322 update_lft:
5323 	write_lock_bh(&idev->lock);
5324 
5325 	if (update_rs) {
5326 		idev->if_flags |= IF_RS_SENT;
5327 		idev->rs_interval = rfc3315_s14_backoff_init(
5328 			idev->cnf.rtr_solicit_interval);
5329 		idev->rs_probes = 1;
5330 		addrconf_mod_rs_timer(idev, idev->rs_interval);
5331 	}
5332 
5333 	/* Well, that's kinda nasty ... */
5334 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
5335 		spin_lock(&ifp->lock);
5336 		if (ifp->tokenized) {
5337 			ifp->valid_lft = 0;
5338 			ifp->prefered_lft = 0;
5339 		}
5340 		spin_unlock(&ifp->lock);
5341 	}
5342 
5343 	write_unlock_bh(&idev->lock);
5344 	inet6_ifinfo_notify(RTM_NEWLINK, idev);
5345 	addrconf_verify_rtnl();
5346 	return 0;
5347 }
5348 
5349 static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = {
5350 	[IFLA_INET6_ADDR_GEN_MODE]	= { .type = NLA_U8 },
5351 	[IFLA_INET6_TOKEN]		= { .len = sizeof(struct in6_addr) },
5352 };
5353 
5354 static int inet6_validate_link_af(const struct net_device *dev,
5355 				  const struct nlattr *nla)
5356 {
5357 	struct nlattr *tb[IFLA_INET6_MAX + 1];
5358 
5359 	if (dev && !__in6_dev_get(dev))
5360 		return -EAFNOSUPPORT;
5361 
5362 	return nla_parse_nested(tb, IFLA_INET6_MAX, nla, inet6_af_policy,
5363 				NULL);
5364 }
5365 
5366 static int check_addr_gen_mode(int mode)
5367 {
5368 	if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
5369 	    mode != IN6_ADDR_GEN_MODE_NONE &&
5370 	    mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5371 	    mode != IN6_ADDR_GEN_MODE_RANDOM)
5372 		return -EINVAL;
5373 	return 1;
5374 }
5375 
5376 static int check_stable_privacy(struct inet6_dev *idev, struct net *net,
5377 				int mode)
5378 {
5379 	if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5380 	    !idev->cnf.stable_secret.initialized &&
5381 	    !net->ipv6.devconf_dflt->stable_secret.initialized)
5382 		return -EINVAL;
5383 	return 1;
5384 }
5385 
5386 static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
5387 {
5388 	int err = -EINVAL;
5389 	struct inet6_dev *idev = __in6_dev_get(dev);
5390 	struct nlattr *tb[IFLA_INET6_MAX + 1];
5391 
5392 	if (!idev)
5393 		return -EAFNOSUPPORT;
5394 
5395 	if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL, NULL) < 0)
5396 		BUG();
5397 
5398 	if (tb[IFLA_INET6_TOKEN]) {
5399 		err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
5400 		if (err)
5401 			return err;
5402 	}
5403 
5404 	if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
5405 		u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);
5406 
5407 		if (check_addr_gen_mode(mode) < 0 ||
5408 		    check_stable_privacy(idev, dev_net(dev), mode) < 0)
5409 			return -EINVAL;
5410 
5411 		idev->cnf.addr_gen_mode = mode;
5412 		err = 0;
5413 	}
5414 
5415 	return err;
5416 }
5417 
5418 static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
5419 			     u32 portid, u32 seq, int event, unsigned int flags)
5420 {
5421 	struct net_device *dev = idev->dev;
5422 	struct ifinfomsg *hdr;
5423 	struct nlmsghdr *nlh;
5424 	void *protoinfo;
5425 
5426 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
5427 	if (!nlh)
5428 		return -EMSGSIZE;
5429 
5430 	hdr = nlmsg_data(nlh);
5431 	hdr->ifi_family = AF_INET6;
5432 	hdr->__ifi_pad = 0;
5433 	hdr->ifi_type = dev->type;
5434 	hdr->ifi_index = dev->ifindex;
5435 	hdr->ifi_flags = dev_get_flags(dev);
5436 	hdr->ifi_change = 0;
5437 
5438 	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
5439 	    (dev->addr_len &&
5440 	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
5441 	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
5442 	    (dev->ifindex != dev_get_iflink(dev) &&
5443 	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
5444 	    nla_put_u8(skb, IFLA_OPERSTATE,
5445 		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN))
5446 		goto nla_put_failure;
5447 	protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
5448 	if (!protoinfo)
5449 		goto nla_put_failure;
5450 
5451 	if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0)
5452 		goto nla_put_failure;
5453 
5454 	nla_nest_end(skb, protoinfo);
5455 	nlmsg_end(skb, nlh);
5456 	return 0;
5457 
5458 nla_put_failure:
5459 	nlmsg_cancel(skb, nlh);
5460 	return -EMSGSIZE;
5461 }
5462 
5463 static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
5464 {
5465 	struct net *net = sock_net(skb->sk);
5466 	int h, s_h;
5467 	int idx = 0, s_idx;
5468 	struct net_device *dev;
5469 	struct inet6_dev *idev;
5470 	struct hlist_head *head;
5471 
5472 	s_h = cb->args[0];
5473 	s_idx = cb->args[1];
5474 
5475 	rcu_read_lock();
5476 	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5477 		idx = 0;
5478 		head = &net->dev_index_head[h];
5479 		hlist_for_each_entry_rcu(dev, head, index_hlist) {
5480 			if (idx < s_idx)
5481 				goto cont;
5482 			idev = __in6_dev_get(dev);
5483 			if (!idev)
5484 				goto cont;
5485 			if (inet6_fill_ifinfo(skb, idev,
5486 					      NETLINK_CB(cb->skb).portid,
5487 					      cb->nlh->nlmsg_seq,
5488 					      RTM_NEWLINK, NLM_F_MULTI) < 0)
5489 				goto out;
5490 cont:
5491 			idx++;
5492 		}
5493 	}
5494 out:
5495 	rcu_read_unlock();
5496 	cb->args[1] = idx;
5497 	cb->args[0] = h;
5498 
5499 	return skb->len;
5500 }
5501 
5502 void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
5503 {
5504 	struct sk_buff *skb;
5505 	struct net *net = dev_net(idev->dev);
5506 	int err = -ENOBUFS;
5507 
5508 	skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
5509 	if (!skb)
5510 		goto errout;
5511 
5512 	err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
5513 	if (err < 0) {
5514 		/* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
5515 		WARN_ON(err == -EMSGSIZE);
5516 		kfree_skb(skb);
5517 		goto errout;
5518 	}
5519 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
5520 	return;
5521 errout:
5522 	if (err < 0)
5523 		rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
5524 }
5525 
5526 static inline size_t inet6_prefix_nlmsg_size(void)
5527 {
5528 	return NLMSG_ALIGN(sizeof(struct prefixmsg))
5529 	       + nla_total_size(sizeof(struct in6_addr))
5530 	       + nla_total_size(sizeof(struct prefix_cacheinfo));
5531 }
5532 
5533 static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
5534 			     struct prefix_info *pinfo, u32 portid, u32 seq,
5535 			     int event, unsigned int flags)
5536 {
5537 	struct prefixmsg *pmsg;
5538 	struct nlmsghdr *nlh;
5539 	struct prefix_cacheinfo	ci;
5540 
5541 	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
5542 	if (!nlh)
5543 		return -EMSGSIZE;
5544 
5545 	pmsg = nlmsg_data(nlh);
5546 	pmsg->prefix_family = AF_INET6;
5547 	pmsg->prefix_pad1 = 0;
5548 	pmsg->prefix_pad2 = 0;
5549 	pmsg->prefix_ifindex = idev->dev->ifindex;
5550 	pmsg->prefix_len = pinfo->prefix_len;
5551 	pmsg->prefix_type = pinfo->type;
5552 	pmsg->prefix_pad3 = 0;
5553 	pmsg->prefix_flags = 0;
5554 	if (pinfo->onlink)
5555 		pmsg->prefix_flags |= IF_PREFIX_ONLINK;
5556 	if (pinfo->autoconf)
5557 		pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
5558 
5559 	if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
5560 		goto nla_put_failure;
5561 	ci.preferred_time = ntohl(pinfo->prefered);
5562 	ci.valid_time = ntohl(pinfo->valid);
5563 	if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
5564 		goto nla_put_failure;
5565 	nlmsg_end(skb, nlh);
5566 	return 0;
5567 
5568 nla_put_failure:
5569 	nlmsg_cancel(skb, nlh);
5570 	return -EMSGSIZE;
5571 }
5572 
5573 static void inet6_prefix_notify(int event, struct inet6_dev *idev,
5574 			 struct prefix_info *pinfo)
5575 {
5576 	struct sk_buff *skb;
5577 	struct net *net = dev_net(idev->dev);
5578 	int err = -ENOBUFS;
5579 
5580 	skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
5581 	if (!skb)
5582 		goto errout;
5583 
5584 	err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
5585 	if (err < 0) {
5586 		/* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
5587 		WARN_ON(err == -EMSGSIZE);
5588 		kfree_skb(skb);
5589 		goto errout;
5590 	}
5591 	rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
5592 	return;
5593 errout:
5594 	if (err < 0)
5595 		rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
5596 }
5597 
5598 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
5599 {
5600 	struct net *net = dev_net(ifp->idev->dev);
5601 
5602 	if (event)
5603 		ASSERT_RTNL();
5604 
5605 	inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
5606 
5607 	switch (event) {
5608 	case RTM_NEWADDR:
5609 		/*
5610 		 * If the address was optimistic
5611 		 * we inserted the route at the start of
5612 		 * our DAD process, so we don't need
5613 		 * to do it again
5614 		 */
5615 		if (!rcu_access_pointer(ifp->rt->fib6_node))
5616 			ip6_ins_rt(net, ifp->rt);
5617 		if (ifp->idev->cnf.forwarding)
5618 			addrconf_join_anycast(ifp);
5619 		if (!ipv6_addr_any(&ifp->peer_addr))
5620 			addrconf_prefix_route(&ifp->peer_addr, 128,
5621 					      ifp->idev->dev, 0, 0,
5622 					      GFP_KERNEL);
5623 		break;
5624 	case RTM_DELADDR:
5625 		if (ifp->idev->cnf.forwarding)
5626 			addrconf_leave_anycast(ifp);
5627 		addrconf_leave_solict(ifp->idev, &ifp->addr);
5628 		if (!ipv6_addr_any(&ifp->peer_addr)) {
5629 			struct fib6_info *rt;
5630 
5631 			rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
5632 						       ifp->idev->dev, 0, 0);
5633 			if (rt)
5634 				ip6_del_rt(net, rt);
5635 		}
5636 		if (ifp->rt) {
5637 			ip6_del_rt(net, ifp->rt);
5638 			ifp->rt = NULL;
5639 		}
5640 		rt_genid_bump_ipv6(net);
5641 		break;
5642 	}
5643 	atomic_inc(&net->ipv6.dev_addr_genid);
5644 }
5645 
5646 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
5647 {
5648 	rcu_read_lock_bh();
5649 	if (likely(ifp->idev->dead == 0))
5650 		__ipv6_ifa_notify(event, ifp);
5651 	rcu_read_unlock_bh();
5652 }
5653 
5654 #ifdef CONFIG_SYSCTL
5655 
5656 static
5657 int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
5658 			   void __user *buffer, size_t *lenp, loff_t *ppos)
5659 {
5660 	int *valp = ctl->data;
5661 	int val = *valp;
5662 	loff_t pos = *ppos;
5663 	struct ctl_table lctl;
5664 	int ret;
5665 
5666 	/*
5667 	 * ctl->data points to idev->cnf.forwarding, we should
5668 	 * not modify it until we get the rtnl lock.
5669 	 */
5670 	lctl = *ctl;
5671 	lctl.data = &val;
5672 
5673 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5674 
5675 	if (write)
5676 		ret = addrconf_fixup_forwarding(ctl, valp, val);
5677 	if (ret)
5678 		*ppos = pos;
5679 	return ret;
5680 }
5681 
5682 static
5683 int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
5684 			void __user *buffer, size_t *lenp, loff_t *ppos)
5685 {
5686 	struct inet6_dev *idev = ctl->extra1;
5687 	int min_mtu = IPV6_MIN_MTU;
5688 	struct ctl_table lctl;
5689 
5690 	lctl = *ctl;
5691 	lctl.extra1 = &min_mtu;
5692 	lctl.extra2 = idev ? &idev->dev->mtu : NULL;
5693 
5694 	return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
5695 }
5696 
5697 static void dev_disable_change(struct inet6_dev *idev)
5698 {
5699 	struct netdev_notifier_info info;
5700 
5701 	if (!idev || !idev->dev)
5702 		return;
5703 
5704 	netdev_notifier_info_init(&info, idev->dev);
5705 	if (idev->cnf.disable_ipv6)
5706 		addrconf_notify(NULL, NETDEV_DOWN, &info);
5707 	else
5708 		addrconf_notify(NULL, NETDEV_UP, &info);
5709 }
5710 
5711 static void addrconf_disable_change(struct net *net, __s32 newf)
5712 {
5713 	struct net_device *dev;
5714 	struct inet6_dev *idev;
5715 
5716 	for_each_netdev(net, dev) {
5717 		idev = __in6_dev_get(dev);
5718 		if (idev) {
5719 			int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
5720 			idev->cnf.disable_ipv6 = newf;
5721 			if (changed)
5722 				dev_disable_change(idev);
5723 		}
5724 	}
5725 }
5726 
5727 static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
5728 {
5729 	struct net *net;
5730 	int old;
5731 
5732 	if (!rtnl_trylock())
5733 		return restart_syscall();
5734 
5735 	net = (struct net *)table->extra2;
5736 	old = *p;
5737 	*p = newf;
5738 
5739 	if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
5740 		rtnl_unlock();
5741 		return 0;
5742 	}
5743 
5744 	if (p == &net->ipv6.devconf_all->disable_ipv6) {
5745 		net->ipv6.devconf_dflt->disable_ipv6 = newf;
5746 		addrconf_disable_change(net, newf);
5747 	} else if ((!newf) ^ (!old))
5748 		dev_disable_change((struct inet6_dev *)table->extra1);
5749 
5750 	rtnl_unlock();
5751 	return 0;
5752 }
5753 
5754 static
5755 int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
5756 			    void __user *buffer, size_t *lenp, loff_t *ppos)
5757 {
5758 	int *valp = ctl->data;
5759 	int val = *valp;
5760 	loff_t pos = *ppos;
5761 	struct ctl_table lctl;
5762 	int ret;
5763 
5764 	/*
5765 	 * ctl->data points to idev->cnf.disable_ipv6, we should
5766 	 * not modify it until we get the rtnl lock.
5767 	 */
5768 	lctl = *ctl;
5769 	lctl.data = &val;
5770 
5771 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5772 
5773 	if (write)
5774 		ret = addrconf_disable_ipv6(ctl, valp, val);
5775 	if (ret)
5776 		*ppos = pos;
5777 	return ret;
5778 }
5779 
5780 static
5781 int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
5782 			      void __user *buffer, size_t *lenp, loff_t *ppos)
5783 {
5784 	int *valp = ctl->data;
5785 	int ret;
5786 	int old, new;
5787 
5788 	old = *valp;
5789 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
5790 	new = *valp;
5791 
5792 	if (write && old != new) {
5793 		struct net *net = ctl->extra2;
5794 
5795 		if (!rtnl_trylock())
5796 			return restart_syscall();
5797 
5798 		if (valp == &net->ipv6.devconf_dflt->proxy_ndp)
5799 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
5800 						     NETCONFA_PROXY_NEIGH,
5801 						     NETCONFA_IFINDEX_DEFAULT,
5802 						     net->ipv6.devconf_dflt);
5803 		else if (valp == &net->ipv6.devconf_all->proxy_ndp)
5804 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
5805 						     NETCONFA_PROXY_NEIGH,
5806 						     NETCONFA_IFINDEX_ALL,
5807 						     net->ipv6.devconf_all);
5808 		else {
5809 			struct inet6_dev *idev = ctl->extra1;
5810 
5811 			inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
5812 						     NETCONFA_PROXY_NEIGH,
5813 						     idev->dev->ifindex,
5814 						     &idev->cnf);
5815 		}
5816 		rtnl_unlock();
5817 	}
5818 
5819 	return ret;
5820 }
5821 
5822 static int addrconf_sysctl_addr_gen_mode(struct ctl_table *ctl, int write,
5823 					 void __user *buffer, size_t *lenp,
5824 					 loff_t *ppos)
5825 {
5826 	int ret = 0;
5827 	int new_val;
5828 	struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1;
5829 	struct net *net = (struct net *)ctl->extra2;
5830 
5831 	if (!rtnl_trylock())
5832 		return restart_syscall();
5833 
5834 	ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
5835 
5836 	if (write) {
5837 		new_val = *((int *)ctl->data);
5838 
5839 		if (check_addr_gen_mode(new_val) < 0) {
5840 			ret = -EINVAL;
5841 			goto out;
5842 		}
5843 
5844 		/* request for default */
5845 		if (&net->ipv6.devconf_dflt->addr_gen_mode == ctl->data) {
5846 			ipv6_devconf_dflt.addr_gen_mode = new_val;
5847 
5848 		/* request for individual net device */
5849 		} else {
5850 			if (!idev)
5851 				goto out;
5852 
5853 			if (check_stable_privacy(idev, net, new_val) < 0) {
5854 				ret = -EINVAL;
5855 				goto out;
5856 			}
5857 
5858 			if (idev->cnf.addr_gen_mode != new_val) {
5859 				idev->cnf.addr_gen_mode = new_val;
5860 				addrconf_dev_config(idev->dev);
5861 			}
5862 		}
5863 	}
5864 
5865 out:
5866 	rtnl_unlock();
5867 
5868 	return ret;
5869 }
5870 
5871 static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write,
5872 					 void __user *buffer, size_t *lenp,
5873 					 loff_t *ppos)
5874 {
5875 	int err;
5876 	struct in6_addr addr;
5877 	char str[IPV6_MAX_STRLEN];
5878 	struct ctl_table lctl = *ctl;
5879 	struct net *net = ctl->extra2;
5880 	struct ipv6_stable_secret *secret = ctl->data;
5881 
5882 	if (&net->ipv6.devconf_all->stable_secret == ctl->data)
5883 		return -EIO;
5884 
5885 	lctl.maxlen = IPV6_MAX_STRLEN;
5886 	lctl.data = str;
5887 
5888 	if (!rtnl_trylock())
5889 		return restart_syscall();
5890 
5891 	if (!write && !secret->initialized) {
5892 		err = -EIO;
5893 		goto out;
5894 	}
5895 
5896 	err = snprintf(str, sizeof(str), "%pI6", &secret->secret);
5897 	if (err >= sizeof(str)) {
5898 		err = -EIO;
5899 		goto out;
5900 	}
5901 
5902 	err = proc_dostring(&lctl, write, buffer, lenp, ppos);
5903 	if (err || !write)
5904 		goto out;
5905 
5906 	if (in6_pton(str, -1, addr.in6_u.u6_addr8, -1, NULL) != 1) {
5907 		err = -EIO;
5908 		goto out;
5909 	}
5910 
5911 	secret->initialized = true;
5912 	secret->secret = addr;
5913 
5914 	if (&net->ipv6.devconf_dflt->stable_secret == ctl->data) {
5915 		struct net_device *dev;
5916 
5917 		for_each_netdev(net, dev) {
5918 			struct inet6_dev *idev = __in6_dev_get(dev);
5919 
5920 			if (idev) {
5921 				idev->cnf.addr_gen_mode =
5922 					IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
5923 			}
5924 		}
5925 	} else {
5926 		struct inet6_dev *idev = ctl->extra1;
5927 
5928 		idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
5929 	}
5930 
5931 out:
5932 	rtnl_unlock();
5933 
5934 	return err;
5935 }
5936 
5937 static
5938 int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl,
5939 						int write,
5940 						void __user *buffer,
5941 						size_t *lenp,
5942 						loff_t *ppos)
5943 {
5944 	int *valp = ctl->data;
5945 	int val = *valp;
5946 	loff_t pos = *ppos;
5947 	struct ctl_table lctl;
5948 	int ret;
5949 
5950 	/* ctl->data points to idev->cnf.ignore_routes_when_linkdown
5951 	 * we should not modify it until we get the rtnl lock.
5952 	 */
5953 	lctl = *ctl;
5954 	lctl.data = &val;
5955 
5956 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
5957 
5958 	if (write)
5959 		ret = addrconf_fixup_linkdown(ctl, valp, val);
5960 	if (ret)
5961 		*ppos = pos;
5962 	return ret;
5963 }
5964 
5965 static
5966 void addrconf_set_nopolicy(struct rt6_info *rt, int action)
5967 {
5968 	if (rt) {
5969 		if (action)
5970 			rt->dst.flags |= DST_NOPOLICY;
5971 		else
5972 			rt->dst.flags &= ~DST_NOPOLICY;
5973 	}
5974 }
5975 
5976 static
5977 void addrconf_disable_policy_idev(struct inet6_dev *idev, int val)
5978 {
5979 	struct inet6_ifaddr *ifa;
5980 
5981 	read_lock_bh(&idev->lock);
5982 	list_for_each_entry(ifa, &idev->addr_list, if_list) {
5983 		spin_lock(&ifa->lock);
5984 		if (ifa->rt) {
5985 			struct fib6_info *rt = ifa->rt;
5986 			int cpu;
5987 
5988 			rcu_read_lock();
5989 			ifa->rt->dst_nopolicy = val ? true : false;
5990 			if (rt->rt6i_pcpu) {
5991 				for_each_possible_cpu(cpu) {
5992 					struct rt6_info **rtp;
5993 
5994 					rtp = per_cpu_ptr(rt->rt6i_pcpu, cpu);
5995 					addrconf_set_nopolicy(*rtp, val);
5996 				}
5997 			}
5998 			rcu_read_unlock();
5999 		}
6000 		spin_unlock(&ifa->lock);
6001 	}
6002 	read_unlock_bh(&idev->lock);
6003 }
6004 
6005 static
6006 int addrconf_disable_policy(struct ctl_table *ctl, int *valp, int val)
6007 {
6008 	struct inet6_dev *idev;
6009 	struct net *net;
6010 
6011 	if (!rtnl_trylock())
6012 		return restart_syscall();
6013 
6014 	*valp = val;
6015 
6016 	net = (struct net *)ctl->extra2;
6017 	if (valp == &net->ipv6.devconf_dflt->disable_policy) {
6018 		rtnl_unlock();
6019 		return 0;
6020 	}
6021 
6022 	if (valp == &net->ipv6.devconf_all->disable_policy)  {
6023 		struct net_device *dev;
6024 
6025 		for_each_netdev(net, dev) {
6026 			idev = __in6_dev_get(dev);
6027 			if (idev)
6028 				addrconf_disable_policy_idev(idev, val);
6029 		}
6030 	} else {
6031 		idev = (struct inet6_dev *)ctl->extra1;
6032 		addrconf_disable_policy_idev(idev, val);
6033 	}
6034 
6035 	rtnl_unlock();
6036 	return 0;
6037 }
6038 
6039 static
6040 int addrconf_sysctl_disable_policy(struct ctl_table *ctl, int write,
6041 				   void __user *buffer, size_t *lenp,
6042 				   loff_t *ppos)
6043 {
6044 	int *valp = ctl->data;
6045 	int val = *valp;
6046 	loff_t pos = *ppos;
6047 	struct ctl_table lctl;
6048 	int ret;
6049 
6050 	lctl = *ctl;
6051 	lctl.data = &val;
6052 	ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
6053 
6054 	if (write && (*valp != val))
6055 		ret = addrconf_disable_policy(ctl, valp, val);
6056 
6057 	if (ret)
6058 		*ppos = pos;
6059 
6060 	return ret;
6061 }
6062 
6063 static int minus_one = -1;
6064 static const int zero = 0;
6065 static const int one = 1;
6066 static const int two_five_five = 255;
6067 
6068 static const struct ctl_table addrconf_sysctl[] = {
6069 	{
6070 		.procname	= "forwarding",
6071 		.data		= &ipv6_devconf.forwarding,
6072 		.maxlen		= sizeof(int),
6073 		.mode		= 0644,
6074 		.proc_handler	= addrconf_sysctl_forward,
6075 	},
6076 	{
6077 		.procname	= "hop_limit",
6078 		.data		= &ipv6_devconf.hop_limit,
6079 		.maxlen		= sizeof(int),
6080 		.mode		= 0644,
6081 		.proc_handler	= proc_dointvec_minmax,
6082 		.extra1		= (void *)&one,
6083 		.extra2		= (void *)&two_five_five,
6084 	},
6085 	{
6086 		.procname	= "mtu",
6087 		.data		= &ipv6_devconf.mtu6,
6088 		.maxlen		= sizeof(int),
6089 		.mode		= 0644,
6090 		.proc_handler	= addrconf_sysctl_mtu,
6091 	},
6092 	{
6093 		.procname	= "accept_ra",
6094 		.data		= &ipv6_devconf.accept_ra,
6095 		.maxlen		= sizeof(int),
6096 		.mode		= 0644,
6097 		.proc_handler	= proc_dointvec,
6098 	},
6099 	{
6100 		.procname	= "accept_redirects",
6101 		.data		= &ipv6_devconf.accept_redirects,
6102 		.maxlen		= sizeof(int),
6103 		.mode		= 0644,
6104 		.proc_handler	= proc_dointvec,
6105 	},
6106 	{
6107 		.procname	= "autoconf",
6108 		.data		= &ipv6_devconf.autoconf,
6109 		.maxlen		= sizeof(int),
6110 		.mode		= 0644,
6111 		.proc_handler	= proc_dointvec,
6112 	},
6113 	{
6114 		.procname	= "dad_transmits",
6115 		.data		= &ipv6_devconf.dad_transmits,
6116 		.maxlen		= sizeof(int),
6117 		.mode		= 0644,
6118 		.proc_handler	= proc_dointvec,
6119 	},
6120 	{
6121 		.procname	= "router_solicitations",
6122 		.data		= &ipv6_devconf.rtr_solicits,
6123 		.maxlen		= sizeof(int),
6124 		.mode		= 0644,
6125 		.proc_handler	= proc_dointvec_minmax,
6126 		.extra1		= &minus_one,
6127 	},
6128 	{
6129 		.procname	= "router_solicitation_interval",
6130 		.data		= &ipv6_devconf.rtr_solicit_interval,
6131 		.maxlen		= sizeof(int),
6132 		.mode		= 0644,
6133 		.proc_handler	= proc_dointvec_jiffies,
6134 	},
6135 	{
6136 		.procname	= "router_solicitation_max_interval",
6137 		.data		= &ipv6_devconf.rtr_solicit_max_interval,
6138 		.maxlen		= sizeof(int),
6139 		.mode		= 0644,
6140 		.proc_handler	= proc_dointvec_jiffies,
6141 	},
6142 	{
6143 		.procname	= "router_solicitation_delay",
6144 		.data		= &ipv6_devconf.rtr_solicit_delay,
6145 		.maxlen		= sizeof(int),
6146 		.mode		= 0644,
6147 		.proc_handler	= proc_dointvec_jiffies,
6148 	},
6149 	{
6150 		.procname	= "force_mld_version",
6151 		.data		= &ipv6_devconf.force_mld_version,
6152 		.maxlen		= sizeof(int),
6153 		.mode		= 0644,
6154 		.proc_handler	= proc_dointvec,
6155 	},
6156 	{
6157 		.procname	= "mldv1_unsolicited_report_interval",
6158 		.data		=
6159 			&ipv6_devconf.mldv1_unsolicited_report_interval,
6160 		.maxlen		= sizeof(int),
6161 		.mode		= 0644,
6162 		.proc_handler	= proc_dointvec_ms_jiffies,
6163 	},
6164 	{
6165 		.procname	= "mldv2_unsolicited_report_interval",
6166 		.data		=
6167 			&ipv6_devconf.mldv2_unsolicited_report_interval,
6168 		.maxlen		= sizeof(int),
6169 		.mode		= 0644,
6170 		.proc_handler	= proc_dointvec_ms_jiffies,
6171 	},
6172 	{
6173 		.procname	= "use_tempaddr",
6174 		.data		= &ipv6_devconf.use_tempaddr,
6175 		.maxlen		= sizeof(int),
6176 		.mode		= 0644,
6177 		.proc_handler	= proc_dointvec,
6178 	},
6179 	{
6180 		.procname	= "temp_valid_lft",
6181 		.data		= &ipv6_devconf.temp_valid_lft,
6182 		.maxlen		= sizeof(int),
6183 		.mode		= 0644,
6184 		.proc_handler	= proc_dointvec,
6185 	},
6186 	{
6187 		.procname	= "temp_prefered_lft",
6188 		.data		= &ipv6_devconf.temp_prefered_lft,
6189 		.maxlen		= sizeof(int),
6190 		.mode		= 0644,
6191 		.proc_handler	= proc_dointvec,
6192 	},
6193 	{
6194 		.procname	= "regen_max_retry",
6195 		.data		= &ipv6_devconf.regen_max_retry,
6196 		.maxlen		= sizeof(int),
6197 		.mode		= 0644,
6198 		.proc_handler	= proc_dointvec,
6199 	},
6200 	{
6201 		.procname	= "max_desync_factor",
6202 		.data		= &ipv6_devconf.max_desync_factor,
6203 		.maxlen		= sizeof(int),
6204 		.mode		= 0644,
6205 		.proc_handler	= proc_dointvec,
6206 	},
6207 	{
6208 		.procname	= "max_addresses",
6209 		.data		= &ipv6_devconf.max_addresses,
6210 		.maxlen		= sizeof(int),
6211 		.mode		= 0644,
6212 		.proc_handler	= proc_dointvec,
6213 	},
6214 	{
6215 		.procname	= "accept_ra_defrtr",
6216 		.data		= &ipv6_devconf.accept_ra_defrtr,
6217 		.maxlen		= sizeof(int),
6218 		.mode		= 0644,
6219 		.proc_handler	= proc_dointvec,
6220 	},
6221 	{
6222 		.procname	= "accept_ra_min_hop_limit",
6223 		.data		= &ipv6_devconf.accept_ra_min_hop_limit,
6224 		.maxlen		= sizeof(int),
6225 		.mode		= 0644,
6226 		.proc_handler	= proc_dointvec,
6227 	},
6228 	{
6229 		.procname	= "accept_ra_pinfo",
6230 		.data		= &ipv6_devconf.accept_ra_pinfo,
6231 		.maxlen		= sizeof(int),
6232 		.mode		= 0644,
6233 		.proc_handler	= proc_dointvec,
6234 	},
6235 #ifdef CONFIG_IPV6_ROUTER_PREF
6236 	{
6237 		.procname	= "accept_ra_rtr_pref",
6238 		.data		= &ipv6_devconf.accept_ra_rtr_pref,
6239 		.maxlen		= sizeof(int),
6240 		.mode		= 0644,
6241 		.proc_handler	= proc_dointvec,
6242 	},
6243 	{
6244 		.procname	= "router_probe_interval",
6245 		.data		= &ipv6_devconf.rtr_probe_interval,
6246 		.maxlen		= sizeof(int),
6247 		.mode		= 0644,
6248 		.proc_handler	= proc_dointvec_jiffies,
6249 	},
6250 #ifdef CONFIG_IPV6_ROUTE_INFO
6251 	{
6252 		.procname	= "accept_ra_rt_info_min_plen",
6253 		.data		= &ipv6_devconf.accept_ra_rt_info_min_plen,
6254 		.maxlen		= sizeof(int),
6255 		.mode		= 0644,
6256 		.proc_handler	= proc_dointvec,
6257 	},
6258 	{
6259 		.procname	= "accept_ra_rt_info_max_plen",
6260 		.data		= &ipv6_devconf.accept_ra_rt_info_max_plen,
6261 		.maxlen		= sizeof(int),
6262 		.mode		= 0644,
6263 		.proc_handler	= proc_dointvec,
6264 	},
6265 #endif
6266 #endif
6267 	{
6268 		.procname	= "proxy_ndp",
6269 		.data		= &ipv6_devconf.proxy_ndp,
6270 		.maxlen		= sizeof(int),
6271 		.mode		= 0644,
6272 		.proc_handler	= addrconf_sysctl_proxy_ndp,
6273 	},
6274 	{
6275 		.procname	= "accept_source_route",
6276 		.data		= &ipv6_devconf.accept_source_route,
6277 		.maxlen		= sizeof(int),
6278 		.mode		= 0644,
6279 		.proc_handler	= proc_dointvec,
6280 	},
6281 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
6282 	{
6283 		.procname	= "optimistic_dad",
6284 		.data		= &ipv6_devconf.optimistic_dad,
6285 		.maxlen		= sizeof(int),
6286 		.mode		= 0644,
6287 		.proc_handler   = proc_dointvec,
6288 	},
6289 	{
6290 		.procname	= "use_optimistic",
6291 		.data		= &ipv6_devconf.use_optimistic,
6292 		.maxlen		= sizeof(int),
6293 		.mode		= 0644,
6294 		.proc_handler	= proc_dointvec,
6295 	},
6296 #endif
6297 #ifdef CONFIG_IPV6_MROUTE
6298 	{
6299 		.procname	= "mc_forwarding",
6300 		.data		= &ipv6_devconf.mc_forwarding,
6301 		.maxlen		= sizeof(int),
6302 		.mode		= 0444,
6303 		.proc_handler	= proc_dointvec,
6304 	},
6305 #endif
6306 	{
6307 		.procname	= "disable_ipv6",
6308 		.data		= &ipv6_devconf.disable_ipv6,
6309 		.maxlen		= sizeof(int),
6310 		.mode		= 0644,
6311 		.proc_handler	= addrconf_sysctl_disable,
6312 	},
6313 	{
6314 		.procname	= "accept_dad",
6315 		.data		= &ipv6_devconf.accept_dad,
6316 		.maxlen		= sizeof(int),
6317 		.mode		= 0644,
6318 		.proc_handler	= proc_dointvec,
6319 	},
6320 	{
6321 		.procname	= "force_tllao",
6322 		.data		= &ipv6_devconf.force_tllao,
6323 		.maxlen		= sizeof(int),
6324 		.mode		= 0644,
6325 		.proc_handler	= proc_dointvec
6326 	},
6327 	{
6328 		.procname	= "ndisc_notify",
6329 		.data		= &ipv6_devconf.ndisc_notify,
6330 		.maxlen		= sizeof(int),
6331 		.mode		= 0644,
6332 		.proc_handler	= proc_dointvec
6333 	},
6334 	{
6335 		.procname	= "suppress_frag_ndisc",
6336 		.data		= &ipv6_devconf.suppress_frag_ndisc,
6337 		.maxlen		= sizeof(int),
6338 		.mode		= 0644,
6339 		.proc_handler	= proc_dointvec
6340 	},
6341 	{
6342 		.procname	= "accept_ra_from_local",
6343 		.data		= &ipv6_devconf.accept_ra_from_local,
6344 		.maxlen		= sizeof(int),
6345 		.mode		= 0644,
6346 		.proc_handler	= proc_dointvec,
6347 	},
6348 	{
6349 		.procname	= "accept_ra_mtu",
6350 		.data		= &ipv6_devconf.accept_ra_mtu,
6351 		.maxlen		= sizeof(int),
6352 		.mode		= 0644,
6353 		.proc_handler	= proc_dointvec,
6354 	},
6355 	{
6356 		.procname	= "stable_secret",
6357 		.data		= &ipv6_devconf.stable_secret,
6358 		.maxlen		= IPV6_MAX_STRLEN,
6359 		.mode		= 0600,
6360 		.proc_handler	= addrconf_sysctl_stable_secret,
6361 	},
6362 	{
6363 		.procname	= "use_oif_addrs_only",
6364 		.data		= &ipv6_devconf.use_oif_addrs_only,
6365 		.maxlen		= sizeof(int),
6366 		.mode		= 0644,
6367 		.proc_handler	= proc_dointvec,
6368 	},
6369 	{
6370 		.procname	= "ignore_routes_with_linkdown",
6371 		.data		= &ipv6_devconf.ignore_routes_with_linkdown,
6372 		.maxlen		= sizeof(int),
6373 		.mode		= 0644,
6374 		.proc_handler	= addrconf_sysctl_ignore_routes_with_linkdown,
6375 	},
6376 	{
6377 		.procname	= "drop_unicast_in_l2_multicast",
6378 		.data		= &ipv6_devconf.drop_unicast_in_l2_multicast,
6379 		.maxlen		= sizeof(int),
6380 		.mode		= 0644,
6381 		.proc_handler	= proc_dointvec,
6382 	},
6383 	{
6384 		.procname	= "drop_unsolicited_na",
6385 		.data		= &ipv6_devconf.drop_unsolicited_na,
6386 		.maxlen		= sizeof(int),
6387 		.mode		= 0644,
6388 		.proc_handler	= proc_dointvec,
6389 	},
6390 	{
6391 		.procname	= "keep_addr_on_down",
6392 		.data		= &ipv6_devconf.keep_addr_on_down,
6393 		.maxlen		= sizeof(int),
6394 		.mode		= 0644,
6395 		.proc_handler	= proc_dointvec,
6396 
6397 	},
6398 	{
6399 		.procname	= "seg6_enabled",
6400 		.data		= &ipv6_devconf.seg6_enabled,
6401 		.maxlen		= sizeof(int),
6402 		.mode		= 0644,
6403 		.proc_handler	= proc_dointvec,
6404 	},
6405 #ifdef CONFIG_IPV6_SEG6_HMAC
6406 	{
6407 		.procname	= "seg6_require_hmac",
6408 		.data		= &ipv6_devconf.seg6_require_hmac,
6409 		.maxlen		= sizeof(int),
6410 		.mode		= 0644,
6411 		.proc_handler	= proc_dointvec,
6412 	},
6413 #endif
6414 	{
6415 		.procname       = "enhanced_dad",
6416 		.data           = &ipv6_devconf.enhanced_dad,
6417 		.maxlen         = sizeof(int),
6418 		.mode           = 0644,
6419 		.proc_handler   = proc_dointvec,
6420 	},
6421 	{
6422 		.procname		= "addr_gen_mode",
6423 		.data			= &ipv6_devconf.addr_gen_mode,
6424 		.maxlen			= sizeof(int),
6425 		.mode			= 0644,
6426 		.proc_handler	= addrconf_sysctl_addr_gen_mode,
6427 	},
6428 	{
6429 		.procname       = "disable_policy",
6430 		.data           = &ipv6_devconf.disable_policy,
6431 		.maxlen         = sizeof(int),
6432 		.mode           = 0644,
6433 		.proc_handler   = addrconf_sysctl_disable_policy,
6434 	},
6435 	{
6436 		.procname	= "ndisc_tclass",
6437 		.data		= &ipv6_devconf.ndisc_tclass,
6438 		.maxlen		= sizeof(int),
6439 		.mode		= 0644,
6440 		.proc_handler	= proc_dointvec_minmax,
6441 		.extra1		= (void *)&zero,
6442 		.extra2		= (void *)&two_five_five,
6443 	},
6444 	{
6445 		/* sentinel */
6446 	}
6447 };
6448 
6449 static int __addrconf_sysctl_register(struct net *net, char *dev_name,
6450 		struct inet6_dev *idev, struct ipv6_devconf *p)
6451 {
6452 	int i, ifindex;
6453 	struct ctl_table *table;
6454 	char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
6455 
6456 	table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL);
6457 	if (!table)
6458 		goto out;
6459 
6460 	for (i = 0; table[i].data; i++) {
6461 		table[i].data += (char *)p - (char *)&ipv6_devconf;
6462 		/* If one of these is already set, then it is not safe to
6463 		 * overwrite either of them: this makes proc_dointvec_minmax
6464 		 * usable.
6465 		 */
6466 		if (!table[i].extra1 && !table[i].extra2) {
6467 			table[i].extra1 = idev; /* embedded; no ref */
6468 			table[i].extra2 = net;
6469 		}
6470 	}
6471 
6472 	snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
6473 
6474 	p->sysctl_header = register_net_sysctl(net, path, table);
6475 	if (!p->sysctl_header)
6476 		goto free;
6477 
6478 	if (!strcmp(dev_name, "all"))
6479 		ifindex = NETCONFA_IFINDEX_ALL;
6480 	else if (!strcmp(dev_name, "default"))
6481 		ifindex = NETCONFA_IFINDEX_DEFAULT;
6482 	else
6483 		ifindex = idev->dev->ifindex;
6484 	inet6_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
6485 				     ifindex, p);
6486 	return 0;
6487 
6488 free:
6489 	kfree(table);
6490 out:
6491 	return -ENOBUFS;
6492 }
6493 
6494 static void __addrconf_sysctl_unregister(struct net *net,
6495 					 struct ipv6_devconf *p, int ifindex)
6496 {
6497 	struct ctl_table *table;
6498 
6499 	if (!p->sysctl_header)
6500 		return;
6501 
6502 	table = p->sysctl_header->ctl_table_arg;
6503 	unregister_net_sysctl_table(p->sysctl_header);
6504 	p->sysctl_header = NULL;
6505 	kfree(table);
6506 
6507 	inet6_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
6508 }
6509 
6510 static int addrconf_sysctl_register(struct inet6_dev *idev)
6511 {
6512 	int err;
6513 
6514 	if (!sysctl_dev_name_is_allowed(idev->dev->name))
6515 		return -EINVAL;
6516 
6517 	err = neigh_sysctl_register(idev->dev, idev->nd_parms,
6518 				    &ndisc_ifinfo_sysctl_change);
6519 	if (err)
6520 		return err;
6521 	err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
6522 					 idev, &idev->cnf);
6523 	if (err)
6524 		neigh_sysctl_unregister(idev->nd_parms);
6525 
6526 	return err;
6527 }
6528 
6529 static void addrconf_sysctl_unregister(struct inet6_dev *idev)
6530 {
6531 	__addrconf_sysctl_unregister(dev_net(idev->dev), &idev->cnf,
6532 				     idev->dev->ifindex);
6533 	neigh_sysctl_unregister(idev->nd_parms);
6534 }
6535 
6536 
6537 #endif
6538 
6539 static int __net_init addrconf_init_net(struct net *net)
6540 {
6541 	int err = -ENOMEM;
6542 	struct ipv6_devconf *all, *dflt;
6543 
6544 	all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
6545 	if (!all)
6546 		goto err_alloc_all;
6547 
6548 	dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
6549 	if (!dflt)
6550 		goto err_alloc_dflt;
6551 
6552 	/* these will be inherited by all namespaces */
6553 	dflt->autoconf = ipv6_defaults.autoconf;
6554 	dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
6555 
6556 	dflt->stable_secret.initialized = false;
6557 	all->stable_secret.initialized = false;
6558 
6559 	net->ipv6.devconf_all = all;
6560 	net->ipv6.devconf_dflt = dflt;
6561 
6562 #ifdef CONFIG_SYSCTL
6563 	err = __addrconf_sysctl_register(net, "all", NULL, all);
6564 	if (err < 0)
6565 		goto err_reg_all;
6566 
6567 	err = __addrconf_sysctl_register(net, "default", NULL, dflt);
6568 	if (err < 0)
6569 		goto err_reg_dflt;
6570 #endif
6571 	return 0;
6572 
6573 #ifdef CONFIG_SYSCTL
6574 err_reg_dflt:
6575 	__addrconf_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
6576 err_reg_all:
6577 	kfree(dflt);
6578 #endif
6579 err_alloc_dflt:
6580 	kfree(all);
6581 err_alloc_all:
6582 	return err;
6583 }
6584 
6585 static void __net_exit addrconf_exit_net(struct net *net)
6586 {
6587 #ifdef CONFIG_SYSCTL
6588 	__addrconf_sysctl_unregister(net, net->ipv6.devconf_dflt,
6589 				     NETCONFA_IFINDEX_DEFAULT);
6590 	__addrconf_sysctl_unregister(net, net->ipv6.devconf_all,
6591 				     NETCONFA_IFINDEX_ALL);
6592 #endif
6593 	kfree(net->ipv6.devconf_dflt);
6594 	kfree(net->ipv6.devconf_all);
6595 }
6596 
6597 static struct pernet_operations addrconf_ops = {
6598 	.init = addrconf_init_net,
6599 	.exit = addrconf_exit_net,
6600 };
6601 
6602 static struct rtnl_af_ops inet6_ops __read_mostly = {
6603 	.family		  = AF_INET6,
6604 	.fill_link_af	  = inet6_fill_link_af,
6605 	.get_link_af_size = inet6_get_link_af_size,
6606 	.validate_link_af = inet6_validate_link_af,
6607 	.set_link_af	  = inet6_set_link_af,
6608 };
6609 
6610 /*
6611  *	Init / cleanup code
6612  */
6613 
6614 int __init addrconf_init(void)
6615 {
6616 	struct inet6_dev *idev;
6617 	int i, err;
6618 
6619 	err = ipv6_addr_label_init();
6620 	if (err < 0) {
6621 		pr_crit("%s: cannot initialize default policy table: %d\n",
6622 			__func__, err);
6623 		goto out;
6624 	}
6625 
6626 	err = register_pernet_subsys(&addrconf_ops);
6627 	if (err < 0)
6628 		goto out_addrlabel;
6629 
6630 	addrconf_wq = create_workqueue("ipv6_addrconf");
6631 	if (!addrconf_wq) {
6632 		err = -ENOMEM;
6633 		goto out_nowq;
6634 	}
6635 
6636 	/* The addrconf netdev notifier requires that loopback_dev
6637 	 * has it's ipv6 private information allocated and setup
6638 	 * before it can bring up and give link-local addresses
6639 	 * to other devices which are up.
6640 	 *
6641 	 * Unfortunately, loopback_dev is not necessarily the first
6642 	 * entry in the global dev_base list of net devices.  In fact,
6643 	 * it is likely to be the very last entry on that list.
6644 	 * So this causes the notifier registry below to try and
6645 	 * give link-local addresses to all devices besides loopback_dev
6646 	 * first, then loopback_dev, which cases all the non-loopback_dev
6647 	 * devices to fail to get a link-local address.
6648 	 *
6649 	 * So, as a temporary fix, allocate the ipv6 structure for
6650 	 * loopback_dev first by hand.
6651 	 * Longer term, all of the dependencies ipv6 has upon the loopback
6652 	 * device and it being up should be removed.
6653 	 */
6654 	rtnl_lock();
6655 	idev = ipv6_add_dev(init_net.loopback_dev);
6656 	rtnl_unlock();
6657 	if (IS_ERR(idev)) {
6658 		err = PTR_ERR(idev);
6659 		goto errlo;
6660 	}
6661 
6662 	ip6_route_init_special_entries();
6663 
6664 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
6665 		INIT_HLIST_HEAD(&inet6_addr_lst[i]);
6666 
6667 	register_netdevice_notifier(&ipv6_dev_notf);
6668 
6669 	addrconf_verify();
6670 
6671 	rtnl_af_register(&inet6_ops);
6672 
6673 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETLINK,
6674 				   NULL, inet6_dump_ifinfo, 0);
6675 	if (err < 0)
6676 		goto errout;
6677 
6678 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWADDR,
6679 				   inet6_rtm_newaddr, NULL, 0);
6680 	if (err < 0)
6681 		goto errout;
6682 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELADDR,
6683 				   inet6_rtm_deladdr, NULL, 0);
6684 	if (err < 0)
6685 		goto errout;
6686 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETADDR,
6687 				   inet6_rtm_getaddr, inet6_dump_ifaddr,
6688 				   RTNL_FLAG_DOIT_UNLOCKED);
6689 	if (err < 0)
6690 		goto errout;
6691 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETMULTICAST,
6692 				   NULL, inet6_dump_ifmcaddr, 0);
6693 	if (err < 0)
6694 		goto errout;
6695 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETANYCAST,
6696 				   NULL, inet6_dump_ifacaddr, 0);
6697 	if (err < 0)
6698 		goto errout;
6699 	err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETNETCONF,
6700 				   inet6_netconf_get_devconf,
6701 				   inet6_netconf_dump_devconf,
6702 				   RTNL_FLAG_DOIT_UNLOCKED);
6703 	if (err < 0)
6704 		goto errout;
6705 	err = ipv6_addr_label_rtnl_register();
6706 	if (err < 0)
6707 		goto errout;
6708 
6709 	return 0;
6710 errout:
6711 	rtnl_unregister_all(PF_INET6);
6712 	rtnl_af_unregister(&inet6_ops);
6713 	unregister_netdevice_notifier(&ipv6_dev_notf);
6714 errlo:
6715 	destroy_workqueue(addrconf_wq);
6716 out_nowq:
6717 	unregister_pernet_subsys(&addrconf_ops);
6718 out_addrlabel:
6719 	ipv6_addr_label_cleanup();
6720 out:
6721 	return err;
6722 }
6723 
6724 void addrconf_cleanup(void)
6725 {
6726 	struct net_device *dev;
6727 	int i;
6728 
6729 	unregister_netdevice_notifier(&ipv6_dev_notf);
6730 	unregister_pernet_subsys(&addrconf_ops);
6731 	ipv6_addr_label_cleanup();
6732 
6733 	rtnl_af_unregister(&inet6_ops);
6734 
6735 	rtnl_lock();
6736 
6737 	/* clean dev list */
6738 	for_each_netdev(&init_net, dev) {
6739 		if (__in6_dev_get(dev) == NULL)
6740 			continue;
6741 		addrconf_ifdown(dev, 1);
6742 	}
6743 	addrconf_ifdown(init_net.loopback_dev, 2);
6744 
6745 	/*
6746 	 *	Check hash table.
6747 	 */
6748 	spin_lock_bh(&addrconf_hash_lock);
6749 	for (i = 0; i < IN6_ADDR_HSIZE; i++)
6750 		WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
6751 	spin_unlock_bh(&addrconf_hash_lock);
6752 	cancel_delayed_work(&addr_chk_work);
6753 	rtnl_unlock();
6754 
6755 	destroy_workqueue(addrconf_wq);
6756 }
6757