Home | History | Annotate | Line # | Download | only in net
if.c revision 1.372
      1  1.372     ozaki /*	$NetBSD: if.c,v 1.372 2017/01/20 08:35:33 ozaki-r Exp $	*/
      2   1.53   thorpej 
      3   1.53   thorpej /*-
      4  1.219        ad  * Copyright (c) 1999, 2000, 2001, 2008 The NetBSD Foundation, Inc.
      5   1.53   thorpej  * All rights reserved.
      6   1.53   thorpej  *
      7   1.53   thorpej  * This code is derived from software contributed to The NetBSD Foundation
      8  1.150     peter  * by William Studenmund and Jason R. Thorpe.
      9   1.53   thorpej  *
     10   1.53   thorpej  * Redistribution and use in source and binary forms, with or without
     11   1.53   thorpej  * modification, are permitted provided that the following conditions
     12   1.53   thorpej  * are met:
     13   1.53   thorpej  * 1. Redistributions of source code must retain the above copyright
     14   1.53   thorpej  *    notice, this list of conditions and the following disclaimer.
     15   1.53   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.53   thorpej  *    notice, this list of conditions and the following disclaimer in the
     17   1.53   thorpej  *    documentation and/or other materials provided with the distribution.
     18   1.53   thorpej  *
     19   1.53   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20   1.53   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21   1.53   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22   1.53   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23   1.53   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24   1.53   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25   1.53   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26   1.53   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27   1.53   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28   1.53   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29   1.53   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     30   1.53   thorpej  */
     31   1.49    itojun 
     32   1.49    itojun /*
     33   1.49    itojun  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
     34   1.49    itojun  * All rights reserved.
     35  1.154     perry  *
     36   1.49    itojun  * Redistribution and use in source and binary forms, with or without
     37   1.49    itojun  * modification, are permitted provided that the following conditions
     38   1.49    itojun  * are met:
     39   1.49    itojun  * 1. Redistributions of source code must retain the above copyright
     40   1.49    itojun  *    notice, this list of conditions and the following disclaimer.
     41   1.49    itojun  * 2. Redistributions in binary form must reproduce the above copyright
     42   1.49    itojun  *    notice, this list of conditions and the following disclaimer in the
     43   1.49    itojun  *    documentation and/or other materials provided with the distribution.
     44   1.49    itojun  * 3. Neither the name of the project nor the names of its contributors
     45   1.49    itojun  *    may be used to endorse or promote products derived from this software
     46   1.49    itojun  *    without specific prior written permission.
     47  1.154     perry  *
     48   1.49    itojun  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     49   1.49    itojun  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50   1.49    itojun  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51   1.49    itojun  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     52   1.49    itojun  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53   1.49    itojun  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54   1.49    itojun  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55   1.49    itojun  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56   1.49    itojun  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57   1.49    itojun  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58   1.49    itojun  * SUCH DAMAGE.
     59   1.49    itojun  */
     60   1.16       cgd 
     61    1.1       cgd /*
     62   1.15   mycroft  * Copyright (c) 1980, 1986, 1993
     63   1.15   mycroft  *	The Regents of the University of California.  All rights reserved.
     64    1.1       cgd  *
     65    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     66    1.1       cgd  * modification, are permitted provided that the following conditions
     67    1.1       cgd  * are met:
     68    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     69    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     70    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     71    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     72    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     73  1.126       agc  * 3. Neither the name of the University nor the names of its contributors
     74    1.1       cgd  *    may be used to endorse or promote products derived from this software
     75    1.1       cgd  *    without specific prior written permission.
     76    1.1       cgd  *
     77    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     78    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     79    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     80    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     81    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     82    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     83    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     84    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     85    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     86    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     87    1.1       cgd  * SUCH DAMAGE.
     88    1.1       cgd  *
     89   1.44      fvdl  *	@(#)if.c	8.5 (Berkeley) 1/9/95
     90    1.1       cgd  */
     91   1.99     lukem 
     92   1.99     lukem #include <sys/cdefs.h>
     93  1.372     ozaki __KERNEL_RCSID(0, "$NetBSD: if.c,v 1.372 2017/01/20 08:35:33 ozaki-r Exp $");
     94   1.50   thorpej 
     95  1.308     ozaki #if defined(_KERNEL_OPT)
     96   1.50   thorpej #include "opt_inet.h"
     97  1.352  knakahar #include "opt_ipsec.h"
     98   1.46   thorpej 
     99   1.51    bouyer #include "opt_atalk.h"
    100  1.120    martin #include "opt_natm.h"
    101  1.288     ozaki #include "opt_wlan.h"
    102  1.308     ozaki #include "opt_net_mpsafe.h"
    103  1.308     ozaki #endif
    104    1.1       cgd 
    105    1.8   mycroft #include <sys/param.h>
    106    1.8   mycroft #include <sys/mbuf.h>
    107    1.8   mycroft #include <sys/systm.h>
    108   1.59   thorpej #include <sys/callout.h>
    109   1.15   mycroft #include <sys/proc.h>
    110    1.8   mycroft #include <sys/socket.h>
    111    1.8   mycroft #include <sys/socketvar.h>
    112   1.56   thorpej #include <sys/domain.h>
    113    1.8   mycroft #include <sys/protosw.h>
    114    1.8   mycroft #include <sys/kernel.h>
    115    1.8   mycroft #include <sys/ioctl.h>
    116  1.133  jonathan #include <sys/sysctl.h>
    117  1.159    dyoung #include <sys/syslog.h>
    118  1.165      elad #include <sys/kauth.h>
    119  1.254    dyoung #include <sys/kmem.h>
    120  1.276     rmind #include <sys/xcall.h>
    121  1.323     ozaki #include <sys/cpu.h>
    122  1.323     ozaki #include <sys/intr.h>
    123    1.1       cgd 
    124    1.8   mycroft #include <net/if.h>
    125    1.8   mycroft #include <net/if_dl.h>
    126   1.66      onoe #include <net/if_ether.h>
    127  1.124    dyoung #include <net/if_media.h>
    128  1.132    dyoung #include <net80211/ieee80211.h>
    129  1.132    dyoung #include <net80211/ieee80211_ioctl.h>
    130    1.8   mycroft #include <net/if_types.h>
    131   1.53   thorpej #include <net/route.h>
    132   1.95    itojun #include <net/netisr.h>
    133  1.262  christos #include <sys/module.h>
    134   1.51    bouyer #ifdef NETATALK
    135   1.51    bouyer #include <netatalk/at_extern.h>
    136   1.51    bouyer #include <netatalk/at.h>
    137   1.51    bouyer #endif
    138  1.143    itojun #include <net/pfil.h>
    139  1.278        he #include <netinet/in.h>
    140  1.276     rmind #include <netinet/in_var.h>
    141  1.352  knakahar #ifndef IPSEC
    142  1.352  knakahar #include <netinet/ip_encap.h>
    143  1.352  knakahar #endif
    144  1.368     ozaki #include <net/bpf.h>
    145    1.1       cgd 
    146   1.49    itojun #ifdef INET6
    147   1.72   thorpej #include <netinet6/in6_var.h>
    148  1.108    itojun #include <netinet6/nd6.h>
    149   1.49    itojun #endif
    150  1.117   thorpej 
    151  1.288     ozaki #include "ether.h"
    152  1.288     ozaki #include "fddi.h"
    153  1.288     ozaki #include "token.h"
    154  1.288     ozaki 
    155  1.166  liamjfoy #include "carp.h"
    156  1.166  liamjfoy #if NCARP > 0
    157  1.166  liamjfoy #include <netinet/ip_carp.h>
    158  1.166  liamjfoy #endif
    159  1.166  liamjfoy 
    160  1.186  christos #include <compat/sys/sockio.h>
    161  1.161  christos #include <compat/sys/socket.h>
    162  1.161  christos 
    163  1.117   thorpej MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
    164  1.117   thorpej MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
    165   1.49    itojun 
    166  1.274     rmind /*
    167  1.274     rmind  * Global list of interfaces.
    168  1.274     rmind  */
    169  1.334     ozaki /* DEPRECATED. Remove it once kvm(3) users disappeared */
    170  1.274     rmind struct ifnet_head		ifnet_list;
    171  1.334     ozaki 
    172  1.334     ozaki struct pslist_head		ifnet_pslist;
    173  1.274     rmind static ifnet_t **		ifindex2ifnet = NULL;
    174  1.274     rmind static u_int			if_index = 1;
    175  1.274     rmind static size_t			if_indexlim = 0;
    176  1.274     rmind static uint64_t			index_gen;
    177  1.334     ozaki /* Mutex to protect the above objects. */
    178  1.334     ozaki kmutex_t			ifnet_mtx __cacheline_aligned;
    179  1.334     ozaki struct psref_class		*ifnet_psref_class __read_mostly;
    180  1.334     ozaki static pserialize_t		ifnet_psz;
    181  1.334     ozaki 
    182  1.292  christos static kmutex_t			if_clone_mtx;
    183  1.274     rmind 
    184  1.274     rmind struct ifnet *lo0ifp;
    185    1.1       cgd int	ifqmaxlen = IFQ_MAXLEN;
    186  1.104      matt 
    187  1.357     ozaki struct psref_class		*ifa_psref_class __read_mostly;
    188  1.357     ozaki 
    189  1.362     ozaki static int	if_delroute_matcher(struct rtentry *, void *);
    190   1.53   thorpej 
    191  1.163   thorpej static struct if_clone *if_clone_lookup(const char *, int *);
    192   1.63   thorpej 
    193  1.163   thorpej static LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
    194  1.163   thorpej static int if_cloners_count;
    195   1.63   thorpej 
    196  1.265     rmind /* Packet filtering hook for interfaces. */
    197  1.369  christos pfil_head_t *			if_pfil __read_mostly;
    198  1.143    itojun 
    199  1.239      elad static kauth_listener_t if_listener;
    200  1.239      elad 
    201  1.273     pooka static int doifioctl(struct socket *, u_long, void *, struct lwp *);
    202  1.163   thorpej static void if_detach_queues(struct ifnet *, struct ifqueue *);
    203  1.234    dyoung static void sysctl_sndq_setup(struct sysctllog **, const char *,
    204  1.234    dyoung     struct ifaltq *);
    205  1.294     ozaki static void if_slowtimo(void *);
    206  1.300     ozaki static void if_free_sadl(struct ifnet *);
    207  1.302     ozaki static void if_attachdomain1(struct ifnet *);
    208  1.302     ozaki static int ifconf(u_long, void *);
    209  1.345  knakahar static int if_transmit(struct ifnet *, struct mbuf *);
    210  1.302     ozaki static int if_clone_create(const char *);
    211  1.302     ozaki static int if_clone_destroy(const char *);
    212  1.324     ozaki static void if_link_state_change_si(void *);
    213   1.95    itojun 
    214  1.323     ozaki struct if_percpuq {
    215  1.323     ozaki 	struct ifnet	*ipq_ifp;
    216  1.323     ozaki 	void		*ipq_si;
    217  1.323     ozaki 	struct percpu	*ipq_ifqs;	/* struct ifqueue */
    218  1.323     ozaki };
    219  1.323     ozaki 
    220  1.323     ozaki static struct mbuf *if_percpuq_dequeue(struct if_percpuq *);
    221  1.323     ozaki 
    222  1.327  knakahar static void if_percpuq_drops(void *, void *, struct cpu_info *);
    223  1.327  knakahar static int sysctl_percpuq_drops_handler(SYSCTLFN_PROTO);
    224  1.327  knakahar static void sysctl_percpuq_setup(struct sysctllog **, const char *,
    225  1.327  knakahar     struct if_percpuq *);
    226  1.327  knakahar 
    227  1.364     ozaki struct if_deferred_start {
    228  1.364     ozaki 	struct ifnet	*ids_ifp;
    229  1.364     ozaki 	void		(*ids_if_start)(struct ifnet *);
    230  1.364     ozaki 	void		*ids_si;
    231  1.364     ozaki };
    232  1.364     ozaki 
    233  1.364     ozaki static void if_deferred_start_softint(void *);
    234  1.364     ozaki static void if_deferred_start_common(struct ifnet *);
    235  1.364     ozaki static void if_deferred_start_destroy(struct ifnet *);
    236  1.364     ozaki 
    237  1.240    cegger #if defined(INET) || defined(INET6)
    238  1.276     rmind static void sysctl_net_pktq_setup(struct sysctllog **, int);
    239  1.240    cegger #endif
    240  1.237     pooka 
    241  1.370     ozaki static void if_sysctl_setup(struct sysctllog **);
    242  1.370     ozaki 
    243  1.361  pgoyette /*
    244  1.361  pgoyette  * Pointer to stub or real compat_cvtcmd() depending on presence of
    245  1.361  pgoyette  * the compat module
    246  1.361  pgoyette  */
    247  1.361  pgoyette u_long stub_compat_cvtcmd(u_long);
    248  1.361  pgoyette u_long (*vec_compat_cvtcmd)(u_long) = stub_compat_cvtcmd;
    249  1.361  pgoyette 
    250  1.361  pgoyette /* Similarly, pointer to compat_ifioctl() if it is present */
    251  1.361  pgoyette 
    252  1.361  pgoyette int (*vec_compat_ifioctl)(struct socket *, u_long, u_long, void *,
    253  1.361  pgoyette 	struct lwp *) = NULL;
    254  1.361  pgoyette 
    255  1.361  pgoyette /* The stub version of compat_cvtcmd() */
    256  1.361  pgoyette u_long stub_compat_cvtcmd(u_long cmd)
    257  1.361  pgoyette {
    258  1.361  pgoyette 
    259  1.361  pgoyette 	return cmd;
    260  1.361  pgoyette }
    261  1.361  pgoyette 
    262  1.239      elad static int
    263  1.239      elad if_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
    264  1.239      elad     void *arg0, void *arg1, void *arg2, void *arg3)
    265  1.239      elad {
    266  1.239      elad 	int result;
    267  1.239      elad 	enum kauth_network_req req;
    268  1.239      elad 
    269  1.239      elad 	result = KAUTH_RESULT_DEFER;
    270  1.239      elad 	req = (enum kauth_network_req)arg1;
    271  1.239      elad 
    272  1.239      elad 	if (action != KAUTH_NETWORK_INTERFACE)
    273  1.239      elad 		return result;
    274  1.239      elad 
    275  1.239      elad 	if ((req == KAUTH_REQ_NETWORK_INTERFACE_GET) ||
    276  1.239      elad 	    (req == KAUTH_REQ_NETWORK_INTERFACE_SET))
    277  1.239      elad 		result = KAUTH_RESULT_ALLOW;
    278  1.239      elad 
    279  1.239      elad 	return result;
    280  1.239      elad }
    281  1.239      elad 
    282    1.1       cgd /*
    283    1.1       cgd  * Network interface utility routines.
    284    1.1       cgd  *
    285    1.1       cgd  * Routines with ifa_ifwith* names take sockaddr *'s as
    286    1.1       cgd  * parameters.
    287    1.1       cgd  */
    288    1.4    andrew void
    289  1.163   thorpej ifinit(void)
    290    1.1       cgd {
    291  1.370     ozaki 
    292  1.370     ozaki 	if_sysctl_setup(NULL);
    293    1.1       cgd 
    294  1.353  knakahar #if (defined(INET) || defined(INET6)) && !defined(IPSEC)
    295  1.352  knakahar 	encapinit();
    296  1.352  knakahar #endif
    297  1.352  knakahar 
    298  1.239      elad 	if_listener = kauth_listen_scope(KAUTH_SCOPE_NETWORK,
    299  1.239      elad 	    if_listener_cb, NULL);
    300  1.273     pooka 
    301  1.273     pooka 	/* interfaces are available, inform socket code */
    302  1.273     pooka 	ifioctl = doifioctl;
    303  1.227      yamt }
    304  1.227      yamt 
    305  1.227      yamt /*
    306  1.227      yamt  * XXX Initialization before configure().
    307  1.227      yamt  * XXX hack to get pfil_add_hook working in autoconf.
    308  1.227      yamt  */
    309  1.227      yamt void
    310  1.227      yamt ifinit1(void)
    311  1.227      yamt {
    312  1.292  christos 	mutex_init(&if_clone_mtx, MUTEX_DEFAULT, IPL_NONE);
    313  1.357     ozaki 
    314  1.274     rmind 	TAILQ_INIT(&ifnet_list);
    315  1.334     ozaki 	mutex_init(&ifnet_mtx, MUTEX_DEFAULT, IPL_NONE);
    316  1.334     ozaki 	ifnet_psz = pserialize_create();
    317  1.334     ozaki 	ifnet_psref_class = psref_class_create("ifnet", IPL_SOFTNET);
    318  1.357     ozaki 	ifa_psref_class = psref_class_create("ifa", IPL_SOFTNET);
    319  1.334     ozaki 	PSLIST_INIT(&ifnet_pslist);
    320  1.357     ozaki 
    321  1.274     rmind 	if_indexlim = 8;
    322  1.274     rmind 
    323  1.265     rmind 	if_pfil = pfil_head_create(PFIL_TYPE_IFNET, NULL);
    324  1.265     rmind 	KASSERT(if_pfil != NULL);
    325  1.286     ozaki 
    326  1.288     ozaki #if NETHER > 0 || NFDDI > 0 || defined(NETATALK) || NTOKEN > 0 || defined(WLAN)
    327  1.286     ozaki 	etherinit();
    328  1.288     ozaki #endif
    329    1.1       cgd }
    330    1.1       cgd 
    331  1.274     rmind ifnet_t *
    332  1.226  christos if_alloc(u_char type)
    333  1.226  christos {
    334  1.274     rmind 	return kmem_zalloc(sizeof(ifnet_t), KM_SLEEP);
    335  1.226  christos }
    336  1.226  christos 
    337  1.226  christos void
    338  1.274     rmind if_free(ifnet_t *ifp)
    339  1.251    dyoung {
    340  1.274     rmind 	kmem_free(ifp, sizeof(ifnet_t));
    341  1.251    dyoung }
    342  1.251    dyoung 
    343  1.251    dyoung void
    344  1.226  christos if_initname(struct ifnet *ifp, const char *name, int unit)
    345  1.226  christos {
    346  1.226  christos 	(void)snprintf(ifp->if_xname, sizeof(ifp->if_xname),
    347  1.226  christos 	    "%s%d", name, unit);
    348  1.226  christos }
    349  1.226  christos 
    350   1.53   thorpej /*
    351   1.53   thorpej  * Null routines used while an interface is going away.  These routines
    352   1.53   thorpej  * just return an error.
    353   1.53   thorpej  */
    354   1.53   thorpej 
    355   1.53   thorpej int
    356  1.177  christos if_nulloutput(struct ifnet *ifp, struct mbuf *m,
    357  1.331     ozaki     const struct sockaddr *so, const struct rtentry *rt)
    358   1.53   thorpej {
    359   1.53   thorpej 
    360  1.185    dyoung 	return ENXIO;
    361   1.53   thorpej }
    362   1.53   thorpej 
    363   1.53   thorpej void
    364  1.177  christos if_nullinput(struct ifnet *ifp, struct mbuf *m)
    365   1.53   thorpej {
    366   1.53   thorpej 
    367   1.53   thorpej 	/* Nothing. */
    368   1.53   thorpej }
    369   1.53   thorpej 
    370   1.53   thorpej void
    371  1.177  christos if_nullstart(struct ifnet *ifp)
    372   1.53   thorpej {
    373   1.53   thorpej 
    374   1.53   thorpej 	/* Nothing. */
    375   1.53   thorpej }
    376   1.53   thorpej 
    377   1.53   thorpej int
    378  1.332  knakahar if_nulltransmit(struct ifnet *ifp, struct mbuf *m)
    379  1.332  knakahar {
    380  1.332  knakahar 
    381  1.332  knakahar 	return ENXIO;
    382  1.332  knakahar }
    383  1.332  knakahar 
    384  1.332  knakahar int
    385  1.183  christos if_nullioctl(struct ifnet *ifp, u_long cmd, void *data)
    386   1.53   thorpej {
    387   1.53   thorpej 
    388  1.185    dyoung 	return ENXIO;
    389   1.53   thorpej }
    390   1.53   thorpej 
    391   1.53   thorpej int
    392  1.177  christos if_nullinit(struct ifnet *ifp)
    393   1.53   thorpej {
    394   1.53   thorpej 
    395  1.185    dyoung 	return ENXIO;
    396   1.53   thorpej }
    397   1.53   thorpej 
    398   1.53   thorpej void
    399  1.177  christos if_nullstop(struct ifnet *ifp, int disable)
    400   1.75   thorpej {
    401   1.75   thorpej 
    402   1.75   thorpej 	/* Nothing. */
    403   1.75   thorpej }
    404   1.75   thorpej 
    405   1.75   thorpej void
    406  1.295     ozaki if_nullslowtimo(struct ifnet *ifp)
    407   1.53   thorpej {
    408   1.53   thorpej 
    409   1.53   thorpej 	/* Nothing. */
    410   1.53   thorpej }
    411   1.53   thorpej 
    412   1.53   thorpej void
    413  1.177  christos if_nulldrain(struct ifnet *ifp)
    414   1.53   thorpej {
    415   1.53   thorpej 
    416   1.53   thorpej 	/* Nothing. */
    417   1.53   thorpej }
    418   1.53   thorpej 
    419  1.210    dyoung void
    420  1.231    dyoung if_set_sadl(struct ifnet *ifp, const void *lla, u_char addrlen, bool factory)
    421  1.210    dyoung {
    422  1.210    dyoung 	struct ifaddr *ifa;
    423  1.210    dyoung 	struct sockaddr_dl *sdl;
    424  1.210    dyoung 
    425  1.210    dyoung 	ifp->if_addrlen = addrlen;
    426  1.210    dyoung 	if_alloc_sadl(ifp);
    427  1.210    dyoung 	ifa = ifp->if_dl;
    428  1.210    dyoung 	sdl = satosdl(ifa->ifa_addr);
    429  1.210    dyoung 
    430  1.210    dyoung 	(void)sockaddr_dl_setaddr(sdl, sdl->sdl_len, lla, ifp->if_addrlen);
    431  1.231    dyoung 	if (factory) {
    432  1.231    dyoung 		ifp->if_hwdl = ifp->if_dl;
    433  1.291     rmind 		ifaref(ifp->if_hwdl);
    434  1.231    dyoung 	}
    435  1.223    dyoung 	/* TBD routing socket */
    436  1.210    dyoung }
    437  1.210    dyoung 
    438  1.211    dyoung struct ifaddr *
    439  1.211    dyoung if_dl_create(const struct ifnet *ifp, const struct sockaddr_dl **sdlp)
    440  1.211    dyoung {
    441  1.211    dyoung 	unsigned socksize, ifasize;
    442  1.211    dyoung 	int addrlen, namelen;
    443  1.211    dyoung 	struct sockaddr_dl *mask, *sdl;
    444  1.211    dyoung 	struct ifaddr *ifa;
    445  1.211    dyoung 
    446  1.211    dyoung 	namelen = strlen(ifp->if_xname);
    447  1.211    dyoung 	addrlen = ifp->if_addrlen;
    448  1.211    dyoung 	socksize = roundup(sockaddr_dl_measure(namelen, addrlen), sizeof(long));
    449  1.211    dyoung 	ifasize = sizeof(*ifa) + 2 * socksize;
    450  1.211    dyoung 	ifa = (struct ifaddr *)malloc(ifasize, M_IFADDR, M_WAITOK|M_ZERO);
    451  1.211    dyoung 
    452  1.211    dyoung 	sdl = (struct sockaddr_dl *)(ifa + 1);
    453  1.211    dyoung 	mask = (struct sockaddr_dl *)(socksize + (char *)sdl);
    454  1.211    dyoung 
    455  1.211    dyoung 	sockaddr_dl_init(sdl, socksize, ifp->if_index, ifp->if_type,
    456  1.211    dyoung 	    ifp->if_xname, namelen, NULL, addrlen);
    457  1.211    dyoung 	mask->sdl_len = sockaddr_dl_measure(namelen, 0);
    458  1.211    dyoung 	memset(&mask->sdl_data[0], 0xff, namelen);
    459  1.211    dyoung 	ifa->ifa_rtrequest = link_rtrequest;
    460  1.211    dyoung 	ifa->ifa_addr = (struct sockaddr *)sdl;
    461  1.211    dyoung 	ifa->ifa_netmask = (struct sockaddr *)mask;
    462  1.357     ozaki 	ifa_psref_init(ifa);
    463  1.211    dyoung 
    464  1.211    dyoung 	*sdlp = sdl;
    465  1.211    dyoung 
    466  1.211    dyoung 	return ifa;
    467  1.211    dyoung }
    468  1.211    dyoung 
    469  1.223    dyoung static void
    470  1.223    dyoung if_sadl_setrefs(struct ifnet *ifp, struct ifaddr *ifa)
    471  1.223    dyoung {
    472  1.223    dyoung 	const struct sockaddr_dl *sdl;
    473  1.316     ozaki 
    474  1.223    dyoung 	ifp->if_dl = ifa;
    475  1.291     rmind 	ifaref(ifa);
    476  1.223    dyoung 	sdl = satosdl(ifa->ifa_addr);
    477  1.223    dyoung 	ifp->if_sadl = sdl;
    478  1.223    dyoung }
    479  1.223    dyoung 
    480    1.1       cgd /*
    481   1.81   thorpej  * Allocate the link level name for the specified interface.  This
    482   1.81   thorpej  * is an attachment helper.  It must be called after ifp->if_addrlen
    483   1.81   thorpej  * is initialized, which may not be the case when if_attach() is
    484   1.81   thorpej  * called.
    485   1.81   thorpej  */
    486   1.81   thorpej void
    487   1.81   thorpej if_alloc_sadl(struct ifnet *ifp)
    488   1.81   thorpej {
    489   1.81   thorpej 	struct ifaddr *ifa;
    490  1.211    dyoung 	const struct sockaddr_dl *sdl;
    491   1.84   thorpej 
    492   1.84   thorpej 	/*
    493   1.84   thorpej 	 * If the interface already has a link name, release it
    494   1.84   thorpej 	 * now.  This is useful for interfaces that can change
    495   1.84   thorpej 	 * link types, and thus switch link names often.
    496   1.84   thorpej 	 */
    497   1.84   thorpej 	if (ifp->if_sadl != NULL)
    498   1.84   thorpej 		if_free_sadl(ifp);
    499   1.81   thorpej 
    500  1.211    dyoung 	ifa = if_dl_create(ifp, &sdl);
    501  1.195    dyoung 
    502  1.207    dyoung 	ifa_insert(ifp, ifa);
    503  1.223    dyoung 	if_sadl_setrefs(ifp, ifa);
    504  1.223    dyoung }
    505  1.223    dyoung 
    506  1.223    dyoung static void
    507  1.223    dyoung if_deactivate_sadl(struct ifnet *ifp)
    508  1.223    dyoung {
    509  1.223    dyoung 	struct ifaddr *ifa;
    510  1.223    dyoung 
    511  1.223    dyoung 	KASSERT(ifp->if_dl != NULL);
    512  1.223    dyoung 
    513  1.223    dyoung 	ifa = ifp->if_dl;
    514  1.223    dyoung 
    515  1.223    dyoung 	ifp->if_sadl = NULL;
    516  1.223    dyoung 
    517  1.223    dyoung 	ifp->if_dl = NULL;
    518  1.291     rmind 	ifafree(ifa);
    519  1.223    dyoung }
    520  1.223    dyoung 
    521  1.224    dyoung void
    522  1.357     ozaki if_activate_sadl(struct ifnet *ifp, struct ifaddr *ifa0,
    523  1.223    dyoung     const struct sockaddr_dl *sdl)
    524  1.223    dyoung {
    525  1.357     ozaki 	int s, ss;
    526  1.357     ozaki 	struct ifaddr *ifa;
    527  1.357     ozaki 	int bound = curlwp_bind();
    528  1.223    dyoung 
    529  1.223    dyoung 	s = splnet();
    530  1.223    dyoung 
    531  1.223    dyoung 	if_deactivate_sadl(ifp);
    532  1.223    dyoung 
    533  1.357     ozaki 	if_sadl_setrefs(ifp, ifa0);
    534  1.357     ozaki 
    535  1.357     ozaki 	ss = pserialize_read_enter();
    536  1.357     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
    537  1.357     ozaki 		struct psref psref;
    538  1.357     ozaki 		ifa_acquire(ifa, &psref);
    539  1.357     ozaki 		pserialize_read_exit(ss);
    540  1.357     ozaki 
    541  1.231    dyoung 		rtinit(ifa, RTM_LLINFO_UPD, 0);
    542  1.354     ozaki 
    543  1.357     ozaki 		ss = pserialize_read_enter();
    544  1.357     ozaki 		ifa_release(ifa, &psref);
    545  1.357     ozaki 	}
    546  1.357     ozaki 	pserialize_read_exit(ss);
    547  1.357     ozaki 
    548  1.223    dyoung 	splx(s);
    549  1.357     ozaki 	curlwp_bindx(bound);
    550   1.81   thorpej }
    551   1.81   thorpej 
    552   1.81   thorpej /*
    553   1.81   thorpej  * Free the link level name for the specified interface.  This is
    554  1.300     ozaki  * a detach helper.  This is called from if_detach().
    555   1.81   thorpej  */
    556  1.300     ozaki static void
    557   1.81   thorpej if_free_sadl(struct ifnet *ifp)
    558   1.81   thorpej {
    559   1.81   thorpej 	struct ifaddr *ifa;
    560   1.81   thorpej 	int s;
    561   1.81   thorpej 
    562  1.316     ozaki 	ifa = ifp->if_dl;
    563   1.81   thorpej 	if (ifa == NULL) {
    564   1.81   thorpej 		KASSERT(ifp->if_sadl == NULL);
    565   1.81   thorpej 		return;
    566   1.81   thorpej 	}
    567   1.81   thorpej 
    568   1.81   thorpej 	KASSERT(ifp->if_sadl != NULL);
    569   1.81   thorpej 
    570   1.88   thorpej 	s = splnet();
    571   1.81   thorpej 	rtinit(ifa, RTM_DELETE, 0);
    572  1.207    dyoung 	ifa_remove(ifp, ifa);
    573  1.223    dyoung 	if_deactivate_sadl(ifp);
    574  1.231    dyoung 	if (ifp->if_hwdl == ifa) {
    575  1.291     rmind 		ifafree(ifa);
    576  1.231    dyoung 		ifp->if_hwdl = NULL;
    577  1.231    dyoung 	}
    578   1.81   thorpej 	splx(s);
    579   1.81   thorpej }
    580   1.81   thorpej 
    581  1.274     rmind static void
    582  1.274     rmind if_getindex(ifnet_t *ifp)
    583    1.1       cgd {
    584  1.274     rmind 	bool hitlimit = false;
    585  1.231    dyoung 
    586  1.234    dyoung 	ifp->if_index_gen = index_gen++;
    587  1.234    dyoung 
    588  1.102    atatat 	ifp->if_index = if_index;
    589  1.274     rmind 	if (ifindex2ifnet == NULL) {
    590  1.102    atatat 		if_index++;
    591  1.274     rmind 		goto skip;
    592  1.274     rmind 	}
    593  1.274     rmind 	while (if_byindex(ifp->if_index)) {
    594  1.274     rmind 		/*
    595  1.274     rmind 		 * If we hit USHRT_MAX, we skip back to 0 since
    596  1.274     rmind 		 * there are a number of places where the value
    597  1.274     rmind 		 * of if_index or if_index itself is compared
    598  1.274     rmind 		 * to or stored in an unsigned short.  By
    599  1.274     rmind 		 * jumping back, we won't botch those assignments
    600  1.274     rmind 		 * or comparisons.
    601  1.274     rmind 		 */
    602  1.274     rmind 		if (++if_index == 0) {
    603  1.274     rmind 			if_index = 1;
    604  1.274     rmind 		} else if (if_index == USHRT_MAX) {
    605  1.102    atatat 			/*
    606  1.274     rmind 			 * However, if we have to jump back to
    607  1.274     rmind 			 * zero *twice* without finding an empty
    608  1.274     rmind 			 * slot in ifindex2ifnet[], then there
    609  1.274     rmind 			 * there are too many (>65535) interfaces.
    610  1.102    atatat 			 */
    611  1.274     rmind 			if (hitlimit) {
    612  1.274     rmind 				panic("too many interfaces");
    613  1.102    atatat 			}
    614  1.274     rmind 			hitlimit = true;
    615  1.274     rmind 			if_index = 1;
    616  1.102    atatat 		}
    617  1.274     rmind 		ifp->if_index = if_index;
    618  1.274     rmind 	}
    619  1.274     rmind skip:
    620   1.49    itojun 	/*
    621  1.316     ozaki 	 * ifindex2ifnet is indexed by if_index. Since if_index will
    622  1.316     ozaki 	 * grow dynamically, it should grow too.
    623   1.49    itojun 	 */
    624  1.316     ozaki 	if (ifindex2ifnet == NULL || ifp->if_index >= if_indexlim) {
    625  1.131    itojun 		size_t m, n, oldlim;
    626  1.183  christos 		void *q;
    627  1.154     perry 
    628  1.131    itojun 		oldlim = if_indexlim;
    629   1.53   thorpej 		while (ifp->if_index >= if_indexlim)
    630   1.49    itojun 			if_indexlim <<= 1;
    631   1.49    itojun 
    632   1.49    itojun 		/* grow ifindex2ifnet */
    633  1.131    itojun 		m = oldlim * sizeof(struct ifnet *);
    634   1.49    itojun 		n = if_indexlim * sizeof(struct ifnet *);
    635  1.230    dyoung 		q = malloc(n, M_IFADDR, M_WAITOK|M_ZERO);
    636  1.185    dyoung 		if (ifindex2ifnet != NULL) {
    637  1.230    dyoung 			memcpy(q, ifindex2ifnet, m);
    638  1.230    dyoung 			free(ifindex2ifnet, M_IFADDR);
    639   1.49    itojun 		}
    640   1.49    itojun 		ifindex2ifnet = (struct ifnet **)q;
    641    1.1       cgd 	}
    642  1.274     rmind 	ifindex2ifnet[ifp->if_index] = ifp;
    643  1.274     rmind }
    644  1.274     rmind 
    645  1.274     rmind /*
    646  1.307     ozaki  * Initialize an interface and assign an index for it.
    647  1.307     ozaki  *
    648  1.307     ozaki  * It must be called prior to a device specific attach routine
    649  1.307     ozaki  * (e.g., ether_ifattach and ieee80211_ifattach) or if_alloc_sadl,
    650  1.307     ozaki  * and be followed by if_register:
    651  1.307     ozaki  *
    652  1.307     ozaki  *     if_initialize(ifp);
    653  1.307     ozaki  *     ether_ifattach(ifp, enaddr);
    654  1.307     ozaki  *     if_register(ifp);
    655  1.274     rmind  */
    656  1.274     rmind void
    657  1.307     ozaki if_initialize(ifnet_t *ifp)
    658  1.274     rmind {
    659  1.274     rmind 	KASSERT(if_indexlim > 0);
    660  1.274     rmind 	TAILQ_INIT(&ifp->if_addrlist);
    661   1.49    itojun 
    662    1.1       cgd 	/*
    663   1.81   thorpej 	 * Link level name is allocated later by a separate call to
    664   1.81   thorpej 	 * if_alloc_sadl().
    665    1.1       cgd 	 */
    666   1.81   thorpej 
    667   1.40   thorpej 	if (ifp->if_snd.ifq_maxlen == 0)
    668   1.94    itojun 		ifp->if_snd.ifq_maxlen = ifqmaxlen;
    669  1.234    dyoung 
    670   1.42        is 	ifp->if_broadcastaddr = 0; /* reliably crash if used uninitialized */
    671   1.57   thorpej 
    672   1.57   thorpej 	ifp->if_link_state = LINK_STATE_UNKNOWN;
    673  1.325       roy 	ifp->if_link_queue = -1; /* all bits set, see link_state_change() */
    674   1.57   thorpej 
    675   1.89   thorpej 	ifp->if_capenable = 0;
    676   1.97   thorpej 	ifp->if_csum_flags_tx = 0;
    677   1.97   thorpej 	ifp->if_csum_flags_rx = 0;
    678   1.89   thorpej 
    679   1.86   thorpej #ifdef ALTQ
    680   1.86   thorpej 	ifp->if_snd.altq_type = 0;
    681   1.86   thorpej 	ifp->if_snd.altq_disc = NULL;
    682   1.86   thorpej 	ifp->if_snd.altq_flags &= ALTQF_CANTCHANGE;
    683   1.86   thorpej 	ifp->if_snd.altq_tbr  = NULL;
    684   1.86   thorpej 	ifp->if_snd.altq_ifp  = ifp;
    685   1.86   thorpej #endif
    686   1.86   thorpej 
    687  1.358     ozaki 	IFQ_LOCK_INIT(&ifp->if_snd);
    688  1.285     ozaki 
    689  1.265     rmind 	ifp->if_pfil = pfil_head_create(PFIL_TYPE_IFNET, ifp);
    690  1.369  christos 	pfil_run_ifhooks(if_pfil, PFIL_IFNET_ATTACH, ifp);
    691   1.87   thorpej 
    692  1.318     ozaki 	IF_AFDATA_LOCK_INIT(ifp);
    693  1.318     ozaki 
    694  1.347  knakahar 	if (if_is_link_state_changeable(ifp)) {
    695  1.346  knakahar 		ifp->if_link_si = softint_establish(SOFTINT_NET,
    696  1.346  knakahar 		    if_link_state_change_si, ifp);
    697  1.346  knakahar 		if (ifp->if_link_si == NULL)
    698  1.346  knakahar 			panic("%s: softint_establish() failed", __func__);
    699  1.346  knakahar 	}
    700  1.324     ozaki 
    701  1.334     ozaki 	PSLIST_ENTRY_INIT(ifp, if_pslist_entry);
    702  1.354     ozaki 	PSLIST_INIT(&ifp->if_addr_pslist);
    703  1.334     ozaki 	psref_target_init(&ifp->if_psref, ifnet_psref_class);
    704  1.336     ozaki 	ifp->if_ioctl_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
    705  1.334     ozaki 
    706  1.334     ozaki 	IFNET_LOCK();
    707  1.307     ozaki 	if_getindex(ifp);
    708  1.334     ozaki 	IFNET_UNLOCK();
    709  1.307     ozaki }
    710  1.307     ozaki 
    711  1.307     ozaki /*
    712  1.307     ozaki  * Register an interface to the list of "active" interfaces.
    713  1.307     ozaki  */
    714  1.307     ozaki void
    715  1.307     ozaki if_register(ifnet_t *ifp)
    716  1.307     ozaki {
    717  1.336     ozaki 	/*
    718  1.336     ozaki 	 * If the driver has not supplied its own if_ioctl, then
    719  1.336     ozaki 	 * supply the default.
    720  1.336     ozaki 	 */
    721  1.336     ozaki 	if (ifp->if_ioctl == NULL)
    722  1.336     ozaki 		ifp->if_ioctl = ifioctl_common;
    723  1.307     ozaki 
    724  1.307     ozaki 	sysctl_sndq_setup(&ifp->if_sysctl_log, ifp->if_xname, &ifp->if_snd);
    725  1.307     ozaki 
    726  1.152      matt 	if (!STAILQ_EMPTY(&domains))
    727  1.147      tron 		if_attachdomain1(ifp);
    728  1.147      tron 
    729  1.107    itojun 	/* Announce the interface. */
    730  1.107    itojun 	rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
    731  1.296     ozaki 
    732  1.296     ozaki 	if (ifp->if_slowtimo != NULL) {
    733  1.297     ozaki 		ifp->if_slowtimo_ch =
    734  1.297     ozaki 		    kmem_zalloc(sizeof(*ifp->if_slowtimo_ch), KM_SLEEP);
    735  1.297     ozaki 		callout_init(ifp->if_slowtimo_ch, 0);
    736  1.297     ozaki 		callout_setfunc(ifp->if_slowtimo_ch, if_slowtimo, ifp);
    737  1.296     ozaki 		if_slowtimo(ifp);
    738  1.296     ozaki 	}
    739  1.307     ozaki 
    740  1.332  knakahar 	if (ifp->if_transmit == NULL || ifp->if_transmit == if_nulltransmit)
    741  1.332  knakahar 		ifp->if_transmit = if_transmit;
    742  1.332  knakahar 
    743  1.334     ozaki 	IFNET_LOCK();
    744  1.307     ozaki 	TAILQ_INSERT_TAIL(&ifnet_list, ifp, if_list);
    745  1.334     ozaki 	IFNET_WRITER_INSERT_TAIL(ifp);
    746  1.334     ozaki 	IFNET_UNLOCK();
    747  1.307     ozaki }
    748  1.307     ozaki 
    749  1.307     ozaki /*
    750  1.323     ozaki  * The if_percpuq framework
    751  1.323     ozaki  *
    752  1.323     ozaki  * It allows network device drivers to execute the network stack
    753  1.323     ozaki  * in softint (so called softint-based if_input). It utilizes
    754  1.323     ozaki  * softint and percpu ifqueue. It doesn't distribute any packets
    755  1.323     ozaki  * between CPUs, unlike pktqueue(9).
    756  1.323     ozaki  *
    757  1.323     ozaki  * Currently we support two options for device drivers to apply the framework:
    758  1.323     ozaki  * - Use it implicitly with less changes
    759  1.323     ozaki  *   - If you use if_attach in driver's _attach function and if_input in
    760  1.323     ozaki  *     driver's Rx interrupt handler, a packet is queued and a softint handles
    761  1.323     ozaki  *     the packet implicitly
    762  1.323     ozaki  * - Use it explicitly in each driver (recommended)
    763  1.323     ozaki  *   - You can use if_percpuq_* directly in your driver
    764  1.323     ozaki  *   - In this case, you need to allocate struct if_percpuq in driver's softc
    765  1.323     ozaki  *   - See wm(4) as a reference implementation
    766  1.323     ozaki  */
    767  1.323     ozaki 
    768  1.323     ozaki static void
    769  1.323     ozaki if_percpuq_softint(void *arg)
    770  1.323     ozaki {
    771  1.323     ozaki 	struct if_percpuq *ipq = arg;
    772  1.323     ozaki 	struct ifnet *ifp = ipq->ipq_ifp;
    773  1.323     ozaki 	struct mbuf *m;
    774  1.323     ozaki 
    775  1.368     ozaki 	while ((m = if_percpuq_dequeue(ipq)) != NULL) {
    776  1.368     ozaki 		ifp->if_ipackets++;
    777  1.368     ozaki #ifndef NET_MPSAFE
    778  1.368     ozaki 		KERNEL_LOCK(1, NULL);
    779  1.368     ozaki #endif
    780  1.368     ozaki 		bpf_mtap(ifp, m);
    781  1.368     ozaki #ifndef NET_MPSAFE
    782  1.368     ozaki 		KERNEL_UNLOCK_ONE(NULL);
    783  1.368     ozaki #endif
    784  1.368     ozaki 
    785  1.323     ozaki 		ifp->_if_input(ifp, m);
    786  1.368     ozaki 	}
    787  1.323     ozaki }
    788  1.323     ozaki 
    789  1.323     ozaki static void
    790  1.323     ozaki if_percpuq_init_ifq(void *p, void *arg __unused, struct cpu_info *ci __unused)
    791  1.323     ozaki {
    792  1.323     ozaki 	struct ifqueue *const ifq = p;
    793  1.323     ozaki 
    794  1.323     ozaki 	memset(ifq, 0, sizeof(*ifq));
    795  1.323     ozaki 	ifq->ifq_maxlen = IFQ_MAXLEN;
    796  1.323     ozaki }
    797  1.323     ozaki 
    798  1.323     ozaki struct if_percpuq *
    799  1.323     ozaki if_percpuq_create(struct ifnet *ifp)
    800  1.323     ozaki {
    801  1.323     ozaki 	struct if_percpuq *ipq;
    802  1.323     ozaki 
    803  1.323     ozaki 	ipq = kmem_zalloc(sizeof(*ipq), KM_SLEEP);
    804  1.323     ozaki 	if (ipq == NULL)
    805  1.323     ozaki 		panic("kmem_zalloc failed");
    806  1.323     ozaki 
    807  1.323     ozaki 	ipq->ipq_ifp = ifp;
    808  1.323     ozaki 	ipq->ipq_si = softint_establish(SOFTINT_NET|SOFTINT_MPSAFE,
    809  1.323     ozaki 	    if_percpuq_softint, ipq);
    810  1.323     ozaki 	ipq->ipq_ifqs = percpu_alloc(sizeof(struct ifqueue));
    811  1.323     ozaki 	percpu_foreach(ipq->ipq_ifqs, &if_percpuq_init_ifq, NULL);
    812  1.323     ozaki 
    813  1.327  knakahar 	sysctl_percpuq_setup(&ifp->if_sysctl_log, ifp->if_xname, ipq);
    814  1.327  knakahar 
    815  1.323     ozaki 	return ipq;
    816  1.323     ozaki }
    817  1.323     ozaki 
    818  1.323     ozaki static struct mbuf *
    819  1.323     ozaki if_percpuq_dequeue(struct if_percpuq *ipq)
    820  1.323     ozaki {
    821  1.323     ozaki 	struct mbuf *m;
    822  1.323     ozaki 	struct ifqueue *ifq;
    823  1.323     ozaki 	int s;
    824  1.323     ozaki 
    825  1.323     ozaki 	s = splnet();
    826  1.323     ozaki 	ifq = percpu_getref(ipq->ipq_ifqs);
    827  1.323     ozaki 	IF_DEQUEUE(ifq, m);
    828  1.323     ozaki 	percpu_putref(ipq->ipq_ifqs);
    829  1.323     ozaki 	splx(s);
    830  1.323     ozaki 
    831  1.323     ozaki 	return m;
    832  1.323     ozaki }
    833  1.323     ozaki 
    834  1.323     ozaki static void
    835  1.323     ozaki if_percpuq_purge_ifq(void *p, void *arg __unused, struct cpu_info *ci __unused)
    836  1.323     ozaki {
    837  1.323     ozaki 	struct ifqueue *const ifq = p;
    838  1.323     ozaki 
    839  1.323     ozaki 	IF_PURGE(ifq);
    840  1.323     ozaki }
    841  1.323     ozaki 
    842  1.323     ozaki void
    843  1.323     ozaki if_percpuq_destroy(struct if_percpuq *ipq)
    844  1.323     ozaki {
    845  1.323     ozaki 
    846  1.323     ozaki 	/* if_detach may already destroy it */
    847  1.323     ozaki 	if (ipq == NULL)
    848  1.323     ozaki 		return;
    849  1.323     ozaki 
    850  1.323     ozaki 	softint_disestablish(ipq->ipq_si);
    851  1.323     ozaki 	percpu_foreach(ipq->ipq_ifqs, &if_percpuq_purge_ifq, NULL);
    852  1.323     ozaki 	percpu_free(ipq->ipq_ifqs, sizeof(struct ifqueue));
    853  1.363     ozaki 	kmem_free(ipq, sizeof(*ipq));
    854  1.323     ozaki }
    855  1.323     ozaki 
    856  1.323     ozaki void
    857  1.323     ozaki if_percpuq_enqueue(struct if_percpuq *ipq, struct mbuf *m)
    858  1.323     ozaki {
    859  1.323     ozaki 	struct ifqueue *ifq;
    860  1.323     ozaki 	int s;
    861  1.323     ozaki 
    862  1.323     ozaki 	KASSERT(ipq != NULL);
    863  1.323     ozaki 
    864  1.323     ozaki 	s = splnet();
    865  1.323     ozaki 	ifq = percpu_getref(ipq->ipq_ifqs);
    866  1.323     ozaki 	if (IF_QFULL(ifq)) {
    867  1.323     ozaki 		IF_DROP(ifq);
    868  1.326     ozaki 		percpu_putref(ipq->ipq_ifqs);
    869  1.323     ozaki 		m_freem(m);
    870  1.323     ozaki 		goto out;
    871  1.323     ozaki 	}
    872  1.323     ozaki 	IF_ENQUEUE(ifq, m);
    873  1.323     ozaki 	percpu_putref(ipq->ipq_ifqs);
    874  1.323     ozaki 
    875  1.323     ozaki 	softint_schedule(ipq->ipq_si);
    876  1.323     ozaki out:
    877  1.323     ozaki 	splx(s);
    878  1.323     ozaki }
    879  1.323     ozaki 
    880  1.327  knakahar static void
    881  1.327  knakahar if_percpuq_drops(void *p, void *arg, struct cpu_info *ci __unused)
    882  1.327  knakahar {
    883  1.327  knakahar 	struct ifqueue *const ifq = p;
    884  1.327  knakahar 	int *sum = arg;
    885  1.327  knakahar 
    886  1.327  knakahar 	*sum += ifq->ifq_drops;
    887  1.327  knakahar }
    888  1.327  knakahar 
    889  1.327  knakahar static int
    890  1.327  knakahar sysctl_percpuq_drops_handler(SYSCTLFN_ARGS)
    891  1.327  knakahar {
    892  1.327  knakahar 	struct sysctlnode node;
    893  1.327  knakahar 	struct if_percpuq *ipq;
    894  1.327  knakahar 	int sum = 0;
    895  1.327  knakahar 	int error;
    896  1.327  knakahar 
    897  1.327  knakahar 	node = *rnode;
    898  1.327  knakahar 	ipq = node.sysctl_data;
    899  1.327  knakahar 
    900  1.327  knakahar 	percpu_foreach(ipq->ipq_ifqs, if_percpuq_drops, &sum);
    901  1.327  knakahar 
    902  1.327  knakahar 	node.sysctl_data = &sum;
    903  1.327  knakahar 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    904  1.327  knakahar 	if (error != 0 || newp == NULL)
    905  1.327  knakahar 		return error;
    906  1.327  knakahar 
    907  1.327  knakahar 	return 0;
    908  1.327  knakahar }
    909  1.327  knakahar 
    910  1.327  knakahar static void
    911  1.327  knakahar sysctl_percpuq_setup(struct sysctllog **clog, const char* ifname,
    912  1.327  knakahar     struct if_percpuq *ipq)
    913  1.327  knakahar {
    914  1.327  knakahar 	const struct sysctlnode *cnode, *rnode;
    915  1.327  knakahar 
    916  1.327  knakahar 	if (sysctl_createv(clog, 0, NULL, &rnode,
    917  1.327  knakahar 		       CTLFLAG_PERMANENT,
    918  1.327  knakahar 		       CTLTYPE_NODE, "interfaces",
    919  1.327  knakahar 		       SYSCTL_DESCR("Per-interface controls"),
    920  1.327  knakahar 		       NULL, 0, NULL, 0,
    921  1.327  knakahar 		       CTL_NET, CTL_CREATE, CTL_EOL) != 0)
    922  1.327  knakahar 		goto bad;
    923  1.327  knakahar 
    924  1.327  knakahar 	if (sysctl_createv(clog, 0, &rnode, &rnode,
    925  1.327  knakahar 		       CTLFLAG_PERMANENT,
    926  1.327  knakahar 		       CTLTYPE_NODE, ifname,
    927  1.327  knakahar 		       SYSCTL_DESCR("Interface controls"),
    928  1.327  knakahar 		       NULL, 0, NULL, 0,
    929  1.327  knakahar 		       CTL_CREATE, CTL_EOL) != 0)
    930  1.327  knakahar 		goto bad;
    931  1.327  knakahar 
    932  1.327  knakahar 	if (sysctl_createv(clog, 0, &rnode, &rnode,
    933  1.327  knakahar 		       CTLFLAG_PERMANENT,
    934  1.327  knakahar 		       CTLTYPE_NODE, "rcvq",
    935  1.327  knakahar 		       SYSCTL_DESCR("Interface input queue controls"),
    936  1.327  knakahar 		       NULL, 0, NULL, 0,
    937  1.327  knakahar 		       CTL_CREATE, CTL_EOL) != 0)
    938  1.327  knakahar 		goto bad;
    939  1.327  knakahar 
    940  1.327  knakahar #ifdef NOTYET
    941  1.327  knakahar 	/* XXX Should show each per-CPU queue length? */
    942  1.327  knakahar 	if (sysctl_createv(clog, 0, &rnode, &rnode,
    943  1.327  knakahar 		       CTLFLAG_PERMANENT,
    944  1.327  knakahar 		       CTLTYPE_INT, "len",
    945  1.327  knakahar 		       SYSCTL_DESCR("Current input queue length"),
    946  1.327  knakahar 		       sysctl_percpuq_len, 0, NULL, 0,
    947  1.327  knakahar 		       CTL_CREATE, CTL_EOL) != 0)
    948  1.327  knakahar 		goto bad;
    949  1.327  knakahar 
    950  1.327  knakahar 	if (sysctl_createv(clog, 0, &rnode, &cnode,
    951  1.327  knakahar 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
    952  1.327  knakahar 		       CTLTYPE_INT, "maxlen",
    953  1.327  knakahar 		       SYSCTL_DESCR("Maximum allowed input queue length"),
    954  1.327  knakahar 		       sysctl_percpuq_maxlen_handler, 0, (void *)ipq, 0,
    955  1.327  knakahar 		       CTL_CREATE, CTL_EOL) != 0)
    956  1.327  knakahar 		goto bad;
    957  1.327  knakahar #endif
    958  1.327  knakahar 
    959  1.327  knakahar 	if (sysctl_createv(clog, 0, &rnode, &cnode,
    960  1.327  knakahar 		       CTLFLAG_PERMANENT,
    961  1.327  knakahar 		       CTLTYPE_INT, "drops",
    962  1.327  knakahar 		       SYSCTL_DESCR("Total packets dropped due to full input queue"),
    963  1.327  knakahar 		       sysctl_percpuq_drops_handler, 0, (void *)ipq, 0,
    964  1.327  knakahar 		       CTL_CREATE, CTL_EOL) != 0)
    965  1.327  knakahar 		goto bad;
    966  1.327  knakahar 
    967  1.327  knakahar 	return;
    968  1.327  knakahar bad:
    969  1.327  knakahar 	printf("%s: could not attach sysctl nodes\n", ifname);
    970  1.327  knakahar 	return;
    971  1.327  knakahar }
    972  1.327  knakahar 
    973  1.364     ozaki /*
    974  1.364     ozaki  * The deferred if_start framework
    975  1.364     ozaki  *
    976  1.364     ozaki  * The common APIs to defer if_start to softint when if_start is requested
    977  1.364     ozaki  * from a device driver running in hardware interrupt context.
    978  1.364     ozaki  */
    979  1.364     ozaki /*
    980  1.364     ozaki  * Call ifp->if_start (or equivalent) in a dedicated softint for
    981  1.364     ozaki  * deferred if_start.
    982  1.364     ozaki  */
    983  1.364     ozaki static void
    984  1.364     ozaki if_deferred_start_softint(void *arg)
    985  1.364     ozaki {
    986  1.364     ozaki 	struct if_deferred_start *ids = arg;
    987  1.364     ozaki 	struct ifnet *ifp = ids->ids_ifp;
    988  1.364     ozaki 
    989  1.364     ozaki 	ids->ids_if_start(ifp);
    990  1.364     ozaki }
    991  1.364     ozaki 
    992  1.364     ozaki /*
    993  1.364     ozaki  * The default callback function for deferred if_start.
    994  1.364     ozaki  */
    995  1.364     ozaki static void
    996  1.364     ozaki if_deferred_start_common(struct ifnet *ifp)
    997  1.364     ozaki {
    998  1.364     ozaki 
    999  1.364     ozaki 	if_start_lock(ifp);
   1000  1.364     ozaki }
   1001  1.364     ozaki 
   1002  1.364     ozaki static inline bool
   1003  1.364     ozaki if_snd_is_used(struct ifnet *ifp)
   1004  1.364     ozaki {
   1005  1.364     ozaki 
   1006  1.364     ozaki 	return ifp->if_transmit == NULL || ifp->if_transmit == if_nulltransmit ||
   1007  1.364     ozaki 	    ALTQ_IS_ENABLED(&ifp->if_snd);
   1008  1.364     ozaki }
   1009  1.364     ozaki 
   1010  1.364     ozaki /*
   1011  1.364     ozaki  * Schedule deferred if_start.
   1012  1.364     ozaki  */
   1013  1.364     ozaki void
   1014  1.364     ozaki if_schedule_deferred_start(struct ifnet *ifp)
   1015  1.364     ozaki {
   1016  1.364     ozaki 
   1017  1.364     ozaki 	KASSERT(ifp->if_deferred_start != NULL);
   1018  1.364     ozaki 
   1019  1.364     ozaki 	if (if_snd_is_used(ifp) && IFQ_IS_EMPTY(&ifp->if_snd))
   1020  1.364     ozaki 		return;
   1021  1.364     ozaki 
   1022  1.364     ozaki 	softint_schedule(ifp->if_deferred_start->ids_si);
   1023  1.364     ozaki }
   1024  1.364     ozaki 
   1025  1.364     ozaki /*
   1026  1.364     ozaki  * Create an instance of deferred if_start. A driver should call the function
   1027  1.364     ozaki  * only if the driver needs deferred if_start. Drivers can setup their own
   1028  1.364     ozaki  * deferred if_start function via 2nd argument.
   1029  1.364     ozaki  */
   1030  1.364     ozaki void
   1031  1.364     ozaki if_deferred_start_init(struct ifnet *ifp, void (*func)(struct ifnet *))
   1032  1.364     ozaki {
   1033  1.364     ozaki 	struct if_deferred_start *ids;
   1034  1.364     ozaki 
   1035  1.364     ozaki 	ids = kmem_zalloc(sizeof(*ids), KM_SLEEP);
   1036  1.364     ozaki 	if (ids == NULL)
   1037  1.364     ozaki 		panic("kmem_zalloc failed");
   1038  1.364     ozaki 
   1039  1.364     ozaki 	ids->ids_ifp = ifp;
   1040  1.364     ozaki 	ids->ids_si = softint_establish(SOFTINT_NET|SOFTINT_MPSAFE,
   1041  1.364     ozaki 	    if_deferred_start_softint, ids);
   1042  1.364     ozaki 	if (func != NULL)
   1043  1.364     ozaki 		ids->ids_if_start = func;
   1044  1.364     ozaki 	else
   1045  1.364     ozaki 		ids->ids_if_start = if_deferred_start_common;
   1046  1.364     ozaki 
   1047  1.364     ozaki 	ifp->if_deferred_start = ids;
   1048  1.364     ozaki }
   1049  1.364     ozaki 
   1050  1.364     ozaki static void
   1051  1.364     ozaki if_deferred_start_destroy(struct ifnet *ifp)
   1052  1.364     ozaki {
   1053  1.364     ozaki 
   1054  1.364     ozaki 	if (ifp->if_deferred_start == NULL)
   1055  1.364     ozaki 		return;
   1056  1.364     ozaki 
   1057  1.364     ozaki 	softint_disestablish(ifp->if_deferred_start->ids_si);
   1058  1.364     ozaki 	kmem_free(ifp->if_deferred_start, sizeof(*ifp->if_deferred_start));
   1059  1.364     ozaki 	ifp->if_deferred_start = NULL;
   1060  1.364     ozaki }
   1061  1.327  knakahar 
   1062  1.323     ozaki /*
   1063  1.323     ozaki  * The common interface input routine that is called by device drivers,
   1064  1.323     ozaki  * which should be used only when the driver's rx handler already runs
   1065  1.323     ozaki  * in softint.
   1066  1.323     ozaki  */
   1067  1.323     ozaki void
   1068  1.323     ozaki if_input(struct ifnet *ifp, struct mbuf *m)
   1069  1.323     ozaki {
   1070  1.323     ozaki 
   1071  1.323     ozaki 	KASSERT(ifp->if_percpuq == NULL);
   1072  1.323     ozaki 	KASSERT(!cpu_intr_p());
   1073  1.323     ozaki 
   1074  1.368     ozaki 	ifp->if_ipackets++;
   1075  1.368     ozaki #ifndef NET_MPSAFE
   1076  1.368     ozaki 	KERNEL_LOCK(1, NULL);
   1077  1.368     ozaki #endif
   1078  1.368     ozaki 	bpf_mtap(ifp, m);
   1079  1.368     ozaki #ifndef NET_MPSAFE
   1080  1.368     ozaki 	KERNEL_UNLOCK_ONE(NULL);
   1081  1.368     ozaki #endif
   1082  1.368     ozaki 
   1083  1.323     ozaki 	ifp->_if_input(ifp, m);
   1084  1.323     ozaki }
   1085  1.323     ozaki 
   1086  1.323     ozaki /*
   1087  1.323     ozaki  * DEPRECATED. Use if_initialize and if_register instead.
   1088  1.307     ozaki  * See the above comment of if_initialize.
   1089  1.323     ozaki  *
   1090  1.323     ozaki  * Note that it implicitly enables if_percpuq to make drivers easy to
   1091  1.333     skrll  * migrate softint-based if_input without much changes. If you don't
   1092  1.323     ozaki  * want to enable it, use if_initialize instead.
   1093  1.307     ozaki  */
   1094  1.307     ozaki void
   1095  1.307     ozaki if_attach(ifnet_t *ifp)
   1096  1.307     ozaki {
   1097  1.323     ozaki 
   1098  1.307     ozaki 	if_initialize(ifp);
   1099  1.323     ozaki 	ifp->if_percpuq = if_percpuq_create(ifp);
   1100  1.307     ozaki 	if_register(ifp);
   1101  1.107    itojun }
   1102  1.107    itojun 
   1103  1.107    itojun void
   1104  1.163   thorpej if_attachdomain(void)
   1105  1.107    itojun {
   1106  1.107    itojun 	struct ifnet *ifp;
   1107  1.110    itojun 	int s;
   1108  1.339     ozaki 	int bound = curlwp_bind();
   1109  1.107    itojun 
   1110  1.334     ozaki 	s = pserialize_read_enter();
   1111  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   1112  1.334     ozaki 		struct psref psref;
   1113  1.334     ozaki 		psref_acquire(&psref, &ifp->if_psref, ifnet_psref_class);
   1114  1.334     ozaki 		pserialize_read_exit(s);
   1115  1.107    itojun 		if_attachdomain1(ifp);
   1116  1.334     ozaki 		s = pserialize_read_enter();
   1117  1.334     ozaki 		psref_release(&psref, &ifp->if_psref, ifnet_psref_class);
   1118  1.334     ozaki 	}
   1119  1.334     ozaki 	pserialize_read_exit(s);
   1120  1.339     ozaki 	curlwp_bindx(bound);
   1121  1.107    itojun }
   1122  1.107    itojun 
   1123  1.302     ozaki static void
   1124  1.163   thorpej if_attachdomain1(struct ifnet *ifp)
   1125  1.107    itojun {
   1126  1.107    itojun 	struct domain *dp;
   1127  1.109    itojun 	int s;
   1128  1.109    itojun 
   1129  1.109    itojun 	s = splnet();
   1130  1.107    itojun 
   1131  1.106    itojun 	/* address family dependent data region */
   1132  1.106    itojun 	memset(ifp->if_afdata, 0, sizeof(ifp->if_afdata));
   1133  1.152      matt 	DOMAIN_FOREACH(dp) {
   1134  1.185    dyoung 		if (dp->dom_ifattach != NULL)
   1135  1.106    itojun 			ifp->if_afdata[dp->dom_family] =
   1136  1.106    itojun 			    (*dp->dom_ifattach)(ifp);
   1137  1.106    itojun 	}
   1138  1.109    itojun 
   1139  1.109    itojun 	splx(s);
   1140    1.1       cgd }
   1141   1.53   thorpej 
   1142   1.53   thorpej /*
   1143   1.53   thorpej  * Deactivate an interface.  This points all of the procedure
   1144   1.53   thorpej  * handles at error stubs.  May be called from interrupt context.
   1145   1.53   thorpej  */
   1146   1.53   thorpej void
   1147  1.163   thorpej if_deactivate(struct ifnet *ifp)
   1148   1.53   thorpej {
   1149   1.53   thorpej 	int s;
   1150   1.53   thorpej 
   1151   1.88   thorpej 	s = splnet();
   1152   1.53   thorpej 
   1153   1.53   thorpej 	ifp->if_output	 = if_nulloutput;
   1154  1.323     ozaki 	ifp->_if_input	 = if_nullinput;
   1155   1.53   thorpej 	ifp->if_start	 = if_nullstart;
   1156  1.332  knakahar 	ifp->if_transmit = if_nulltransmit;
   1157   1.53   thorpej 	ifp->if_ioctl	 = if_nullioctl;
   1158   1.75   thorpej 	ifp->if_init	 = if_nullinit;
   1159   1.75   thorpej 	ifp->if_stop	 = if_nullstop;
   1160  1.295     ozaki 	ifp->if_slowtimo = if_nullslowtimo;
   1161   1.53   thorpej 	ifp->if_drain	 = if_nulldrain;
   1162   1.53   thorpej 
   1163   1.53   thorpej 	/* No more packets may be enqueued. */
   1164   1.53   thorpej 	ifp->if_snd.ifq_maxlen = 0;
   1165   1.53   thorpej 
   1166   1.53   thorpej 	splx(s);
   1167   1.53   thorpej }
   1168   1.53   thorpej 
   1169  1.348     ozaki bool
   1170  1.367     ozaki if_is_deactivated(const struct ifnet *ifp)
   1171  1.348     ozaki {
   1172  1.348     ozaki 
   1173  1.348     ozaki 	return ifp->if_output == if_nulloutput;
   1174  1.348     ozaki }
   1175  1.348     ozaki 
   1176  1.206    dyoung void
   1177  1.218    dyoung if_purgeaddrs(struct ifnet *ifp, int family, void (*purgeaddr)(struct ifaddr *))
   1178  1.206    dyoung {
   1179  1.289     ozaki 	struct ifaddr *ifa, *nifa;
   1180  1.357     ozaki 	int s;
   1181  1.206    dyoung 
   1182  1.357     ozaki 	s = pserialize_read_enter();
   1183  1.354     ozaki 	for (ifa = IFADDR_READER_FIRST(ifp); ifa; ifa = nifa) {
   1184  1.354     ozaki 		nifa = IFADDR_READER_NEXT(ifa);
   1185  1.206    dyoung 		if (ifa->ifa_addr->sa_family != family)
   1186  1.206    dyoung 			continue;
   1187  1.357     ozaki 		pserialize_read_exit(s);
   1188  1.357     ozaki 
   1189  1.206    dyoung 		(*purgeaddr)(ifa);
   1190  1.357     ozaki 
   1191  1.357     ozaki 		s = pserialize_read_enter();
   1192  1.206    dyoung 	}
   1193  1.357     ozaki 	pserialize_read_exit(s);
   1194  1.206    dyoung }
   1195  1.206    dyoung 
   1196  1.349     ozaki #ifdef IFAREF_DEBUG
   1197  1.349     ozaki static struct ifaddr **ifa_list;
   1198  1.349     ozaki static int ifa_list_size;
   1199  1.349     ozaki 
   1200  1.349     ozaki /* Depends on only one if_attach runs at once */
   1201  1.349     ozaki static void
   1202  1.349     ozaki if_build_ifa_list(struct ifnet *ifp)
   1203  1.349     ozaki {
   1204  1.349     ozaki 	struct ifaddr *ifa;
   1205  1.349     ozaki 	int i;
   1206  1.349     ozaki 
   1207  1.349     ozaki 	KASSERT(ifa_list == NULL);
   1208  1.349     ozaki 	KASSERT(ifa_list_size == 0);
   1209  1.349     ozaki 
   1210  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp)
   1211  1.349     ozaki 		ifa_list_size++;
   1212  1.349     ozaki 
   1213  1.349     ozaki 	ifa_list = kmem_alloc(sizeof(*ifa) * ifa_list_size, KM_SLEEP);
   1214  1.349     ozaki 	if (ifa_list == NULL)
   1215  1.349     ozaki 		return;
   1216  1.349     ozaki 
   1217  1.349     ozaki 	i = 0;
   1218  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
   1219  1.349     ozaki 		ifa_list[i++] = ifa;
   1220  1.349     ozaki 		ifaref(ifa);
   1221  1.349     ozaki 	}
   1222  1.349     ozaki }
   1223  1.349     ozaki 
   1224  1.349     ozaki static void
   1225  1.349     ozaki if_check_and_free_ifa_list(struct ifnet *ifp)
   1226  1.349     ozaki {
   1227  1.349     ozaki 	int i;
   1228  1.349     ozaki 	struct ifaddr *ifa;
   1229  1.349     ozaki 
   1230  1.349     ozaki 	if (ifa_list == NULL)
   1231  1.349     ozaki 		return;
   1232  1.349     ozaki 
   1233  1.349     ozaki 	for (i = 0; i < ifa_list_size; i++) {
   1234  1.349     ozaki 		char buf[64];
   1235  1.349     ozaki 
   1236  1.349     ozaki 		ifa = ifa_list[i];
   1237  1.349     ozaki 		sockaddr_format(ifa->ifa_addr, buf, sizeof(buf));
   1238  1.349     ozaki 		if (ifa->ifa_refcnt > 1) {
   1239  1.349     ozaki 			log(LOG_WARNING,
   1240  1.349     ozaki 			    "ifa(%s) still referenced (refcnt=%d)\n",
   1241  1.349     ozaki 			    buf, ifa->ifa_refcnt - 1);
   1242  1.349     ozaki 		} else
   1243  1.349     ozaki 			log(LOG_DEBUG,
   1244  1.349     ozaki 			    "ifa(%s) not referenced (refcnt=%d)\n",
   1245  1.349     ozaki 			    buf, ifa->ifa_refcnt - 1);
   1246  1.349     ozaki 		ifafree(ifa);
   1247  1.349     ozaki 	}
   1248  1.349     ozaki 
   1249  1.349     ozaki 	kmem_free(ifa_list, sizeof(*ifa) * ifa_list_size);
   1250  1.349     ozaki 	ifa_list = NULL;
   1251  1.349     ozaki 	ifa_list_size = 0;
   1252  1.349     ozaki }
   1253  1.349     ozaki #endif
   1254  1.349     ozaki 
   1255   1.53   thorpej /*
   1256   1.53   thorpej  * Detach an interface from the list of "active" interfaces,
   1257   1.53   thorpej  * freeing any resources as we go along.
   1258   1.53   thorpej  *
   1259   1.53   thorpej  * NOTE: This routine must be called with a valid thread context,
   1260   1.53   thorpej  * as it may block.
   1261   1.53   thorpej  */
   1262   1.53   thorpej void
   1263  1.163   thorpej if_detach(struct ifnet *ifp)
   1264   1.53   thorpej {
   1265   1.56   thorpej 	struct socket so;
   1266  1.178    dyoung 	struct ifaddr *ifa;
   1267   1.53   thorpej #ifdef IFAREF_DEBUG
   1268   1.53   thorpej 	struct ifaddr *last_ifa = NULL;
   1269   1.53   thorpej #endif
   1270   1.56   thorpej 	struct domain *dp;
   1271  1.141      matt 	const struct protosw *pr;
   1272  1.322  riastrad 	int s, i, family, purged;
   1273  1.276     rmind 	uint64_t xc;
   1274   1.53   thorpej 
   1275  1.349     ozaki #ifdef IFAREF_DEBUG
   1276  1.349     ozaki 	if_build_ifa_list(ifp);
   1277  1.349     ozaki #endif
   1278   1.56   thorpej 	/*
   1279   1.56   thorpej 	 * XXX It's kind of lame that we have to have the
   1280   1.56   thorpej 	 * XXX socket structure...
   1281   1.56   thorpej 	 */
   1282   1.56   thorpej 	memset(&so, 0, sizeof(so));
   1283   1.53   thorpej 
   1284   1.88   thorpej 	s = splnet();
   1285   1.53   thorpej 
   1286  1.334     ozaki 	sysctl_teardown(&ifp->if_sysctl_log);
   1287  1.336     ozaki 	mutex_enter(ifp->if_ioctl_lock);
   1288  1.350     ozaki 	if_deactivate(ifp);
   1289  1.336     ozaki 	mutex_exit(ifp->if_ioctl_lock);
   1290  1.334     ozaki 
   1291  1.334     ozaki 	IFNET_LOCK();
   1292  1.319     ozaki 	ifindex2ifnet[ifp->if_index] = NULL;
   1293  1.319     ozaki 	TAILQ_REMOVE(&ifnet_list, ifp, if_list);
   1294  1.334     ozaki 	IFNET_WRITER_REMOVE(ifp);
   1295  1.334     ozaki 	pserialize_perform(ifnet_psz);
   1296  1.334     ozaki 	IFNET_UNLOCK();
   1297  1.334     ozaki 
   1298  1.357     ozaki 	/* Wait for all readers to drain before freeing.  */
   1299  1.357     ozaki 	psref_target_destroy(&ifp->if_psref, ifnet_psref_class);
   1300  1.357     ozaki 	PSLIST_ENTRY_DESTROY(ifp, if_pslist_entry);
   1301  1.357     ozaki 
   1302  1.336     ozaki 	mutex_obj_free(ifp->if_ioctl_lock);
   1303  1.336     ozaki 	ifp->if_ioctl_lock = NULL;
   1304  1.336     ozaki 
   1305  1.350     ozaki 	if (ifp->if_slowtimo != NULL && ifp->if_slowtimo_ch != NULL) {
   1306  1.305    martin 		ifp->if_slowtimo = NULL;
   1307  1.297     ozaki 		callout_halt(ifp->if_slowtimo_ch, NULL);
   1308  1.297     ozaki 		callout_destroy(ifp->if_slowtimo_ch);
   1309  1.297     ozaki 		kmem_free(ifp->if_slowtimo_ch, sizeof(*ifp->if_slowtimo_ch));
   1310  1.296     ozaki 	}
   1311  1.364     ozaki 	if_deferred_start_destroy(ifp);
   1312  1.296     ozaki 
   1313   1.53   thorpej 	/*
   1314   1.53   thorpej 	 * Do an if_down() to give protocols a chance to do something.
   1315   1.53   thorpej 	 */
   1316   1.53   thorpej 	if_down(ifp);
   1317   1.86   thorpej 
   1318   1.86   thorpej #ifdef ALTQ
   1319   1.86   thorpej 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
   1320   1.86   thorpej 		altq_disable(&ifp->if_snd);
   1321   1.86   thorpej 	if (ALTQ_IS_ATTACHED(&ifp->if_snd))
   1322   1.86   thorpej 		altq_detach(&ifp->if_snd);
   1323   1.87   thorpej #endif
   1324   1.87   thorpej 
   1325  1.355  knakahar 	mutex_obj_free(ifp->if_snd.ifq_lock);
   1326  1.285     ozaki 
   1327  1.166  liamjfoy #if NCARP > 0
   1328  1.166  liamjfoy 	/* Remove the interface from any carp group it is a part of.  */
   1329  1.185    dyoung 	if (ifp->if_carp != NULL && ifp->if_type != IFT_CARP)
   1330  1.166  liamjfoy 		carp_ifdetach(ifp);
   1331  1.166  liamjfoy #endif
   1332  1.166  liamjfoy 
   1333   1.53   thorpej 	/*
   1334   1.53   thorpej 	 * Rip all the addresses off the interface.  This should make
   1335   1.53   thorpej 	 * all of the routes go away.
   1336  1.178    dyoung 	 *
   1337  1.178    dyoung 	 * pr_usrreq calls can remove an arbitrary number of ifaddrs
   1338  1.178    dyoung 	 * from the list, including our "cursor", ifa.  For safety,
   1339  1.178    dyoung 	 * and to honor the TAILQ abstraction, I just restart the
   1340  1.178    dyoung 	 * loop after each removal.  Note that the loop will exit
   1341  1.178    dyoung 	 * when all of the remaining ifaddrs belong to the AF_LINK
   1342  1.178    dyoung 	 * family.  I am counting on the historical fact that at
   1343  1.178    dyoung 	 * least one pr_usrreq in each address domain removes at
   1344  1.178    dyoung 	 * least one ifaddr.
   1345   1.53   thorpej 	 */
   1346  1.178    dyoung again:
   1347  1.357     ozaki 	/*
   1348  1.357     ozaki 	 * At this point, no other one tries to remove ifa in the list,
   1349  1.357     ozaki 	 * so we don't need to take a lock or psref.
   1350  1.357     ozaki 	 */
   1351  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
   1352   1.56   thorpej 		family = ifa->ifa_addr->sa_family;
   1353   1.53   thorpej #ifdef IFAREF_DEBUG
   1354   1.53   thorpej 		printf("if_detach: ifaddr %p, family %d, refcnt %d\n",
   1355   1.56   thorpej 		    ifa, family, ifa->ifa_refcnt);
   1356   1.53   thorpej 		if (last_ifa != NULL && ifa == last_ifa)
   1357   1.56   thorpej 			panic("if_detach: loop detected");
   1358   1.53   thorpej 		last_ifa = ifa;
   1359   1.53   thorpej #endif
   1360  1.178    dyoung 		if (family == AF_LINK)
   1361  1.118    itojun 			continue;
   1362  1.118    itojun 		dp = pffinddomain(family);
   1363   1.56   thorpej #ifdef DIAGNOSTIC
   1364  1.118    itojun 		if (dp == NULL)
   1365  1.118    itojun 			panic("if_detach: no domain for AF %d",
   1366  1.118    itojun 			    family);
   1367   1.56   thorpej #endif
   1368  1.160       gdt 		/*
   1369  1.160       gdt 		 * XXX These PURGEIF calls are redundant with the
   1370  1.160       gdt 		 * purge-all-families calls below, but are left in for
   1371  1.160       gdt 		 * now both to make a smaller change, and to avoid
   1372  1.160       gdt 		 * unplanned interactions with clearing of
   1373  1.160       gdt 		 * ifp->if_addrlist.
   1374  1.160       gdt 		 */
   1375  1.118    itojun 		purged = 0;
   1376  1.322  riastrad 		for (pr = dp->dom_protosw;
   1377  1.322  riastrad 		     pr < dp->dom_protoswNPROTOSW; pr++) {
   1378  1.118    itojun 			so.so_proto = pr;
   1379  1.275     rmind 			if (pr->pr_usrreqs) {
   1380  1.290       rtr 				(void) (*pr->pr_usrreqs->pr_purgeif)(&so, ifp);
   1381  1.118    itojun 				purged = 1;
   1382   1.53   thorpej 			}
   1383  1.118    itojun 		}
   1384  1.118    itojun 		if (purged == 0) {
   1385  1.118    itojun 			/*
   1386  1.118    itojun 			 * XXX What's really the best thing to do
   1387  1.135    keihan 			 * XXX here?  --thorpej (at) NetBSD.org
   1388  1.118    itojun 			 */
   1389  1.118    itojun 			printf("if_detach: WARNING: AF %d not purged\n",
   1390  1.118    itojun 			    family);
   1391  1.207    dyoung 			ifa_remove(ifp, ifa);
   1392   1.53   thorpej 		}
   1393  1.178    dyoung 		goto again;
   1394   1.53   thorpej 	}
   1395  1.118    itojun 
   1396  1.118    itojun 	if_free_sadl(ifp);
   1397   1.53   thorpej 
   1398  1.362     ozaki 	/* Delete stray routes from the routing table. */
   1399  1.362     ozaki 	for (i = 0; i <= AF_MAX; i++)
   1400  1.362     ozaki 		rt_delete_matched_entries(i, if_delroute_matcher, ifp);
   1401  1.106    itojun 
   1402  1.152      matt 	DOMAIN_FOREACH(dp) {
   1403  1.185    dyoung 		if (dp->dom_ifdetach != NULL && ifp->if_afdata[dp->dom_family])
   1404  1.260  christos 		{
   1405  1.260  christos 			void *p = ifp->if_afdata[dp->dom_family];
   1406  1.260  christos 			if (p) {
   1407  1.260  christos 				ifp->if_afdata[dp->dom_family] = NULL;
   1408  1.260  christos 				(*dp->dom_ifdetach)(ifp, p);
   1409  1.260  christos 			}
   1410  1.260  christos 		}
   1411  1.160       gdt 
   1412  1.160       gdt 		/*
   1413  1.160       gdt 		 * One would expect multicast memberships (INET and
   1414  1.160       gdt 		 * INET6) on UDP sockets to be purged by the PURGEIF
   1415  1.160       gdt 		 * calls above, but if all addresses were removed from
   1416  1.160       gdt 		 * the interface prior to destruction, the calls will
   1417  1.160       gdt 		 * not be made (e.g. ppp, for which pppd(8) generally
   1418  1.160       gdt 		 * removes addresses before destroying the interface).
   1419  1.160       gdt 		 * Because there is no invariant that multicast
   1420  1.160       gdt 		 * memberships only exist for interfaces with IPv4
   1421  1.160       gdt 		 * addresses, we must call PURGEIF regardless of
   1422  1.160       gdt 		 * addresses.  (Protocols which might store ifnet
   1423  1.160       gdt 		 * pointers are marked with PR_PURGEIF.)
   1424  1.160       gdt 		 */
   1425  1.185    dyoung 		for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
   1426  1.160       gdt 			so.so_proto = pr;
   1427  1.275     rmind 			if (pr->pr_usrreqs && pr->pr_flags & PR_PURGEIF)
   1428  1.290       rtr 				(void)(*pr->pr_usrreqs->pr_purgeif)(&so, ifp);
   1429  1.160       gdt 		}
   1430   1.53   thorpej 	}
   1431   1.57   thorpej 
   1432  1.369  christos 	pfil_run_ifhooks(if_pfil, PFIL_IFNET_DETACH, ifp);
   1433  1.265     rmind 	(void)pfil_head_destroy(ifp->if_pfil);
   1434  1.184    dyoung 
   1435   1.57   thorpej 	/* Announce that the interface is gone. */
   1436   1.57   thorpej 	rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
   1437   1.93    itojun 
   1438  1.320     ozaki 	IF_AFDATA_LOCK_DESTROY(ifp);
   1439  1.320     ozaki 
   1440  1.347  knakahar 	if (if_is_link_state_changeable(ifp)) {
   1441  1.346  knakahar 		softint_disestablish(ifp->if_link_si);
   1442  1.346  knakahar 		ifp->if_link_si = NULL;
   1443  1.346  knakahar 	}
   1444  1.324     ozaki 
   1445   1.95    itojun 	/*
   1446  1.168      matt 	 * remove packets that came from ifp, from software interrupt queues.
   1447   1.95    itojun 	 */
   1448  1.168      matt 	DOMAIN_FOREACH(dp) {
   1449  1.168      matt 		for (i = 0; i < __arraycount(dp->dom_ifqueues); i++) {
   1450  1.260  christos 			struct ifqueue *iq = dp->dom_ifqueues[i];
   1451  1.260  christos 			if (iq == NULL)
   1452  1.168      matt 				break;
   1453  1.260  christos 			dp->dom_ifqueues[i] = NULL;
   1454  1.260  christos 			if_detach_queues(ifp, iq);
   1455  1.168      matt 		}
   1456  1.168      matt 	}
   1457   1.95    itojun 
   1458  1.276     rmind 	/*
   1459  1.276     rmind 	 * IP queues have to be processed separately: net-queue barrier
   1460  1.276     rmind 	 * ensures that the packets are dequeued while a cross-call will
   1461  1.276     rmind 	 * ensure that the interrupts have completed. FIXME: not quite..
   1462  1.276     rmind 	 */
   1463  1.278        he #ifdef INET
   1464  1.276     rmind 	pktq_barrier(ip_pktq);
   1465  1.278        he #endif
   1466  1.281     rmind #ifdef INET6
   1467  1.293     pooka 	if (in6_present)
   1468  1.293     pooka 		pktq_barrier(ip6_pktq);
   1469  1.281     rmind #endif
   1470  1.276     rmind 	xc = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
   1471  1.276     rmind 	xc_wait(xc);
   1472  1.276     rmind 
   1473  1.323     ozaki 	if (ifp->if_percpuq != NULL) {
   1474  1.323     ozaki 		if_percpuq_destroy(ifp->if_percpuq);
   1475  1.323     ozaki 		ifp->if_percpuq = NULL;
   1476  1.323     ozaki 	}
   1477  1.323     ozaki 
   1478   1.53   thorpej 	splx(s);
   1479  1.349     ozaki 
   1480  1.349     ozaki #ifdef IFAREF_DEBUG
   1481  1.349     ozaki 	if_check_and_free_ifa_list(ifp);
   1482  1.349     ozaki #endif
   1483   1.95    itojun }
   1484   1.95    itojun 
   1485   1.95    itojun static void
   1486  1.163   thorpej if_detach_queues(struct ifnet *ifp, struct ifqueue *q)
   1487   1.95    itojun {
   1488   1.95    itojun 	struct mbuf *m, *prev, *next;
   1489   1.95    itojun 
   1490   1.95    itojun 	prev = NULL;
   1491  1.185    dyoung 	for (m = q->ifq_head; m != NULL; m = next) {
   1492  1.274     rmind 		KASSERT((m->m_flags & M_PKTHDR) != 0);
   1493  1.274     rmind 
   1494   1.95    itojun 		next = m->m_nextpkt;
   1495  1.338     ozaki 		if (m->m_pkthdr.rcvif_index != ifp->if_index) {
   1496   1.96    itojun 			prev = m;
   1497   1.95    itojun 			continue;
   1498   1.96    itojun 		}
   1499   1.95    itojun 
   1500  1.185    dyoung 		if (prev != NULL)
   1501   1.95    itojun 			prev->m_nextpkt = m->m_nextpkt;
   1502   1.95    itojun 		else
   1503   1.95    itojun 			q->ifq_head = m->m_nextpkt;
   1504   1.95    itojun 		if (q->ifq_tail == m)
   1505   1.95    itojun 			q->ifq_tail = prev;
   1506   1.95    itojun 		q->ifq_len--;
   1507   1.95    itojun 
   1508   1.95    itojun 		m->m_nextpkt = NULL;
   1509   1.95    itojun 		m_freem(m);
   1510   1.95    itojun 		IF_DROP(q);
   1511   1.95    itojun 	}
   1512   1.53   thorpej }
   1513   1.53   thorpej 
   1514   1.53   thorpej /*
   1515   1.53   thorpej  * Callback for a radix tree walk to delete all references to an
   1516   1.53   thorpej  * ifnet.
   1517   1.53   thorpej  */
   1518  1.163   thorpej static int
   1519  1.362     ozaki if_delroute_matcher(struct rtentry *rt, void *v)
   1520   1.53   thorpej {
   1521   1.55    itojun 	struct ifnet *ifp = (struct ifnet *)v;
   1522   1.53   thorpej 
   1523  1.362     ozaki 	if (rt->rt_ifp == ifp)
   1524  1.362     ozaki 		return 1;
   1525  1.362     ozaki 	else
   1526  1.185    dyoung 		return 0;
   1527   1.53   thorpej }
   1528   1.53   thorpej 
   1529    1.1       cgd /*
   1530   1.63   thorpej  * Create a clone network interface.
   1531   1.63   thorpej  */
   1532  1.302     ozaki static int
   1533  1.163   thorpej if_clone_create(const char *name)
   1534   1.63   thorpej {
   1535   1.63   thorpej 	struct if_clone *ifc;
   1536   1.63   thorpej 	int unit;
   1537  1.336     ozaki 	struct ifnet *ifp;
   1538  1.336     ozaki 	struct psref psref;
   1539   1.63   thorpej 
   1540  1.372     ozaki 	KASSERT(mutex_owned(&if_clone_mtx));
   1541  1.372     ozaki 
   1542   1.63   thorpej 	ifc = if_clone_lookup(name, &unit);
   1543   1.63   thorpej 	if (ifc == NULL)
   1544  1.185    dyoung 		return EINVAL;
   1545   1.63   thorpej 
   1546  1.336     ozaki 	ifp = if_get(name, &psref);
   1547  1.336     ozaki 	if (ifp != NULL) {
   1548  1.336     ozaki 		if_put(ifp, &psref);
   1549  1.185    dyoung 		return EEXIST;
   1550  1.336     ozaki 	}
   1551   1.63   thorpej 
   1552  1.185    dyoung 	return (*ifc->ifc_create)(ifc, unit);
   1553   1.63   thorpej }
   1554   1.63   thorpej 
   1555   1.63   thorpej /*
   1556   1.63   thorpej  * Destroy a clone network interface.
   1557   1.63   thorpej  */
   1558  1.302     ozaki static int
   1559  1.163   thorpej if_clone_destroy(const char *name)
   1560   1.63   thorpej {
   1561   1.63   thorpej 	struct if_clone *ifc;
   1562   1.63   thorpej 	struct ifnet *ifp;
   1563  1.336     ozaki 	struct psref psref;
   1564   1.63   thorpej 
   1565  1.372     ozaki 	KASSERT(mutex_owned(&if_clone_mtx));
   1566  1.372     ozaki 
   1567   1.63   thorpej 	ifc = if_clone_lookup(name, NULL);
   1568   1.63   thorpej 	if (ifc == NULL)
   1569  1.185    dyoung 		return EINVAL;
   1570   1.63   thorpej 
   1571  1.336     ozaki 	if (ifc->ifc_destroy == NULL)
   1572  1.336     ozaki 		return EOPNOTSUPP;
   1573  1.336     ozaki 
   1574  1.336     ozaki 	ifp = if_get(name, &psref);
   1575   1.63   thorpej 	if (ifp == NULL)
   1576  1.185    dyoung 		return ENXIO;
   1577   1.63   thorpej 
   1578  1.336     ozaki 	/* We have to disable ioctls here */
   1579  1.336     ozaki 	mutex_enter(ifp->if_ioctl_lock);
   1580  1.336     ozaki 	ifp->if_ioctl = if_nullioctl;
   1581  1.336     ozaki 	mutex_exit(ifp->if_ioctl_lock);
   1582  1.336     ozaki 
   1583  1.336     ozaki 	/*
   1584  1.336     ozaki 	 * We cannot call ifc_destroy with holding ifp.
   1585  1.336     ozaki 	 * Releasing ifp here is safe thanks to if_clone_mtx.
   1586  1.336     ozaki 	 */
   1587  1.336     ozaki 	if_put(ifp, &psref);
   1588   1.63   thorpej 
   1589  1.185    dyoung 	return (*ifc->ifc_destroy)(ifp);
   1590   1.63   thorpej }
   1591   1.63   thorpej 
   1592   1.63   thorpej /*
   1593   1.63   thorpej  * Look up a network interface cloner.
   1594   1.63   thorpej  */
   1595  1.163   thorpej static struct if_clone *
   1596  1.163   thorpej if_clone_lookup(const char *name, int *unitp)
   1597   1.63   thorpej {
   1598   1.63   thorpej 	struct if_clone *ifc;
   1599   1.63   thorpej 	const char *cp;
   1600  1.262  christos 	char *dp, ifname[IFNAMSIZ + 3];
   1601  1.128    itojun 	int unit;
   1602   1.63   thorpej 
   1603  1.372     ozaki 	KASSERT(mutex_owned(&if_clone_mtx));
   1604  1.372     ozaki 
   1605  1.262  christos 	strcpy(ifname, "if_");
   1606  1.128    itojun 	/* separate interface name from unit */
   1607  1.262  christos 	for (dp = ifname + 3, cp = name; cp - name < IFNAMSIZ &&
   1608  1.262  christos 	    *cp && (*cp < '0' || *cp > '9');)
   1609  1.262  christos 		*dp++ = *cp++;
   1610  1.128    itojun 
   1611  1.128    itojun 	if (cp == name || cp - name == IFNAMSIZ || !*cp)
   1612  1.185    dyoung 		return NULL;	/* No name or unit number */
   1613  1.262  christos 	*dp++ = '\0';
   1614  1.128    itojun 
   1615  1.262  christos again:
   1616  1.128    itojun 	LIST_FOREACH(ifc, &if_cloners, ifc_list) {
   1617  1.262  christos 		if (strcmp(ifname + 3, ifc->ifc_name) == 0)
   1618  1.128    itojun 			break;
   1619   1.63   thorpej 	}
   1620   1.63   thorpej 
   1621  1.262  christos 	if (ifc == NULL) {
   1622  1.262  christos 		if (*ifname == '\0' ||
   1623  1.267  christos 		    module_autoload(ifname, MODULE_CLASS_DRIVER))
   1624  1.262  christos 			return NULL;
   1625  1.262  christos 		*ifname = '\0';
   1626  1.262  christos 		goto again;
   1627  1.262  christos 	}
   1628   1.63   thorpej 
   1629  1.128    itojun 	unit = 0;
   1630  1.129    itojun 	while (cp - name < IFNAMSIZ && *cp) {
   1631  1.245  christos 		if (*cp < '0' || *cp > '9' || unit >= INT_MAX / 10) {
   1632   1.63   thorpej 			/* Bogus unit number. */
   1633  1.185    dyoung 			return NULL;
   1634   1.63   thorpej 		}
   1635  1.128    itojun 		unit = (unit * 10) + (*cp++ - '0');
   1636   1.63   thorpej 	}
   1637   1.63   thorpej 
   1638   1.63   thorpej 	if (unitp != NULL)
   1639  1.128    itojun 		*unitp = unit;
   1640  1.185    dyoung 	return ifc;
   1641   1.63   thorpej }
   1642   1.63   thorpej 
   1643   1.63   thorpej /*
   1644   1.63   thorpej  * Register a network interface cloner.
   1645   1.63   thorpej  */
   1646   1.63   thorpej void
   1647  1.163   thorpej if_clone_attach(struct if_clone *ifc)
   1648   1.63   thorpej {
   1649   1.63   thorpej 
   1650  1.372     ozaki 	mutex_enter(&if_clone_mtx);
   1651   1.63   thorpej 	LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
   1652   1.67   thorpej 	if_cloners_count++;
   1653  1.372     ozaki 	mutex_exit(&if_clone_mtx);
   1654   1.63   thorpej }
   1655   1.63   thorpej 
   1656   1.63   thorpej /*
   1657   1.63   thorpej  * Unregister a network interface cloner.
   1658   1.63   thorpej  */
   1659   1.63   thorpej void
   1660  1.163   thorpej if_clone_detach(struct if_clone *ifc)
   1661   1.63   thorpej {
   1662   1.63   thorpej 
   1663  1.372     ozaki 	KASSERT(mutex_owned(&if_clone_mtx));
   1664   1.63   thorpej 	LIST_REMOVE(ifc, ifc_list);
   1665   1.67   thorpej 	if_cloners_count--;
   1666   1.67   thorpej }
   1667   1.67   thorpej 
   1668   1.67   thorpej /*
   1669   1.67   thorpej  * Provide list of interface cloners to userspace.
   1670   1.67   thorpej  */
   1671  1.315    martin int
   1672  1.315    martin if_clone_list(int buf_count, char *buffer, int *total)
   1673   1.67   thorpej {
   1674   1.67   thorpej 	char outbuf[IFNAMSIZ], *dst;
   1675   1.67   thorpej 	struct if_clone *ifc;
   1676   1.67   thorpej 	int count, error = 0;
   1677   1.67   thorpej 
   1678  1.372     ozaki 	mutex_enter(&if_clone_mtx);
   1679  1.315    martin 	*total = if_cloners_count;
   1680  1.315    martin 	if ((dst = buffer) == NULL) {
   1681   1.67   thorpej 		/* Just asking how many there are. */
   1682  1.372     ozaki 		goto out;
   1683   1.67   thorpej 	}
   1684   1.67   thorpej 
   1685  1.372     ozaki 	if (buf_count < 0) {
   1686  1.372     ozaki 		error = EINVAL;
   1687  1.372     ozaki 		goto out;
   1688  1.372     ozaki 	}
   1689   1.67   thorpej 
   1690  1.315    martin 	count = (if_cloners_count < buf_count) ?
   1691  1.315    martin 	    if_cloners_count : buf_count;
   1692   1.67   thorpej 
   1693   1.67   thorpej 	for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0;
   1694   1.67   thorpej 	     ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) {
   1695  1.175  christos 		(void)strncpy(outbuf, ifc->ifc_name, sizeof(outbuf));
   1696  1.372     ozaki 		if (outbuf[sizeof(outbuf) - 1] != '\0') {
   1697  1.372     ozaki 			error = ENAMETOOLONG;
   1698  1.372     ozaki 			goto out;
   1699  1.372     ozaki 		}
   1700  1.172  christos 		error = copyout(outbuf, dst, sizeof(outbuf));
   1701  1.185    dyoung 		if (error != 0)
   1702   1.67   thorpej 			break;
   1703   1.67   thorpej 	}
   1704   1.67   thorpej 
   1705  1.372     ozaki out:
   1706  1.372     ozaki 	mutex_exit(&if_clone_mtx);
   1707  1.185    dyoung 	return error;
   1708   1.63   thorpej }
   1709   1.63   thorpej 
   1710  1.207    dyoung void
   1711  1.357     ozaki ifa_psref_init(struct ifaddr *ifa)
   1712  1.357     ozaki {
   1713  1.357     ozaki 
   1714  1.357     ozaki 	psref_target_init(&ifa->ifa_psref, ifa_psref_class);
   1715  1.357     ozaki }
   1716  1.357     ozaki 
   1717  1.357     ozaki void
   1718  1.291     rmind ifaref(struct ifaddr *ifa)
   1719  1.291     rmind {
   1720  1.366     ozaki 	KASSERT(!ISSET(ifa->ifa_flags, IFA_DESTROYING));
   1721  1.291     rmind 	ifa->ifa_refcnt++;
   1722  1.291     rmind }
   1723  1.291     rmind 
   1724  1.291     rmind void
   1725  1.291     rmind ifafree(struct ifaddr *ifa)
   1726  1.291     rmind {
   1727  1.291     rmind 	KASSERT(ifa != NULL);
   1728  1.291     rmind 	KASSERT(ifa->ifa_refcnt > 0);
   1729  1.291     rmind 
   1730  1.291     rmind 	if (--ifa->ifa_refcnt == 0) {
   1731  1.291     rmind 		free(ifa, M_IFADDR);
   1732  1.291     rmind 	}
   1733  1.291     rmind }
   1734  1.291     rmind 
   1735  1.366     ozaki bool
   1736  1.366     ozaki ifa_is_destroying(struct ifaddr *ifa)
   1737  1.366     ozaki {
   1738  1.366     ozaki 
   1739  1.366     ozaki 	return ISSET(ifa->ifa_flags, IFA_DESTROYING);
   1740  1.366     ozaki }
   1741  1.366     ozaki 
   1742  1.291     rmind void
   1743  1.207    dyoung ifa_insert(struct ifnet *ifp, struct ifaddr *ifa)
   1744  1.207    dyoung {
   1745  1.357     ozaki 
   1746  1.207    dyoung 	ifa->ifa_ifp = ifp;
   1747  1.357     ozaki 
   1748  1.357     ozaki 	IFNET_LOCK();
   1749  1.208    dyoung 	TAILQ_INSERT_TAIL(&ifp->if_addrlist, ifa, ifa_list);
   1750  1.354     ozaki 	IFADDR_ENTRY_INIT(ifa);
   1751  1.354     ozaki 	IFADDR_WRITER_INSERT_TAIL(ifp, ifa);
   1752  1.357     ozaki 	IFNET_UNLOCK();
   1753  1.357     ozaki 
   1754  1.291     rmind 	ifaref(ifa);
   1755  1.207    dyoung }
   1756  1.207    dyoung 
   1757  1.207    dyoung void
   1758  1.207    dyoung ifa_remove(struct ifnet *ifp, struct ifaddr *ifa)
   1759  1.207    dyoung {
   1760  1.357     ozaki 
   1761  1.207    dyoung 	KASSERT(ifa->ifa_ifp == ifp);
   1762  1.357     ozaki 
   1763  1.357     ozaki 	IFNET_LOCK();
   1764  1.207    dyoung 	TAILQ_REMOVE(&ifp->if_addrlist, ifa, ifa_list);
   1765  1.354     ozaki 	IFADDR_WRITER_REMOVE(ifa);
   1766  1.359     ozaki #ifdef NET_MPSAFE
   1767  1.357     ozaki 	pserialize_perform(ifnet_psz);
   1768  1.357     ozaki #endif
   1769  1.357     ozaki 	IFNET_UNLOCK();
   1770  1.357     ozaki 
   1771  1.359     ozaki #ifdef NET_MPSAFE
   1772  1.357     ozaki 	psref_target_destroy(&ifa->ifa_psref, ifa_psref_class);
   1773  1.357     ozaki #endif
   1774  1.360     ozaki 	IFADDR_ENTRY_DESTROY(ifa);
   1775  1.291     rmind 	ifafree(ifa);
   1776  1.207    dyoung }
   1777  1.207    dyoung 
   1778  1.357     ozaki void
   1779  1.357     ozaki ifa_acquire(struct ifaddr *ifa, struct psref *psref)
   1780  1.357     ozaki {
   1781  1.357     ozaki 
   1782  1.357     ozaki 	psref_acquire(psref, &ifa->ifa_psref, ifa_psref_class);
   1783  1.357     ozaki }
   1784  1.357     ozaki 
   1785  1.357     ozaki void
   1786  1.357     ozaki ifa_release(struct ifaddr *ifa, struct psref *psref)
   1787  1.357     ozaki {
   1788  1.357     ozaki 
   1789  1.357     ozaki 	if (ifa == NULL)
   1790  1.357     ozaki 		return;
   1791  1.357     ozaki 
   1792  1.357     ozaki 	psref_release(psref, &ifa->ifa_psref, ifa_psref_class);
   1793  1.357     ozaki }
   1794  1.357     ozaki 
   1795  1.357     ozaki bool
   1796  1.357     ozaki ifa_held(struct ifaddr *ifa)
   1797  1.357     ozaki {
   1798  1.357     ozaki 
   1799  1.357     ozaki 	return psref_held(&ifa->ifa_psref, ifa_psref_class);
   1800  1.357     ozaki }
   1801  1.357     ozaki 
   1802  1.194    dyoung static inline int
   1803  1.194    dyoung equal(const struct sockaddr *sa1, const struct sockaddr *sa2)
   1804  1.194    dyoung {
   1805  1.194    dyoung 	return sockaddr_cmp(sa1, sa2) == 0;
   1806  1.194    dyoung }
   1807  1.194    dyoung 
   1808   1.63   thorpej /*
   1809    1.1       cgd  * Locate an interface based on a complete address.
   1810    1.1       cgd  */
   1811    1.1       cgd /*ARGSUSED*/
   1812    1.1       cgd struct ifaddr *
   1813  1.163   thorpej ifa_ifwithaddr(const struct sockaddr *addr)
   1814    1.1       cgd {
   1815   1.61  augustss 	struct ifnet *ifp;
   1816   1.61  augustss 	struct ifaddr *ifa;
   1817    1.1       cgd 
   1818  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   1819  1.348     ozaki 		if (if_is_deactivated(ifp))
   1820    1.1       cgd 			continue;
   1821  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   1822   1.53   thorpej 			if (ifa->ifa_addr->sa_family != addr->sa_family)
   1823   1.53   thorpej 				continue;
   1824   1.53   thorpej 			if (equal(addr, ifa->ifa_addr))
   1825  1.185    dyoung 				return ifa;
   1826   1.53   thorpej 			if ((ifp->if_flags & IFF_BROADCAST) &&
   1827   1.53   thorpej 			    ifa->ifa_broadaddr &&
   1828   1.53   thorpej 			    /* IP6 doesn't have broadcast */
   1829   1.53   thorpej 			    ifa->ifa_broadaddr->sa_len != 0 &&
   1830   1.53   thorpej 			    equal(ifa->ifa_broadaddr, addr))
   1831  1.185    dyoung 				return ifa;
   1832   1.53   thorpej 		}
   1833    1.1       cgd 	}
   1834  1.357     ozaki 	return NULL;
   1835  1.357     ozaki }
   1836  1.357     ozaki 
   1837  1.357     ozaki struct ifaddr *
   1838  1.357     ozaki ifa_ifwithaddr_psref(const struct sockaddr *addr, struct psref *psref)
   1839  1.357     ozaki {
   1840  1.357     ozaki 	struct ifaddr *ifa;
   1841  1.357     ozaki 	int s = pserialize_read_enter();
   1842  1.357     ozaki 
   1843  1.357     ozaki 	ifa = ifa_ifwithaddr(addr);
   1844  1.357     ozaki 	if (ifa != NULL)
   1845  1.357     ozaki 		ifa_acquire(ifa, psref);
   1846  1.334     ozaki 	pserialize_read_exit(s);
   1847  1.357     ozaki 
   1848  1.357     ozaki 	return ifa;
   1849    1.1       cgd }
   1850   1.49    itojun 
   1851    1.1       cgd /*
   1852    1.1       cgd  * Locate the point to point interface with a given destination address.
   1853    1.1       cgd  */
   1854    1.1       cgd /*ARGSUSED*/
   1855    1.1       cgd struct ifaddr *
   1856  1.163   thorpej ifa_ifwithdstaddr(const struct sockaddr *addr)
   1857    1.1       cgd {
   1858   1.61  augustss 	struct ifnet *ifp;
   1859   1.61  augustss 	struct ifaddr *ifa;
   1860    1.1       cgd 
   1861  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   1862  1.348     ozaki 		if (if_is_deactivated(ifp))
   1863   1.53   thorpej 			continue;
   1864  1.185    dyoung 		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
   1865  1.185    dyoung 			continue;
   1866  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   1867  1.185    dyoung 			if (ifa->ifa_addr->sa_family != addr->sa_family ||
   1868  1.185    dyoung 			    ifa->ifa_dstaddr == NULL)
   1869  1.185    dyoung 				continue;
   1870  1.185    dyoung 			if (equal(addr, ifa->ifa_dstaddr))
   1871  1.185    dyoung 				return ifa;
   1872   1.53   thorpej 		}
   1873    1.1       cgd 	}
   1874  1.357     ozaki 
   1875  1.357     ozaki 	return NULL;
   1876  1.357     ozaki }
   1877  1.357     ozaki 
   1878  1.357     ozaki struct ifaddr *
   1879  1.357     ozaki ifa_ifwithdstaddr_psref(const struct sockaddr *addr, struct psref *psref)
   1880  1.357     ozaki {
   1881  1.357     ozaki 	struct ifaddr *ifa;
   1882  1.357     ozaki 	int s;
   1883  1.357     ozaki 
   1884  1.357     ozaki 	s = pserialize_read_enter();
   1885  1.357     ozaki 	ifa = ifa_ifwithdstaddr(addr);
   1886  1.357     ozaki 	if (ifa != NULL)
   1887  1.357     ozaki 		ifa_acquire(ifa, psref);
   1888  1.334     ozaki 	pserialize_read_exit(s);
   1889  1.357     ozaki 
   1890  1.357     ozaki 	return ifa;
   1891    1.1       cgd }
   1892    1.1       cgd 
   1893    1.1       cgd /*
   1894    1.1       cgd  * Find an interface on a specific network.  If many, choice
   1895   1.15   mycroft  * is most specific found.
   1896    1.1       cgd  */
   1897    1.1       cgd struct ifaddr *
   1898  1.163   thorpej ifa_ifwithnet(const struct sockaddr *addr)
   1899    1.1       cgd {
   1900   1.61  augustss 	struct ifnet *ifp;
   1901  1.357     ozaki 	struct ifaddr *ifa, *ifa_maybe = NULL;
   1902  1.140      matt 	const struct sockaddr_dl *sdl;
   1903    1.1       cgd 	u_int af = addr->sa_family;
   1904  1.171     pooka 	const char *addr_data = addr->sa_data, *cplim;
   1905    1.1       cgd 
   1906    1.1       cgd 	if (af == AF_LINK) {
   1907  1.195    dyoung 		sdl = satocsdl(addr);
   1908  1.137    itojun 		if (sdl->sdl_index && sdl->sdl_index < if_indexlim &&
   1909  1.137    itojun 		    ifindex2ifnet[sdl->sdl_index] &&
   1910  1.348     ozaki 		    !if_is_deactivated(ifindex2ifnet[sdl->sdl_index])) {
   1911  1.316     ozaki 			return ifindex2ifnet[sdl->sdl_index]->if_dl;
   1912  1.316     ozaki 		}
   1913    1.1       cgd 	}
   1914   1.51    bouyer #ifdef NETATALK
   1915   1.51    bouyer 	if (af == AF_APPLETALK) {
   1916  1.140      matt 		const struct sockaddr_at *sat, *sat2;
   1917  1.158  christos 		sat = (const struct sockaddr_at *)addr;
   1918  1.334     ozaki 		IFNET_READER_FOREACH(ifp) {
   1919  1.348     ozaki 			if (if_is_deactivated(ifp))
   1920   1.53   thorpej 				continue;
   1921  1.158  christos 			ifa = at_ifawithnet((const struct sockaddr_at *)addr, ifp);
   1922   1.62    bouyer 			if (ifa == NULL)
   1923   1.62    bouyer 				continue;
   1924   1.62    bouyer 			sat2 = (struct sockaddr_at *)ifa->ifa_addr;
   1925   1.62    bouyer 			if (sat2->sat_addr.s_net == sat->sat_addr.s_net)
   1926  1.185    dyoung 				return ifa; /* exact match */
   1927   1.62    bouyer 			if (ifa_maybe == NULL) {
   1928  1.112       wiz 				/* else keep the if with the right range */
   1929   1.62    bouyer 				ifa_maybe = ifa;
   1930   1.62    bouyer 			}
   1931   1.51    bouyer 		}
   1932  1.185    dyoung 		return ifa_maybe;
   1933   1.51    bouyer 	}
   1934   1.51    bouyer #endif
   1935  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   1936  1.348     ozaki 		if (if_is_deactivated(ifp))
   1937   1.53   thorpej 			continue;
   1938  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   1939  1.171     pooka 			const char *cp, *cp2, *cp3;
   1940   1.15   mycroft 
   1941   1.15   mycroft 			if (ifa->ifa_addr->sa_family != af ||
   1942  1.185    dyoung 			    ifa->ifa_netmask == NULL)
   1943   1.53   thorpej  next:				continue;
   1944   1.15   mycroft 			cp = addr_data;
   1945   1.15   mycroft 			cp2 = ifa->ifa_addr->sa_data;
   1946   1.15   mycroft 			cp3 = ifa->ifa_netmask->sa_data;
   1947  1.171     pooka 			cplim = (const char *)ifa->ifa_netmask +
   1948   1.53   thorpej 			    ifa->ifa_netmask->sa_len;
   1949   1.53   thorpej 			while (cp3 < cplim) {
   1950   1.53   thorpej 				if ((*cp++ ^ *cp2++) & *cp3++) {
   1951   1.53   thorpej 					/* want to continue for() loop */
   1952   1.32       mrg 					goto next;
   1953   1.53   thorpej 				}
   1954   1.53   thorpej 			}
   1955  1.185    dyoung 			if (ifa_maybe == NULL ||
   1956  1.329     ozaki 			    rt_refines(ifa->ifa_netmask,
   1957  1.329     ozaki 			               ifa_maybe->ifa_netmask))
   1958   1.15   mycroft 				ifa_maybe = ifa;
   1959   1.15   mycroft 		}
   1960   1.53   thorpej 	}
   1961  1.357     ozaki 	return ifa_maybe;
   1962  1.357     ozaki }
   1963  1.357     ozaki 
   1964  1.357     ozaki struct ifaddr *
   1965  1.357     ozaki ifa_ifwithnet_psref(const struct sockaddr *addr, struct psref *psref)
   1966  1.357     ozaki {
   1967  1.357     ozaki 	struct ifaddr *ifa;
   1968  1.357     ozaki 	int s;
   1969  1.357     ozaki 
   1970  1.357     ozaki 	s = pserialize_read_enter();
   1971  1.357     ozaki 	ifa = ifa_ifwithnet(addr);
   1972  1.357     ozaki 	if (ifa != NULL)
   1973  1.357     ozaki 		ifa_acquire(ifa, psref);
   1974  1.334     ozaki 	pserialize_read_exit(s);
   1975  1.357     ozaki 
   1976  1.357     ozaki 	return ifa;
   1977   1.26       mrg }
   1978   1.53   thorpej 
   1979   1.26       mrg /*
   1980   1.26       mrg  * Find the interface of the addresss.
   1981   1.26       mrg  */
   1982   1.26       mrg struct ifaddr *
   1983  1.163   thorpej ifa_ifwithladdr(const struct sockaddr *addr)
   1984   1.26       mrg {
   1985   1.26       mrg 	struct ifaddr *ia;
   1986   1.26       mrg 
   1987   1.53   thorpej 	if ((ia = ifa_ifwithaddr(addr)) || (ia = ifa_ifwithdstaddr(addr)) ||
   1988   1.53   thorpej 	    (ia = ifa_ifwithnet(addr)))
   1989  1.185    dyoung 		return ia;
   1990  1.185    dyoung 	return NULL;
   1991    1.1       cgd }
   1992    1.1       cgd 
   1993  1.357     ozaki struct ifaddr *
   1994  1.357     ozaki ifa_ifwithladdr_psref(const struct sockaddr *addr, struct psref *psref)
   1995  1.357     ozaki {
   1996  1.357     ozaki 	struct ifaddr *ifa;
   1997  1.357     ozaki 	int s;
   1998  1.357     ozaki 
   1999  1.357     ozaki 	s = pserialize_read_enter();
   2000  1.357     ozaki 	ifa = ifa_ifwithladdr(addr);
   2001  1.357     ozaki 	if (ifa != NULL)
   2002  1.357     ozaki 		ifa_acquire(ifa, psref);
   2003  1.357     ozaki 	pserialize_read_exit(s);
   2004  1.357     ozaki 
   2005  1.357     ozaki 	return ifa;
   2006  1.357     ozaki }
   2007  1.357     ozaki 
   2008    1.1       cgd /*
   2009    1.1       cgd  * Find an interface using a specific address family
   2010    1.1       cgd  */
   2011    1.1       cgd struct ifaddr *
   2012  1.163   thorpej ifa_ifwithaf(int af)
   2013    1.1       cgd {
   2014   1.61  augustss 	struct ifnet *ifp;
   2015  1.334     ozaki 	struct ifaddr *ifa = NULL;
   2016  1.334     ozaki 	int s;
   2017    1.1       cgd 
   2018  1.334     ozaki 	s = pserialize_read_enter();
   2019  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   2020  1.348     ozaki 		if (if_is_deactivated(ifp))
   2021   1.53   thorpej 			continue;
   2022  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   2023   1.21   mycroft 			if (ifa->ifa_addr->sa_family == af)
   2024  1.334     ozaki 				goto out;
   2025   1.53   thorpej 		}
   2026   1.53   thorpej 	}
   2027  1.334     ozaki out:
   2028  1.334     ozaki 	pserialize_read_exit(s);
   2029  1.334     ozaki 	return ifa;
   2030    1.1       cgd }
   2031    1.1       cgd 
   2032    1.1       cgd /*
   2033    1.1       cgd  * Find an interface address specific to an interface best matching
   2034    1.1       cgd  * a given address.
   2035    1.1       cgd  */
   2036    1.1       cgd struct ifaddr *
   2037  1.163   thorpej ifaof_ifpforaddr(const struct sockaddr *addr, struct ifnet *ifp)
   2038    1.1       cgd {
   2039   1.61  augustss 	struct ifaddr *ifa;
   2040  1.140      matt 	const char *cp, *cp2, *cp3;
   2041  1.140      matt 	const char *cplim;
   2042    1.1       cgd 	struct ifaddr *ifa_maybe = 0;
   2043    1.1       cgd 	u_int af = addr->sa_family;
   2044    1.1       cgd 
   2045  1.348     ozaki 	if (if_is_deactivated(ifp))
   2046  1.185    dyoung 		return NULL;
   2047   1.53   thorpej 
   2048    1.1       cgd 	if (af >= AF_MAX)
   2049  1.185    dyoung 		return NULL;
   2050   1.53   thorpej 
   2051  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
   2052    1.1       cgd 		if (ifa->ifa_addr->sa_family != af)
   2053    1.1       cgd 			continue;
   2054    1.1       cgd 		ifa_maybe = ifa;
   2055  1.185    dyoung 		if (ifa->ifa_netmask == NULL) {
   2056    1.1       cgd 			if (equal(addr, ifa->ifa_addr) ||
   2057   1.53   thorpej 			    (ifa->ifa_dstaddr &&
   2058   1.53   thorpej 			     equal(addr, ifa->ifa_dstaddr)))
   2059  1.185    dyoung 				return ifa;
   2060    1.1       cgd 			continue;
   2061    1.1       cgd 		}
   2062    1.1       cgd 		cp = addr->sa_data;
   2063    1.1       cgd 		cp2 = ifa->ifa_addr->sa_data;
   2064    1.1       cgd 		cp3 = ifa->ifa_netmask->sa_data;
   2065    1.1       cgd 		cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
   2066   1.53   thorpej 		for (; cp3 < cplim; cp3++) {
   2067    1.1       cgd 			if ((*cp++ ^ *cp2++) & *cp3)
   2068    1.1       cgd 				break;
   2069   1.53   thorpej 		}
   2070    1.1       cgd 		if (cp3 == cplim)
   2071  1.185    dyoung 			return ifa;
   2072    1.1       cgd 	}
   2073  1.185    dyoung 	return ifa_maybe;
   2074    1.1       cgd }
   2075    1.9   mycroft 
   2076  1.357     ozaki struct ifaddr *
   2077  1.357     ozaki ifaof_ifpforaddr_psref(const struct sockaddr *addr, struct ifnet *ifp,
   2078  1.357     ozaki     struct psref *psref)
   2079  1.357     ozaki {
   2080  1.357     ozaki 	struct ifaddr *ifa;
   2081  1.357     ozaki 	int s;
   2082  1.357     ozaki 
   2083  1.357     ozaki 	s = pserialize_read_enter();
   2084  1.357     ozaki 	ifa = ifaof_ifpforaddr(addr, ifp);
   2085  1.357     ozaki 	if (ifa != NULL)
   2086  1.357     ozaki 		ifa_acquire(ifa, psref);
   2087  1.357     ozaki 	pserialize_read_exit(s);
   2088  1.357     ozaki 
   2089  1.357     ozaki 	return ifa;
   2090  1.357     ozaki }
   2091  1.357     ozaki 
   2092    1.1       cgd /*
   2093    1.1       cgd  * Default action when installing a route with a Link Level gateway.
   2094    1.1       cgd  * Lookup an appropriate real ifa to point to.
   2095    1.1       cgd  * This should be moved to /sys/net/link.c eventually.
   2096    1.1       cgd  */
   2097   1.15   mycroft void
   2098  1.228    dyoung link_rtrequest(int cmd, struct rtentry *rt, const struct rt_addrinfo *info)
   2099    1.1       cgd {
   2100   1.61  augustss 	struct ifaddr *ifa;
   2101  1.194    dyoung 	const struct sockaddr *dst;
   2102   1.15   mycroft 	struct ifnet *ifp;
   2103  1.357     ozaki 	struct psref psref;
   2104    1.1       cgd 
   2105  1.225    dyoung 	if (cmd != RTM_ADD || (ifa = rt->rt_ifa) == NULL ||
   2106  1.225    dyoung 	    (ifp = ifa->ifa_ifp) == NULL || (dst = rt_getkey(rt)) == NULL)
   2107    1.1       cgd 		return;
   2108  1.357     ozaki 	if ((ifa = ifaof_ifpforaddr_psref(dst, ifp, &psref)) != NULL) {
   2109  1.176    dyoung 		rt_replace_ifa(rt, ifa);
   2110    1.1       cgd 		if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
   2111   1.82    itojun 			ifa->ifa_rtrequest(cmd, rt, info);
   2112  1.357     ozaki 		ifa_release(ifa, &psref);
   2113    1.1       cgd 	}
   2114    1.1       cgd }
   2115    1.1       cgd 
   2116    1.1       cgd /*
   2117  1.325       roy  * bitmask macros to manage a densely packed link_state change queue.
   2118  1.325       roy  * Because we need to store LINK_STATE_UNKNOWN(0), LINK_STATE_DOWN(1) and
   2119  1.325       roy  * LINK_STATE_UP(2) we need 2 bits for each state change.
   2120  1.325       roy  * As a state change to store is 0, treat all bits set as an unset item.
   2121  1.325       roy  */
   2122  1.325       roy #define LQ_ITEM_BITS		2
   2123  1.325       roy #define LQ_ITEM_MASK		((1 << LQ_ITEM_BITS) - 1)
   2124  1.325       roy #define LQ_MASK(i)		(LQ_ITEM_MASK << (i) * LQ_ITEM_BITS)
   2125  1.325       roy #define LINK_STATE_UNSET	LQ_ITEM_MASK
   2126  1.325       roy #define LQ_ITEM(q, i)		(((q) & LQ_MASK((i))) >> (i) * LQ_ITEM_BITS)
   2127  1.325       roy #define LQ_STORE(q, i, v)						      \
   2128  1.325       roy 	do {								      \
   2129  1.325       roy 		(q) &= ~LQ_MASK((i));					      \
   2130  1.325       roy 		(q) |= (v) << (i) * LQ_ITEM_BITS;			      \
   2131  1.325       roy 	} while (0 /* CONSTCOND */)
   2132  1.325       roy #define LQ_MAX(q)		((sizeof((q)) * NBBY) / LQ_ITEM_BITS)
   2133  1.325       roy #define LQ_POP(q, v)							      \
   2134  1.325       roy 	do {								      \
   2135  1.325       roy 		(v) = LQ_ITEM((q), 0);					      \
   2136  1.325       roy 		(q) >>= LQ_ITEM_BITS;					      \
   2137  1.325       roy 		(q) |= LINK_STATE_UNSET << (LQ_MAX((q)) - 1) * LQ_ITEM_BITS;  \
   2138  1.325       roy 	} while (0 /* CONSTCOND */)
   2139  1.325       roy #define LQ_PUSH(q, v)							      \
   2140  1.325       roy 	do {								      \
   2141  1.325       roy 		(q) >>= LQ_ITEM_BITS;					      \
   2142  1.325       roy 		(q) |= (v) << (LQ_MAX((q)) - 1) * LQ_ITEM_BITS;		      \
   2143  1.325       roy 	} while (0 /* CONSTCOND */)
   2144  1.325       roy #define LQ_FIND_UNSET(q, i)						      \
   2145  1.325       roy 	for ((i) = 0; i < LQ_MAX((q)); (i)++) {				      \
   2146  1.325       roy 		if (LQ_ITEM((q), (i)) == LINK_STATE_UNSET)		      \
   2147  1.325       roy 			break;						      \
   2148  1.325       roy 	}
   2149  1.325       roy /*
   2150  1.325       roy  * Handle a change in the interface link state and
   2151  1.325       roy  * queue notifications.
   2152  1.159    dyoung  */
   2153  1.159    dyoung void
   2154  1.159    dyoung if_link_state_change(struct ifnet *ifp, int link_state)
   2155  1.159    dyoung {
   2156  1.325       roy 	int s, idx;
   2157  1.263       roy 
   2158  1.347  knakahar 	KASSERTMSG(if_is_link_state_changeable(ifp),
   2159  1.346  knakahar 	    "%s: IFEF_NO_LINK_STATE_CHANGE must not be set, but if_extflags=0x%x",
   2160  1.346  knakahar 	    ifp->if_xname, ifp->if_extflags);
   2161  1.346  knakahar 
   2162  1.325       roy 	/* Ensure change is to a valid state */
   2163  1.325       roy 	switch (link_state) {
   2164  1.325       roy 	case LINK_STATE_UNKNOWN:	/* FALLTHROUGH */
   2165  1.325       roy 	case LINK_STATE_DOWN:		/* FALLTHROUGH */
   2166  1.325       roy 	case LINK_STATE_UP:
   2167  1.325       roy 		break;
   2168  1.325       roy 	default:
   2169  1.325       roy #ifdef DEBUG
   2170  1.325       roy 		printf("%s: invalid link state %d\n",
   2171  1.325       roy 		    ifp->if_xname, link_state);
   2172  1.325       roy #endif
   2173  1.185    dyoung 		return;
   2174  1.264       roy 	}
   2175  1.263       roy 
   2176  1.325       roy 	s = splnet();
   2177  1.325       roy 
   2178  1.325       roy 	/* Find the last unset event in the queue. */
   2179  1.325       roy 	LQ_FIND_UNSET(ifp->if_link_queue, idx);
   2180  1.325       roy 
   2181  1.325       roy 	/*
   2182  1.325       roy 	 * Ensure link_state doesn't match the last event in the queue.
   2183  1.325       roy 	 * ifp->if_link_state is not checked and set here because
   2184  1.325       roy 	 * that would present an inconsistent picture to the system.
   2185  1.325       roy 	 */
   2186  1.325       roy 	if (idx != 0 &&
   2187  1.325       roy 	    LQ_ITEM(ifp->if_link_queue, idx - 1) == (uint8_t)link_state)
   2188  1.325       roy 		goto out;
   2189  1.325       roy 
   2190  1.325       roy 	/* Handle queue overflow. */
   2191  1.325       roy 	if (idx == LQ_MAX(ifp->if_link_queue)) {
   2192  1.325       roy 		uint8_t lost;
   2193  1.325       roy 
   2194  1.325       roy 		/*
   2195  1.325       roy 		 * The DOWN state must be protected from being pushed off
   2196  1.325       roy 		 * the queue to ensure that userland will always be
   2197  1.325       roy 		 * in a sane state.
   2198  1.325       roy 		 * Because DOWN is protected, there is no need to protect
   2199  1.325       roy 		 * UNKNOWN.
   2200  1.325       roy 		 * It should be invalid to change from any other state to
   2201  1.325       roy 		 * UNKNOWN anyway ...
   2202  1.325       roy 		 */
   2203  1.325       roy 		lost = LQ_ITEM(ifp->if_link_queue, 0);
   2204  1.325       roy 		LQ_PUSH(ifp->if_link_queue, (uint8_t)link_state);
   2205  1.325       roy 		if (lost == LINK_STATE_DOWN) {
   2206  1.325       roy 			lost = LQ_ITEM(ifp->if_link_queue, 0);
   2207  1.325       roy 			LQ_STORE(ifp->if_link_queue, 0, LINK_STATE_DOWN);
   2208  1.325       roy 		}
   2209  1.325       roy 		printf("%s: lost link state change %s\n",
   2210  1.325       roy 		    ifp->if_xname,
   2211  1.325       roy 		    lost == LINK_STATE_UP ? "UP" :
   2212  1.325       roy 		    lost == LINK_STATE_DOWN ? "DOWN" :
   2213  1.325       roy 		    "UNKNOWN");
   2214  1.325       roy 	} else
   2215  1.325       roy 		LQ_STORE(ifp->if_link_queue, idx, (uint8_t)link_state);
   2216  1.325       roy 
   2217  1.324     ozaki 	softint_schedule(ifp->if_link_si);
   2218  1.324     ozaki 
   2219  1.325       roy out:
   2220  1.324     ozaki 	splx(s);
   2221  1.324     ozaki }
   2222  1.324     ozaki 
   2223  1.325       roy /*
   2224  1.325       roy  * Handle interface link state change notifications.
   2225  1.325       roy  * Must be called at splnet().
   2226  1.325       roy  */
   2227  1.324     ozaki static void
   2228  1.325       roy if_link_state_change0(struct ifnet *ifp, int link_state)
   2229  1.324     ozaki {
   2230  1.324     ozaki 	struct domain *dp;
   2231  1.324     ozaki 
   2232  1.325       roy 	/* Ensure the change is still valid. */
   2233  1.325       roy 	if (ifp->if_link_state == link_state)
   2234  1.325       roy 		return;
   2235  1.324     ozaki 
   2236  1.263       roy #ifdef DEBUG
   2237  1.263       roy 	log(LOG_DEBUG, "%s: link state %s (was %s)\n", ifp->if_xname,
   2238  1.263       roy 		link_state == LINK_STATE_UP ? "UP" :
   2239  1.263       roy 		link_state == LINK_STATE_DOWN ? "DOWN" :
   2240  1.263       roy 		"UNKNOWN",
   2241  1.325       roy 		ifp->if_link_state == LINK_STATE_UP ? "UP" :
   2242  1.325       roy 		ifp->if_link_state == LINK_STATE_DOWN ? "DOWN" :
   2243  1.263       roy 		"UNKNOWN");
   2244  1.263       roy #endif
   2245  1.263       roy 
   2246  1.263       roy 	/*
   2247  1.263       roy 	 * When going from UNKNOWN to UP, we need to mark existing
   2248  1.314       roy 	 * addresses as tentative and restart DAD as we may have
   2249  1.263       roy 	 * erroneously not found a duplicate.
   2250  1.263       roy 	 *
   2251  1.263       roy 	 * This needs to happen before rt_ifmsg to avoid a race where
   2252  1.263       roy 	 * listeners would have an address and expect it to work right
   2253  1.263       roy 	 * away.
   2254  1.263       roy 	 */
   2255  1.312       roy 	if (link_state == LINK_STATE_UP &&
   2256  1.325       roy 	    ifp->if_link_state == LINK_STATE_UNKNOWN)
   2257  1.312       roy 	{
   2258  1.312       roy 		DOMAIN_FOREACH(dp) {
   2259  1.312       roy 			if (dp->dom_if_link_state_change != NULL)
   2260  1.312       roy 				dp->dom_if_link_state_change(ifp,
   2261  1.312       roy 				    LINK_STATE_DOWN);
   2262  1.312       roy 		}
   2263  1.312       roy 	}
   2264  1.263       roy 
   2265  1.325       roy 	ifp->if_link_state = link_state;
   2266  1.325       roy 
   2267  1.159    dyoung 	/* Notify that the link state has changed. */
   2268  1.185    dyoung 	rt_ifmsg(ifp);
   2269  1.263       roy 
   2270  1.166  liamjfoy #if NCARP > 0
   2271  1.185    dyoung 	if (ifp->if_carp)
   2272  1.185    dyoung 		carp_carpdev_state(ifp);
   2273  1.166  liamjfoy #endif
   2274  1.263       roy 
   2275  1.312       roy 	DOMAIN_FOREACH(dp) {
   2276  1.312       roy 		if (dp->dom_if_link_state_change != NULL)
   2277  1.312       roy 			dp->dom_if_link_state_change(ifp, link_state);
   2278  1.270     pooka 	}
   2279  1.325       roy }
   2280  1.325       roy 
   2281  1.325       roy /*
   2282  1.325       roy  * Process the interface link state change queue.
   2283  1.325       roy  */
   2284  1.325       roy static void
   2285  1.325       roy if_link_state_change_si(void *arg)
   2286  1.325       roy {
   2287  1.325       roy 	struct ifnet *ifp = arg;
   2288  1.325       roy 	int s;
   2289  1.325       roy 	uint8_t state;
   2290  1.325       roy 
   2291  1.371     ozaki #ifndef NET_MPSAFE
   2292  1.371     ozaki 	mutex_enter(softnet_lock);
   2293  1.371     ozaki 	KERNEL_LOCK(1, NULL);
   2294  1.371     ozaki #endif
   2295  1.325       roy 	s = splnet();
   2296  1.325       roy 
   2297  1.325       roy 	/* Pop a link state change from the queue and process it. */
   2298  1.325       roy 	LQ_POP(ifp->if_link_queue, state);
   2299  1.325       roy 	if_link_state_change0(ifp, state);
   2300  1.325       roy 
   2301  1.325       roy 	/* If there is a link state change to come, schedule it. */
   2302  1.325       roy 	if (LQ_ITEM(ifp->if_link_queue, 0) != LINK_STATE_UNSET)
   2303  1.325       roy 		softint_schedule(ifp->if_link_si);
   2304  1.264       roy 
   2305  1.264       roy 	splx(s);
   2306  1.371     ozaki #ifndef NET_MPSAFE
   2307  1.371     ozaki 	KERNEL_UNLOCK_ONE(NULL);
   2308  1.371     ozaki 	mutex_exit(softnet_lock);
   2309  1.371     ozaki #endif
   2310  1.159    dyoung }
   2311  1.159    dyoung 
   2312  1.159    dyoung /*
   2313  1.310       roy  * Default action when installing a local route on a point-to-point
   2314  1.310       roy  * interface.
   2315  1.310       roy  */
   2316  1.310       roy void
   2317  1.310       roy p2p_rtrequest(int req, struct rtentry *rt,
   2318  1.310       roy     __unused const struct rt_addrinfo *info)
   2319  1.310       roy {
   2320  1.310       roy 	struct ifnet *ifp = rt->rt_ifp;
   2321  1.310       roy 	struct ifaddr *ifa, *lo0ifa;
   2322  1.357     ozaki 	int s = pserialize_read_enter();
   2323  1.310       roy 
   2324  1.310       roy 	switch (req) {
   2325  1.310       roy 	case RTM_ADD:
   2326  1.310       roy 		if ((rt->rt_flags & RTF_LOCAL) == 0)
   2327  1.310       roy 			break;
   2328  1.310       roy 
   2329  1.351     ozaki 		rt->rt_ifp = lo0ifp;
   2330  1.351     ozaki 
   2331  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   2332  1.310       roy 			if (equal(rt_getkey(rt), ifa->ifa_addr))
   2333  1.310       roy 				break;
   2334  1.310       roy 		}
   2335  1.310       roy 		if (ifa == NULL)
   2336  1.310       roy 			break;
   2337  1.310       roy 
   2338  1.310       roy 		/*
   2339  1.310       roy 		 * Ensure lo0 has an address of the same family.
   2340  1.310       roy 		 */
   2341  1.354     ozaki 		IFADDR_READER_FOREACH(lo0ifa, lo0ifp) {
   2342  1.310       roy 			if (lo0ifa->ifa_addr->sa_family ==
   2343  1.310       roy 			    ifa->ifa_addr->sa_family)
   2344  1.310       roy 				break;
   2345  1.310       roy 		}
   2346  1.310       roy 		if (lo0ifa == NULL)
   2347  1.310       roy 			break;
   2348  1.310       roy 
   2349  1.310       roy 		/*
   2350  1.310       roy 		 * Make sure to set rt->rt_ifa to the interface
   2351  1.310       roy 		 * address we are using, otherwise we will have trouble
   2352  1.310       roy 		 * with source address selection.
   2353  1.310       roy 		 */
   2354  1.310       roy 		if (ifa != rt->rt_ifa)
   2355  1.310       roy 			rt_replace_ifa(rt, ifa);
   2356  1.310       roy 		break;
   2357  1.310       roy 	case RTM_DELETE:
   2358  1.310       roy 	default:
   2359  1.310       roy 		break;
   2360  1.310       roy 	}
   2361  1.357     ozaki 	pserialize_read_exit(s);
   2362  1.310       roy }
   2363  1.310       roy 
   2364  1.310       roy /*
   2365    1.1       cgd  * Mark an interface down and notify protocols of
   2366    1.1       cgd  * the transition.
   2367   1.23   mycroft  * NOTE: must be called at splsoftnet or equivalent.
   2368    1.1       cgd  */
   2369   1.15   mycroft void
   2370  1.163   thorpej if_down(struct ifnet *ifp)
   2371    1.1       cgd {
   2372   1.61  augustss 	struct ifaddr *ifa;
   2373  1.312       roy 	struct domain *dp;
   2374  1.357     ozaki 	int s, bound;
   2375  1.357     ozaki 	struct psref psref;
   2376    1.1       cgd 
   2377    1.1       cgd 	ifp->if_flags &= ~IFF_UP;
   2378  1.232  christos 	nanotime(&ifp->if_lastchange);
   2379  1.357     ozaki 
   2380  1.357     ozaki 	bound = curlwp_bind();
   2381  1.357     ozaki 	s = pserialize_read_enter();
   2382  1.357     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
   2383  1.357     ozaki 		ifa_acquire(ifa, &psref);
   2384  1.357     ozaki 		pserialize_read_exit(s);
   2385  1.357     ozaki 
   2386    1.1       cgd 		pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
   2387  1.357     ozaki 
   2388  1.357     ozaki 		s = pserialize_read_enter();
   2389  1.357     ozaki 		ifa_release(ifa, &psref);
   2390  1.357     ozaki 	}
   2391  1.357     ozaki 	pserialize_read_exit(s);
   2392  1.357     ozaki 	curlwp_bindx(bound);
   2393  1.357     ozaki 
   2394   1.78   thorpej 	IFQ_PURGE(&ifp->if_snd);
   2395  1.166  liamjfoy #if NCARP > 0
   2396  1.166  liamjfoy 	if (ifp->if_carp)
   2397  1.166  liamjfoy 		carp_carpdev_state(ifp);
   2398  1.166  liamjfoy #endif
   2399   1.15   mycroft 	rt_ifmsg(ifp);
   2400  1.312       roy 	DOMAIN_FOREACH(dp) {
   2401  1.312       roy 		if (dp->dom_if_down)
   2402  1.312       roy 			dp->dom_if_down(ifp);
   2403  1.312       roy 	}
   2404   1.15   mycroft }
   2405   1.15   mycroft 
   2406   1.15   mycroft /*
   2407   1.15   mycroft  * Mark an interface up and notify protocols of
   2408   1.15   mycroft  * the transition.
   2409   1.23   mycroft  * NOTE: must be called at splsoftnet or equivalent.
   2410   1.15   mycroft  */
   2411   1.15   mycroft void
   2412  1.163   thorpej if_up(struct ifnet *ifp)
   2413   1.15   mycroft {
   2414   1.24  christos #ifdef notyet
   2415   1.61  augustss 	struct ifaddr *ifa;
   2416   1.24  christos #endif
   2417  1.312       roy 	struct domain *dp;
   2418   1.15   mycroft 
   2419   1.15   mycroft 	ifp->if_flags |= IFF_UP;
   2420  1.232  christos 	nanotime(&ifp->if_lastchange);
   2421   1.15   mycroft #ifdef notyet
   2422   1.15   mycroft 	/* this has no effect on IP, and will kill all ISO connections XXX */
   2423  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp)
   2424   1.15   mycroft 		pfctlinput(PRC_IFUP, ifa->ifa_addr);
   2425   1.15   mycroft #endif
   2426  1.166  liamjfoy #if NCARP > 0
   2427  1.166  liamjfoy 	if (ifp->if_carp)
   2428  1.166  liamjfoy 		carp_carpdev_state(ifp);
   2429  1.166  liamjfoy #endif
   2430   1.15   mycroft 	rt_ifmsg(ifp);
   2431  1.312       roy 	DOMAIN_FOREACH(dp) {
   2432  1.313       roy 		if (dp->dom_if_up)
   2433  1.313       roy 			dp->dom_if_up(ifp);
   2434  1.312       roy 	}
   2435    1.1       cgd }
   2436    1.1       cgd 
   2437    1.1       cgd /*
   2438  1.296     ozaki  * Handle interface slowtimo timer routine.  Called
   2439  1.296     ozaki  * from softclock, we decrement timer (if set) and
   2440    1.1       cgd  * call the appropriate interface routine on expiration.
   2441    1.1       cgd  */
   2442  1.294     ozaki static void
   2443  1.177  christos if_slowtimo(void *arg)
   2444    1.1       cgd {
   2445  1.306    martin 	void (*slowtimo)(struct ifnet *);
   2446  1.296     ozaki 	struct ifnet *ifp = arg;
   2447  1.305    martin 	int s;
   2448    1.1       cgd 
   2449  1.306    martin 	slowtimo = ifp->if_slowtimo;
   2450  1.306    martin 	if (__predict_false(slowtimo == NULL))
   2451  1.305    martin 		return;
   2452  1.296     ozaki 
   2453  1.305    martin 	s = splnet();
   2454  1.296     ozaki 	if (ifp->if_timer != 0 && --ifp->if_timer == 0)
   2455  1.306    martin 		(*slowtimo)(ifp);
   2456  1.296     ozaki 
   2457    1.1       cgd 	splx(s);
   2458  1.305    martin 
   2459  1.305    martin 	if (__predict_true(ifp->if_slowtimo != NULL))
   2460  1.305    martin 		callout_schedule(ifp->if_slowtimo_ch, hz / IFNET_SLOWHZ);
   2461   1.65   thorpej }
   2462   1.65   thorpej 
   2463   1.65   thorpej /*
   2464   1.65   thorpej  * Set/clear promiscuous mode on interface ifp based on the truth value
   2465   1.65   thorpej  * of pswitch.  The calls are reference counted so that only the first
   2466   1.65   thorpej  * "on" request actually has an effect, as does the final "off" request.
   2467   1.65   thorpej  * Results are undefined if the "off" and "on" requests are not matched.
   2468   1.65   thorpej  */
   2469   1.65   thorpej int
   2470  1.163   thorpej ifpromisc(struct ifnet *ifp, int pswitch)
   2471   1.65   thorpej {
   2472   1.65   thorpej 	int pcount, ret;
   2473  1.259    dyoung 	short nflags;
   2474   1.65   thorpej 
   2475   1.65   thorpej 	pcount = ifp->if_pcount;
   2476   1.65   thorpej 	if (pswitch) {
   2477   1.65   thorpej 		/*
   2478   1.71   thorpej 		 * Allow the device to be "placed" into promiscuous
   2479   1.71   thorpej 		 * mode even if it is not configured up.  It will
   2480  1.242   mbalmer 		 * consult IFF_PROMISC when it is brought up.
   2481   1.65   thorpej 		 */
   2482   1.68        pk 		if (ifp->if_pcount++ != 0)
   2483  1.185    dyoung 			return 0;
   2484  1.252    dyoung 		nflags = ifp->if_flags | IFF_PROMISC;
   2485   1.65   thorpej 	} else {
   2486   1.65   thorpej 		if (--ifp->if_pcount > 0)
   2487  1.185    dyoung 			return 0;
   2488  1.252    dyoung 		nflags = ifp->if_flags & ~IFF_PROMISC;
   2489   1.65   thorpej 	}
   2490  1.252    dyoung 	ret = if_flags_set(ifp, nflags);
   2491   1.65   thorpej 	/* Restore interface state if not successful. */
   2492   1.65   thorpej 	if (ret != 0) {
   2493   1.65   thorpej 		ifp->if_pcount = pcount;
   2494   1.65   thorpej 	}
   2495  1.185    dyoung 	return ret;
   2496    1.1       cgd }
   2497    1.1       cgd 
   2498    1.1       cgd /*
   2499    1.1       cgd  * Map interface name to
   2500    1.1       cgd  * interface structure pointer.
   2501    1.1       cgd  */
   2502    1.1       cgd struct ifnet *
   2503  1.163   thorpej ifunit(const char *name)
   2504    1.1       cgd {
   2505   1.61  augustss 	struct ifnet *ifp;
   2506  1.105      matt 	const char *cp = name;
   2507  1.105      matt 	u_int unit = 0;
   2508  1.105      matt 	u_int i;
   2509  1.334     ozaki 	int s;
   2510  1.105      matt 
   2511  1.105      matt 	/*
   2512  1.105      matt 	 * If the entire name is a number, treat it as an ifindex.
   2513  1.105      matt 	 */
   2514  1.105      matt 	for (i = 0; i < IFNAMSIZ && *cp >= '0' && *cp <= '9'; i++, cp++) {
   2515  1.105      matt 		unit = unit * 10 + (*cp - '0');
   2516  1.105      matt 	}
   2517  1.105      matt 
   2518  1.105      matt 	/*
   2519  1.105      matt 	 * If the number took all of the name, then it's a valid ifindex.
   2520  1.105      matt 	 */
   2521  1.105      matt 	if (i == IFNAMSIZ || (cp != name && *cp == '\0')) {
   2522  1.137    itojun 		if (unit >= if_indexlim)
   2523  1.185    dyoung 			return NULL;
   2524  1.105      matt 		ifp = ifindex2ifnet[unit];
   2525  1.348     ozaki 		if (ifp == NULL || if_is_deactivated(ifp))
   2526  1.185    dyoung 			return NULL;
   2527  1.185    dyoung 		return ifp;
   2528  1.105      matt 	}
   2529   1.34   thorpej 
   2530  1.334     ozaki 	ifp = NULL;
   2531  1.334     ozaki 	s = pserialize_read_enter();
   2532  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   2533  1.348     ozaki 		if (if_is_deactivated(ifp))
   2534   1.53   thorpej 			continue;
   2535   1.53   thorpej 	 	if (strcmp(ifp->if_xname, name) == 0)
   2536  1.334     ozaki 			goto out;
   2537   1.53   thorpej 	}
   2538  1.334     ozaki out:
   2539  1.334     ozaki 	pserialize_read_exit(s);
   2540  1.334     ozaki 	return ifp;
   2541    1.1       cgd }
   2542   1.49    itojun 
   2543  1.335     ozaki /*
   2544  1.335     ozaki  * Get a reference of an ifnet object by an interface name.
   2545  1.335     ozaki  * The returned reference is protected by psref(9). The caller
   2546  1.335     ozaki  * must release a returned reference by if_put after use.
   2547  1.335     ozaki  */
   2548  1.335     ozaki struct ifnet *
   2549  1.335     ozaki if_get(const char *name, struct psref *psref)
   2550  1.335     ozaki {
   2551  1.335     ozaki 	struct ifnet *ifp;
   2552  1.335     ozaki 	const char *cp = name;
   2553  1.335     ozaki 	u_int unit = 0;
   2554  1.335     ozaki 	u_int i;
   2555  1.335     ozaki 	int s;
   2556  1.335     ozaki 
   2557  1.335     ozaki 	/*
   2558  1.335     ozaki 	 * If the entire name is a number, treat it as an ifindex.
   2559  1.335     ozaki 	 */
   2560  1.335     ozaki 	for (i = 0; i < IFNAMSIZ && *cp >= '0' && *cp <= '9'; i++, cp++) {
   2561  1.335     ozaki 		unit = unit * 10 + (*cp - '0');
   2562  1.335     ozaki 	}
   2563  1.335     ozaki 
   2564  1.335     ozaki 	/*
   2565  1.335     ozaki 	 * If the number took all of the name, then it's a valid ifindex.
   2566  1.335     ozaki 	 */
   2567  1.335     ozaki 	if (i == IFNAMSIZ || (cp != name && *cp == '\0')) {
   2568  1.335     ozaki 		if (unit >= if_indexlim)
   2569  1.335     ozaki 			return NULL;
   2570  1.335     ozaki 		ifp = ifindex2ifnet[unit];
   2571  1.348     ozaki 		if (ifp == NULL || if_is_deactivated(ifp))
   2572  1.335     ozaki 			return NULL;
   2573  1.335     ozaki 		return ifp;
   2574  1.335     ozaki 	}
   2575  1.335     ozaki 
   2576  1.335     ozaki 	ifp = NULL;
   2577  1.335     ozaki 	s = pserialize_read_enter();
   2578  1.335     ozaki 	IFNET_READER_FOREACH(ifp) {
   2579  1.348     ozaki 		if (if_is_deactivated(ifp))
   2580  1.335     ozaki 			continue;
   2581  1.335     ozaki 		if (strcmp(ifp->if_xname, name) == 0) {
   2582  1.335     ozaki 			psref_acquire(psref, &ifp->if_psref,
   2583  1.335     ozaki 			    ifnet_psref_class);
   2584  1.335     ozaki 			goto out;
   2585  1.335     ozaki 		}
   2586  1.335     ozaki 	}
   2587  1.335     ozaki out:
   2588  1.335     ozaki 	pserialize_read_exit(s);
   2589  1.335     ozaki 	return ifp;
   2590  1.335     ozaki }
   2591  1.335     ozaki 
   2592  1.335     ozaki /*
   2593  1.335     ozaki  * Release a reference of an ifnet object given by if_get or
   2594  1.335     ozaki  * if_get_byindex.
   2595  1.335     ozaki  */
   2596  1.335     ozaki void
   2597  1.335     ozaki if_put(const struct ifnet *ifp, struct psref *psref)
   2598  1.335     ozaki {
   2599  1.335     ozaki 
   2600  1.344     ozaki 	if (ifp == NULL)
   2601  1.344     ozaki 		return;
   2602  1.344     ozaki 
   2603  1.335     ozaki 	psref_release(psref, &ifp->if_psref, ifnet_psref_class);
   2604  1.335     ozaki }
   2605  1.335     ozaki 
   2606  1.250     rmind ifnet_t *
   2607  1.250     rmind if_byindex(u_int idx)
   2608  1.250     rmind {
   2609  1.357     ozaki 	ifnet_t *ifp;
   2610  1.357     ozaki 
   2611  1.357     ozaki 	ifp = (idx < if_indexlim) ? ifindex2ifnet[idx] : NULL;
   2612  1.357     ozaki 	if (ifp != NULL && if_is_deactivated(ifp))
   2613  1.357     ozaki 		ifp = NULL;
   2614  1.357     ozaki 	return ifp;
   2615  1.250     rmind }
   2616  1.250     rmind 
   2617  1.335     ozaki /*
   2618  1.335     ozaki  * Get a reference of an ifnet object by an interface index.
   2619  1.335     ozaki  * The returned reference is protected by psref(9). The caller
   2620  1.335     ozaki  * must release a returned reference by if_put after use.
   2621  1.335     ozaki  */
   2622  1.335     ozaki ifnet_t *
   2623  1.335     ozaki if_get_byindex(u_int idx, struct psref *psref)
   2624  1.335     ozaki {
   2625  1.335     ozaki 	ifnet_t *ifp;
   2626  1.335     ozaki 	int s;
   2627  1.335     ozaki 
   2628  1.335     ozaki 	s = pserialize_read_enter();
   2629  1.337     ozaki 	ifp = (__predict_true(idx < if_indexlim)) ? ifindex2ifnet[idx] : NULL;
   2630  1.357     ozaki 	if (ifp != NULL && if_is_deactivated(ifp))
   2631  1.357     ozaki 		ifp = NULL;
   2632  1.337     ozaki 	if (__predict_true(ifp != NULL))
   2633  1.335     ozaki 		psref_acquire(psref, &ifp->if_psref, ifnet_psref_class);
   2634  1.335     ozaki 	pserialize_read_exit(s);
   2635  1.335     ozaki 
   2636  1.335     ozaki 	return ifp;
   2637  1.335     ozaki }
   2638  1.335     ozaki 
   2639  1.338     ozaki /*
   2640  1.344     ozaki  * XXX it's safe only if the passed ifp is guaranteed to not be freed,
   2641  1.344     ozaki  * for example the ifp is already held or some other object is held which
   2642  1.344     ozaki  * guarantes the ifp to not be freed indirectly.
   2643  1.338     ozaki  */
   2644  1.338     ozaki void
   2645  1.344     ozaki if_acquire_NOMPSAFE(struct ifnet *ifp, struct psref *psref)
   2646  1.338     ozaki {
   2647  1.338     ozaki 
   2648  1.338     ozaki 	KASSERT(ifp->if_index != 0);
   2649  1.338     ozaki 	psref_acquire(psref, &ifp->if_psref, ifnet_psref_class);
   2650  1.338     ozaki }
   2651  1.338     ozaki 
   2652  1.338     ozaki bool
   2653  1.338     ozaki if_held(struct ifnet *ifp)
   2654  1.338     ozaki {
   2655  1.338     ozaki 
   2656  1.338     ozaki 	return psref_held(&ifp->if_psref, ifnet_psref_class);
   2657  1.338     ozaki }
   2658  1.338     ozaki 
   2659  1.338     ozaki 
   2660  1.211    dyoung /* common */
   2661  1.215    dyoung int
   2662  1.215    dyoung ifioctl_common(struct ifnet *ifp, u_long cmd, void *data)
   2663  1.211    dyoung {
   2664  1.224    dyoung 	int s;
   2665  1.215    dyoung 	struct ifreq *ifr;
   2666  1.215    dyoung 	struct ifcapreq *ifcr;
   2667  1.215    dyoung 	struct ifdatareq *ifdr;
   2668  1.211    dyoung 
   2669  1.211    dyoung 	switch (cmd) {
   2670  1.211    dyoung 	case SIOCSIFCAP:
   2671  1.215    dyoung 		ifcr = data;
   2672  1.211    dyoung 		if ((ifcr->ifcr_capenable & ~ifp->if_capabilities) != 0)
   2673  1.211    dyoung 			return EINVAL;
   2674  1.211    dyoung 
   2675  1.213    dyoung 		if (ifcr->ifcr_capenable == ifp->if_capenable)
   2676  1.213    dyoung 			return 0;
   2677  1.211    dyoung 
   2678  1.213    dyoung 		ifp->if_capenable = ifcr->ifcr_capenable;
   2679  1.211    dyoung 
   2680  1.213    dyoung 		/* Pre-compute the checksum flags mask. */
   2681  1.213    dyoung 		ifp->if_csum_flags_tx = 0;
   2682  1.213    dyoung 		ifp->if_csum_flags_rx = 0;
   2683  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_IPv4_Tx) {
   2684  1.213    dyoung 			ifp->if_csum_flags_tx |= M_CSUM_IPv4;
   2685  1.213    dyoung 		}
   2686  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_IPv4_Rx) {
   2687  1.213    dyoung 			ifp->if_csum_flags_rx |= M_CSUM_IPv4;
   2688  1.213    dyoung 		}
   2689  1.211    dyoung 
   2690  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_TCPv4_Tx) {
   2691  1.213    dyoung 			ifp->if_csum_flags_tx |= M_CSUM_TCPv4;
   2692  1.213    dyoung 		}
   2693  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_TCPv4_Rx) {
   2694  1.213    dyoung 			ifp->if_csum_flags_rx |= M_CSUM_TCPv4;
   2695  1.213    dyoung 		}
   2696  1.211    dyoung 
   2697  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_UDPv4_Tx) {
   2698  1.213    dyoung 			ifp->if_csum_flags_tx |= M_CSUM_UDPv4;
   2699  1.213    dyoung 		}
   2700  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_UDPv4_Rx) {
   2701  1.213    dyoung 			ifp->if_csum_flags_rx |= M_CSUM_UDPv4;
   2702  1.213    dyoung 		}
   2703  1.211    dyoung 
   2704  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_TCPv6_Tx) {
   2705  1.213    dyoung 			ifp->if_csum_flags_tx |= M_CSUM_TCPv6;
   2706  1.213    dyoung 		}
   2707  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_TCPv6_Rx) {
   2708  1.213    dyoung 			ifp->if_csum_flags_rx |= M_CSUM_TCPv6;
   2709  1.213    dyoung 		}
   2710  1.211    dyoung 
   2711  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_UDPv6_Tx) {
   2712  1.213    dyoung 			ifp->if_csum_flags_tx |= M_CSUM_UDPv6;
   2713  1.211    dyoung 		}
   2714  1.213    dyoung 		if (ifp->if_capenable & IFCAP_CSUM_UDPv6_Rx) {
   2715  1.213    dyoung 			ifp->if_csum_flags_rx |= M_CSUM_UDPv6;
   2716  1.213    dyoung 		}
   2717  1.215    dyoung 		if (ifp->if_flags & IFF_UP)
   2718  1.215    dyoung 			return ENETRESET;
   2719  1.215    dyoung 		return 0;
   2720  1.211    dyoung 	case SIOCSIFFLAGS:
   2721  1.215    dyoung 		ifr = data;
   2722  1.211    dyoung 		if (ifp->if_flags & IFF_UP && (ifr->ifr_flags & IFF_UP) == 0) {
   2723  1.211    dyoung 			s = splnet();
   2724  1.211    dyoung 			if_down(ifp);
   2725  1.211    dyoung 			splx(s);
   2726  1.211    dyoung 		}
   2727  1.211    dyoung 		if (ifr->ifr_flags & IFF_UP && (ifp->if_flags & IFF_UP) == 0) {
   2728  1.211    dyoung 			s = splnet();
   2729  1.211    dyoung 			if_up(ifp);
   2730  1.211    dyoung 			splx(s);
   2731  1.211    dyoung 		}
   2732  1.211    dyoung 		ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
   2733  1.211    dyoung 			(ifr->ifr_flags &~ IFF_CANTCHANGE);
   2734  1.211    dyoung 		break;
   2735  1.211    dyoung 	case SIOCGIFFLAGS:
   2736  1.215    dyoung 		ifr = data;
   2737  1.211    dyoung 		ifr->ifr_flags = ifp->if_flags;
   2738  1.211    dyoung 		break;
   2739  1.211    dyoung 
   2740  1.211    dyoung 	case SIOCGIFMETRIC:
   2741  1.215    dyoung 		ifr = data;
   2742  1.211    dyoung 		ifr->ifr_metric = ifp->if_metric;
   2743  1.211    dyoung 		break;
   2744  1.211    dyoung 
   2745  1.211    dyoung 	case SIOCGIFMTU:
   2746  1.215    dyoung 		ifr = data;
   2747  1.211    dyoung 		ifr->ifr_mtu = ifp->if_mtu;
   2748  1.211    dyoung 		break;
   2749  1.211    dyoung 
   2750  1.211    dyoung 	case SIOCGIFDLT:
   2751  1.215    dyoung 		ifr = data;
   2752  1.211    dyoung 		ifr->ifr_dlt = ifp->if_dlt;
   2753  1.211    dyoung 		break;
   2754  1.211    dyoung 
   2755  1.211    dyoung 	case SIOCGIFCAP:
   2756  1.215    dyoung 		ifcr = data;
   2757  1.211    dyoung 		ifcr->ifcr_capabilities = ifp->if_capabilities;
   2758  1.211    dyoung 		ifcr->ifcr_capenable = ifp->if_capenable;
   2759  1.211    dyoung 		break;
   2760  1.211    dyoung 
   2761  1.211    dyoung 	case SIOCSIFMETRIC:
   2762  1.215    dyoung 		ifr = data;
   2763  1.211    dyoung 		ifp->if_metric = ifr->ifr_metric;
   2764  1.211    dyoung 		break;
   2765  1.211    dyoung 
   2766  1.211    dyoung 	case SIOCGIFDATA:
   2767  1.215    dyoung 		ifdr = data;
   2768  1.211    dyoung 		ifdr->ifdr_data = ifp->if_data;
   2769  1.211    dyoung 		break;
   2770  1.211    dyoung 
   2771  1.266  christos 	case SIOCGIFINDEX:
   2772  1.266  christos 		ifr = data;
   2773  1.266  christos 		ifr->ifr_index = ifp->if_index;
   2774  1.266  christos 		break;
   2775  1.266  christos 
   2776  1.211    dyoung 	case SIOCZIFDATA:
   2777  1.215    dyoung 		ifdr = data;
   2778  1.211    dyoung 		ifdr->ifdr_data = ifp->if_data;
   2779  1.211    dyoung 		/*
   2780  1.211    dyoung 		 * Assumes that the volatile counters that can be
   2781  1.211    dyoung 		 * zero'ed are at the end of if_data.
   2782  1.211    dyoung 		 */
   2783  1.211    dyoung 		memset(&ifp->if_data.ifi_ipackets, 0, sizeof(ifp->if_data) -
   2784  1.211    dyoung 		    offsetof(struct if_data, ifi_ipackets));
   2785  1.261   msaitoh 		/*
   2786  1.261   msaitoh 		 * The memset() clears to the bottm of if_data. In the area,
   2787  1.261   msaitoh 		 * if_lastchange is included. Please be careful if new entry
   2788  1.261   msaitoh 		 * will be added into if_data or rewite this.
   2789  1.261   msaitoh 		 *
   2790  1.261   msaitoh 		 * And also, update if_lastchnage.
   2791  1.261   msaitoh 		 */
   2792  1.261   msaitoh 		getnanotime(&ifp->if_lastchange);
   2793  1.211    dyoung 		break;
   2794  1.215    dyoung 	case SIOCSIFMTU:
   2795  1.215    dyoung 		ifr = data;
   2796  1.215    dyoung 		if (ifp->if_mtu == ifr->ifr_mtu)
   2797  1.215    dyoung 			break;
   2798  1.215    dyoung 		ifp->if_mtu = ifr->ifr_mtu;
   2799  1.215    dyoung 		/*
   2800  1.215    dyoung 		 * If the link MTU changed, do network layer specific procedure.
   2801  1.215    dyoung 		 */
   2802  1.215    dyoung #ifdef INET6
   2803  1.271     pooka 		if (in6_present)
   2804  1.271     pooka 			nd6_setmtu(ifp);
   2805  1.215    dyoung #endif
   2806  1.215    dyoung 		return ENETRESET;
   2807  1.211    dyoung 	default:
   2808  1.223    dyoung 		return ENOTTY;
   2809  1.211    dyoung 	}
   2810  1.211    dyoung 	return 0;
   2811  1.211    dyoung }
   2812  1.211    dyoung 
   2813  1.235    dyoung int
   2814  1.284       rtr ifaddrpref_ioctl(struct socket *so, u_long cmd, void *data, struct ifnet *ifp)
   2815  1.235    dyoung {
   2816  1.235    dyoung 	struct if_addrprefreq *ifap = (struct if_addrprefreq *)data;
   2817  1.235    dyoung 	struct ifaddr *ifa;
   2818  1.235    dyoung 	const struct sockaddr *any, *sa;
   2819  1.235    dyoung 	union {
   2820  1.235    dyoung 		struct sockaddr sa;
   2821  1.235    dyoung 		struct sockaddr_storage ss;
   2822  1.236  jakllsch 	} u, v;
   2823  1.357     ozaki 	int s, error = 0;
   2824  1.235    dyoung 
   2825  1.235    dyoung 	switch (cmd) {
   2826  1.235    dyoung 	case SIOCSIFADDRPREF:
   2827  1.284       rtr 		if (kauth_authorize_network(curlwp->l_cred, KAUTH_NETWORK_INTERFACE,
   2828  1.235    dyoung 		    KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd,
   2829  1.235    dyoung 		    NULL) != 0)
   2830  1.235    dyoung 			return EPERM;
   2831  1.235    dyoung 	case SIOCGIFADDRPREF:
   2832  1.235    dyoung 		break;
   2833  1.235    dyoung 	default:
   2834  1.235    dyoung 		return EOPNOTSUPP;
   2835  1.235    dyoung 	}
   2836  1.235    dyoung 
   2837  1.235    dyoung 	/* sanity checks */
   2838  1.235    dyoung 	if (data == NULL || ifp == NULL) {
   2839  1.235    dyoung 		panic("invalid argument to %s", __func__);
   2840  1.235    dyoung 		/*NOTREACHED*/
   2841  1.235    dyoung 	}
   2842  1.235    dyoung 
   2843  1.235    dyoung 	/* address must be specified on ADD and DELETE */
   2844  1.235    dyoung 	sa = sstocsa(&ifap->ifap_addr);
   2845  1.235    dyoung 	if (sa->sa_family != sofamily(so))
   2846  1.235    dyoung 		return EINVAL;
   2847  1.235    dyoung 	if ((any = sockaddr_any(sa)) == NULL || sa->sa_len != any->sa_len)
   2848  1.235    dyoung 		return EINVAL;
   2849  1.235    dyoung 
   2850  1.236  jakllsch 	sockaddr_externalize(&v.sa, sizeof(v.ss), sa);
   2851  1.236  jakllsch 
   2852  1.357     ozaki 	s = pserialize_read_enter();
   2853  1.354     ozaki 	IFADDR_READER_FOREACH(ifa, ifp) {
   2854  1.235    dyoung 		if (ifa->ifa_addr->sa_family != sa->sa_family)
   2855  1.235    dyoung 			continue;
   2856  1.235    dyoung 		sockaddr_externalize(&u.sa, sizeof(u.ss), ifa->ifa_addr);
   2857  1.236  jakllsch 		if (sockaddr_cmp(&u.sa, &v.sa) == 0)
   2858  1.235    dyoung 			break;
   2859  1.235    dyoung 	}
   2860  1.357     ozaki 	if (ifa == NULL) {
   2861  1.357     ozaki 		error = EADDRNOTAVAIL;
   2862  1.357     ozaki 		goto out;
   2863  1.357     ozaki 	}
   2864  1.235    dyoung 
   2865  1.235    dyoung 	switch (cmd) {
   2866  1.235    dyoung 	case SIOCSIFADDRPREF:
   2867  1.235    dyoung 		ifa->ifa_preference = ifap->ifap_preference;
   2868  1.357     ozaki 		goto out;
   2869  1.235    dyoung 	case SIOCGIFADDRPREF:
   2870  1.235    dyoung 		/* fill in the if_laddrreq structure */
   2871  1.235    dyoung 		(void)sockaddr_copy(sstosa(&ifap->ifap_addr),
   2872  1.235    dyoung 		    sizeof(ifap->ifap_addr), ifa->ifa_addr);
   2873  1.235    dyoung 		ifap->ifap_preference = ifa->ifa_preference;
   2874  1.357     ozaki 		goto out;
   2875  1.235    dyoung 	default:
   2876  1.357     ozaki 		error = EOPNOTSUPP;
   2877  1.235    dyoung 	}
   2878  1.357     ozaki out:
   2879  1.357     ozaki 	pserialize_read_exit(s);
   2880  1.357     ozaki 	return error;
   2881  1.235    dyoung }
   2882  1.235    dyoung 
   2883    1.1       cgd /*
   2884    1.1       cgd  * Interface ioctls.
   2885    1.1       cgd  */
   2886  1.273     pooka static int
   2887  1.273     pooka doifioctl(struct socket *so, u_long cmd, void *data, struct lwp *l)
   2888    1.1       cgd {
   2889   1.61  augustss 	struct ifnet *ifp;
   2890   1.61  augustss 	struct ifreq *ifr;
   2891  1.217    martin 	int error = 0;
   2892  1.191  christos #if defined(COMPAT_OSOCK) || defined(COMPAT_OIFREQ)
   2893  1.191  christos 	u_long ocmd = cmd;
   2894  1.191  christos #endif
   2895   1.49    itojun 	short oif_flags;
   2896  1.186  christos #ifdef COMPAT_OIFREQ
   2897  1.186  christos 	struct ifreq ifrb;
   2898  1.187   xtraeme 	struct oifreq *oifr = NULL;
   2899  1.186  christos #endif
   2900  1.292  christos 	int r;
   2901  1.336     ozaki 	struct psref psref;
   2902  1.339     ozaki 	int bound;
   2903    1.1       cgd 
   2904    1.1       cgd 	switch (cmd) {
   2905  1.186  christos #ifdef COMPAT_OIFREQ
   2906  1.186  christos 	case OSIOCGIFCONF:
   2907  1.186  christos 	case OOSIOCGIFCONF:
   2908  1.186  christos 		return compat_ifconf(cmd, data);
   2909  1.186  christos #endif
   2910  1.232  christos #ifdef COMPAT_OIFDATA
   2911  1.232  christos 	case OSIOCGIFDATA:
   2912  1.232  christos 	case OSIOCZIFDATA:
   2913  1.232  christos 		return compat_ifdatareq(l, cmd, data);
   2914  1.232  christos #endif
   2915    1.1       cgd 	case SIOCGIFCONF:
   2916  1.185    dyoung 		return ifconf(cmd, data);
   2917  1.231    dyoung 	case SIOCINITIFADDR:
   2918  1.231    dyoung 		return EPERM;
   2919    1.1       cgd 	}
   2920  1.191  christos 
   2921  1.186  christos #ifdef COMPAT_OIFREQ
   2922  1.361  pgoyette 	cmd = (*vec_compat_cvtcmd)(cmd);
   2923  1.186  christos 	if (cmd != ocmd) {
   2924  1.186  christos 		oifr = data;
   2925  1.186  christos 		data = ifr = &ifrb;
   2926  1.186  christos 		ifreqo2n(oifr, ifr);
   2927  1.186  christos 	} else
   2928  1.186  christos #endif
   2929  1.186  christos 		ifr = data;
   2930   1.63   thorpej 
   2931   1.63   thorpej 	switch (cmd) {
   2932   1.63   thorpej 	case SIOCIFCREATE:
   2933   1.63   thorpej 	case SIOCIFDESTROY:
   2934  1.339     ozaki 		bound = curlwp_bind();
   2935  1.185    dyoung 		if (l != NULL) {
   2936  1.336     ozaki 			ifp = if_get(ifr->ifr_name, &psref);
   2937  1.174      elad 			error = kauth_authorize_network(l->l_cred,
   2938  1.174      elad 			    KAUTH_NETWORK_INTERFACE,
   2939  1.174      elad 			    KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp,
   2940  1.174      elad 			    (void *)cmd, NULL);
   2941  1.336     ozaki 			if (ifp != NULL)
   2942  1.336     ozaki 				if_put(ifp, &psref);
   2943  1.336     ozaki 			if (error != 0) {
   2944  1.339     ozaki 				curlwp_bindx(bound);
   2945  1.151      yamt 				return error;
   2946  1.336     ozaki 			}
   2947  1.151      yamt 		}
   2948  1.292  christos 		mutex_enter(&if_clone_mtx);
   2949  1.292  christos 		r = (cmd == SIOCIFCREATE) ?
   2950   1.64   thorpej 			if_clone_create(ifr->ifr_name) :
   2951  1.185    dyoung 			if_clone_destroy(ifr->ifr_name);
   2952  1.292  christos 		mutex_exit(&if_clone_mtx);
   2953  1.339     ozaki 		curlwp_bindx(bound);
   2954  1.292  christos 		return r;
   2955   1.67   thorpej 
   2956   1.67   thorpej 	case SIOCIFGCLONERS:
   2957  1.315    martin 		{
   2958  1.315    martin 			struct if_clonereq *req = (struct if_clonereq *)data;
   2959  1.315    martin 			return if_clone_list(req->ifcr_count, req->ifcr_buffer,
   2960  1.315    martin 			    &req->ifcr_total);
   2961  1.315    martin 		}
   2962   1.63   thorpej 	}
   2963   1.63   thorpej 
   2964  1.339     ozaki 	bound = curlwp_bind();
   2965  1.336     ozaki 	ifp = if_get(ifr->ifr_name, &psref);
   2966  1.336     ozaki 	if (ifp == NULL) {
   2967  1.339     ozaki 		curlwp_bindx(bound);
   2968  1.185    dyoung 		return ENXIO;
   2969  1.336     ozaki 	}
   2970  1.151      yamt 
   2971  1.151      yamt 	switch (cmd) {
   2972  1.233  christos 	case SIOCALIFADDR:
   2973  1.233  christos 	case SIOCDLIFADDR:
   2974  1.233  christos 	case SIOCSIFADDRPREF:
   2975  1.151      yamt 	case SIOCSIFFLAGS:
   2976  1.151      yamt 	case SIOCSIFCAP:
   2977  1.151      yamt 	case SIOCSIFMETRIC:
   2978  1.151      yamt 	case SIOCZIFDATA:
   2979  1.151      yamt 	case SIOCSIFMTU:
   2980  1.151      yamt 	case SIOCSIFPHYADDR:
   2981  1.151      yamt 	case SIOCDIFPHYADDR:
   2982  1.151      yamt #ifdef INET6
   2983  1.151      yamt 	case SIOCSIFPHYADDR_IN6:
   2984  1.151      yamt #endif
   2985  1.151      yamt 	case SIOCSLIFPHYADDR:
   2986  1.151      yamt 	case SIOCADDMULTI:
   2987  1.151      yamt 	case SIOCDELMULTI:
   2988  1.151      yamt 	case SIOCSIFMEDIA:
   2989  1.154     perry 	case SIOCSDRVSPEC:
   2990  1.196       skd 	case SIOCG80211:
   2991  1.196       skd 	case SIOCS80211:
   2992  1.151      yamt 	case SIOCS80211NWID:
   2993  1.151      yamt 	case SIOCS80211NWKEY:
   2994  1.151      yamt 	case SIOCS80211POWER:
   2995  1.151      yamt 	case SIOCS80211BSSID:
   2996  1.151      yamt 	case SIOCS80211CHANNEL:
   2997  1.249     pooka 	case SIOCSLINKSTR:
   2998  1.185    dyoung 		if (l != NULL) {
   2999  1.174      elad 			error = kauth_authorize_network(l->l_cred,
   3000  1.174      elad 			    KAUTH_NETWORK_INTERFACE,
   3001  1.174      elad 			    KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp,
   3002  1.174      elad 			    (void *)cmd, NULL);
   3003  1.185    dyoung 			if (error != 0)
   3004  1.336     ozaki 				goto out;
   3005  1.151      yamt 		}
   3006  1.151      yamt 	}
   3007  1.151      yamt 
   3008   1.49    itojun 	oif_flags = ifp->if_flags;
   3009    1.1       cgd 
   3010  1.336     ozaki 	mutex_enter(ifp->if_ioctl_lock);
   3011  1.336     ozaki 
   3012  1.231    dyoung 	error = (*ifp->if_ioctl)(ifp, cmd, data);
   3013  1.231    dyoung 	if (error != ENOTTY)
   3014  1.231    dyoung 		;
   3015  1.231    dyoung 	else if (so->so_proto == NULL)
   3016  1.252    dyoung 		error = EOPNOTSUPP;
   3017  1.231    dyoung 	else {
   3018  1.161  christos #ifdef COMPAT_OSOCK
   3019  1.361  pgoyette 		if (vec_compat_ifioctl != NULL)
   3020  1.361  pgoyette 			error = (*vec_compat_ifioctl)(so, ocmd, cmd, data, l);
   3021  1.361  pgoyette 		else
   3022    1.1       cgd #endif
   3023  1.361  pgoyette 			error = (*so->so_proto->pr_usrreqs->pr_ioctl)(so,
   3024  1.361  pgoyette 			    cmd, data, ifp);
   3025   1.49    itojun 	}
   3026    1.1       cgd 
   3027   1.49    itojun 	if (((oif_flags ^ ifp->if_flags) & IFF_UP) != 0) {
   3028  1.312       roy 		if ((ifp->if_flags & IFF_UP) != 0) {
   3029  1.217    martin 			int s = splnet();
   3030  1.312       roy 			if_up(ifp);
   3031   1.49    itojun 			splx(s);
   3032   1.49    itojun 		}
   3033    1.1       cgd 	}
   3034  1.186  christos #ifdef COMPAT_OIFREQ
   3035  1.186  christos 	if (cmd != ocmd)
   3036  1.246  christos 		ifreqn2o(oifr, ifr);
   3037  1.186  christos #endif
   3038   1.49    itojun 
   3039  1.336     ozaki 	mutex_exit(ifp->if_ioctl_lock);
   3040  1.336     ozaki out:
   3041  1.336     ozaki 	if_put(ifp, &psref);
   3042  1.339     ozaki 	curlwp_bindx(bound);
   3043  1.185    dyoung 	return error;
   3044    1.1       cgd }
   3045    1.1       cgd 
   3046    1.1       cgd /*
   3047    1.1       cgd  * Return interface configuration
   3048    1.1       cgd  * of system.  List may be used
   3049    1.1       cgd  * in later ioctl's (above) to get
   3050    1.1       cgd  * other information.
   3051  1.200       gdt  *
   3052  1.200       gdt  * Each record is a struct ifreq.  Before the addition of
   3053  1.200       gdt  * sockaddr_storage, the API rule was that sockaddr flavors that did
   3054  1.200       gdt  * not fit would extend beyond the struct ifreq, with the next struct
   3055  1.200       gdt  * ifreq starting sa_len beyond the struct sockaddr.  Because the
   3056  1.200       gdt  * union in struct ifreq includes struct sockaddr_storage, every kind
   3057  1.200       gdt  * of sockaddr must fit.  Thus, there are no longer any overlength
   3058  1.200       gdt  * records.
   3059  1.200       gdt  *
   3060  1.200       gdt  * Records are added to the user buffer if they fit, and ifc_len is
   3061  1.200       gdt  * adjusted to the length that was written.  Thus, the user is only
   3062  1.200       gdt  * assured of getting the complete list if ifc_len on return is at
   3063  1.200       gdt  * least sizeof(struct ifreq) less than it was on entry.
   3064  1.200       gdt  *
   3065  1.200       gdt  * If the user buffer pointer is NULL, this routine copies no data and
   3066  1.200       gdt  * returns the amount of space that would be needed.
   3067  1.200       gdt  *
   3068  1.200       gdt  * Invariants:
   3069  1.200       gdt  * ifrp points to the next part of the user's buffer to be used.  If
   3070  1.200       gdt  * ifrp != NULL, space holds the number of bytes remaining that we may
   3071  1.200       gdt  * write at ifrp.  Otherwise, space holds the number of bytes that
   3072  1.200       gdt  * would have been written had there been adequate space.
   3073    1.1       cgd  */
   3074    1.1       cgd /*ARGSUSED*/
   3075  1.302     ozaki static int
   3076  1.183  christos ifconf(u_long cmd, void *data)
   3077    1.1       cgd {
   3078   1.61  augustss 	struct ifconf *ifc = (struct ifconf *)data;
   3079   1.61  augustss 	struct ifnet *ifp;
   3080   1.61  augustss 	struct ifaddr *ifa;
   3081  1.304     ozaki 	struct ifreq ifr, *ifrp = NULL;
   3082  1.304     ozaki 	int space = 0, error = 0;
   3083  1.200       gdt 	const int sz = (int)sizeof(struct ifreq);
   3084  1.304     ozaki 	const bool docopy = ifc->ifc_req != NULL;
   3085  1.334     ozaki 	int s;
   3086  1.339     ozaki 	int bound;
   3087  1.334     ozaki 	struct psref psref;
   3088    1.1       cgd 
   3089  1.304     ozaki 	if (docopy) {
   3090  1.190     enami 		space = ifc->ifc_len;
   3091  1.304     ozaki 		ifrp = ifc->ifc_req;
   3092  1.304     ozaki 	}
   3093  1.304     ozaki 
   3094  1.339     ozaki 	bound = curlwp_bind();
   3095  1.334     ozaki 	s = pserialize_read_enter();
   3096  1.334     ozaki 	IFNET_READER_FOREACH(ifp) {
   3097  1.334     ozaki 		psref_acquire(&psref, &ifp->if_psref, ifnet_psref_class);
   3098  1.334     ozaki 		pserialize_read_exit(s);
   3099  1.334     ozaki 
   3100  1.175  christos 		(void)strncpy(ifr.ifr_name, ifp->if_xname,
   3101  1.173  christos 		    sizeof(ifr.ifr_name));
   3102  1.334     ozaki 		if (ifr.ifr_name[sizeof(ifr.ifr_name) - 1] != '\0') {
   3103  1.334     ozaki 			error = ENAMETOOLONG;
   3104  1.334     ozaki 			goto release_exit;
   3105  1.334     ozaki 		}
   3106  1.354     ozaki 		if (IFADDR_READER_EMPTY(ifp)) {
   3107  1.200       gdt 			/* Interface with no addresses - send zero sockaddr. */
   3108  1.127  christos 			memset(&ifr.ifr_addr, 0, sizeof(ifr.ifr_addr));
   3109  1.304     ozaki 			if (!docopy) {
   3110  1.218    dyoung 				space += sz;
   3111  1.218    dyoung 				continue;
   3112  1.218    dyoung 			}
   3113  1.218    dyoung 			if (space >= sz) {
   3114  1.218    dyoung 				error = copyout(&ifr, ifrp, sz);
   3115  1.218    dyoung 				if (error != 0)
   3116  1.334     ozaki 					goto release_exit;
   3117  1.218    dyoung 				ifrp++;
   3118  1.218    dyoung 				space -= sz;
   3119   1.70    mellon 			}
   3120  1.127  christos 		}
   3121  1.127  christos 
   3122  1.354     ozaki 		IFADDR_READER_FOREACH(ifa, ifp) {
   3123   1.61  augustss 			struct sockaddr *sa = ifa->ifa_addr;
   3124  1.200       gdt 			/* all sockaddrs must fit in sockaddr_storage */
   3125  1.200       gdt 			KASSERT(sa->sa_len <= sizeof(ifr.ifr_ifru));
   3126  1.200       gdt 
   3127  1.304     ozaki 			if (!docopy) {
   3128  1.218    dyoung 				space += sz;
   3129  1.218    dyoung 				continue;
   3130  1.218    dyoung 			}
   3131  1.218    dyoung 			memcpy(&ifr.ifr_space, sa, sa->sa_len);
   3132  1.218    dyoung 			if (space >= sz) {
   3133  1.218    dyoung 				error = copyout(&ifr, ifrp, sz);
   3134  1.218    dyoung 				if (error != 0)
   3135  1.334     ozaki 					goto release_exit;
   3136  1.218    dyoung 				ifrp++; space -= sz;
   3137    1.1       cgd 			}
   3138    1.1       cgd 		}
   3139  1.334     ozaki 
   3140  1.334     ozaki 		s = pserialize_read_enter();
   3141  1.334     ozaki 		psref_release(&psref, &ifp->if_psref, ifnet_psref_class);
   3142    1.1       cgd 	}
   3143  1.334     ozaki 	pserialize_read_exit(s);
   3144  1.339     ozaki 	curlwp_bindx(bound);
   3145  1.334     ozaki 
   3146  1.304     ozaki 	if (docopy) {
   3147  1.200       gdt 		KASSERT(0 <= space && space <= ifc->ifc_len);
   3148  1.127  christos 		ifc->ifc_len -= space;
   3149  1.218    dyoung 	} else {
   3150  1.200       gdt 		KASSERT(space >= 0);
   3151  1.200       gdt 		ifc->ifc_len = space;
   3152  1.200       gdt 	}
   3153  1.190     enami 	return (0);
   3154  1.334     ozaki 
   3155  1.334     ozaki release_exit:
   3156  1.334     ozaki 	psref_release(&psref, &ifp->if_psref, ifnet_psref_class);
   3157  1.339     ozaki 	curlwp_bindx(bound);
   3158  1.334     ozaki 	return error;
   3159    1.1       cgd }
   3160  1.133  jonathan 
   3161  1.198    dyoung int
   3162  1.247  christos ifreq_setaddr(u_long cmd, struct ifreq *ifr, const struct sockaddr *sa)
   3163  1.198    dyoung {
   3164  1.198    dyoung 	uint8_t len;
   3165  1.247  christos #ifdef COMPAT_OIFREQ
   3166  1.247  christos 	struct ifreq ifrb;
   3167  1.247  christos 	struct oifreq *oifr = NULL;
   3168  1.247  christos 	u_long ocmd = cmd;
   3169  1.361  pgoyette 	cmd = (*vec_compat_cvtcmd)(cmd);
   3170  1.247  christos 	if (cmd != ocmd) {
   3171  1.247  christos 		oifr = (struct oifreq *)(void *)ifr;
   3172  1.247  christos 		ifr = &ifrb;
   3173  1.247  christos 		ifreqo2n(oifr, ifr);
   3174  1.247  christos 		len = sizeof(oifr->ifr_addr);
   3175  1.247  christos 	} else
   3176  1.247  christos #endif
   3177  1.247  christos 		len = sizeof(ifr->ifr_ifru.ifru_space);
   3178  1.198    dyoung 
   3179  1.198    dyoung 	if (len < sa->sa_len)
   3180  1.198    dyoung 		return EFBIG;
   3181  1.247  christos 
   3182  1.241     joerg 	memset(&ifr->ifr_addr, 0, len);
   3183  1.202    dyoung 	sockaddr_copy(&ifr->ifr_addr, len, sa);
   3184  1.247  christos 
   3185  1.247  christos #ifdef COMPAT_OIFREQ
   3186  1.247  christos 	if (cmd != ocmd)
   3187  1.247  christos 		ifreqn2o(oifr, ifr);
   3188  1.247  christos #endif
   3189  1.198    dyoung 	return 0;
   3190  1.198    dyoung }
   3191  1.198    dyoung 
   3192  1.155  christos /*
   3193  1.332  knakahar  * wrapper function for the drivers which doesn't have if_transmit().
   3194  1.155  christos  */
   3195  1.345  knakahar static int
   3196  1.332  knakahar if_transmit(struct ifnet *ifp, struct mbuf *m)
   3197  1.155  christos {
   3198  1.332  knakahar 	int s, error;
   3199  1.332  knakahar 
   3200  1.332  knakahar 	s = splnet();
   3201  1.155  christos 
   3202  1.330  knakahar 	IFQ_ENQUEUE(&ifp->if_snd, m, error);
   3203  1.332  knakahar 	if (error != 0) {
   3204  1.332  knakahar 		/* mbuf is already freed */
   3205  1.185    dyoung 		goto out;
   3206  1.332  knakahar 	}
   3207  1.332  knakahar 
   3208  1.332  knakahar 	ifp->if_obytes += m->m_pkthdr.len;;
   3209  1.332  knakahar 	if (m->m_flags & M_MCAST)
   3210  1.155  christos 		ifp->if_omcasts++;
   3211  1.332  knakahar 
   3212  1.155  christos 	if ((ifp->if_flags & IFF_OACTIVE) == 0)
   3213  1.343  knakahar 		if_start_lock(ifp);
   3214  1.185    dyoung out:
   3215  1.155  christos 	splx(s);
   3216  1.332  knakahar 
   3217  1.155  christos 	return error;
   3218  1.155  christos }
   3219  1.155  christos 
   3220  1.345  knakahar int
   3221  1.345  knakahar if_transmit_lock(struct ifnet *ifp, struct mbuf *m)
   3222  1.345  knakahar {
   3223  1.345  knakahar 	int error;
   3224  1.345  knakahar 
   3225  1.345  knakahar #ifdef ALTQ
   3226  1.345  knakahar 	KERNEL_LOCK(1, NULL);
   3227  1.345  knakahar 	if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
   3228  1.345  knakahar 		error = if_transmit(ifp, m);
   3229  1.345  knakahar 		KERNEL_UNLOCK_ONE(NULL);
   3230  1.345  knakahar 	} else {
   3231  1.345  knakahar 		KERNEL_UNLOCK_ONE(NULL);
   3232  1.345  knakahar 		error = (*ifp->if_transmit)(ifp, m);
   3233  1.345  knakahar 	}
   3234  1.345  knakahar #else /* !ALTQ */
   3235  1.345  knakahar 	error = (*ifp->if_transmit)(ifp, m);
   3236  1.345  knakahar #endif /* !ALTQ */
   3237  1.345  knakahar 
   3238  1.345  knakahar 	return error;
   3239  1.345  knakahar }
   3240  1.345  knakahar 
   3241  1.155  christos /*
   3242  1.332  knakahar  * Queue message on interface, and start output if interface
   3243  1.332  knakahar  * not yet active.
   3244  1.332  knakahar  */
   3245  1.332  knakahar int
   3246  1.332  knakahar ifq_enqueue(struct ifnet *ifp, struct mbuf *m)
   3247  1.332  knakahar {
   3248  1.332  knakahar 
   3249  1.345  knakahar 	return if_transmit_lock(ifp, m);
   3250  1.332  knakahar }
   3251  1.332  knakahar 
   3252  1.332  knakahar /*
   3253  1.155  christos  * Queue message on interface, possibly using a second fast queue
   3254  1.155  christos  */
   3255  1.155  christos int
   3256  1.330  knakahar ifq_enqueue2(struct ifnet *ifp, struct ifqueue *ifq, struct mbuf *m)
   3257  1.155  christos {
   3258  1.155  christos 	int error = 0;
   3259  1.155  christos 
   3260  1.155  christos 	if (ifq != NULL
   3261  1.155  christos #ifdef ALTQ
   3262  1.155  christos 	    && ALTQ_IS_ENABLED(&ifp->if_snd) == 0
   3263  1.155  christos #endif
   3264  1.155  christos 	    ) {
   3265  1.155  christos 		if (IF_QFULL(ifq)) {
   3266  1.155  christos 			IF_DROP(&ifp->if_snd);
   3267  1.155  christos 			m_freem(m);
   3268  1.155  christos 			if (error == 0)
   3269  1.155  christos 				error = ENOBUFS;
   3270  1.185    dyoung 		} else
   3271  1.155  christos 			IF_ENQUEUE(ifq, m);
   3272  1.155  christos 	} else
   3273  1.330  knakahar 		IFQ_ENQUEUE(&ifp->if_snd, m, error);
   3274  1.155  christos 	if (error != 0) {
   3275  1.155  christos 		++ifp->if_oerrors;
   3276  1.155  christos 		return error;
   3277  1.155  christos 	}
   3278  1.155  christos 	return 0;
   3279  1.155  christos }
   3280  1.155  christos 
   3281  1.252    dyoung int
   3282  1.252    dyoung if_addr_init(ifnet_t *ifp, struct ifaddr *ifa, const bool src)
   3283  1.252    dyoung {
   3284  1.252    dyoung 	int rc;
   3285  1.252    dyoung 
   3286  1.252    dyoung 	if (ifp->if_initaddr != NULL)
   3287  1.252    dyoung 		rc = (*ifp->if_initaddr)(ifp, ifa, src);
   3288  1.252    dyoung 	else if (src ||
   3289  1.336     ozaki 		/* FIXME: may not hold if_ioctl_lock */
   3290  1.252    dyoung 	         (rc = (*ifp->if_ioctl)(ifp, SIOCSIFDSTADDR, ifa)) == ENOTTY)
   3291  1.252    dyoung 		rc = (*ifp->if_ioctl)(ifp, SIOCINITIFADDR, ifa);
   3292  1.252    dyoung 
   3293  1.252    dyoung 	return rc;
   3294  1.252    dyoung }
   3295  1.252    dyoung 
   3296  1.252    dyoung int
   3297  1.309       roy if_do_dad(struct ifnet *ifp)
   3298  1.309       roy {
   3299  1.309       roy 	if ((ifp->if_flags & IFF_LOOPBACK) != 0)
   3300  1.309       roy 		return 0;
   3301  1.309       roy 
   3302  1.309       roy 	switch (ifp->if_type) {
   3303  1.309       roy 	case IFT_FAITH:
   3304  1.309       roy 		/*
   3305  1.309       roy 		 * These interfaces do not have the IFF_LOOPBACK flag,
   3306  1.309       roy 		 * but loop packets back.  We do not have to do DAD on such
   3307  1.309       roy 		 * interfaces.  We should even omit it, because loop-backed
   3308  1.309       roy 		 * responses would confuse the DAD procedure.
   3309  1.309       roy 		 */
   3310  1.309       roy 		return 0;
   3311  1.309       roy 	default:
   3312  1.309       roy 		/*
   3313  1.309       roy 		 * Our DAD routine requires the interface up and running.
   3314  1.309       roy 		 * However, some interfaces can be up before the RUNNING
   3315  1.309       roy 		 * status.  Additionaly, users may try to assign addresses
   3316  1.309       roy 		 * before the interface becomes up (or running).
   3317  1.309       roy 		 * We simply skip DAD in such a case as a work around.
   3318  1.309       roy 		 * XXX: we should rather mark "tentative" on such addresses,
   3319  1.309       roy 		 * and do DAD after the interface becomes ready.
   3320  1.309       roy 		 */
   3321  1.309       roy 		if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) !=
   3322  1.309       roy 		    (IFF_UP|IFF_RUNNING))
   3323  1.309       roy 			return 0;
   3324  1.309       roy 
   3325  1.309       roy 		return 1;
   3326  1.309       roy 	}
   3327  1.309       roy }
   3328  1.309       roy 
   3329  1.309       roy int
   3330  1.252    dyoung if_flags_set(ifnet_t *ifp, const short flags)
   3331  1.252    dyoung {
   3332  1.252    dyoung 	int rc;
   3333  1.252    dyoung 
   3334  1.252    dyoung 	if (ifp->if_setflags != NULL)
   3335  1.252    dyoung 		rc = (*ifp->if_setflags)(ifp, flags);
   3336  1.252    dyoung 	else {
   3337  1.259    dyoung 		short cantflags, chgdflags;
   3338  1.256    dyoung 		struct ifreq ifr;
   3339  1.256    dyoung 
   3340  1.259    dyoung 		chgdflags = ifp->if_flags ^ flags;
   3341  1.259    dyoung 		cantflags = chgdflags & IFF_CANTCHANGE;
   3342  1.256    dyoung 
   3343  1.256    dyoung 		if (cantflags != 0)
   3344  1.256    dyoung 			ifp->if_flags ^= cantflags;
   3345  1.256    dyoung 
   3346  1.259    dyoung                 /* Traditionally, we do not call if_ioctl after
   3347  1.259    dyoung                  * setting/clearing only IFF_PROMISC if the interface
   3348  1.259    dyoung                  * isn't IFF_UP.  Uphold that tradition.
   3349  1.259    dyoung 		 */
   3350  1.259    dyoung 		if (chgdflags == IFF_PROMISC && (ifp->if_flags & IFF_UP) == 0)
   3351  1.259    dyoung 			return 0;
   3352  1.259    dyoung 
   3353  1.259    dyoung 		memset(&ifr, 0, sizeof(ifr));
   3354  1.259    dyoung 
   3355  1.256    dyoung 		ifr.ifr_flags = flags & ~IFF_CANTCHANGE;
   3356  1.336     ozaki 		/* FIXME: may not hold if_ioctl_lock */
   3357  1.252    dyoung 		rc = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, &ifr);
   3358  1.256    dyoung 
   3359  1.256    dyoung 		if (rc != 0 && cantflags != 0)
   3360  1.256    dyoung 			ifp->if_flags ^= cantflags;
   3361  1.252    dyoung 	}
   3362  1.252    dyoung 
   3363  1.252    dyoung 	return rc;
   3364  1.252    dyoung }
   3365  1.252    dyoung 
   3366  1.252    dyoung int
   3367  1.252    dyoung if_mcast_op(ifnet_t *ifp, const unsigned long cmd, const struct sockaddr *sa)
   3368  1.252    dyoung {
   3369  1.252    dyoung 	int rc;
   3370  1.252    dyoung 	struct ifreq ifr;
   3371  1.252    dyoung 
   3372  1.252    dyoung 	if (ifp->if_mcastop != NULL)
   3373  1.252    dyoung 		rc = (*ifp->if_mcastop)(ifp, cmd, sa);
   3374  1.252    dyoung 	else {
   3375  1.252    dyoung 		ifreq_setaddr(cmd, &ifr, sa);
   3376  1.252    dyoung 		rc = (*ifp->if_ioctl)(ifp, cmd, &ifr);
   3377  1.252    dyoung 	}
   3378  1.252    dyoung 
   3379  1.252    dyoung 	return rc;
   3380  1.252    dyoung }
   3381  1.155  christos 
   3382  1.234    dyoung static void
   3383  1.234    dyoung sysctl_sndq_setup(struct sysctllog **clog, const char *ifname,
   3384  1.234    dyoung     struct ifaltq *ifq)
   3385  1.234    dyoung {
   3386  1.234    dyoung 	const struct sysctlnode *cnode, *rnode;
   3387  1.234    dyoung 
   3388  1.234    dyoung 	if (sysctl_createv(clog, 0, NULL, &rnode,
   3389  1.234    dyoung 		       CTLFLAG_PERMANENT,
   3390  1.234    dyoung 		       CTLTYPE_NODE, "interfaces",
   3391  1.234    dyoung 		       SYSCTL_DESCR("Per-interface controls"),
   3392  1.234    dyoung 		       NULL, 0, NULL, 0,
   3393  1.272     pooka 		       CTL_NET, CTL_CREATE, CTL_EOL) != 0)
   3394  1.234    dyoung 		goto bad;
   3395  1.234    dyoung 
   3396  1.234    dyoung 	if (sysctl_createv(clog, 0, &rnode, &rnode,
   3397  1.234    dyoung 		       CTLFLAG_PERMANENT,
   3398  1.234    dyoung 		       CTLTYPE_NODE, ifname,
   3399  1.234    dyoung 		       SYSCTL_DESCR("Interface controls"),
   3400  1.234    dyoung 		       NULL, 0, NULL, 0,
   3401  1.234    dyoung 		       CTL_CREATE, CTL_EOL) != 0)
   3402  1.234    dyoung 		goto bad;
   3403  1.234    dyoung 
   3404  1.234    dyoung 	if (sysctl_createv(clog, 0, &rnode, &rnode,
   3405  1.234    dyoung 		       CTLFLAG_PERMANENT,
   3406  1.234    dyoung 		       CTLTYPE_NODE, "sndq",
   3407  1.234    dyoung 		       SYSCTL_DESCR("Interface output queue controls"),
   3408  1.234    dyoung 		       NULL, 0, NULL, 0,
   3409  1.234    dyoung 		       CTL_CREATE, CTL_EOL) != 0)
   3410  1.234    dyoung 		goto bad;
   3411  1.234    dyoung 
   3412  1.234    dyoung 	if (sysctl_createv(clog, 0, &rnode, &cnode,
   3413  1.234    dyoung 		       CTLFLAG_PERMANENT,
   3414  1.234    dyoung 		       CTLTYPE_INT, "len",
   3415  1.234    dyoung 		       SYSCTL_DESCR("Current output queue length"),
   3416  1.234    dyoung 		       NULL, 0, &ifq->ifq_len, 0,
   3417  1.234    dyoung 		       CTL_CREATE, CTL_EOL) != 0)
   3418  1.234    dyoung 		goto bad;
   3419  1.234    dyoung 
   3420  1.234    dyoung 	if (sysctl_createv(clog, 0, &rnode, &cnode,
   3421  1.234    dyoung 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   3422  1.234    dyoung 		       CTLTYPE_INT, "maxlen",
   3423  1.234    dyoung 		       SYSCTL_DESCR("Maximum allowed output queue length"),
   3424  1.234    dyoung 		       NULL, 0, &ifq->ifq_maxlen, 0,
   3425  1.234    dyoung 		       CTL_CREATE, CTL_EOL) != 0)
   3426  1.234    dyoung 		goto bad;
   3427  1.234    dyoung 
   3428  1.234    dyoung 	if (sysctl_createv(clog, 0, &rnode, &cnode,
   3429  1.234    dyoung 		       CTLFLAG_PERMANENT,
   3430  1.234    dyoung 		       CTLTYPE_INT, "drops",
   3431  1.234    dyoung 		       SYSCTL_DESCR("Packets dropped due to full output queue"),
   3432  1.234    dyoung 		       NULL, 0, &ifq->ifq_drops, 0,
   3433  1.234    dyoung 		       CTL_CREATE, CTL_EOL) != 0)
   3434  1.234    dyoung 		goto bad;
   3435  1.234    dyoung 
   3436  1.234    dyoung 	return;
   3437  1.234    dyoung bad:
   3438  1.234    dyoung 	printf("%s: could not attach sysctl nodes\n", ifname);
   3439  1.234    dyoung 	return;
   3440  1.234    dyoung }
   3441  1.234    dyoung 
   3442  1.138  drochner #if defined(INET) || defined(INET6)
   3443  1.276     rmind 
   3444  1.276     rmind #define	SYSCTL_NET_PKTQ(q, cn, c)					\
   3445  1.276     rmind 	static int							\
   3446  1.276     rmind 	sysctl_net_##q##_##cn(SYSCTLFN_ARGS)				\
   3447  1.276     rmind 	{								\
   3448  1.276     rmind 		return sysctl_pktq_count(SYSCTLFN_CALL(rnode), q, c);	\
   3449  1.276     rmind 	}
   3450  1.276     rmind 
   3451  1.276     rmind #if defined(INET)
   3452  1.279     rmind static int
   3453  1.279     rmind sysctl_net_ip_pktq_maxlen(SYSCTLFN_ARGS)
   3454  1.279     rmind {
   3455  1.279     rmind 	return sysctl_pktq_maxlen(SYSCTLFN_CALL(rnode), ip_pktq);
   3456  1.279     rmind }
   3457  1.276     rmind SYSCTL_NET_PKTQ(ip_pktq, items, PKTQ_NITEMS)
   3458  1.276     rmind SYSCTL_NET_PKTQ(ip_pktq, drops, PKTQ_DROPS)
   3459  1.276     rmind #endif
   3460  1.279     rmind 
   3461  1.276     rmind #if defined(INET6)
   3462  1.279     rmind static int
   3463  1.279     rmind sysctl_net_ip6_pktq_maxlen(SYSCTLFN_ARGS)
   3464  1.279     rmind {
   3465  1.279     rmind 	return sysctl_pktq_maxlen(SYSCTLFN_CALL(rnode), ip6_pktq);
   3466  1.279     rmind }
   3467  1.276     rmind SYSCTL_NET_PKTQ(ip6_pktq, items, PKTQ_NITEMS)
   3468  1.276     rmind SYSCTL_NET_PKTQ(ip6_pktq, drops, PKTQ_DROPS)
   3469  1.276     rmind #endif
   3470  1.276     rmind 
   3471  1.136    atatat static void
   3472  1.276     rmind sysctl_net_pktq_setup(struct sysctllog **clog, int pf)
   3473  1.136    atatat {
   3474  1.276     rmind 	sysctlfn len_func = NULL, maxlen_func = NULL, drops_func = NULL;
   3475  1.276     rmind 	const char *pfname = NULL, *ipname = NULL;
   3476  1.276     rmind 	int ipn = 0, qid = 0;
   3477  1.276     rmind 
   3478  1.276     rmind 	switch (pf) {
   3479  1.276     rmind #if defined(INET)
   3480  1.276     rmind 	case PF_INET:
   3481  1.276     rmind 		len_func = sysctl_net_ip_pktq_items;
   3482  1.276     rmind 		maxlen_func = sysctl_net_ip_pktq_maxlen;
   3483  1.276     rmind 		drops_func = sysctl_net_ip_pktq_drops;
   3484  1.276     rmind 		pfname = "inet", ipn = IPPROTO_IP;
   3485  1.276     rmind 		ipname = "ip", qid = IPCTL_IFQ;
   3486  1.276     rmind 		break;
   3487  1.276     rmind #endif
   3488  1.276     rmind #if defined(INET6)
   3489  1.276     rmind 	case PF_INET6:
   3490  1.276     rmind 		len_func = sysctl_net_ip6_pktq_items;
   3491  1.276     rmind 		maxlen_func = sysctl_net_ip6_pktq_maxlen;
   3492  1.276     rmind 		drops_func = sysctl_net_ip6_pktq_drops;
   3493  1.276     rmind 		pfname = "inet6", ipn = IPPROTO_IPV6;
   3494  1.276     rmind 		ipname = "ip6", qid = IPV6CTL_IFQ;
   3495  1.276     rmind 		break;
   3496  1.276     rmind #endif
   3497  1.276     rmind 	default:
   3498  1.276     rmind 		KASSERT(false);
   3499  1.276     rmind 	}
   3500  1.136    atatat 
   3501  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3502  1.139    atatat 		       CTLFLAG_PERMANENT,
   3503  1.136    atatat 		       CTLTYPE_NODE, pfname, NULL,
   3504  1.136    atatat 		       NULL, 0, NULL, 0,
   3505  1.136    atatat 		       CTL_NET, pf, CTL_EOL);
   3506  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3507  1.139    atatat 		       CTLFLAG_PERMANENT,
   3508  1.136    atatat 		       CTLTYPE_NODE, ipname, NULL,
   3509  1.136    atatat 		       NULL, 0, NULL, 0,
   3510  1.136    atatat 		       CTL_NET, pf, ipn, CTL_EOL);
   3511  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3512  1.139    atatat 		       CTLFLAG_PERMANENT,
   3513  1.142    atatat 		       CTLTYPE_NODE, "ifq",
   3514  1.142    atatat 		       SYSCTL_DESCR("Protocol input queue controls"),
   3515  1.139    atatat 		       NULL, 0, NULL, 0,
   3516  1.139    atatat 		       CTL_NET, pf, ipn, qid, CTL_EOL);
   3517  1.136    atatat 
   3518  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3519  1.139    atatat 		       CTLFLAG_PERMANENT,
   3520  1.142    atatat 		       CTLTYPE_INT, "len",
   3521  1.142    atatat 		       SYSCTL_DESCR("Current input queue length"),
   3522  1.276     rmind 		       len_func, 0, NULL, 0,
   3523  1.136    atatat 		       CTL_NET, pf, ipn, qid, IFQCTL_LEN, CTL_EOL);
   3524  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3525  1.139    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   3526  1.142    atatat 		       CTLTYPE_INT, "maxlen",
   3527  1.142    atatat 		       SYSCTL_DESCR("Maximum allowed input queue length"),
   3528  1.276     rmind 		       maxlen_func, 0, NULL, 0,
   3529  1.136    atatat 		       CTL_NET, pf, ipn, qid, IFQCTL_MAXLEN, CTL_EOL);
   3530  1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   3531  1.139    atatat 		       CTLFLAG_PERMANENT,
   3532  1.142    atatat 		       CTLTYPE_INT, "drops",
   3533  1.142    atatat 		       SYSCTL_DESCR("Packets dropped due to full input queue"),
   3534  1.276     rmind 		       drops_func, 0, NULL, 0,
   3535  1.136    atatat 		       CTL_NET, pf, ipn, qid, IFQCTL_DROPS, CTL_EOL);
   3536  1.136    atatat }
   3537  1.138  drochner #endif /* INET || INET6 */
   3538  1.280     joerg 
   3539  1.280     joerg static int
   3540  1.280     joerg if_sdl_sysctl(SYSCTLFN_ARGS)
   3541  1.280     joerg {
   3542  1.280     joerg 	struct ifnet *ifp;
   3543  1.280     joerg 	const struct sockaddr_dl *sdl;
   3544  1.340     ozaki 	struct psref psref;
   3545  1.340     ozaki 	int error = 0;
   3546  1.340     ozaki 	int bound;
   3547  1.280     joerg 
   3548  1.280     joerg 	if (namelen != 1)
   3549  1.280     joerg 		return EINVAL;
   3550  1.280     joerg 
   3551  1.340     ozaki 	bound = curlwp_bind();
   3552  1.340     ozaki 	ifp = if_get_byindex(name[0], &psref);
   3553  1.340     ozaki 	if (ifp == NULL) {
   3554  1.340     ozaki 		error = ENODEV;
   3555  1.341  riastrad 		goto out0;
   3556  1.340     ozaki 	}
   3557  1.280     joerg 
   3558  1.280     joerg 	sdl = ifp->if_sadl;
   3559  1.280     joerg 	if (sdl == NULL) {
   3560  1.280     joerg 		*oldlenp = 0;
   3561  1.341  riastrad 		goto out1;
   3562  1.280     joerg 	}
   3563  1.280     joerg 
   3564  1.280     joerg 	if (oldp == NULL) {
   3565  1.280     joerg 		*oldlenp = sdl->sdl_alen;
   3566  1.341  riastrad 		goto out1;
   3567  1.280     joerg 	}
   3568  1.280     joerg 
   3569  1.280     joerg 	if (*oldlenp >= sdl->sdl_alen)
   3570  1.280     joerg 		*oldlenp = sdl->sdl_alen;
   3571  1.340     ozaki 	error = sysctl_copyout(l, &sdl->sdl_data[sdl->sdl_nlen], oldp, *oldlenp);
   3572  1.341  riastrad out1:
   3573  1.340     ozaki 	if_put(ifp, &psref);
   3574  1.341  riastrad out0:
   3575  1.340     ozaki 	curlwp_bindx(bound);
   3576  1.340     ozaki 	return error;
   3577  1.280     joerg }
   3578  1.280     joerg 
   3579  1.370     ozaki static void
   3580  1.370     ozaki if_sysctl_setup(struct sysctllog **clog)
   3581  1.280     joerg {
   3582  1.280     joerg 	const struct sysctlnode *rnode = NULL;
   3583  1.280     joerg 
   3584  1.280     joerg 	sysctl_createv(clog, 0, NULL, &rnode,
   3585  1.280     joerg 		       CTLFLAG_PERMANENT,
   3586  1.280     joerg 		       CTLTYPE_NODE, "sdl",
   3587  1.280     joerg 		       SYSCTL_DESCR("Get active link-layer address"),
   3588  1.280     joerg 		       if_sdl_sysctl, 0, NULL, 0,
   3589  1.280     joerg 		       CTL_NET, CTL_CREATE, CTL_EOL);
   3590  1.370     ozaki 
   3591  1.370     ozaki #if defined(INET)
   3592  1.370     ozaki 	sysctl_net_pktq_setup(NULL, PF_INET);
   3593  1.370     ozaki #endif
   3594  1.370     ozaki #ifdef INET6
   3595  1.370     ozaki 	if (in6_present)
   3596  1.370     ozaki 		sysctl_net_pktq_setup(NULL, PF_INET6);
   3597  1.370     ozaki #endif
   3598  1.280     joerg }
   3599