LCOV - code coverage report
Current view: top level - net/ipv6 - addrconf.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 1007 2538 39.7 %
Date: 2020-09-30 20:25:40 Functions: 84 160 52.5 %
Branches: 504 2046 24.6 %

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

Generated by: LCOV version 1.14