xref: /freebsd/sys/net/if.c (revision 5a4e46f6ec470593be5a3d2d41591e714759e1c0)
1c398230bSWarner Losh /*-
251369649SPedro F. Giffuni  * SPDX-License-Identifier: BSD-3-Clause
351369649SPedro F. Giffuni  *
4df8bae1dSRodney W. Grimes  * Copyright (c) 1980, 1986, 1993
5df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
6df8bae1dSRodney W. Grimes  *
7df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
8df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
9df8bae1dSRodney W. Grimes  * are met:
10df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
12df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
13df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
14df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
15fbbd9655SWarner Losh  * 3. Neither the name of the University nor the names of its contributors
16df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
17df8bae1dSRodney W. Grimes  *    without specific prior written permission.
18df8bae1dSRodney W. Grimes  *
19df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
30df8bae1dSRodney W. Grimes  *
3166afbd68SRuslan Ermilov  *	@(#)if.c	8.5 (Berkeley) 1/9/95
32c3aac50fSPeter Wemm  * $FreeBSD$
33df8bae1dSRodney W. Grimes  */
34df8bae1dSRodney W. Grimes 
353232273fSBjoern A. Zeeb #include "opt_bpf.h"
36cfa1ca9dSYoshinobu Inoue #include "opt_inet6.h"
370d0f9d1eSYoshinobu Inoue #include "opt_inet.h"
385591b823SEivind Eklund 
39df8bae1dSRodney W. Grimes #include <sys/param.h>
4027457983SMark Johnston #include <sys/capsicum.h>
41f13ad206SJonathan Lemon #include <sys/conf.h>
42e2e050c8SConrad Meyer #include <sys/eventhandler.h>
434d1d4912SBruce Evans #include <sys/malloc.h>
447687707dSAndrew Gallatin #include <sys/domainset.h>
454dcf2bbbSBrooks Davis #include <sys/sbuf.h>
46d2b4566aSJonathan Lemon #include <sys/bus.h>
47d7c5a620SMatt Macy #include <sys/epoch.h>
48df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
49df8bae1dSRodney W. Grimes #include <sys/systm.h>
50acd3428bSRobert Watson #include <sys/priv.h>
51df8bae1dSRodney W. Grimes #include <sys/proc.h>
52df8bae1dSRodney W. Grimes #include <sys/socket.h>
53df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
54df8bae1dSRodney W. Grimes #include <sys/protosw.h>
55df8bae1dSRodney W. Grimes #include <sys/kernel.h>
56653735c4SBjoern A. Zeeb #include <sys/lock.h>
5727d37320SRobert Watson #include <sys/refcount.h>
5821ca7b57SMarko Zec #include <sys/module.h>
59653735c4SBjoern A. Zeeb #include <sys/rwlock.h>
6051a53488SBruce Evans #include <sys/sockio.h>
61963e4c2aSGarrett Wollman #include <sys/syslog.h>
62602d513cSGarrett Wollman #include <sys/sysctl.h>
6386d2ef16SBrooks Davis #include <sys/sysent.h>
64af5e59bfSRobert Watson #include <sys/taskqueue.h>
6531b1bfe1SHajimu UMEMOTO #include <sys/domain.h>
6691421ba2SRobert Watson #include <sys/jail.h>
6735fd7bc0SBjoern A. Zeeb #include <sys/priv.h>
6835fd7bc0SBjoern A. Zeeb 
69fa882e87SBrooks Davis #include <machine/stdarg.h>
706e6b3f7cSQing Li #include <vm/uma.h>
71df8bae1dSRodney W. Grimes 
7262d76917SMarcel Moolenaar #include <net/bpf.h>
7362d76917SMarcel Moolenaar #include <net/ethernet.h>
74df8bae1dSRodney W. Grimes #include <net/if.h>
755a97c9d4SBjoern A. Zeeb #include <net/if_arp.h>
76f889d2efSBrooks Davis #include <net/if_clone.h>
77df8bae1dSRodney W. Grimes #include <net/if_dl.h>
7866ce51ceSArchie Cobbs #include <net/if_types.h>
7930aad87dSBrooks Davis #include <net/if_var.h>
8062d76917SMarcel Moolenaar #include <net/if_media.h>
8162d76917SMarcel Moolenaar #include <net/if_vlan_var.h>
829448326fSPoul-Henning Kamp #include <net/radix.h>
835500d3beSWarner Losh #include <net/route.h>
84e1c05fd2SAlexander V. Chernikov #include <net/route/route_ctl.h>
854b79449eSBjoern A. Zeeb #include <net/vnet.h>
86df8bae1dSRodney W. Grimes 
870d0f9d1eSYoshinobu Inoue #if defined(INET) || defined(INET6)
88209579aeSRick Macklem #include <net/ethernet.h>
8982cd038dSYoshinobu Inoue #include <netinet/in.h>
900d0f9d1eSYoshinobu Inoue #include <netinet/in_var.h>
913c914c54SAndre Oppermann #include <netinet/ip.h>
929963e8a5SWill Andrews #include <netinet/ip_carp.h>
933c914c54SAndre Oppermann #ifdef INET
947790c8c1SConrad Meyer #include <net/debugnet.h>
953c914c54SAndre Oppermann #include <netinet/if_ether.h>
963c914c54SAndre Oppermann #endif /* INET */
973411310dSYoshinobu Inoue #ifdef INET6
98978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_var.h>
99978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_ifattach.h>
1003c914c54SAndre Oppermann #endif /* INET6 */
1013c914c54SAndre Oppermann #endif /* INET || INET6 */
10282cd038dSYoshinobu Inoue 
103aed55708SRobert Watson #include <security/mac/mac_framework.h>
104aed55708SRobert Watson 
1058708f1bdSBrooks Davis /*
1068708f1bdSBrooks Davis  * Consumers of struct ifreq such as tcpdump assume no pad between ifr_name
1078708f1bdSBrooks Davis  * and ifr_ifru when it is used in SIOCGIFCONF.
1088708f1bdSBrooks Davis  */
1098708f1bdSBrooks Davis _Static_assert(sizeof(((struct ifreq *)0)->ifr_name) ==
1108708f1bdSBrooks Davis     offsetof(struct ifreq, ifr_ifru), "gap between ifr_name and ifr_ifru");
1118708f1bdSBrooks Davis 
112d71e30deSMatt Macy __read_mostly epoch_t net_epoch_preempt;
1139af74f3dSSergey Kandaurov #ifdef COMPAT_FREEBSD32
1149af74f3dSSergey Kandaurov #include <sys/mount.h>
1159af74f3dSSergey Kandaurov #include <compat/freebsd32/freebsd32.h>
11686d2ef16SBrooks Davis 
11786d2ef16SBrooks Davis struct ifreq_buffer32 {
11886d2ef16SBrooks Davis 	uint32_t	length;		/* (size_t) */
11986d2ef16SBrooks Davis 	uint32_t	buffer;		/* (void *) */
12086d2ef16SBrooks Davis };
12186d2ef16SBrooks Davis 
12286d2ef16SBrooks Davis /*
12386d2ef16SBrooks Davis  * Interface request structure used for socket
12486d2ef16SBrooks Davis  * ioctl's.  All interface ioctl's must have parameter
12586d2ef16SBrooks Davis  * definitions which begin with ifr_name.  The
12686d2ef16SBrooks Davis  * remainder may be interface specific.
12786d2ef16SBrooks Davis  */
12886d2ef16SBrooks Davis struct ifreq32 {
12986d2ef16SBrooks Davis 	char	ifr_name[IFNAMSIZ];		/* if name, e.g. "en0" */
13086d2ef16SBrooks Davis 	union {
13186d2ef16SBrooks Davis 		struct sockaddr	ifru_addr;
13286d2ef16SBrooks Davis 		struct sockaddr	ifru_dstaddr;
13386d2ef16SBrooks Davis 		struct sockaddr	ifru_broadaddr;
13486d2ef16SBrooks Davis 		struct ifreq_buffer32 ifru_buffer;
13586d2ef16SBrooks Davis 		short		ifru_flags[2];
13686d2ef16SBrooks Davis 		short		ifru_index;
13786d2ef16SBrooks Davis 		int		ifru_jid;
13886d2ef16SBrooks Davis 		int		ifru_metric;
13986d2ef16SBrooks Davis 		int		ifru_mtu;
14086d2ef16SBrooks Davis 		int		ifru_phys;
14186d2ef16SBrooks Davis 		int		ifru_media;
14286d2ef16SBrooks Davis 		uint32_t	ifru_data;
14386d2ef16SBrooks Davis 		int		ifru_cap[2];
14486d2ef16SBrooks Davis 		u_int		ifru_fib;
14586d2ef16SBrooks Davis 		u_char		ifru_vlan_pcp;
14686d2ef16SBrooks Davis 	} ifr_ifru;
14786d2ef16SBrooks Davis };
14886d2ef16SBrooks Davis CTASSERT(sizeof(struct ifreq) == sizeof(struct ifreq32));
14986d2ef16SBrooks Davis CTASSERT(__offsetof(struct ifreq, ifr_ifru) ==
15086d2ef16SBrooks Davis     __offsetof(struct ifreq32, ifr_ifru));
151756181b8SBrooks Davis 
1529c87db4bSJohn Baldwin struct ifconf32 {
1539c87db4bSJohn Baldwin 	int32_t	ifc_len;
1549c87db4bSJohn Baldwin 	union {
1559c87db4bSJohn Baldwin 		uint32_t	ifcu_buf;
1569c87db4bSJohn Baldwin 		uint32_t	ifcu_req;
1579c87db4bSJohn Baldwin 	} ifc_ifcu;
1589c87db4bSJohn Baldwin };
1599c87db4bSJohn Baldwin #define	SIOCGIFCONF32	_IOWR('i', 36, struct ifconf32)
1609c87db4bSJohn Baldwin 
161d61d98f4SJohn Baldwin struct ifdrv32 {
162d61d98f4SJohn Baldwin 	char		ifd_name[IFNAMSIZ];
163d61d98f4SJohn Baldwin 	uint32_t	ifd_cmd;
164d61d98f4SJohn Baldwin 	uint32_t	ifd_len;
165d61d98f4SJohn Baldwin 	uint32_t	ifd_data;
166d61d98f4SJohn Baldwin };
167d61d98f4SJohn Baldwin #define SIOCSDRVSPEC32	_IOC_NEWTYPE(SIOCSDRVSPEC, struct ifdrv32)
168d61d98f4SJohn Baldwin #define SIOCGDRVSPEC32	_IOC_NEWTYPE(SIOCGDRVSPEC, struct ifdrv32)
169d61d98f4SJohn Baldwin 
170756181b8SBrooks Davis struct ifgroupreq32 {
171756181b8SBrooks Davis 	char	ifgr_name[IFNAMSIZ];
172756181b8SBrooks Davis 	u_int	ifgr_len;
173756181b8SBrooks Davis 	union {
174756181b8SBrooks Davis 		char		ifgru_group[IFNAMSIZ];
175756181b8SBrooks Davis 		uint32_t	ifgru_groups;
176756181b8SBrooks Davis 	} ifgr_ifgru;
177756181b8SBrooks Davis };
17801e9cbc4SJohn Baldwin #define	SIOCAIFGROUP32	_IOC_NEWTYPE(SIOCAIFGROUP, struct ifgroupreq32)
17901e9cbc4SJohn Baldwin #define	SIOCGIFGROUP32	_IOC_NEWTYPE(SIOCGIFGROUP, struct ifgroupreq32)
18001e9cbc4SJohn Baldwin #define	SIOCDIFGROUP32	_IOC_NEWTYPE(SIOCDIFGROUP, struct ifgroupreq32)
18101e9cbc4SJohn Baldwin #define	SIOCGIFGMEMB32	_IOC_NEWTYPE(SIOCGIFGMEMB, struct ifgroupreq32)
1823edb7f4eSBrooks Davis 
1833edb7f4eSBrooks Davis struct ifmediareq32 {
1843edb7f4eSBrooks Davis 	char		ifm_name[IFNAMSIZ];
1853edb7f4eSBrooks Davis 	int		ifm_current;
1863edb7f4eSBrooks Davis 	int		ifm_mask;
1873edb7f4eSBrooks Davis 	int		ifm_status;
1883edb7f4eSBrooks Davis 	int		ifm_active;
1893edb7f4eSBrooks Davis 	int		ifm_count;
1903edb7f4eSBrooks Davis 	uint32_t	ifm_ulist;	/* (int *) */
1913edb7f4eSBrooks Davis };
1923edb7f4eSBrooks Davis #define	SIOCGIFMEDIA32	_IOC_NEWTYPE(SIOCGIFMEDIA, struct ifmediareq32)
1933edb7f4eSBrooks Davis #define	SIOCGIFXMEDIA32	_IOC_NEWTYPE(SIOCGIFXMEDIA, struct ifmediareq32)
19401e9cbc4SJohn Baldwin #endif /* COMPAT_FREEBSD32 */
1959af74f3dSSergey Kandaurov 
19686d2ef16SBrooks Davis union ifreq_union {
19786d2ef16SBrooks Davis 	struct ifreq	ifr;
19886d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
19986d2ef16SBrooks Davis 	struct ifreq32	ifr32;
20086d2ef16SBrooks Davis #endif
20186d2ef16SBrooks Davis };
20286d2ef16SBrooks Davis 
2037029da5cSPawel Biernacki SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
2047029da5cSPawel Biernacki     "Link layers");
2057029da5cSPawel Biernacki SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
2067029da5cSPawel Biernacki     "Generic link-management");
2075515c2e7SGleb Smirnoff 
208f88910cdSMatthew D Fleming SYSCTL_INT(_net_link, OID_AUTO, ifqmaxlen, CTLFLAG_RDTUN,
209e50d35e6SMaxim Sobolev     &ifqmaxlen, 0, "max send queue size");
210e50d35e6SMaxim Sobolev 
2115515c2e7SGleb Smirnoff /* Log link state change events */
2125515c2e7SGleb Smirnoff static int log_link_state_change = 1;
2135515c2e7SGleb Smirnoff 
2145515c2e7SGleb Smirnoff SYSCTL_INT(_net_link, OID_AUTO, log_link_state_change, CTLFLAG_RW,
2155515c2e7SGleb Smirnoff 	&log_link_state_change, 0,
2165515c2e7SGleb Smirnoff 	"log interface link state change events");
2175515c2e7SGleb Smirnoff 
2186d07c157SNick Hibma /* Log promiscuous mode change events */
2196d07c157SNick Hibma static int log_promisc_mode_change = 1;
2206d07c157SNick Hibma 
221dbd2ee46SNick Hibma SYSCTL_INT(_net_link, OID_AUTO, log_promisc_mode_change, CTLFLAG_RDTUN,
2226d07c157SNick Hibma 	&log_promisc_mode_change, 1,
2236d07c157SNick Hibma 	"log promiscuous mode change events");
2246d07c157SNick Hibma 
225215940b3SXin LI /* Interface description */
226215940b3SXin LI static unsigned int ifdescr_maxlen = 1024;
227215940b3SXin LI SYSCTL_UINT(_net, OID_AUTO, ifdescr_maxlen, CTLFLAG_RW,
228215940b3SXin LI 	&ifdescr_maxlen, 0,
229215940b3SXin LI 	"administrative maximum length for interface description");
230215940b3SXin LI 
231d745c852SEd Schouten static MALLOC_DEFINE(M_IFDESCR, "ifdescr", "ifnet descriptions");
232215940b3SXin LI 
233215940b3SXin LI /* global sx for non-critical path ifdescr */
234215940b3SXin LI static struct sx ifdescr_sx;
235215940b3SXin LI SX_SYSINIT(ifdescr_sx, &ifdescr_sx, "ifnet descr");
236215940b3SXin LI 
2371c7899c7SGleb Smirnoff void	(*ng_ether_link_state_p)(struct ifnet *ifp, int state);
238d6e82913SSteven Hartland void	(*lagg_linkstate_p)(struct ifnet *ifp, int state);
2399963e8a5SWill Andrews /* These are external hooks for CARP. */
24054bfbd51SWill Andrews void	(*carp_linkstate_p)(struct ifnet *ifp);
241f08535f8SGleb Smirnoff void	(*carp_demote_adj_p)(int, char *);
24224421c1cSGleb Smirnoff int	(*carp_master_p)(struct ifaddr *);
2439963e8a5SWill Andrews #if defined(INET) || defined(INET6)
24408b68b0eSGleb Smirnoff int	(*carp_forus_p)(struct ifnet *ifp, u_char *dhost);
2459963e8a5SWill Andrews int	(*carp_output_p)(struct ifnet *ifp, struct mbuf *m,
24647e8d432SGleb Smirnoff     const struct sockaddr *sa);
24708b68b0eSGleb Smirnoff int	(*carp_ioctl_p)(struct ifreq *, u_long, struct thread *);
24808b68b0eSGleb Smirnoff int	(*carp_attach_p)(struct ifaddr *, int);
249338e227aSLuiz Otavio O Souza void	(*carp_detach_p)(struct ifaddr *, bool);
2509963e8a5SWill Andrews #endif
2519963e8a5SWill Andrews #ifdef INET
25208b68b0eSGleb Smirnoff int	(*carp_iamatch_p)(struct ifaddr *, uint8_t **);
2539963e8a5SWill Andrews #endif
2549963e8a5SWill Andrews #ifdef INET6
2559963e8a5SWill Andrews struct ifaddr *(*carp_iamatch6_p)(struct ifnet *ifp, struct in6_addr *taddr6);
2569963e8a5SWill Andrews caddr_t	(*carp_macmatch6_p)(struct ifnet *ifp, struct mbuf *m,
2579963e8a5SWill Andrews     const struct in6_addr *taddr);
2589963e8a5SWill Andrews #endif
2591c7899c7SGleb Smirnoff 
2604cb655c0SMax Laier struct mbuf *(*tbr_dequeue_ptr)(struct ifaltq *, int) = NULL;
2614cb655c0SMax Laier 
262ec002feeSBruce M Simpson /*
263ec002feeSBruce M Simpson  * XXX: Style; these should be sorted alphabetically, and unprototyped
264ec002feeSBruce M Simpson  * static functions should be prototyped. Currently they are sorted by
265ec002feeSBruce M Simpson  * declaration order.
266ec002feeSBruce M Simpson  */
26731b1bfe1SHajimu UMEMOTO static void	if_attachdomain(void *);
26831b1bfe1SHajimu UMEMOTO static void	if_attachdomain1(struct ifnet *);
2690b59d917SJonathan Lemon static int	ifconf(u_long, caddr_t);
2704f6c66ccSMatt Macy static void	*if_grow(void);
271b57d9721SAndrey V. Elsukov static void	if_input_default(struct ifnet *, struct mbuf *);
2724fb3a820SAlexander V. Chernikov static int	if_requestencap_default(struct ifnet *, struct if_encap_req *);
2738614fb12SMax Laier static void	if_route(struct ifnet *, int flag, int fam);
2741a3b6859SYaroslav Tykhiy static int	if_setflag(struct ifnet *, int, int, int *, int);
275db7f0b97SKip Macy static int	if_transmit(struct ifnet *ifp, struct mbuf *m);
2768614fb12SMax Laier static void	if_unroute(struct ifnet *, int flag, int fam);
277ec002feeSBruce M Simpson static int	if_delmulti_locked(struct ifnet *, struct ifmultiaddr *, int);
27868a3482fSGleb Smirnoff static void	do_link_state_change(void *, int);
2790dad3f0eSMax Laier static int	if_getgroup(struct ifgroupreq *, struct ifnet *);
2800dad3f0eSMax Laier static int	if_getgroupmembers(struct ifgroupreq *);
2818623f9fdSMax Laier static void	if_delgroups(struct ifnet *);
282c92a456bSHiroki Sato static void	if_attach_internal(struct ifnet *, int, struct if_clone *);
283f501e6f1SBjoern A. Zeeb static int	if_detach_internal(struct ifnet *, int, struct if_clone **);
2840839aa5cSGleb Smirnoff static void	if_siocaddmulti(void *, int);
285a779388fSKristof Provost static void	if_link_ifnet(struct ifnet *);
286a779388fSKristof Provost static bool	if_unlink_ifnet(struct ifnet *, bool);
287ad4e9116SBjoern A. Zeeb #ifdef VIMAGE
288c7bab2a7SKyle Evans static int	if_vmove(struct ifnet *, struct vnet *);
289ad4e9116SBjoern A. Zeeb #endif
290db7f0b97SKip Macy 
29182cd038dSYoshinobu Inoue #ifdef INET6
29282cd038dSYoshinobu Inoue /*
29382cd038dSYoshinobu Inoue  * XXX: declare here to avoid to include many inet6 related files..
29482cd038dSYoshinobu Inoue  * should be more generalized?
29582cd038dSYoshinobu Inoue  */
296929ddbbbSAlfred Perlstein extern void	nd6_setmtu(struct ifnet *);
29782cd038dSYoshinobu Inoue #endif
29882cd038dSYoshinobu Inoue 
299ef91a976SAndrey V. Elsukov /* ipsec helper hooks */
300ef91a976SAndrey V. Elsukov VNET_DEFINE(struct hhook_head *, ipsec_hhh_in[HHOOK_IPSEC_COUNT]);
301ef91a976SAndrey V. Elsukov VNET_DEFINE(struct hhook_head *, ipsec_hhh_out[HHOOK_IPSEC_COUNT]);
302ef91a976SAndrey V. Elsukov 
30382cea7e6SBjoern A. Zeeb VNET_DEFINE(int, if_index);
30482cea7e6SBjoern A. Zeeb int	ifqmaxlen = IFQ_MAXLEN;
305eddfbb76SRobert Watson VNET_DEFINE(struct ifnethead, ifnet);	/* depend on static init XXX */
306eddfbb76SRobert Watson VNET_DEFINE(struct ifgrouphead, ifg_head);
30782cea7e6SBjoern A. Zeeb 
3085f901c92SAndrew Turner VNET_DEFINE_STATIC(int, if_indexlim) = 8;
309eddfbb76SRobert Watson 
31077dfcdc4SRobert Watson /* Table of ifnet by index. */
311e6abef09SGleb Smirnoff VNET_DEFINE(struct ifnet **, ifindex_table);
312eddfbb76SRobert Watson 
3131e77c105SRobert Watson #define	V_if_indexlim		VNET(if_indexlim)
3141e77c105SRobert Watson #define	V_ifindex_table		VNET(ifindex_table)
31544e33a07SMarko Zec 
31677dfcdc4SRobert Watson /*
31777dfcdc4SRobert Watson  * The global network interface list (V_ifnet) and related state (such as
318a60100fdSKristof Provost  * if_index, if_indexlim, and ifindex_table) are protected by an sxlock.
319a60100fdSKristof Provost  * This may be acquired to stabilise the list, or we may rely on NET_EPOCH.
32077dfcdc4SRobert Watson  */
32177dfcdc4SRobert Watson struct sx ifnet_sxlock;
3224ea05db8SGleb Smirnoff SX_SYSINIT_FLAGS(ifnet_sx, &ifnet_sxlock, "ifnet_sx", SX_RECURSE);
32377dfcdc4SRobert Watson 
324e133271fSKristof Provost struct sx ifnet_detach_sxlock;
3256d2a10d9SKristof Provost SX_SYSINIT_FLAGS(ifnet_detach, &ifnet_detach_sxlock, "ifnet_detach_sx",
3266d2a10d9SKristof Provost     SX_RECURSE);
327e133271fSKristof Provost 
328ed2dabfcSRobert Watson /*
329ed2dabfcSRobert Watson  * The allocation of network interfaces is a rather non-atomic affair; we
330ed2dabfcSRobert Watson  * need to select an index before we are ready to expose the interface for
331ed2dabfcSRobert Watson  * use, so will use this pointer value to indicate reservation.
332ed2dabfcSRobert Watson  */
333ed2dabfcSRobert Watson #define	IFNET_HOLD	(void *)(uintptr_t)(-1)
334ed2dabfcSRobert Watson 
33510108cb6SBjoern A. Zeeb #ifdef VIMAGE
33610108cb6SBjoern A. Zeeb #define	VNET_IS_SHUTTING_DOWN(_vnet)					\
33710108cb6SBjoern A. Zeeb     ((_vnet)->vnet_shutdown && (_vnet)->vnet_state < SI_SUB_VNET_DONE)
33810108cb6SBjoern A. Zeeb #endif
33910108cb6SBjoern A. Zeeb 
340fc74a9f9SBrooks Davis static	if_com_alloc_t *if_com_alloc[256];
341fc74a9f9SBrooks Davis static	if_com_free_t *if_com_free[256];
3420b59d917SJonathan Lemon 
343d745c852SEd Schouten static MALLOC_DEFINE(M_IFNET, "ifnet", "interface internals");
3440b59d917SJonathan Lemon MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
3450b59d917SJonathan Lemon MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
34630aad87dSBrooks Davis 
34721ca7b57SMarko Zec struct ifnet *
348d24c444cSKip Macy ifnet_byindex(u_short idx)
349d24c444cSKip Macy {
350d24c444cSKip Macy 	struct ifnet *ifp;
351d24c444cSKip Macy 
352270b83b9SHans Petter Selasky 	if (__predict_false(idx > V_if_index))
353270b83b9SHans Petter Selasky 		return (NULL);
354270b83b9SHans Petter Selasky 
355270b83b9SHans Petter Selasky 	ifp = *(struct ifnet * const volatile *)(V_ifindex_table + idx);
356270b83b9SHans Petter Selasky 	return (__predict_false(ifp == IFNET_HOLD) ? NULL : ifp);
35702f4879dSRobert Watson }
35802f4879dSRobert Watson 
35927d37320SRobert Watson struct ifnet *
36027d37320SRobert Watson ifnet_byindex_ref(u_short idx)
36127d37320SRobert Watson {
36227d37320SRobert Watson 	struct ifnet *ifp;
36327d37320SRobert Watson 
364b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
365b8a6e03fSGleb Smirnoff 
366270b83b9SHans Petter Selasky 	ifp = ifnet_byindex(idx);
367b8a6e03fSGleb Smirnoff 	if (ifp == NULL || (ifp->if_flags & IFF_DYING))
36827d37320SRobert Watson 		return (NULL);
3697563019bSAlexander V. Chernikov 	if (!if_try_ref(ifp))
3707563019bSAlexander V. Chernikov 		return (NULL);
37127d37320SRobert Watson 	return (ifp);
37227d37320SRobert Watson }
37327d37320SRobert Watson 
37461f6986bSRobert Watson /*
37561f6986bSRobert Watson  * Allocate an ifindex array entry; return 0 on success or an error on
37661f6986bSRobert Watson  * failure.
37761f6986bSRobert Watson  */
378f4507b71SGleb Smirnoff static u_short
3794f6c66ccSMatt Macy ifindex_alloc(void **old)
38061f6986bSRobert Watson {
38161f6986bSRobert Watson 	u_short idx;
38261f6986bSRobert Watson 
38361f6986bSRobert Watson 	IFNET_WLOCK_ASSERT();
38461f6986bSRobert Watson 	/*
385ed2dabfcSRobert Watson 	 * Try to find an empty slot below V_if_index.  If we fail, take the
38661f6986bSRobert Watson 	 * next slot.
38761f6986bSRobert Watson 	 */
38861f6986bSRobert Watson 	for (idx = 1; idx <= V_if_index; idx++) {
389e6abef09SGleb Smirnoff 		if (V_ifindex_table[idx] == NULL)
39061f6986bSRobert Watson 			break;
39161f6986bSRobert Watson 	}
39261f6986bSRobert Watson 
39361f6986bSRobert Watson 	/* Catch if_index overflow. */
3945f3b301aSJohn Baldwin 	if (idx >= V_if_indexlim) {
3954f6c66ccSMatt Macy 		*old = if_grow();
3964f6c66ccSMatt Macy 		return (USHRT_MAX);
3975f3b301aSJohn Baldwin 	}
39861f6986bSRobert Watson 	if (idx > V_if_index)
39961f6986bSRobert Watson 		V_if_index = idx;
400f4507b71SGleb Smirnoff 	return (idx);
40161f6986bSRobert Watson }
40261f6986bSRobert Watson 
403e0c14af9SMarko Zec static void
404ed2dabfcSRobert Watson ifindex_free_locked(u_short idx)
405ed2dabfcSRobert Watson {
406ed2dabfcSRobert Watson 
407ed2dabfcSRobert Watson 	IFNET_WLOCK_ASSERT();
408ed2dabfcSRobert Watson 
409e6abef09SGleb Smirnoff 	V_ifindex_table[idx] = NULL;
410ed2dabfcSRobert Watson 	while (V_if_index > 0 &&
411e6abef09SGleb Smirnoff 	    V_ifindex_table[V_if_index] == NULL)
412ed2dabfcSRobert Watson 		V_if_index--;
413ed2dabfcSRobert Watson }
414ed2dabfcSRobert Watson 
415ed2dabfcSRobert Watson static void
416ed2dabfcSRobert Watson ifindex_free(u_short idx)
417ed2dabfcSRobert Watson {
418ed2dabfcSRobert Watson 
419ed2dabfcSRobert Watson 	IFNET_WLOCK();
420ed2dabfcSRobert Watson 	ifindex_free_locked(idx);
421ed2dabfcSRobert Watson 	IFNET_WUNLOCK();
422ed2dabfcSRobert Watson }
423ed2dabfcSRobert Watson 
424ed2dabfcSRobert Watson static void
42577dfcdc4SRobert Watson ifnet_setbyindex(u_short idx, struct ifnet *ifp)
42677dfcdc4SRobert Watson {
42777dfcdc4SRobert Watson 
4284f6c66ccSMatt Macy 	V_ifindex_table[idx] = ifp;
42977dfcdc4SRobert Watson }
43077dfcdc4SRobert Watson 
43102f4879dSRobert Watson struct ifaddr *
43202f4879dSRobert Watson ifaddr_byindex(u_short idx)
43302f4879dSRobert Watson {
43422a93840SMarko Zec 	struct ifnet *ifp;
43522a93840SMarko Zec 	struct ifaddr *ifa = NULL;
43602f4879dSRobert Watson 
437b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
438b8a6e03fSGleb Smirnoff 
439270b83b9SHans Petter Selasky 	ifp = ifnet_byindex(idx);
44022a93840SMarko Zec 	if (ifp != NULL && (ifa = ifp->if_addr) != NULL)
4418c0fec80SRobert Watson 		ifa_ref(ifa);
44202f4879dSRobert Watson 	return (ifa);
44302f4879dSRobert Watson }
44402f4879dSRobert Watson 
445df8bae1dSRodney W. Grimes /*
446df8bae1dSRodney W. Grimes  * Network interface utility routines.
447df8bae1dSRodney W. Grimes  *
448df8bae1dSRodney W. Grimes  * Routines with ifa_ifwith* names take sockaddr *'s as
449df8bae1dSRodney W. Grimes  * parameters.
450df8bae1dSRodney W. Grimes  */
451a45cbf12SBrooks Davis 
452f9132cebSJonathan Lemon static void
453d0728d71SRobert Watson vnet_if_init(const void *unused __unused)
4541ed81b73SMarko Zec {
4554f6c66ccSMatt Macy 	void *old;
45644e33a07SMarko Zec 
4574f6c66ccSMatt Macy 	CK_STAILQ_INIT(&V_ifnet);
4584f6c66ccSMatt Macy 	CK_STAILQ_INIT(&V_ifg_head);
4595f3b301aSJohn Baldwin 	IFNET_WLOCK();
4604f6c66ccSMatt Macy 	old = if_grow();				/* create initial table */
4615f3b301aSJohn Baldwin 	IFNET_WUNLOCK();
4624f6c66ccSMatt Macy 	epoch_wait_preempt(net_epoch_preempt);
4634f6c66ccSMatt Macy 	free(old, M_IFNET);
464d0728d71SRobert Watson 	vnet_if_clone_init();
465f9132cebSJonathan Lemon }
4665f3b301aSJohn Baldwin VNET_SYSINIT(vnet_if_init, SI_SUB_INIT_IF, SI_ORDER_SECOND, vnet_if_init,
467d0728d71SRobert Watson     NULL);
468d0728d71SRobert Watson 
469bc29160dSMarko Zec #ifdef VIMAGE
470d0728d71SRobert Watson static void
471d0728d71SRobert Watson vnet_if_uninit(const void *unused __unused)
472bc29160dSMarko Zec {
473bc29160dSMarko Zec 
4744f6c66ccSMatt Macy 	VNET_ASSERT(CK_STAILQ_EMPTY(&V_ifnet), ("%s:%d tailq &V_ifnet=%p "
4750028e524SBjoern A. Zeeb 	    "not empty", __func__, __LINE__, &V_ifnet));
4764f6c66ccSMatt Macy 	VNET_ASSERT(CK_STAILQ_EMPTY(&V_ifg_head), ("%s:%d tailq &V_ifg_head=%p "
4770028e524SBjoern A. Zeeb 	    "not empty", __func__, __LINE__, &V_ifg_head));
478bc29160dSMarko Zec 
479bc29160dSMarko Zec 	free((caddr_t)V_ifindex_table, M_IFNET);
480bc29160dSMarko Zec }
481d0728d71SRobert Watson VNET_SYSUNINIT(vnet_if_uninit, SI_SUB_INIT_IF, SI_ORDER_FIRST,
482d0728d71SRobert Watson     vnet_if_uninit, NULL);
483bca0e1d2SKristof Provost #endif
484ad4e9116SBjoern A. Zeeb 
485ad4e9116SBjoern A. Zeeb static void
486a779388fSKristof Provost if_link_ifnet(struct ifnet *ifp)
487a779388fSKristof Provost {
488a779388fSKristof Provost 
489a779388fSKristof Provost 	IFNET_WLOCK();
490a779388fSKristof Provost 	CK_STAILQ_INSERT_TAIL(&V_ifnet, ifp, if_link);
491a779388fSKristof Provost #ifdef VIMAGE
492a779388fSKristof Provost 	curvnet->vnet_ifcnt++;
493a779388fSKristof Provost #endif
494a779388fSKristof Provost 	IFNET_WUNLOCK();
495a779388fSKristof Provost }
496a779388fSKristof Provost 
497a779388fSKristof Provost static bool
498a779388fSKristof Provost if_unlink_ifnet(struct ifnet *ifp, bool vmove)
499a779388fSKristof Provost {
500a779388fSKristof Provost 	struct ifnet *iter;
501a779388fSKristof Provost 	int found = 0;
502a779388fSKristof Provost 
503a779388fSKristof Provost 	IFNET_WLOCK();
504a779388fSKristof Provost 	CK_STAILQ_FOREACH(iter, &V_ifnet, if_link)
505a779388fSKristof Provost 		if (iter == ifp) {
506a779388fSKristof Provost 			CK_STAILQ_REMOVE(&V_ifnet, ifp, ifnet, if_link);
507a779388fSKristof Provost 			if (!vmove)
508a779388fSKristof Provost 				ifp->if_flags |= IFF_DYING;
509a779388fSKristof Provost 			found = 1;
510a779388fSKristof Provost 			break;
511a779388fSKristof Provost 		}
512a779388fSKristof Provost #ifdef VIMAGE
513a779388fSKristof Provost 	curvnet->vnet_ifcnt--;
514a779388fSKristof Provost #endif
515a779388fSKristof Provost 	IFNET_WUNLOCK();
516a779388fSKristof Provost 
517a779388fSKristof Provost 	return (found);
518a779388fSKristof Provost }
519a779388fSKristof Provost 
520bca0e1d2SKristof Provost #ifdef VIMAGE
521a779388fSKristof Provost static void
522ad4e9116SBjoern A. Zeeb vnet_if_return(const void *unused __unused)
523ad4e9116SBjoern A. Zeeb {
524ad4e9116SBjoern A. Zeeb 	struct ifnet *ifp, *nifp;
525a779388fSKristof Provost 	struct ifnet **pending;
526a779388fSKristof Provost 	int found, i;
527a779388fSKristof Provost 
528a779388fSKristof Provost 	i = 0;
529a779388fSKristof Provost 
530a779388fSKristof Provost 	/*
531a779388fSKristof Provost 	 * We need to protect our access to the V_ifnet tailq. Ordinarily we'd
532a779388fSKristof Provost 	 * enter NET_EPOCH, but that's not possible, because if_vmove() calls
533a779388fSKristof Provost 	 * if_detach_internal(), which waits for NET_EPOCH callbacks to
534a779388fSKristof Provost 	 * complete. We can't do that from within NET_EPOCH.
535a779388fSKristof Provost 	 *
536a779388fSKristof Provost 	 * However, we can also use the IFNET_xLOCK, which is the V_ifnet
537a779388fSKristof Provost 	 * read/write lock. We cannot hold the lock as we call if_vmove()
538a779388fSKristof Provost 	 * though, as that presents LOR w.r.t ifnet_sx, in_multi_sx and iflib
539a779388fSKristof Provost 	 * ctx lock.
540a779388fSKristof Provost 	 */
541a779388fSKristof Provost 	IFNET_WLOCK();
542a779388fSKristof Provost 
543a779388fSKristof Provost 	pending = malloc(sizeof(struct ifnet *) * curvnet->vnet_ifcnt,
544a779388fSKristof Provost 	    M_IFNET, M_WAITOK | M_ZERO);
545ad4e9116SBjoern A. Zeeb 
546ad4e9116SBjoern A. Zeeb 	/* Return all inherited interfaces to their parent vnets. */
5474f6c66ccSMatt Macy 	CK_STAILQ_FOREACH_SAFE(ifp, &V_ifnet, if_link, nifp) {
548a779388fSKristof Provost 		if (ifp->if_home_vnet != ifp->if_vnet) {
549a779388fSKristof Provost 			found = if_unlink_ifnet(ifp, true);
550a779388fSKristof Provost 			MPASS(found);
551a779388fSKristof Provost 
552a779388fSKristof Provost 			pending[i++] = ifp;
553ad4e9116SBjoern A. Zeeb 		}
554ad4e9116SBjoern A. Zeeb 	}
555a779388fSKristof Provost 	IFNET_WUNLOCK();
556a779388fSKristof Provost 
557a779388fSKristof Provost 	for (int j = 0; j < i; j++) {
558a779388fSKristof Provost 		if_vmove(pending[j], pending[j]->if_home_vnet);
559a779388fSKristof Provost 	}
560a779388fSKristof Provost 
561a779388fSKristof Provost 	free(pending, M_IFNET);
562a779388fSKristof Provost }
563ad4e9116SBjoern A. Zeeb VNET_SYSUNINIT(vnet_if_return, SI_SUB_VNET_DONE, SI_ORDER_ANY,
564ad4e9116SBjoern A. Zeeb     vnet_if_return, NULL);
565bc29160dSMarko Zec #endif
566bc29160dSMarko Zec 
5674f6c66ccSMatt Macy static void *
568f9132cebSJonathan Lemon if_grow(void)
569f9132cebSJonathan Lemon {
5705f3b301aSJohn Baldwin 	int oldlim;
571f9132cebSJonathan Lemon 	u_int n;
572e6abef09SGleb Smirnoff 	struct ifnet **e;
5734f6c66ccSMatt Macy 	void *old;
574f9132cebSJonathan Lemon 
5754f6c66ccSMatt Macy 	old = NULL;
5765f3b301aSJohn Baldwin 	IFNET_WLOCK_ASSERT();
5775f3b301aSJohn Baldwin 	oldlim = V_if_indexlim;
5785f3b301aSJohn Baldwin 	IFNET_WUNLOCK();
5795f3b301aSJohn Baldwin 	n = (oldlim << 1) * sizeof(*e);
580fc74a9f9SBrooks Davis 	e = malloc(n, M_IFNET, M_WAITOK | M_ZERO);
5815f3b301aSJohn Baldwin 	IFNET_WLOCK();
5825f3b301aSJohn Baldwin 	if (V_if_indexlim != oldlim) {
5835f3b301aSJohn Baldwin 		free(e, M_IFNET);
5844f6c66ccSMatt Macy 		return (NULL);
5855f3b301aSJohn Baldwin 	}
586603724d3SBjoern A. Zeeb 	if (V_ifindex_table != NULL) {
587603724d3SBjoern A. Zeeb 		memcpy((caddr_t)e, (caddr_t)V_ifindex_table, n/2);
5884f6c66ccSMatt Macy 		old = V_ifindex_table;
589f9132cebSJonathan Lemon 	}
5905f3b301aSJohn Baldwin 	V_if_indexlim <<= 1;
591603724d3SBjoern A. Zeeb 	V_ifindex_table = e;
5924f6c66ccSMatt Macy 	return (old);
593f9132cebSJonathan Lemon }
594f9132cebSJonathan Lemon 
595df8bae1dSRodney W. Grimes /*
596a45cbf12SBrooks Davis  * Allocate a struct ifnet and an index for an interface.  A layer 2
597a45cbf12SBrooks Davis  * common structure will also be allocated if an allocation routine is
598a45cbf12SBrooks Davis  * registered for the passed type.
599fc74a9f9SBrooks Davis  */
600fc74a9f9SBrooks Davis struct ifnet *
6017687707dSAndrew Gallatin if_alloc_domain(u_char type, int numa_domain)
602fc74a9f9SBrooks Davis {
603fc74a9f9SBrooks Davis 	struct ifnet *ifp;
60461f6986bSRobert Watson 	u_short idx;
6054f6c66ccSMatt Macy 	void *old;
606fc74a9f9SBrooks Davis 
6077687707dSAndrew Gallatin 	KASSERT(numa_domain <= IF_NODOM, ("numa_domain too large"));
6087687707dSAndrew Gallatin 	if (numa_domain == IF_NODOM)
6097687707dSAndrew Gallatin 		ifp = malloc(sizeof(struct ifnet), M_IFNET,
6107687707dSAndrew Gallatin 		    M_WAITOK | M_ZERO);
6117687707dSAndrew Gallatin 	else
6127687707dSAndrew Gallatin 		ifp = malloc_domainset(sizeof(struct ifnet), M_IFNET,
6137687707dSAndrew Gallatin 		    DOMAINSET_PREF(numa_domain), M_WAITOK | M_ZERO);
6144f6c66ccSMatt Macy  restart:
61561f6986bSRobert Watson 	IFNET_WLOCK();
6164f6c66ccSMatt Macy 	idx = ifindex_alloc(&old);
6174f6c66ccSMatt Macy 	if (__predict_false(idx == USHRT_MAX)) {
6184f6c66ccSMatt Macy 		IFNET_WUNLOCK();
6194f6c66ccSMatt Macy 		epoch_wait_preempt(net_epoch_preempt);
6204f6c66ccSMatt Macy 		free(old, M_IFNET);
6214f6c66ccSMatt Macy 		goto restart;
6224f6c66ccSMatt Macy 	}
6234f6c66ccSMatt Macy 	ifnet_setbyindex(idx, IFNET_HOLD);
62461f6986bSRobert Watson 	IFNET_WUNLOCK();
62561f6986bSRobert Watson 	ifp->if_index = idx;
626fc74a9f9SBrooks Davis 	ifp->if_type = type;
62727d37320SRobert Watson 	ifp->if_alloctype = type;
6287687707dSAndrew Gallatin 	ifp->if_numa_domain = numa_domain;
629a29c7aebSBjoern A. Zeeb #ifdef VIMAGE
630a29c7aebSBjoern A. Zeeb 	ifp->if_vnet = curvnet;
631a29c7aebSBjoern A. Zeeb #endif
632fc74a9f9SBrooks Davis 	if (if_com_alloc[type] != NULL) {
633fc74a9f9SBrooks Davis 		ifp->if_l2com = if_com_alloc[type](type, ifp);
63428ef2db4SBrooks Davis 		if (ifp->if_l2com == NULL) {
635fc74a9f9SBrooks Davis 			free(ifp, M_IFNET);
636ed2dabfcSRobert Watson 			ifindex_free(idx);
63728ef2db4SBrooks Davis 			return (NULL);
63828ef2db4SBrooks Davis 		}
639fc74a9f9SBrooks Davis 	}
64027d37320SRobert Watson 
64127d37320SRobert Watson 	IF_ADDR_LOCK_INIT(ifp);
642d6f157eaSRobert Watson 	TASK_INIT(&ifp->if_linktask, 0, do_link_state_change, ifp);
6430839aa5cSGleb Smirnoff 	TASK_INIT(&ifp->if_addmultitask, 0, if_siocaddmulti, ifp);
644d6f157eaSRobert Watson 	ifp->if_afdata_initialized = 0;
645e0c14af9SMarko Zec 	IF_AFDATA_LOCK_INIT(ifp);
646d7c5a620SMatt Macy 	CK_STAILQ_INIT(&ifp->if_addrhead);
647d7c5a620SMatt Macy 	CK_STAILQ_INIT(&ifp->if_multiaddrs);
6484f6c66ccSMatt Macy 	CK_STAILQ_INIT(&ifp->if_groups);
649d6f157eaSRobert Watson #ifdef MAC
650d6f157eaSRobert Watson 	mac_ifnet_init(ifp);
651d6f157eaSRobert Watson #endif
652d659538fSSam Leffler 	ifq_init(&ifp->if_snd, ifp);
653d6f157eaSRobert Watson 
65427d37320SRobert Watson 	refcount_init(&ifp->if_refcount, 1);	/* Index reference. */
655112f50ffSGleb Smirnoff 	for (int i = 0; i < IFCOUNTERS; i++)
656112f50ffSGleb Smirnoff 		ifp->if_counters[i] = counter_u64_alloc(M_WAITOK);
65761dc4344SAndrey V. Elsukov 	ifp->if_get_counter = if_get_counter_default;
658f1379734SKonstantin Belousov 	ifp->if_pcp = IFNET_PCP_NONE;
65961dc4344SAndrey V. Elsukov 	ifnet_setbyindex(ifp->if_index, ifp);
660fc74a9f9SBrooks Davis 	return (ifp);
661fc74a9f9SBrooks Davis }
662fc74a9f9SBrooks Davis 
6637687707dSAndrew Gallatin struct ifnet *
6647687707dSAndrew Gallatin if_alloc_dev(u_char type, device_t dev)
6657687707dSAndrew Gallatin {
6667687707dSAndrew Gallatin 	int numa_domain;
6677687707dSAndrew Gallatin 
6687687707dSAndrew Gallatin 	if (dev == NULL || bus_get_domain(dev, &numa_domain) != 0)
6697687707dSAndrew Gallatin 		return (if_alloc_domain(type, IF_NODOM));
6707687707dSAndrew Gallatin 	return (if_alloc_domain(type, numa_domain));
6717687707dSAndrew Gallatin }
6727687707dSAndrew Gallatin 
6737687707dSAndrew Gallatin struct ifnet *
6747687707dSAndrew Gallatin if_alloc(u_char type)
6757687707dSAndrew Gallatin {
6767687707dSAndrew Gallatin 
6777687707dSAndrew Gallatin 	return (if_alloc_domain(type, IF_NODOM));
6787687707dSAndrew Gallatin }
679a45cbf12SBrooks Davis /*
6804c506522SGleb Smirnoff  * Do the actual work of freeing a struct ifnet, and layer 2 common
6814c506522SGleb Smirnoff  * structure.  This call is made when the last reference to an
682242a8e72SRobert Watson  * interface is released.
683a45cbf12SBrooks Davis  */
684242a8e72SRobert Watson static void
685242a8e72SRobert Watson if_free_internal(struct ifnet *ifp)
686fc74a9f9SBrooks Davis {
687fc74a9f9SBrooks Davis 
688242a8e72SRobert Watson 	KASSERT((ifp->if_flags & IFF_DYING),
689242a8e72SRobert Watson 	    ("if_free_internal: interface not dying"));
690fc74a9f9SBrooks Davis 
69127d37320SRobert Watson 	if (if_com_free[ifp->if_alloctype] != NULL)
69227d37320SRobert Watson 		if_com_free[ifp->if_alloctype](ifp->if_l2com,
69327d37320SRobert Watson 		    ifp->if_alloctype);
694fc74a9f9SBrooks Davis 
695d6f157eaSRobert Watson #ifdef MAC
696d6f157eaSRobert Watson 	mac_ifnet_destroy(ifp);
697d6f157eaSRobert Watson #endif /* MAC */
698d6f157eaSRobert Watson 	IF_AFDATA_DESTROY(ifp);
69902f4879dSRobert Watson 	IF_ADDR_LOCK_DESTROY(ifp);
700d659538fSSam Leffler 	ifq_delete(&ifp->if_snd);
701112f50ffSGleb Smirnoff 
702112f50ffSGleb Smirnoff 	for (int i = 0; i < IFCOUNTERS; i++)
703112f50ffSGleb Smirnoff 		counter_u64_free(ifp->if_counters[i]);
704112f50ffSGleb Smirnoff 
70585107355SAndrey V. Elsukov 	free(ifp->if_description, M_IFDESCR);
70685107355SAndrey V. Elsukov 	free(ifp->if_hw_addr, M_IFADDR);
707fc74a9f9SBrooks Davis 	free(ifp, M_IFNET);
708c0c9ea90SSam Leffler }
709fc74a9f9SBrooks Davis 
7104f6c66ccSMatt Macy static void
7114f6c66ccSMatt Macy if_destroy(epoch_context_t ctx)
7124f6c66ccSMatt Macy {
7134f6c66ccSMatt Macy 	struct ifnet *ifp;
7144f6c66ccSMatt Macy 
7154f6c66ccSMatt Macy 	ifp = __containerof(ctx, struct ifnet, if_epoch_ctx);
7164f6c66ccSMatt Macy 	if_free_internal(ifp);
7174f6c66ccSMatt Macy }
7184f6c66ccSMatt Macy 
719242a8e72SRobert Watson /*
720f26fa169SBrooks Davis  * Deregister an interface and free the associated storage.
721242a8e72SRobert Watson  */
722242a8e72SRobert Watson void
723f26fa169SBrooks Davis if_free(struct ifnet *ifp)
724242a8e72SRobert Watson {
725242a8e72SRobert Watson 
726242a8e72SRobert Watson 	ifp->if_flags |= IFF_DYING;			/* XXX: Locking */
7274c506522SGleb Smirnoff 
728719fb725SCraig Rodrigues 	CURVNET_SET_QUIET(ifp->if_vnet);
7294c506522SGleb Smirnoff 	IFNET_WLOCK();
730270b83b9SHans Petter Selasky 	KASSERT(ifp == ifnet_byindex(ifp->if_index),
7314c506522SGleb Smirnoff 	    ("%s: freeing unallocated ifnet", ifp->if_xname));
7324c506522SGleb Smirnoff 
7334c506522SGleb Smirnoff 	ifindex_free_locked(ifp->if_index);
7344c506522SGleb Smirnoff 	IFNET_WUNLOCK();
7354c506522SGleb Smirnoff 
736719fb725SCraig Rodrigues 	if (refcount_release(&ifp->if_refcount))
7372a4bd982SGleb Smirnoff 		NET_EPOCH_CALL(if_destroy, &ifp->if_epoch_ctx);
738719fb725SCraig Rodrigues 	CURVNET_RESTORE();
739242a8e72SRobert Watson }
740242a8e72SRobert Watson 
741242a8e72SRobert Watson /*
742242a8e72SRobert Watson  * Interfaces to keep an ifnet type-stable despite the possibility of the
743242a8e72SRobert Watson  * driver calling if_free().  If there are additional references, we defer
744242a8e72SRobert Watson  * freeing the underlying data structure.
745242a8e72SRobert Watson  */
746db7f0b97SKip Macy void
74727d37320SRobert Watson if_ref(struct ifnet *ifp)
74827d37320SRobert Watson {
749*5a4e46f6SMateusz Guzik 	u_int old __diagused;
75027d37320SRobert Watson 
75127d37320SRobert Watson 	/* We don't assert the ifnet list lock here, but arguably should. */
7527563019bSAlexander V. Chernikov 	old = refcount_acquire(&ifp->if_refcount);
7537563019bSAlexander V. Chernikov 	KASSERT(old > 0, ("%s: ifp %p has 0 refs", __func__, ifp));
7547563019bSAlexander V. Chernikov }
7557563019bSAlexander V. Chernikov 
7567563019bSAlexander V. Chernikov bool
7577563019bSAlexander V. Chernikov if_try_ref(struct ifnet *ifp)
7587563019bSAlexander V. Chernikov {
7597563019bSAlexander V. Chernikov 	NET_EPOCH_ASSERT();
7607563019bSAlexander V. Chernikov 	return (refcount_acquire_if_not_zero(&ifp->if_refcount));
76127d37320SRobert Watson }
76227d37320SRobert Watson 
76327d37320SRobert Watson void
76427d37320SRobert Watson if_rele(struct ifnet *ifp)
76527d37320SRobert Watson {
76627d37320SRobert Watson 
767242a8e72SRobert Watson 	if (!refcount_release(&ifp->if_refcount))
768242a8e72SRobert Watson 		return;
7692a4bd982SGleb Smirnoff 	NET_EPOCH_CALL(if_destroy, &ifp->if_epoch_ctx);
77027d37320SRobert Watson }
77127d37320SRobert Watson 
77227d37320SRobert Watson void
773d659538fSSam Leffler ifq_init(struct ifaltq *ifq, struct ifnet *ifp)
774db7f0b97SKip Macy {
775db7f0b97SKip Macy 
776db7f0b97SKip Macy 	mtx_init(&ifq->ifq_mtx, ifp->if_xname, "if send queue", MTX_DEF);
777db7f0b97SKip Macy 
778db7f0b97SKip Macy 	if (ifq->ifq_maxlen == 0)
779db7f0b97SKip Macy 		ifq->ifq_maxlen = ifqmaxlen;
780db7f0b97SKip Macy 
781db7f0b97SKip Macy 	ifq->altq_type = 0;
782db7f0b97SKip Macy 	ifq->altq_disc = NULL;
783db7f0b97SKip Macy 	ifq->altq_flags &= ALTQF_CANTCHANGE;
784db7f0b97SKip Macy 	ifq->altq_tbr  = NULL;
785db7f0b97SKip Macy 	ifq->altq_ifp  = ifp;
786db7f0b97SKip Macy }
787db7f0b97SKip Macy 
788db7f0b97SKip Macy void
789d659538fSSam Leffler ifq_delete(struct ifaltq *ifq)
790db7f0b97SKip Macy {
791db7f0b97SKip Macy 	mtx_destroy(&ifq->ifq_mtx);
792db7f0b97SKip Macy }
793db7f0b97SKip Macy 
794fc74a9f9SBrooks Davis /*
795a4641f4eSPedro F. Giffuni  * Perform generic interface initialization tasks and attach the interface
796e0c14af9SMarko Zec  * to the list of "active" interfaces.  If vmove flag is set on entry
797e0c14af9SMarko Zec  * to if_attach_internal(), perform only a limited subset of initialization
798e0c14af9SMarko Zec  * tasks, given that we are moving from one vnet to another an ifnet which
799e0c14af9SMarko Zec  * has already been fully initialized.
800a45cbf12SBrooks Davis  *
801c92a456bSHiroki Sato  * Note that if_detach_internal() removes group membership unconditionally
802c92a456bSHiroki Sato  * even when vmove flag is set, and if_attach_internal() adds only IFG_ALL.
803c92a456bSHiroki Sato  * Thus, when if_vmove() is applied to a cloned interface, group membership
804c92a456bSHiroki Sato  * is lost while a cloned one always joins a group whose name is
805c92a456bSHiroki Sato  * ifc->ifc_name.  To recover this after if_detach_internal() and
806c92a456bSHiroki Sato  * if_attach_internal(), the cloner should be specified to
807c92a456bSHiroki Sato  * if_attach_internal() via ifc.  If it is non-NULL, if_attach_internal()
808c92a456bSHiroki Sato  * attempts to join a group whose name is ifc->ifc_name.
809c92a456bSHiroki Sato  *
810a45cbf12SBrooks Davis  * XXX:
811a45cbf12SBrooks Davis  *  - The decision to return void and thus require this function to
812a45cbf12SBrooks Davis  *    succeed is questionable.
813a45cbf12SBrooks Davis  *  - We should probably do more sanity checking.  For instance we don't
814a45cbf12SBrooks Davis  *    do anything to insure if_xname is unique or non-empty.
815df8bae1dSRodney W. Grimes  */
816df8bae1dSRodney W. Grimes void
81772fd1b6aSDag-Erling Smørgrav if_attach(struct ifnet *ifp)
818df8bae1dSRodney W. Grimes {
819e0c14af9SMarko Zec 
820c92a456bSHiroki Sato 	if_attach_internal(ifp, 0, NULL);
821e0c14af9SMarko Zec }
822e0c14af9SMarko Zec 
8239fd573c3SHans Petter Selasky /*
8249fd573c3SHans Petter Selasky  * Compute the least common TSO limit.
8259fd573c3SHans Petter Selasky  */
8269fd573c3SHans Petter Selasky void
8279fd573c3SHans Petter Selasky if_hw_tsomax_common(if_t ifp, struct ifnet_hw_tsomax *pmax)
8289fd573c3SHans Petter Selasky {
8299fd573c3SHans Petter Selasky 	/*
8309fd573c3SHans Petter Selasky 	 * 1) If there is no limit currently, take the limit from
8319fd573c3SHans Petter Selasky 	 * the network adapter.
8329fd573c3SHans Petter Selasky 	 *
8339fd573c3SHans Petter Selasky 	 * 2) If the network adapter has a limit below the current
8349fd573c3SHans Petter Selasky 	 * limit, apply it.
8359fd573c3SHans Petter Selasky 	 */
8369fd573c3SHans Petter Selasky 	if (pmax->tsomaxbytes == 0 || (ifp->if_hw_tsomax != 0 &&
8379fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomax < pmax->tsomaxbytes)) {
8389fd573c3SHans Petter Selasky 		pmax->tsomaxbytes = ifp->if_hw_tsomax;
8399fd573c3SHans Petter Selasky 	}
8409fd573c3SHans Petter Selasky 	if (pmax->tsomaxsegcount == 0 || (ifp->if_hw_tsomaxsegcount != 0 &&
8419fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomaxsegcount < pmax->tsomaxsegcount)) {
8429fd573c3SHans Petter Selasky 		pmax->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
8439fd573c3SHans Petter Selasky 	}
8449fd573c3SHans Petter Selasky 	if (pmax->tsomaxsegsize == 0 || (ifp->if_hw_tsomaxsegsize != 0 &&
8459fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomaxsegsize < pmax->tsomaxsegsize)) {
8469fd573c3SHans Petter Selasky 		pmax->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
8479fd573c3SHans Petter Selasky 	}
8489fd573c3SHans Petter Selasky }
8499fd573c3SHans Petter Selasky 
8509fd573c3SHans Petter Selasky /*
8519fd573c3SHans Petter Selasky  * Update TSO limit of a network adapter.
8529fd573c3SHans Petter Selasky  *
8539fd573c3SHans Petter Selasky  * Returns zero if no change. Else non-zero.
8549fd573c3SHans Petter Selasky  */
8559fd573c3SHans Petter Selasky int
8569fd573c3SHans Petter Selasky if_hw_tsomax_update(if_t ifp, struct ifnet_hw_tsomax *pmax)
8579fd573c3SHans Petter Selasky {
8589fd573c3SHans Petter Selasky 	int retval = 0;
8599fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomax != pmax->tsomaxbytes) {
8609fd573c3SHans Petter Selasky 		ifp->if_hw_tsomax = pmax->tsomaxbytes;
8619fd573c3SHans Petter Selasky 		retval++;
8629fd573c3SHans Petter Selasky 	}
8639fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomaxsegsize != pmax->tsomaxsegsize) {
8649fd573c3SHans Petter Selasky 		ifp->if_hw_tsomaxsegsize = pmax->tsomaxsegsize;
8659fd573c3SHans Petter Selasky 		retval++;
8669fd573c3SHans Petter Selasky 	}
8679fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomaxsegcount != pmax->tsomaxsegcount) {
8689fd573c3SHans Petter Selasky 		ifp->if_hw_tsomaxsegcount = pmax->tsomaxsegcount;
8699fd573c3SHans Petter Selasky 		retval++;
8709fd573c3SHans Petter Selasky 	}
8719fd573c3SHans Petter Selasky 	return (retval);
8729fd573c3SHans Petter Selasky }
8739fd573c3SHans Petter Selasky 
874e0c14af9SMarko Zec static void
875c92a456bSHiroki Sato if_attach_internal(struct ifnet *ifp, int vmove, struct if_clone *ifc)
876e0c14af9SMarko Zec {
877df8bae1dSRodney W. Grimes 	unsigned socksize, ifasize;
8781ce9bf88SPoul-Henning Kamp 	int namelen, masklen;
87972fd1b6aSDag-Erling Smørgrav 	struct sockaddr_dl *sdl;
88072fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
881df8bae1dSRodney W. Grimes 
882fc74a9f9SBrooks Davis 	if (ifp->if_index == 0 || ifp != ifnet_byindex(ifp->if_index))
883fc74a9f9SBrooks Davis 		panic ("%s: BUG: if_attach called without if_alloc'd input()\n",
884fc74a9f9SBrooks Davis 		    ifp->if_xname);
885fc74a9f9SBrooks Davis 
886f6dfe47aSMarko Zec #ifdef VIMAGE
887f6dfe47aSMarko Zec 	ifp->if_vnet = curvnet;
888bc29160dSMarko Zec 	if (ifp->if_home_vnet == NULL)
889bc29160dSMarko Zec 		ifp->if_home_vnet = curvnet;
890f6dfe47aSMarko Zec #endif
891f6dfe47aSMarko Zec 
8920dad3f0eSMax Laier 	if_addgroup(ifp, IFG_ALL);
8930dad3f0eSMax Laier 
894c92a456bSHiroki Sato 	/* Restore group membership for cloned interfaces. */
895c92a456bSHiroki Sato 	if (vmove && ifc != NULL)
896c92a456bSHiroki Sato 		if_clone_addgroup(ifp, ifc);
897c92a456bSHiroki Sato 
89898b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
899e6485f73SGleb Smirnoff 	ifp->if_epoch = time_uptime;
900d6f157eaSRobert Watson 
9017cc5b47fSKip Macy 	KASSERT((ifp->if_transmit == NULL && ifp->if_qflush == NULL) ||
9027cc5b47fSKip Macy 	    (ifp->if_transmit != NULL && ifp->if_qflush != NULL),
9037cc5b47fSKip Macy 	    ("transmit and qflush must both either be set or both be NULL"));
9047cc5b47fSKip Macy 	if (ifp->if_transmit == NULL) {
905db7f0b97SKip Macy 		ifp->if_transmit = if_transmit;
906db7f0b97SKip Macy 		ifp->if_qflush = if_qflush;
9077cc5b47fSKip Macy 	}
908b57d9721SAndrey V. Elsukov 	if (ifp->if_input == NULL)
909b57d9721SAndrey V. Elsukov 		ifp->if_input = if_input_default;
9107cc5b47fSKip Macy 
9114fb3a820SAlexander V. Chernikov 	if (ifp->if_requestencap == NULL)
9124fb3a820SAlexander V. Chernikov 		ifp->if_requestencap = if_requestencap_default;
9134fb3a820SAlexander V. Chernikov 
914e0c14af9SMarko Zec 	if (!vmove) {
915e70cd263SRobert Watson #ifdef MAC
91630d239bcSRobert Watson 		mac_ifnet_create(ifp);
917e70cd263SRobert Watson #endif
918e70cd263SRobert Watson 
919df8bae1dSRodney W. Grimes 		/*
920e0c14af9SMarko Zec 		 * Create a Link Level name for this device.
921df8bae1dSRodney W. Grimes 		 */
9229bf40edeSBrooks Davis 		namelen = strlen(ifp->if_xname);
92336c19a57SBrooks Davis 		/*
924e0c14af9SMarko Zec 		 * Always save enough space for any possiable name so we
925e0c14af9SMarko Zec 		 * can do a rename in place later.
92636c19a57SBrooks Davis 		 */
92736c19a57SBrooks Davis 		masklen = offsetof(struct sockaddr_dl, sdl_data[0]) + IFNAMSIZ;
928df8bae1dSRodney W. Grimes 		socksize = masklen + ifp->if_addrlen;
929df8bae1dSRodney W. Grimes 		if (socksize < sizeof(*sdl))
930df8bae1dSRodney W. Grimes 			socksize = sizeof(*sdl);
931ccb82468SBrooks Davis 		socksize = roundup2(socksize, sizeof(long));
932df8bae1dSRodney W. Grimes 		ifasize = sizeof(*ifa) + 2 * socksize;
93346758960SGleb Smirnoff 		ifa = ifa_alloc(ifasize, M_WAITOK);
934df8bae1dSRodney W. Grimes 		sdl = (struct sockaddr_dl *)(ifa + 1);
935df8bae1dSRodney W. Grimes 		sdl->sdl_len = socksize;
936df8bae1dSRodney W. Grimes 		sdl->sdl_family = AF_LINK;
9379bf40edeSBrooks Davis 		bcopy(ifp->if_xname, sdl->sdl_data, namelen);
9381ce9bf88SPoul-Henning Kamp 		sdl->sdl_nlen = namelen;
939df8bae1dSRodney W. Grimes 		sdl->sdl_index = ifp->if_index;
940df8bae1dSRodney W. Grimes 		sdl->sdl_type = ifp->if_type;
9414a0d6638SRuslan Ermilov 		ifp->if_addr = ifa;
942df8bae1dSRodney W. Grimes 		ifa->ifa_ifp = ifp;
943df8bae1dSRodney W. Grimes 		ifa->ifa_addr = (struct sockaddr *)sdl;
944df8bae1dSRodney W. Grimes 		sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
945df8bae1dSRodney W. Grimes 		ifa->ifa_netmask = (struct sockaddr *)sdl;
946df8bae1dSRodney W. Grimes 		sdl->sdl_len = masklen;
947df8bae1dSRodney W. Grimes 		while (namelen != 0)
948df8bae1dSRodney W. Grimes 			sdl->sdl_data[--namelen] = 0xff;
949d7c5a620SMatt Macy 		CK_STAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
950e0c14af9SMarko Zec 		/* Reliably crash if used uninitialized. */
951e0c14af9SMarko Zec 		ifp->if_broadcastaddr = NULL;
95272f31000SHans Petter Selasky 
953ddae5750SRavi Pokala 		if (ifp->if_type == IFT_ETHER) {
954ddae5750SRavi Pokala 			ifp->if_hw_addr = malloc(ifp->if_addrlen, M_IFADDR,
955ddae5750SRavi Pokala 			    M_WAITOK | M_ZERO);
956ddae5750SRavi Pokala 		}
957ddae5750SRavi Pokala 
95872f31000SHans Petter Selasky #if defined(INET) || defined(INET6)
9599fd573c3SHans Petter Selasky 		/* Use defaults for TSO, if nothing is set */
9609fd573c3SHans Petter Selasky 		if (ifp->if_hw_tsomax == 0 &&
9619fd573c3SHans Petter Selasky 		    ifp->if_hw_tsomaxsegcount == 0 &&
9629fd573c3SHans Petter Selasky 		    ifp->if_hw_tsomaxsegsize == 0) {
9639fd573c3SHans Petter Selasky 			/*
9649fd573c3SHans Petter Selasky 			 * The TSO defaults needs to be such that an
9659fd573c3SHans Petter Selasky 			 * NFS mbuf list of 35 mbufs totalling just
9669fd573c3SHans Petter Selasky 			 * below 64K works and that a chain of mbufs
9679fd573c3SHans Petter Selasky 			 * can be defragged into at most 32 segments:
9689fd573c3SHans Petter Selasky 			 */
9699fd573c3SHans Petter Selasky 			ifp->if_hw_tsomax = min(IP_MAXPACKET, (32 * MCLBYTES) -
97072f31000SHans Petter Selasky 			    (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN));
9719fd573c3SHans Petter Selasky 			ifp->if_hw_tsomaxsegcount = 35;
9729fd573c3SHans Petter Selasky 			ifp->if_hw_tsomaxsegsize = 2048;	/* 2K */
9739fd573c3SHans Petter Selasky 
9749fd573c3SHans Petter Selasky 			/* XXX some drivers set IFCAP_TSO after ethernet attach */
9759fd573c3SHans Petter Selasky 			if (ifp->if_capabilities & IFCAP_TSO) {
9769fd573c3SHans Petter Selasky 				if_printf(ifp, "Using defaults for TSO: %u/%u/%u\n",
9779fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomax,
9789fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomaxsegcount,
9799fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomaxsegsize);
9809fd573c3SHans Petter Selasky 			}
9819fd573c3SHans Petter Selasky 		}
98272f31000SHans Petter Selasky #endif
983e0c14af9SMarko Zec 	}
98452db6805SMarko Zec #ifdef VIMAGE
98552db6805SMarko Zec 	else {
98652db6805SMarko Zec 		/*
98752db6805SMarko Zec 		 * Update the interface index in the link layer address
98852db6805SMarko Zec 		 * of the interface.
98952db6805SMarko Zec 		 */
99052db6805SMarko Zec 		for (ifa = ifp->if_addr; ifa != NULL;
991d7c5a620SMatt Macy 		    ifa = CK_STAILQ_NEXT(ifa, ifa_link)) {
99252db6805SMarko Zec 			if (ifa->ifa_addr->sa_family == AF_LINK) {
99352db6805SMarko Zec 				sdl = (struct sockaddr_dl *)ifa->ifa_addr;
99452db6805SMarko Zec 				sdl->sdl_index = ifp->if_index;
99552db6805SMarko Zec 			}
99652db6805SMarko Zec 		}
99752db6805SMarko Zec 	}
99852db6805SMarko Zec #endif
999d94ccb09SBrooks Davis 
1000a779388fSKristof Provost 	if_link_ifnet(ifp);
1001457f48e6SGleb Smirnoff 
100269fb23b7SMax Laier 	if (domain_init_status >= 2)
100331b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
100431b1bfe1SHajimu UMEMOTO 
100525a4adceSMax Laier 	EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
100621ca7b57SMarko Zec 	if (IS_DEFAULT_VNET(curvnet))
1007f3b90d48SAndrew Thompson 		devctl_notify("IFNET", ifp->if_xname, "ATTACH", NULL);
100825a4adceSMax Laier 
10097b6edd04SRuslan Ermilov 	/* Announce the interface. */
10107b6edd04SRuslan Ermilov 	rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
1011df8bae1dSRodney W. Grimes }
10126182fdbdSPeter Wemm 
101331b1bfe1SHajimu UMEMOTO static void
1014f2d19f98SMatt Macy if_epochalloc(void *dummy __unused)
1015f2d19f98SMatt Macy {
1016f2d19f98SMatt Macy 
1017dd902d01SGleb Smirnoff 	net_epoch_preempt = epoch_alloc("Net preemptible", EPOCH_PREEMPT);
1018f2d19f98SMatt Macy }
10197993a104SConrad Meyer SYSINIT(ifepochalloc, SI_SUB_EPOCH, SI_ORDER_ANY, if_epochalloc, NULL);
1020f2d19f98SMatt Macy 
1021f2d19f98SMatt Macy static void
102272fd1b6aSDag-Erling Smørgrav if_attachdomain(void *dummy)
102331b1bfe1SHajimu UMEMOTO {
102431b1bfe1SHajimu UMEMOTO 	struct ifnet *ifp;
102531b1bfe1SHajimu UMEMOTO 
10264f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link)
102731b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
102831b1bfe1SHajimu UMEMOTO }
102969fb23b7SMax Laier SYSINIT(domainifattach, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_SECOND,
103031b1bfe1SHajimu UMEMOTO     if_attachdomain, NULL);
103131b1bfe1SHajimu UMEMOTO 
103231b1bfe1SHajimu UMEMOTO static void
103372fd1b6aSDag-Erling Smørgrav if_attachdomain1(struct ifnet *ifp)
103431b1bfe1SHajimu UMEMOTO {
103531b1bfe1SHajimu UMEMOTO 	struct domain *dp;
103631b1bfe1SHajimu UMEMOTO 
1037234a35c7SHajimu UMEMOTO 	/*
1038234a35c7SHajimu UMEMOTO 	 * Since dp->dom_ifattach calls malloc() with M_WAITOK, we
1039234a35c7SHajimu UMEMOTO 	 * cannot lock ifp->if_afdata initialization, entirely.
1040234a35c7SHajimu UMEMOTO 	 */
1041c169d9feSBjoern A. Zeeb 	IF_AFDATA_LOCK(ifp);
104269fb23b7SMax Laier 	if (ifp->if_afdata_initialized >= domain_init_status) {
1043234a35c7SHajimu UMEMOTO 		IF_AFDATA_UNLOCK(ifp);
1044813ee737SAndre Oppermann 		log(LOG_WARNING, "%s called more than once on %s\n",
1045813ee737SAndre Oppermann 		    __func__, ifp->if_xname);
1046234a35c7SHajimu UMEMOTO 		return;
1047234a35c7SHajimu UMEMOTO 	}
104869fb23b7SMax Laier 	ifp->if_afdata_initialized = domain_init_status;
1049234a35c7SHajimu UMEMOTO 	IF_AFDATA_UNLOCK(ifp);
1050234a35c7SHajimu UMEMOTO 
105131b1bfe1SHajimu UMEMOTO 	/* address family dependent data region */
105231b1bfe1SHajimu UMEMOTO 	bzero(ifp->if_afdata, sizeof(ifp->if_afdata));
105331b1bfe1SHajimu UMEMOTO 	for (dp = domains; dp; dp = dp->dom_next) {
105431b1bfe1SHajimu UMEMOTO 		if (dp->dom_ifattach)
105531b1bfe1SHajimu UMEMOTO 			ifp->if_afdata[dp->dom_family] =
105631b1bfe1SHajimu UMEMOTO 			    (*dp->dom_ifattach)(ifp);
105731b1bfe1SHajimu UMEMOTO 	}
105831b1bfe1SHajimu UMEMOTO }
105931b1bfe1SHajimu UMEMOTO 
10606182fdbdSPeter Wemm /*
1061ec002feeSBruce M Simpson  * Remove any unicast or broadcast network addresses from an interface.
106245778b37SPeter Edwards  */
106345778b37SPeter Edwards void
106445778b37SPeter Edwards if_purgeaddrs(struct ifnet *ifp)
106545778b37SPeter Edwards {
106688d57e9eSHans Petter Selasky 	struct ifaddr *ifa;
106745778b37SPeter Edwards 
106888d57e9eSHans Petter Selasky 	while (1) {
1069a68cc388SGleb Smirnoff 		struct epoch_tracker et;
1070a68cc388SGleb Smirnoff 
1071a68cc388SGleb Smirnoff 		NET_EPOCH_ENTER(et);
107288d57e9eSHans Petter Selasky 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
107388d57e9eSHans Petter Selasky 			if (ifa->ifa_addr->sa_family != AF_LINK)
107488d57e9eSHans Petter Selasky 				break;
107588d57e9eSHans Petter Selasky 		}
1076a68cc388SGleb Smirnoff 		NET_EPOCH_EXIT(et);
107788d57e9eSHans Petter Selasky 
107888d57e9eSHans Petter Selasky 		if (ifa == NULL)
107988d57e9eSHans Petter Selasky 			break;
108045778b37SPeter Edwards #ifdef INET
108145778b37SPeter Edwards 		/* XXX: Ugly!! ad hoc just for INET */
10824b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET) {
108345778b37SPeter Edwards 			struct ifaliasreq ifr;
108445778b37SPeter Edwards 
108545778b37SPeter Edwards 			bzero(&ifr, sizeof(ifr));
108645778b37SPeter Edwards 			ifr.ifra_addr = *ifa->ifa_addr;
108745778b37SPeter Edwards 			if (ifa->ifa_dstaddr)
108845778b37SPeter Edwards 				ifr.ifra_broadaddr = *ifa->ifa_dstaddr;
108945778b37SPeter Edwards 			if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp,
109045778b37SPeter Edwards 			    NULL) == 0)
109145778b37SPeter Edwards 				continue;
109245778b37SPeter Edwards 		}
109345778b37SPeter Edwards #endif /* INET */
109445778b37SPeter Edwards #ifdef INET6
10954b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET6) {
1096f9e0752eSAlexander V. Chernikov 			in6_purgeifaddr((struct in6_ifaddr *)ifa);
109745778b37SPeter Edwards 			/* ifp_addrhead is already updated */
109845778b37SPeter Edwards 			continue;
109945778b37SPeter Edwards 		}
110045778b37SPeter Edwards #endif /* INET6 */
1101f22d78c0SBjoern A. Zeeb 		IF_ADDR_WLOCK(ifp);
1102d7c5a620SMatt Macy 		CK_STAILQ_REMOVE(&ifp->if_addrhead, ifa, ifaddr, ifa_link);
1103f22d78c0SBjoern A. Zeeb 		IF_ADDR_WUNLOCK(ifp);
11041099f828SRobert Watson 		ifa_free(ifa);
110545778b37SPeter Edwards 	}
110645778b37SPeter Edwards }
110745778b37SPeter Edwards 
110845778b37SPeter Edwards /*
110993ec7edcSShteryana Shopova  * Remove any multicast network addresses from an interface when an ifnet
111093ec7edcSShteryana Shopova  * is going away.
1111ec002feeSBruce M Simpson  */
111293ec7edcSShteryana Shopova static void
1113ec002feeSBruce M Simpson if_purgemaddrs(struct ifnet *ifp)
1114ec002feeSBruce M Simpson {
1115ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
1116ec002feeSBruce M Simpson 
1117137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
1118d7c5a620SMatt Macy 	while (!CK_STAILQ_EMPTY(&ifp->if_multiaddrs)) {
1119d7c5a620SMatt Macy 		ifma = CK_STAILQ_FIRST(&ifp->if_multiaddrs);
1120d7c5a620SMatt Macy 		CK_STAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifmultiaddr, ifma_link);
1121ec002feeSBruce M Simpson 		if_delmulti_locked(ifp, ifma, 1);
1122f3e1324bSStephen Hurd 	}
1123137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
1124ec002feeSBruce M Simpson }
1125ec002feeSBruce M Simpson 
1126ec002feeSBruce M Simpson /*
1127e0c14af9SMarko Zec  * Detach an interface, removing it from the list of "active" interfaces.
1128e0c14af9SMarko Zec  * If vmove flag is set on entry to if_detach_internal(), perform only a
1129e0c14af9SMarko Zec  * limited subset of cleanup tasks, given that we are moving an ifnet from
1130e0c14af9SMarko Zec  * one vnet to another, where it must be fully operational.
1131b1c53bc9SRobert Watson  *
1132b1c53bc9SRobert Watson  * XXXRW: There are some significant questions about event ordering, and
1133b1c53bc9SRobert Watson  * how to prevent things from starting to use the interface during detach.
11346182fdbdSPeter Wemm  */
11356182fdbdSPeter Wemm void
113672fd1b6aSDag-Erling Smørgrav if_detach(struct ifnet *ifp)
11376182fdbdSPeter Wemm {
1138a779388fSKristof Provost 	bool found;
1139e0c14af9SMarko Zec 
1140719fb725SCraig Rodrigues 	CURVNET_SET_QUIET(ifp->if_vnet);
1141a779388fSKristof Provost 	found = if_unlink_ifnet(ifp, false);
1142e133271fSKristof Provost 	if (found) {
11436d2a10d9SKristof Provost 		sx_xlock(&ifnet_detach_sxlock);
1144c92a456bSHiroki Sato 		if_detach_internal(ifp, 0, NULL);
11456d2a10d9SKristof Provost 		sx_xunlock(&ifnet_detach_sxlock);
1146e133271fSKristof Provost 	}
1147719fb725SCraig Rodrigues 	CURVNET_RESTORE();
1148e0c14af9SMarko Zec }
1149e0c14af9SMarko Zec 
115089856f7eSBjoern A. Zeeb /*
115189856f7eSBjoern A. Zeeb  * The vmove flag, if set, indicates that we are called from a callpath
115289856f7eSBjoern A. Zeeb  * that is moving an interface to a different vnet instance.
115389856f7eSBjoern A. Zeeb  *
115489856f7eSBjoern A. Zeeb  * The shutdown flag, if set, indicates that we are called in the
115589856f7eSBjoern A. Zeeb  * process of shutting down a vnet instance.  Currently only the
115689856f7eSBjoern A. Zeeb  * vnet_if_return SYSUNINIT function sets it.  Note: we can be called
115789856f7eSBjoern A. Zeeb  * on a vnet instance shutdown without this flag being set, e.g., when
115889856f7eSBjoern A. Zeeb  * the cloned interfaces are destoyed as first thing of teardown.
115989856f7eSBjoern A. Zeeb  */
1160f501e6f1SBjoern A. Zeeb static int
1161c92a456bSHiroki Sato if_detach_internal(struct ifnet *ifp, int vmove, struct if_clone **ifcp)
1162e0c14af9SMarko Zec {
116345778b37SPeter Edwards 	struct ifaddr *ifa;
11644bdf0b6aSAlexander V. Chernikov 	int i;
116531b1bfe1SHajimu UMEMOTO 	struct domain *dp;
1166d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
1167204e2f30SHans Petter Selasky 	bool shutdown;
1168457f48e6SGleb Smirnoff 
116910108cb6SBjoern A. Zeeb 	shutdown = VNET_IS_SHUTTING_DOWN(ifp->if_vnet);
1170d3f6f80fSBjoern A. Zeeb #endif
11716182fdbdSPeter Wemm 
117289856f7eSBjoern A. Zeeb 	/*
117389856f7eSBjoern A. Zeeb 	 * At this point we know the interface still was on the ifnet list
117489856f7eSBjoern A. Zeeb 	 * and we removed it so we are in a stable state.
117589856f7eSBjoern A. Zeeb 	 */
11764f6c66ccSMatt Macy 	epoch_wait_preempt(net_epoch_preempt);
11770dbdf041SHans Petter Selasky 
11780dbdf041SHans Petter Selasky 	/*
11790dbdf041SHans Petter Selasky 	 * Ensure all pending EPOCH(9) callbacks have been executed. This
11800dbdf041SHans Petter Selasky 	 * fixes issues about late destruction of multicast options
11810dbdf041SHans Petter Selasky 	 * which lead to leave group calls, which in turn access the
11820dbdf041SHans Petter Selasky 	 * belonging ifnet structure:
11830dbdf041SHans Petter Selasky 	 */
11840dbdf041SHans Petter Selasky 	epoch_drain_callbacks(net_epoch_preempt);
11850dbdf041SHans Petter Selasky 
118689856f7eSBjoern A. Zeeb 	/*
118789856f7eSBjoern A. Zeeb 	 * In any case (destroy or vmove) detach us from the groups
118889856f7eSBjoern A. Zeeb 	 * and remove/wait for pending events on the taskq.
118989856f7eSBjoern A. Zeeb 	 * XXX-BZ in theory an interface could still enqueue a taskq change?
119089856f7eSBjoern A. Zeeb 	 */
119189856f7eSBjoern A. Zeeb 	if_delgroups(ifp);
119289856f7eSBjoern A. Zeeb 
119389856f7eSBjoern A. Zeeb 	taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
11940839aa5cSGleb Smirnoff 	taskqueue_drain(taskqueue_swi, &ifp->if_addmultitask);
119589856f7eSBjoern A. Zeeb 
119689856f7eSBjoern A. Zeeb 	/*
119789856f7eSBjoern A. Zeeb 	 * Check if this is a cloned interface or not. Must do even if
119889856f7eSBjoern A. Zeeb 	 * shutting down as a if_vmove_reclaim() would move the ifp and
119989856f7eSBjoern A. Zeeb 	 * the if_clone_addgroup() will have a corrupted string overwise
120089856f7eSBjoern A. Zeeb 	 * from a gibberish pointer.
120189856f7eSBjoern A. Zeeb 	 */
1202c92a456bSHiroki Sato 	if (vmove && ifcp != NULL)
1203c92a456bSHiroki Sato 		*ifcp = if_clone_findifc(ifp);
1204c92a456bSHiroki Sato 
120589856f7eSBjoern A. Zeeb 	if_down(ifp);
120689856f7eSBjoern A. Zeeb 
1207d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
120868a3482fSGleb Smirnoff 	/*
120989856f7eSBjoern A. Zeeb 	 * On VNET shutdown abort here as the stack teardown will do all
121089856f7eSBjoern A. Zeeb 	 * the work top-down for us.
121168a3482fSGleb Smirnoff 	 */
121289856f7eSBjoern A. Zeeb 	if (shutdown) {
121325c6ab1bSKristof Provost 		/* Give interface users the chance to clean up. */
121425c6ab1bSKristof Provost 		EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
121525c6ab1bSKristof Provost 
121689856f7eSBjoern A. Zeeb 		/*
121789856f7eSBjoern A. Zeeb 		 * In case of a vmove we are done here without error.
121889856f7eSBjoern A. Zeeb 		 * If we would signal an error it would lead to the same
121989856f7eSBjoern A. Zeeb 		 * abort as if we did not find the ifnet anymore.
122089856f7eSBjoern A. Zeeb 		 * if_detach() calls us in void context and does not care
122189856f7eSBjoern A. Zeeb 		 * about an early abort notification, so life is splendid :)
122289856f7eSBjoern A. Zeeb 		 */
122389856f7eSBjoern A. Zeeb 		goto finish_vnet_shutdown;
122489856f7eSBjoern A. Zeeb 	}
1225d3f6f80fSBjoern A. Zeeb #endif
122689856f7eSBjoern A. Zeeb 
122789856f7eSBjoern A. Zeeb 	/*
122889856f7eSBjoern A. Zeeb 	 * At this point we are not tearing down a VNET and are either
122989856f7eSBjoern A. Zeeb 	 * going to destroy or vmove the interface and have to cleanup
123089856f7eSBjoern A. Zeeb 	 * accordingly.
123189856f7eSBjoern A. Zeeb 	 */
123268a3482fSGleb Smirnoff 
12336182fdbdSPeter Wemm 	/*
12346182fdbdSPeter Wemm 	 * Remove routes and flush queues.
12356182fdbdSPeter Wemm 	 */
123602b199f1SMax Laier #ifdef ALTQ
123702b199f1SMax Laier 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
123802b199f1SMax Laier 		altq_disable(&ifp->if_snd);
123902b199f1SMax Laier 	if (ALTQ_IS_ATTACHED(&ifp->if_snd))
124002b199f1SMax Laier 		altq_detach(&ifp->if_snd);
124102b199f1SMax Laier #endif
12426182fdbdSPeter Wemm 
124345778b37SPeter Edwards 	if_purgeaddrs(ifp);
12446182fdbdSPeter Wemm 
1245b1c53bc9SRobert Watson #ifdef INET
1246b1c53bc9SRobert Watson 	in_ifdetach(ifp);
1247b1c53bc9SRobert Watson #endif
1248b1c53bc9SRobert Watson 
124933841545SHajimu UMEMOTO #ifdef INET6
125033841545SHajimu UMEMOTO 	/*
125133841545SHajimu UMEMOTO 	 * Remove all IPv6 kernel structs related to ifp.  This should be done
125233841545SHajimu UMEMOTO 	 * before removing routing entries below, since IPv6 interface direct
125333841545SHajimu UMEMOTO 	 * routes are expected to be removed by the IPv6-specific kernel API.
125433841545SHajimu UMEMOTO 	 * Otherwise, the kernel will detect some inconsistency and bark it.
125533841545SHajimu UMEMOTO 	 */
125633841545SHajimu UMEMOTO 	in6_ifdetach(ifp);
125733841545SHajimu UMEMOTO #endif
1258ec002feeSBruce M Simpson 	if_purgemaddrs(ifp);
1259ec002feeSBruce M Simpson 
1260af371fc6SRoger Pau Monné 	/* Announce that the interface is gone. */
1261af371fc6SRoger Pau Monné 	rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
1262af371fc6SRoger Pau Monné 	EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
1263af371fc6SRoger Pau Monné 	if (IS_DEFAULT_VNET(curvnet))
1264af371fc6SRoger Pau Monné 		devctl_notify("IFNET", ifp->if_xname, "DETACH", NULL);
1265af371fc6SRoger Pau Monné 
1266e0c14af9SMarko Zec 	if (!vmove) {
1267f4247b59SLuigi Rizzo 		/*
1268111c6b61SRobert Watson 		 * Prevent further calls into the device driver via ifnet.
1269111c6b61SRobert Watson 		 */
1270111c6b61SRobert Watson 		if_dead(ifp);
1271111c6b61SRobert Watson 
1272111c6b61SRobert Watson 		/*
1273f4247b59SLuigi Rizzo 		 * Clean up all addresses.
1274f4247b59SLuigi Rizzo 		 */
1275d117fd80SBjoern A. Zeeb 		IF_ADDR_WLOCK(ifp);
1276d7c5a620SMatt Macy 		if (!CK_STAILQ_EMPTY(&ifp->if_addrhead)) {
1277d7c5a620SMatt Macy 			ifa = CK_STAILQ_FIRST(&ifp->if_addrhead);
1278d7c5a620SMatt Macy 			CK_STAILQ_REMOVE(&ifp->if_addrhead, ifa, ifaddr, ifa_link);
1279d117fd80SBjoern A. Zeeb 			IF_ADDR_WUNLOCK(ifp);
12801099f828SRobert Watson 			ifa_free(ifa);
1281d117fd80SBjoern A. Zeeb 		} else
1282d117fd80SBjoern A. Zeeb 			IF_ADDR_WUNLOCK(ifp);
1283e0c14af9SMarko Zec 	}
1284212bd869SHajimu UMEMOTO 
12854bdf0b6aSAlexander V. Chernikov 	rt_flushifroutes(ifp);
12867b6edd04SRuslan Ermilov 
1287d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
128889856f7eSBjoern A. Zeeb finish_vnet_shutdown:
1289d3f6f80fSBjoern A. Zeeb #endif
1290d8c13659SBjoern A. Zeeb 	/*
1291d8c13659SBjoern A. Zeeb 	 * We cannot hold the lock over dom_ifdetach calls as they might
1292d8c13659SBjoern A. Zeeb 	 * sleep, for example trying to drain a callout, thus open up the
1293d8c13659SBjoern A. Zeeb 	 * theoretical race with re-attaching.
1294d8c13659SBjoern A. Zeeb 	 */
1295234a35c7SHajimu UMEMOTO 	IF_AFDATA_LOCK(ifp);
1296d8c13659SBjoern A. Zeeb 	i = ifp->if_afdata_initialized;
1297d8c13659SBjoern A. Zeeb 	ifp->if_afdata_initialized = 0;
1298d8c13659SBjoern A. Zeeb 	IF_AFDATA_UNLOCK(ifp);
1299d8c13659SBjoern A. Zeeb 	for (dp = domains; i > 0 && dp; dp = dp->dom_next) {
13002d5ad99aSBjoern A. Zeeb 		if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family]) {
130131b1bfe1SHajimu UMEMOTO 			(*dp->dom_ifdetach)(ifp,
130231b1bfe1SHajimu UMEMOTO 			    ifp->if_afdata[dp->dom_family]);
13032d5ad99aSBjoern A. Zeeb 			ifp->if_afdata[dp->dom_family] = NULL;
13042d5ad99aSBjoern A. Zeeb 		}
130531b1bfe1SHajimu UMEMOTO 	}
1306f501e6f1SBjoern A. Zeeb 
1307f501e6f1SBjoern A. Zeeb 	return (0);
13085500d3beSWarner Losh }
13095500d3beSWarner Losh 
1310e0c14af9SMarko Zec #ifdef VIMAGE
1311e0c14af9SMarko Zec /*
1312e0c14af9SMarko Zec  * if_vmove() performs a limited version of if_detach() in current
1313e0c14af9SMarko Zec  * vnet and if_attach()es the ifnet to the vnet specified as 2nd arg.
1314e0c14af9SMarko Zec  * An attempt is made to shrink if_index in current vnet, find an
1315e0c14af9SMarko Zec  * unused if_index in target vnet and calls if_grow() if necessary,
1316e0c14af9SMarko Zec  * and finally find an unused if_xname for the target vnet.
1317e0c14af9SMarko Zec  */
1318c7bab2a7SKyle Evans static int
1319e0c14af9SMarko Zec if_vmove(struct ifnet *ifp, struct vnet *new_vnet)
1320e0c14af9SMarko Zec {
1321c92a456bSHiroki Sato 	struct if_clone *ifc;
13223232273fSBjoern A. Zeeb #ifdef DEV_BPF
132305fc4164SBjoern A. Zeeb 	u_int bif_dlt, bif_hdrlen;
13243232273fSBjoern A. Zeeb #endif
13254f6c66ccSMatt Macy 	void *old;
1326f501e6f1SBjoern A. Zeeb 	int rc;
1327e0c14af9SMarko Zec 
13283232273fSBjoern A. Zeeb #ifdef DEV_BPF
1329e0c14af9SMarko Zec  	/*
133005fc4164SBjoern A. Zeeb 	 * if_detach_internal() will call the eventhandler to notify
133105fc4164SBjoern A. Zeeb 	 * interface departure.  That will detach if_bpf.  We need to
133205fc4164SBjoern A. Zeeb 	 * safe the dlt and hdrlen so we can re-attach it later.
133305fc4164SBjoern A. Zeeb 	 */
133405fc4164SBjoern A. Zeeb 	bpf_get_bp_params(ifp->if_bpf, &bif_dlt, &bif_hdrlen);
13353232273fSBjoern A. Zeeb #endif
133605fc4164SBjoern A. Zeeb 
133705fc4164SBjoern A. Zeeb 	/*
1338e0c14af9SMarko Zec 	 * Detach from current vnet, but preserve LLADDR info, do not
1339e0c14af9SMarko Zec 	 * mark as dead etc. so that the ifnet can be reattached later.
1340f501e6f1SBjoern A. Zeeb 	 * If we cannot find it, we lost the race to someone else.
1341e0c14af9SMarko Zec 	 */
1342f501e6f1SBjoern A. Zeeb 	rc = if_detach_internal(ifp, 1, &ifc);
1343f501e6f1SBjoern A. Zeeb 	if (rc != 0)
1344c7bab2a7SKyle Evans 		return (rc);
1345e0c14af9SMarko Zec 
1346e0c14af9SMarko Zec 	/*
134777dfcdc4SRobert Watson 	 * Unlink the ifnet from ifindex_table[] in current vnet, and shrink
134877dfcdc4SRobert Watson 	 * the if_index for that vnet if possible.
134977dfcdc4SRobert Watson 	 *
135077dfcdc4SRobert Watson 	 * NOTE: IFNET_WLOCK/IFNET_WUNLOCK() are assumed to be unvirtualized,
135177dfcdc4SRobert Watson 	 * or we'd lock on one vnet and unlock on another.
1352e0c14af9SMarko Zec 	 */
1353e0c14af9SMarko Zec 	IFNET_WLOCK();
1354ed2dabfcSRobert Watson 	ifindex_free_locked(ifp->if_index);
1355d3c351c5SMarko Zec 	IFNET_WUNLOCK();
1356d3c351c5SMarko Zec 
1357d3c351c5SMarko Zec 	/*
1358d3c351c5SMarko Zec 	 * Perform interface-specific reassignment tasks, if provided by
1359d3c351c5SMarko Zec 	 * the driver.
1360d3c351c5SMarko Zec 	 */
1361d3c351c5SMarko Zec 	if (ifp->if_reassign != NULL)
1362d3c351c5SMarko Zec 		ifp->if_reassign(ifp, new_vnet, NULL);
1363e0c14af9SMarko Zec 
1364e0c14af9SMarko Zec 	/*
1365e0c14af9SMarko Zec 	 * Switch to the context of the target vnet.
1366e0c14af9SMarko Zec 	 */
1367e0c14af9SMarko Zec 	CURVNET_SET_QUIET(new_vnet);
13684f6c66ccSMatt Macy  restart:
1369d3c351c5SMarko Zec 	IFNET_WLOCK();
13704f6c66ccSMatt Macy 	ifp->if_index = ifindex_alloc(&old);
13714f6c66ccSMatt Macy 	if (__predict_false(ifp->if_index == USHRT_MAX)) {
13724f6c66ccSMatt Macy 		IFNET_WUNLOCK();
13734f6c66ccSMatt Macy 		epoch_wait_preempt(net_epoch_preempt);
13744f6c66ccSMatt Macy 		free(old, M_IFNET);
13754f6c66ccSMatt Macy 		goto restart;
13764f6c66ccSMatt Macy 	}
13774f6c66ccSMatt Macy 	ifnet_setbyindex(ifp->if_index, ifp);
1378e0c14af9SMarko Zec 	IFNET_WUNLOCK();
1379e0c14af9SMarko Zec 
1380c92a456bSHiroki Sato 	if_attach_internal(ifp, 1, ifc);
1381e0c14af9SMarko Zec 
13823232273fSBjoern A. Zeeb #ifdef DEV_BPF
138305fc4164SBjoern A. Zeeb 	if (ifp->if_bpf == NULL)
138405fc4164SBjoern A. Zeeb 		bpfattach(ifp, bif_dlt, bif_hdrlen);
13853232273fSBjoern A. Zeeb #endif
138605fc4164SBjoern A. Zeeb 
1387e0c14af9SMarko Zec 	CURVNET_RESTORE();
1388c7bab2a7SKyle Evans 	return (0);
1389e0c14af9SMarko Zec }
1390be31e5e7SBjoern A. Zeeb 
1391be31e5e7SBjoern A. Zeeb /*
1392be31e5e7SBjoern A. Zeeb  * Move an ifnet to or from another child prison/vnet, specified by the jail id.
1393be31e5e7SBjoern A. Zeeb  */
1394be31e5e7SBjoern A. Zeeb static int
1395be31e5e7SBjoern A. Zeeb if_vmove_loan(struct thread *td, struct ifnet *ifp, char *ifname, int jid)
1396be31e5e7SBjoern A. Zeeb {
1397be31e5e7SBjoern A. Zeeb 	struct prison *pr;
1398be31e5e7SBjoern A. Zeeb 	struct ifnet *difp;
1399c7bab2a7SKyle Evans 	int error;
1400a779388fSKristof Provost 	bool found;
140110108cb6SBjoern A. Zeeb 	bool shutdown;
1402be31e5e7SBjoern A. Zeeb 
1403be31e5e7SBjoern A. Zeeb 	/* Try to find the prison within our visibility. */
1404be31e5e7SBjoern A. Zeeb 	sx_slock(&allprison_lock);
1405be31e5e7SBjoern A. Zeeb 	pr = prison_find_child(td->td_ucred->cr_prison, jid);
1406be31e5e7SBjoern A. Zeeb 	sx_sunlock(&allprison_lock);
1407be31e5e7SBjoern A. Zeeb 	if (pr == NULL)
1408be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1409be31e5e7SBjoern A. Zeeb 	prison_hold_locked(pr);
1410be31e5e7SBjoern A. Zeeb 	mtx_unlock(&pr->pr_mtx);
1411be31e5e7SBjoern A. Zeeb 
1412be31e5e7SBjoern A. Zeeb 	/* Do not try to move the iface from and to the same prison. */
1413be31e5e7SBjoern A. Zeeb 	if (pr->pr_vnet == ifp->if_vnet) {
1414be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1415be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1416be31e5e7SBjoern A. Zeeb 	}
1417be31e5e7SBjoern A. Zeeb 
1418be31e5e7SBjoern A. Zeeb 	/* Make sure the named iface does not exists in the dst. prison/vnet. */
1419be31e5e7SBjoern A. Zeeb 	/* XXX Lock interfaces to avoid races. */
14209abb4862SMarko Zec 	CURVNET_SET_QUIET(pr->pr_vnet);
1421be31e5e7SBjoern A. Zeeb 	difp = ifunit(ifname);
1422be31e5e7SBjoern A. Zeeb 	if (difp != NULL) {
142389856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
1424be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1425be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1426be31e5e7SBjoern A. Zeeb 	}
1427be31e5e7SBjoern A. Zeeb 
142889856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
142910108cb6SBjoern A. Zeeb 	shutdown = VNET_IS_SHUTTING_DOWN(ifp->if_vnet);
143010108cb6SBjoern A. Zeeb 	if (shutdown) {
143189856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
143289856f7eSBjoern A. Zeeb 		prison_free(pr);
143389856f7eSBjoern A. Zeeb 		return (EBUSY);
143489856f7eSBjoern A. Zeeb 	}
143589856f7eSBjoern A. Zeeb 	CURVNET_RESTORE();
143689856f7eSBjoern A. Zeeb 
1437a779388fSKristof Provost 	found = if_unlink_ifnet(ifp, true);
1438a779388fSKristof Provost 	MPASS(found);
1439a779388fSKristof Provost 
1440be31e5e7SBjoern A. Zeeb 	/* Move the interface into the child jail/vnet. */
1441c7bab2a7SKyle Evans 	error = if_vmove(ifp, pr->pr_vnet);
1442be31e5e7SBjoern A. Zeeb 
1443c7bab2a7SKyle Evans 	/* Report the new if_xname back to the userland on success. */
1444c7bab2a7SKyle Evans 	if (error == 0)
1445be31e5e7SBjoern A. Zeeb 		sprintf(ifname, "%s", ifp->if_xname);
1446be31e5e7SBjoern A. Zeeb 
1447be31e5e7SBjoern A. Zeeb 	prison_free(pr);
1448c7bab2a7SKyle Evans 	return (error);
1449be31e5e7SBjoern A. Zeeb }
1450be31e5e7SBjoern A. Zeeb 
1451be31e5e7SBjoern A. Zeeb static int
1452be31e5e7SBjoern A. Zeeb if_vmove_reclaim(struct thread *td, char *ifname, int jid)
1453be31e5e7SBjoern A. Zeeb {
1454be31e5e7SBjoern A. Zeeb 	struct prison *pr;
1455be31e5e7SBjoern A. Zeeb 	struct vnet *vnet_dst;
1456be31e5e7SBjoern A. Zeeb 	struct ifnet *ifp;
1457a779388fSKristof Provost 	int error, found;
145810108cb6SBjoern A. Zeeb  	bool shutdown;
1459be31e5e7SBjoern A. Zeeb 
1460be31e5e7SBjoern A. Zeeb 	/* Try to find the prison within our visibility. */
1461be31e5e7SBjoern A. Zeeb 	sx_slock(&allprison_lock);
1462be31e5e7SBjoern A. Zeeb 	pr = prison_find_child(td->td_ucred->cr_prison, jid);
1463be31e5e7SBjoern A. Zeeb 	sx_sunlock(&allprison_lock);
1464be31e5e7SBjoern A. Zeeb 	if (pr == NULL)
1465be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1466be31e5e7SBjoern A. Zeeb 	prison_hold_locked(pr);
1467be31e5e7SBjoern A. Zeeb 	mtx_unlock(&pr->pr_mtx);
1468be31e5e7SBjoern A. Zeeb 
1469be31e5e7SBjoern A. Zeeb 	/* Make sure the named iface exists in the source prison/vnet. */
1470be31e5e7SBjoern A. Zeeb 	CURVNET_SET(pr->pr_vnet);
1471be31e5e7SBjoern A. Zeeb 	ifp = ifunit(ifname);		/* XXX Lock to avoid races. */
1472be31e5e7SBjoern A. Zeeb 	if (ifp == NULL) {
1473be31e5e7SBjoern A. Zeeb 		CURVNET_RESTORE();
1474be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1475be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1476be31e5e7SBjoern A. Zeeb 	}
1477be31e5e7SBjoern A. Zeeb 
1478be31e5e7SBjoern A. Zeeb 	/* Do not try to move the iface from and to the same prison. */
1479be31e5e7SBjoern A. Zeeb 	vnet_dst = TD_TO_VNET(td);
1480be31e5e7SBjoern A. Zeeb 	if (vnet_dst == ifp->if_vnet) {
1481be31e5e7SBjoern A. Zeeb 		CURVNET_RESTORE();
1482be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1483be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1484be31e5e7SBjoern A. Zeeb 	}
1485be31e5e7SBjoern A. Zeeb 
148689856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
148710108cb6SBjoern A. Zeeb 	shutdown = VNET_IS_SHUTTING_DOWN(ifp->if_vnet);
148810108cb6SBjoern A. Zeeb 	if (shutdown) {
148989856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
149089856f7eSBjoern A. Zeeb 		prison_free(pr);
149189856f7eSBjoern A. Zeeb 		return (EBUSY);
149289856f7eSBjoern A. Zeeb 	}
149389856f7eSBjoern A. Zeeb 
1494be31e5e7SBjoern A. Zeeb 	/* Get interface back from child jail/vnet. */
1495a779388fSKristof Provost 	found = if_unlink_ifnet(ifp, true);
1496a779388fSKristof Provost 	MPASS(found);
1497c7bab2a7SKyle Evans 	error = if_vmove(ifp, vnet_dst);
1498be31e5e7SBjoern A. Zeeb 	CURVNET_RESTORE();
1499be31e5e7SBjoern A. Zeeb 
1500c7bab2a7SKyle Evans 	/* Report the new if_xname back to the userland on success. */
1501c7bab2a7SKyle Evans 	if (error == 0)
1502be31e5e7SBjoern A. Zeeb 		sprintf(ifname, "%s", ifp->if_xname);
1503be31e5e7SBjoern A. Zeeb 
1504be31e5e7SBjoern A. Zeeb 	prison_free(pr);
1505c7bab2a7SKyle Evans 	return (error);
1506be31e5e7SBjoern A. Zeeb }
1507e0c14af9SMarko Zec #endif /* VIMAGE */
1508e0c14af9SMarko Zec 
15095500d3beSWarner Losh /*
15100dad3f0eSMax Laier  * Add a group to an interface
15110dad3f0eSMax Laier  */
15120dad3f0eSMax Laier int
15130dad3f0eSMax Laier if_addgroup(struct ifnet *ifp, const char *groupname)
15140dad3f0eSMax Laier {
15150dad3f0eSMax Laier 	struct ifg_list		*ifgl;
15160dad3f0eSMax Laier 	struct ifg_group	*ifg = NULL;
15170dad3f0eSMax Laier 	struct ifg_member	*ifgm;
1518d6d3f01eSGleb Smirnoff 	int 			 new = 0;
15190dad3f0eSMax Laier 
15200dad3f0eSMax Laier 	if (groupname[0] && groupname[strlen(groupname) - 1] >= '0' &&
15210dad3f0eSMax Laier 	    groupname[strlen(groupname) - 1] <= '9')
15220dad3f0eSMax Laier 		return (EINVAL);
15230dad3f0eSMax Laier 
15240dad3f0eSMax Laier 	IFNET_WLOCK();
15254f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
15260dad3f0eSMax Laier 		if (!strcmp(ifgl->ifgl_group->ifg_group, groupname)) {
15270dad3f0eSMax Laier 			IFNET_WUNLOCK();
15280dad3f0eSMax Laier 			return (EEXIST);
15290dad3f0eSMax Laier 		}
15300dad3f0eSMax Laier 
15313f197b13SMark Johnston 	if ((ifgl = malloc(sizeof(*ifgl), M_TEMP, M_NOWAIT)) == NULL) {
15320dad3f0eSMax Laier 	    	IFNET_WUNLOCK();
15330dad3f0eSMax Laier 		return (ENOMEM);
15340dad3f0eSMax Laier 	}
15350dad3f0eSMax Laier 
15363f197b13SMark Johnston 	if ((ifgm = malloc(sizeof(*ifgm), M_TEMP, M_NOWAIT)) == NULL) {
15370dad3f0eSMax Laier 		free(ifgl, M_TEMP);
15380dad3f0eSMax Laier 		IFNET_WUNLOCK();
15390dad3f0eSMax Laier 		return (ENOMEM);
15400dad3f0eSMax Laier 	}
15410dad3f0eSMax Laier 
15424f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
15430dad3f0eSMax Laier 		if (!strcmp(ifg->ifg_group, groupname))
15440dad3f0eSMax Laier 			break;
15450dad3f0eSMax Laier 
15460dad3f0eSMax Laier 	if (ifg == NULL) {
15473f197b13SMark Johnston 		if ((ifg = malloc(sizeof(*ifg), M_TEMP, M_NOWAIT)) == NULL) {
15480dad3f0eSMax Laier 			free(ifgl, M_TEMP);
15490dad3f0eSMax Laier 			free(ifgm, M_TEMP);
15500dad3f0eSMax Laier 			IFNET_WUNLOCK();
15510dad3f0eSMax Laier 			return (ENOMEM);
15520dad3f0eSMax Laier 		}
15530dad3f0eSMax Laier 		strlcpy(ifg->ifg_group, groupname, sizeof(ifg->ifg_group));
15540dad3f0eSMax Laier 		ifg->ifg_refcnt = 0;
15554f6c66ccSMatt Macy 		CK_STAILQ_INIT(&ifg->ifg_members);
15564f6c66ccSMatt Macy 		CK_STAILQ_INSERT_TAIL(&V_ifg_head, ifg, ifg_next);
1557d6d3f01eSGleb Smirnoff 		new = 1;
15580dad3f0eSMax Laier 	}
15590dad3f0eSMax Laier 
15600dad3f0eSMax Laier 	ifg->ifg_refcnt++;
15610dad3f0eSMax Laier 	ifgl->ifgl_group = ifg;
15620dad3f0eSMax Laier 	ifgm->ifgm_ifp = ifp;
15630dad3f0eSMax Laier 
1564137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
15654f6c66ccSMatt Macy 	CK_STAILQ_INSERT_TAIL(&ifg->ifg_members, ifgm, ifgm_next);
15664f6c66ccSMatt Macy 	CK_STAILQ_INSERT_TAIL(&ifp->if_groups, ifgl, ifgl_next);
1567137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
15680dad3f0eSMax Laier 
15690dad3f0eSMax Laier 	IFNET_WUNLOCK();
15700dad3f0eSMax Laier 
1571d6d3f01eSGleb Smirnoff 	if (new)
1572d6d3f01eSGleb Smirnoff 		EVENTHANDLER_INVOKE(group_attach_event, ifg);
15730dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
15740dad3f0eSMax Laier 
15750dad3f0eSMax Laier 	return (0);
15760dad3f0eSMax Laier }
15770dad3f0eSMax Laier 
15780dad3f0eSMax Laier /*
15793f197b13SMark Johnston  * Helper function to remove a group out of an interface.  Expects the global
15803f197b13SMark Johnston  * ifnet lock to be write-locked, and drops it before returning.
15810dad3f0eSMax Laier  */
15823f197b13SMark Johnston static void
15833f197b13SMark Johnston _if_delgroup_locked(struct ifnet *ifp, struct ifg_list *ifgl,
15843f197b13SMark Johnston     const char *groupname)
15850dad3f0eSMax Laier {
15860dad3f0eSMax Laier 	struct ifg_member *ifgm;
15873f197b13SMark Johnston 	bool freeifgl;
15880dad3f0eSMax Laier 
15893f197b13SMark Johnston 	IFNET_WLOCK_ASSERT();
15900dad3f0eSMax Laier 
1591137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
15924f6c66ccSMatt Macy 	CK_STAILQ_REMOVE(&ifp->if_groups, ifgl, ifg_list, ifgl_next);
1593137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
15940dad3f0eSMax Laier 
15953f197b13SMark Johnston 	CK_STAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next) {
15963f197b13SMark Johnston 		if (ifgm->ifgm_ifp == ifp) {
15973f197b13SMark Johnston 			CK_STAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm,
15983f197b13SMark Johnston 			    ifg_member, ifgm_next);
15990dad3f0eSMax Laier 			break;
16003f197b13SMark Johnston 		}
16013f197b13SMark Johnston 	}
16020dad3f0eSMax Laier 
16030dad3f0eSMax Laier 	if (--ifgl->ifgl_group->ifg_refcnt == 0) {
16043f197b13SMark Johnston 		CK_STAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_group,
16053f197b13SMark Johnston 		    ifg_next);
16063f197b13SMark Johnston 		freeifgl = true;
16073f197b13SMark Johnston 	} else {
16083f197b13SMark Johnston 		freeifgl = false;
16094f6c66ccSMatt Macy 	}
16100dad3f0eSMax Laier 	IFNET_WUNLOCK();
16110dad3f0eSMax Laier 
16124f6c66ccSMatt Macy 	epoch_wait_preempt(net_epoch_preempt);
16134f6c66ccSMatt Macy 	if (freeifgl) {
16144f6c66ccSMatt Macy 		EVENTHANDLER_INVOKE(group_detach_event, ifgl->ifgl_group);
16154f6c66ccSMatt Macy 		free(ifgl->ifgl_group, M_TEMP);
16164f6c66ccSMatt Macy 	}
16174f6c66ccSMatt Macy 	free(ifgm, M_TEMP);
16180dad3f0eSMax Laier 	free(ifgl, M_TEMP);
16190dad3f0eSMax Laier 
16200dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
16213f197b13SMark Johnston }
16223f197b13SMark Johnston 
16233f197b13SMark Johnston /*
16243f197b13SMark Johnston  * Remove a group from an interface
16253f197b13SMark Johnston  */
16263f197b13SMark Johnston int
16273f197b13SMark Johnston if_delgroup(struct ifnet *ifp, const char *groupname)
16283f197b13SMark Johnston {
16293f197b13SMark Johnston 	struct ifg_list *ifgl;
16303f197b13SMark Johnston 
16313f197b13SMark Johnston 	IFNET_WLOCK();
16323f197b13SMark Johnston 	CK_STAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
16333f197b13SMark Johnston 		if (strcmp(ifgl->ifgl_group->ifg_group, groupname) == 0)
16343f197b13SMark Johnston 			break;
16353f197b13SMark Johnston 	if (ifgl == NULL) {
16363f197b13SMark Johnston 		IFNET_WUNLOCK();
16373f197b13SMark Johnston 		return (ENOENT);
16383f197b13SMark Johnston 	}
16393f197b13SMark Johnston 
16403f197b13SMark Johnston 	_if_delgroup_locked(ifp, ifgl, groupname);
16410dad3f0eSMax Laier 
16420dad3f0eSMax Laier 	return (0);
16430dad3f0eSMax Laier }
16440dad3f0eSMax Laier 
16450dad3f0eSMax Laier /*
16468623f9fdSMax Laier  * Remove an interface from all groups
16478623f9fdSMax Laier  */
16488623f9fdSMax Laier static void
16498623f9fdSMax Laier if_delgroups(struct ifnet *ifp)
16508623f9fdSMax Laier {
16518623f9fdSMax Laier 	struct ifg_list *ifgl;
16528623f9fdSMax Laier 	char groupname[IFNAMSIZ];
16538623f9fdSMax Laier 
16548623f9fdSMax Laier 	IFNET_WLOCK();
16553f197b13SMark Johnston 	while ((ifgl = CK_STAILQ_FIRST(&ifp->if_groups)) != NULL) {
16568623f9fdSMax Laier 		strlcpy(groupname, ifgl->ifgl_group->ifg_group, IFNAMSIZ);
16573f197b13SMark Johnston 		_if_delgroup_locked(ifp, ifgl, groupname);
16588623f9fdSMax Laier 		IFNET_WLOCK();
16598623f9fdSMax Laier 	}
16608623f9fdSMax Laier 	IFNET_WUNLOCK();
16618623f9fdSMax Laier }
16628623f9fdSMax Laier 
16638623f9fdSMax Laier /*
1664756181b8SBrooks Davis  * Stores all groups from an interface in memory pointed to by ifgr.
16650dad3f0eSMax Laier  */
16660dad3f0eSMax Laier static int
1667756181b8SBrooks Davis if_getgroup(struct ifgroupreq *ifgr, struct ifnet *ifp)
16680dad3f0eSMax Laier {
16690dad3f0eSMax Laier 	int			 len, error;
16700dad3f0eSMax Laier 	struct ifg_list		*ifgl;
16710dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
16720dad3f0eSMax Laier 
1673b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
1674b8a6e03fSGleb Smirnoff 
16750dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
16764f6c66ccSMatt Macy 		CK_STAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
16770dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(struct ifg_req);
16780dad3f0eSMax Laier 		return (0);
16790dad3f0eSMax Laier 	}
16800dad3f0eSMax Laier 
16810dad3f0eSMax Laier 	len = ifgr->ifgr_len;
168201e9cbc4SJohn Baldwin 	ifgp = ifgr->ifgr_groups;
16830dad3f0eSMax Laier 	/* XXX: wire */
16844f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
1685b8a6e03fSGleb Smirnoff 		if (len < sizeof(ifgrq))
16860dad3f0eSMax Laier 			return (EINVAL);
16870dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
16880dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_group, ifgl->ifgl_group->ifg_group,
16890dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_group));
1690b8a6e03fSGleb Smirnoff 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req))))
16910dad3f0eSMax Laier 			return (error);
16920dad3f0eSMax Laier 		len -= sizeof(ifgrq);
16930dad3f0eSMax Laier 		ifgp++;
16940dad3f0eSMax Laier 	}
16950dad3f0eSMax Laier 
16960dad3f0eSMax Laier 	return (0);
16970dad3f0eSMax Laier }
16980dad3f0eSMax Laier 
16990dad3f0eSMax Laier /*
1700756181b8SBrooks Davis  * Stores all members of a group in memory pointed to by igfr
17010dad3f0eSMax Laier  */
17020dad3f0eSMax Laier static int
1703756181b8SBrooks Davis if_getgroupmembers(struct ifgroupreq *ifgr)
17040dad3f0eSMax Laier {
17050dad3f0eSMax Laier 	struct ifg_group	*ifg;
17060dad3f0eSMax Laier 	struct ifg_member	*ifgm;
17070dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
17080dad3f0eSMax Laier 	int			 len, error;
17090dad3f0eSMax Laier 
17100dad3f0eSMax Laier 	IFNET_RLOCK();
17114f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
17123f197b13SMark Johnston 		if (strcmp(ifg->ifg_group, ifgr->ifgr_name) == 0)
17130dad3f0eSMax Laier 			break;
17140dad3f0eSMax Laier 	if (ifg == NULL) {
17150dad3f0eSMax Laier 		IFNET_RUNLOCK();
17160dad3f0eSMax Laier 		return (ENOENT);
17170dad3f0eSMax Laier 	}
17180dad3f0eSMax Laier 
17190dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
17204f6c66ccSMatt Macy 		CK_STAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
17210dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(ifgrq);
17220dad3f0eSMax Laier 		IFNET_RUNLOCK();
17230dad3f0eSMax Laier 		return (0);
17240dad3f0eSMax Laier 	}
17250dad3f0eSMax Laier 
17260dad3f0eSMax Laier 	len = ifgr->ifgr_len;
172701e9cbc4SJohn Baldwin 	ifgp = ifgr->ifgr_groups;
17284f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next) {
17290dad3f0eSMax Laier 		if (len < sizeof(ifgrq)) {
17300dad3f0eSMax Laier 			IFNET_RUNLOCK();
17310dad3f0eSMax Laier 			return (EINVAL);
17320dad3f0eSMax Laier 		}
17330dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
17340dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_member, ifgm->ifgm_ifp->if_xname,
17350dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_member));
17360dad3f0eSMax Laier 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
17370dad3f0eSMax Laier 			IFNET_RUNLOCK();
17380dad3f0eSMax Laier 			return (error);
17390dad3f0eSMax Laier 		}
17400dad3f0eSMax Laier 		len -= sizeof(ifgrq);
17410dad3f0eSMax Laier 		ifgp++;
17420dad3f0eSMax Laier 	}
17430dad3f0eSMax Laier 	IFNET_RUNLOCK();
17440dad3f0eSMax Laier 
17450dad3f0eSMax Laier 	return (0);
17460dad3f0eSMax Laier }
17470dad3f0eSMax Laier 
17480dad3f0eSMax Laier /*
1749112f50ffSGleb Smirnoff  * Return counter values from counter(9)s stored in ifnet.
1750e6485f73SGleb Smirnoff  */
1751e6485f73SGleb Smirnoff uint64_t
17521b7fb1d9SGleb Smirnoff if_get_counter_default(struct ifnet *ifp, ift_counter cnt)
1753e6485f73SGleb Smirnoff {
1754e6485f73SGleb Smirnoff 
1755112f50ffSGleb Smirnoff 	KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1756112f50ffSGleb Smirnoff 
1757112f50ffSGleb Smirnoff 	return (counter_u64_fetch(ifp->if_counters[cnt]));
1758e6485f73SGleb Smirnoff }
1759e6485f73SGleb Smirnoff 
1760e6485f73SGleb Smirnoff /*
17610b7b006cSGleb Smirnoff  * Increase an ifnet counter. Usually used for counters shared
17620b7b006cSGleb Smirnoff  * between the stack and a driver, but function supports them all.
17630b7b006cSGleb Smirnoff  */
17640b7b006cSGleb Smirnoff void
17651b7fb1d9SGleb Smirnoff if_inc_counter(struct ifnet *ifp, ift_counter cnt, int64_t inc)
17660b7b006cSGleb Smirnoff {
17670b7b006cSGleb Smirnoff 
1768112f50ffSGleb Smirnoff 	KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1769112f50ffSGleb Smirnoff 
1770112f50ffSGleb Smirnoff 	counter_u64_add(ifp->if_counters[cnt], inc);
17710b7b006cSGleb Smirnoff }
17720b7b006cSGleb Smirnoff 
17730b7b006cSGleb Smirnoff /*
1774e6485f73SGleb Smirnoff  * Copy data from ifnet to userland API structure if_data.
1775e6485f73SGleb Smirnoff  */
1776e6485f73SGleb Smirnoff void
1777e6485f73SGleb Smirnoff if_data_copy(struct ifnet *ifp, struct if_data *ifd)
1778e6485f73SGleb Smirnoff {
1779e6485f73SGleb Smirnoff 
1780e6485f73SGleb Smirnoff 	ifd->ifi_type = ifp->if_type;
1781e6485f73SGleb Smirnoff 	ifd->ifi_physical = 0;
1782e6485f73SGleb Smirnoff 	ifd->ifi_addrlen = ifp->if_addrlen;
1783e6485f73SGleb Smirnoff 	ifd->ifi_hdrlen = ifp->if_hdrlen;
1784e6485f73SGleb Smirnoff 	ifd->ifi_link_state = ifp->if_link_state;
1785e6485f73SGleb Smirnoff 	ifd->ifi_vhid = 0;
1786e6485f73SGleb Smirnoff 	ifd->ifi_datalen = sizeof(struct if_data);
1787e6485f73SGleb Smirnoff 	ifd->ifi_mtu = ifp->if_mtu;
1788e6485f73SGleb Smirnoff 	ifd->ifi_metric = ifp->if_metric;
1789e6485f73SGleb Smirnoff 	ifd->ifi_baudrate = ifp->if_baudrate;
1790e6485f73SGleb Smirnoff 	ifd->ifi_hwassist = ifp->if_hwassist;
1791e6485f73SGleb Smirnoff 	ifd->ifi_epoch = ifp->if_epoch;
1792e6485f73SGleb Smirnoff 	ifd->ifi_lastchange = ifp->if_lastchange;
1793e6485f73SGleb Smirnoff 
1794e6485f73SGleb Smirnoff 	ifd->ifi_ipackets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS);
1795e6485f73SGleb Smirnoff 	ifd->ifi_ierrors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS);
1796e6485f73SGleb Smirnoff 	ifd->ifi_opackets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS);
1797e6485f73SGleb Smirnoff 	ifd->ifi_oerrors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS);
1798e6485f73SGleb Smirnoff 	ifd->ifi_collisions = ifp->if_get_counter(ifp, IFCOUNTER_COLLISIONS);
1799e6485f73SGleb Smirnoff 	ifd->ifi_ibytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES);
1800e6485f73SGleb Smirnoff 	ifd->ifi_obytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES);
1801e6485f73SGleb Smirnoff 	ifd->ifi_imcasts = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS);
1802e6485f73SGleb Smirnoff 	ifd->ifi_omcasts = ifp->if_get_counter(ifp, IFCOUNTER_OMCASTS);
1803e6485f73SGleb Smirnoff 	ifd->ifi_iqdrops = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS);
1804e6485f73SGleb Smirnoff 	ifd->ifi_oqdrops = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS);
1805e6485f73SGleb Smirnoff 	ifd->ifi_noproto = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO);
1806e6485f73SGleb Smirnoff }
1807e6485f73SGleb Smirnoff 
1808e6485f73SGleb Smirnoff /*
1809e8aa8bddSGleb Smirnoff  * Initialization, destruction and refcounting functions for ifaddrs.
18101099f828SRobert Watson  */
181146758960SGleb Smirnoff struct ifaddr *
181246758960SGleb Smirnoff ifa_alloc(size_t size, int flags)
18131099f828SRobert Watson {
181446758960SGleb Smirnoff 	struct ifaddr *ifa;
181546758960SGleb Smirnoff 
181646758960SGleb Smirnoff 	KASSERT(size >= sizeof(struct ifaddr),
181746758960SGleb Smirnoff 	    ("%s: invalid size %zu", __func__, size));
181846758960SGleb Smirnoff 
181946758960SGleb Smirnoff 	ifa = malloc(size, M_IFADDR, M_ZERO | flags);
182046758960SGleb Smirnoff 	if (ifa == NULL)
182146758960SGleb Smirnoff 		return (NULL);
18221099f828SRobert Watson 
18237caf4ab7SGleb Smirnoff 	if ((ifa->ifa_opackets = counter_u64_alloc(flags)) == NULL)
18247caf4ab7SGleb Smirnoff 		goto fail;
18257caf4ab7SGleb Smirnoff 	if ((ifa->ifa_ipackets = counter_u64_alloc(flags)) == NULL)
18267caf4ab7SGleb Smirnoff 		goto fail;
18277caf4ab7SGleb Smirnoff 	if ((ifa->ifa_obytes = counter_u64_alloc(flags)) == NULL)
18287caf4ab7SGleb Smirnoff 		goto fail;
18297caf4ab7SGleb Smirnoff 	if ((ifa->ifa_ibytes = counter_u64_alloc(flags)) == NULL)
18307caf4ab7SGleb Smirnoff 		goto fail;
18317caf4ab7SGleb Smirnoff 
18321099f828SRobert Watson 	refcount_init(&ifa->ifa_refcnt, 1);
183346758960SGleb Smirnoff 
183446758960SGleb Smirnoff 	return (ifa);
18357caf4ab7SGleb Smirnoff 
18367caf4ab7SGleb Smirnoff fail:
18377caf4ab7SGleb Smirnoff 	/* free(NULL) is okay */
18387caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_opackets);
18397caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ipackets);
18407caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_obytes);
18417caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ibytes);
18427caf4ab7SGleb Smirnoff 	free(ifa, M_IFADDR);
18437caf4ab7SGleb Smirnoff 
18447caf4ab7SGleb Smirnoff 	return (NULL);
18451099f828SRobert Watson }
18461099f828SRobert Watson 
18471099f828SRobert Watson void
18481099f828SRobert Watson ifa_ref(struct ifaddr *ifa)
18491099f828SRobert Watson {
1850*5a4e46f6SMateusz Guzik 	u_int old __diagused;
18511099f828SRobert Watson 
1852600eade2SAlexander V. Chernikov 	old = refcount_acquire(&ifa->ifa_refcnt);
1853600eade2SAlexander V. Chernikov 	KASSERT(old > 0, ("%s: ifa %p has 0 refs", __func__, ifa));
1854600eade2SAlexander V. Chernikov }
1855600eade2SAlexander V. Chernikov 
1856600eade2SAlexander V. Chernikov int
1857600eade2SAlexander V. Chernikov ifa_try_ref(struct ifaddr *ifa)
1858600eade2SAlexander V. Chernikov {
1859600eade2SAlexander V. Chernikov 
1860600eade2SAlexander V. Chernikov 	NET_EPOCH_ASSERT();
1861600eade2SAlexander V. Chernikov 	return (refcount_acquire_if_not_zero(&ifa->ifa_refcnt));
18621099f828SRobert Watson }
18631099f828SRobert Watson 
1864d7c5a620SMatt Macy static void
1865d7c5a620SMatt Macy ifa_destroy(epoch_context_t ctx)
18661099f828SRobert Watson {
1867d7c5a620SMatt Macy 	struct ifaddr *ifa;
18681099f828SRobert Watson 
1869d7c5a620SMatt Macy 	ifa = __containerof(ctx, struct ifaddr, ifa_epoch_ctx);
18707caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_opackets);
18717caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ipackets);
18727caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_obytes);
18737caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ibytes);
18741099f828SRobert Watson 	free(ifa, M_IFADDR);
18751099f828SRobert Watson }
1876d7c5a620SMatt Macy 
1877d7c5a620SMatt Macy void
1878d7c5a620SMatt Macy ifa_free(struct ifaddr *ifa)
1879d7c5a620SMatt Macy {
1880d7c5a620SMatt Macy 
1881d7c5a620SMatt Macy 	if (refcount_release(&ifa->ifa_refcnt))
18822a4bd982SGleb Smirnoff 		NET_EPOCH_CALL(ifa_destroy, &ifa->ifa_epoch_ctx);
18831099f828SRobert Watson }
18841099f828SRobert Watson 
18851099f828SRobert Watson /*
188640d8a302SBruce M Simpson  * XXX: Because sockaddr_dl has deeper structure than the sockaddr
188740d8a302SBruce M Simpson  * structs used to represent other address families, it is necessary
188840d8a302SBruce M Simpson  * to perform a different comparison.
188940d8a302SBruce M Simpson  */
189040d8a302SBruce M Simpson 
189140d8a302SBruce M Simpson #define	sa_dl_equal(a1, a2)	\
1892441f9243SAlexander V. Chernikov 	((((const struct sockaddr_dl *)(a1))->sdl_len ==		\
1893441f9243SAlexander V. Chernikov 	 ((const struct sockaddr_dl *)(a2))->sdl_len) &&		\
1894441f9243SAlexander V. Chernikov 	 (bcmp(CLLADDR((const struct sockaddr_dl *)(a1)),		\
1895441f9243SAlexander V. Chernikov 	       CLLADDR((const struct sockaddr_dl *)(a2)),		\
1896441f9243SAlexander V. Chernikov 	       ((const struct sockaddr_dl *)(a1))->sdl_alen) == 0))
189719fc74fbSJeffrey Hsu 
189830aad87dSBrooks Davis /*
1899df8bae1dSRodney W. Grimes  * Locate an interface based on a complete address.
1900df8bae1dSRodney W. Grimes  */
1901df8bae1dSRodney W. Grimes /*ARGSUSED*/
19024f6c66ccSMatt Macy struct ifaddr *
19034f6c66ccSMatt Macy ifa_ifwithaddr(const struct sockaddr *addr)
1904df8bae1dSRodney W. Grimes {
19050b59d917SJonathan Lemon 	struct ifnet *ifp;
19060b59d917SJonathan Lemon 	struct ifaddr *ifa;
1907df8bae1dSRodney W. Grimes 
1908b8a6e03fSGleb Smirnoff 	NET_EPOCH_ASSERT();
1909b8a6e03fSGleb Smirnoff 
19104f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1911d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1912df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1913df8bae1dSRodney W. Grimes 				continue;
1914ab5ed8a5SRobert Watson 			if (sa_equal(addr, ifa->ifa_addr)) {
19150b59d917SJonathan Lemon 				goto done;
1916ab5ed8a5SRobert Watson 			}
191782cd038dSYoshinobu Inoue 			/* IP6 doesn't have broadcast */
19180b59d917SJonathan Lemon 			if ((ifp->if_flags & IFF_BROADCAST) &&
19190b59d917SJonathan Lemon 			    ifa->ifa_broadaddr &&
192082cd038dSYoshinobu Inoue 			    ifa->ifa_broadaddr->sa_len != 0 &&
1921ab5ed8a5SRobert Watson 			    sa_equal(ifa->ifa_broadaddr, addr)) {
19220b59d917SJonathan Lemon 				goto done;
19230b59d917SJonathan Lemon 			}
1924ab5ed8a5SRobert Watson 		}
1925ab5ed8a5SRobert Watson 	}
19260b59d917SJonathan Lemon 	ifa = NULL;
19270b59d917SJonathan Lemon done:
1928df8bae1dSRodney W. Grimes 	return (ifa);
1929df8bae1dSRodney W. Grimes }
19300b59d917SJonathan Lemon 
19318896f83aSRobert Watson int
1932441f9243SAlexander V. Chernikov ifa_ifwithaddr_check(const struct sockaddr *addr)
19338896f83aSRobert Watson {
1934a68cc388SGleb Smirnoff 	struct epoch_tracker et;
19354f6c66ccSMatt Macy 	int rc;
19368896f83aSRobert Watson 
1937a68cc388SGleb Smirnoff 	NET_EPOCH_ENTER(et);
19384f6c66ccSMatt Macy 	rc = (ifa_ifwithaddr(addr) != NULL);
1939a68cc388SGleb Smirnoff 	NET_EPOCH_EXIT(et);
19404f6c66ccSMatt Macy 	return (rc);
19418896f83aSRobert Watson }
19428896f83aSRobert Watson 
1943df8bae1dSRodney W. Grimes /*
1944773725a2SAndre Oppermann  * Locate an interface based on the broadcast address.
1945773725a2SAndre Oppermann  */
1946773725a2SAndre Oppermann /* ARGSUSED */
1947773725a2SAndre Oppermann struct ifaddr *
1948441f9243SAlexander V. Chernikov ifa_ifwithbroadaddr(const struct sockaddr *addr, int fibnum)
1949773725a2SAndre Oppermann {
1950773725a2SAndre Oppermann 	struct ifnet *ifp;
1951773725a2SAndre Oppermann 	struct ifaddr *ifa;
1952773725a2SAndre Oppermann 
195397168be8SGleb Smirnoff 	NET_EPOCH_ASSERT();
19544f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
19554f8585e0SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
19564f8585e0SAlan Somers 			continue;
1957d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1958773725a2SAndre Oppermann 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1959773725a2SAndre Oppermann 				continue;
1960773725a2SAndre Oppermann 			if ((ifp->if_flags & IFF_BROADCAST) &&
1961773725a2SAndre Oppermann 			    ifa->ifa_broadaddr &&
1962773725a2SAndre Oppermann 			    ifa->ifa_broadaddr->sa_len != 0 &&
1963ab5ed8a5SRobert Watson 			    sa_equal(ifa->ifa_broadaddr, addr)) {
1964773725a2SAndre Oppermann 				goto done;
1965773725a2SAndre Oppermann 			}
1966ab5ed8a5SRobert Watson 		}
1967ab5ed8a5SRobert Watson 	}
1968773725a2SAndre Oppermann 	ifa = NULL;
1969773725a2SAndre Oppermann done:
1970773725a2SAndre Oppermann 	return (ifa);
1971773725a2SAndre Oppermann }
1972773725a2SAndre Oppermann 
1973773725a2SAndre Oppermann /*
1974df8bae1dSRodney W. Grimes  * Locate the point to point interface with a given destination address.
1975df8bae1dSRodney W. Grimes  */
1976df8bae1dSRodney W. Grimes /*ARGSUSED*/
1977df8bae1dSRodney W. Grimes struct ifaddr *
1978441f9243SAlexander V. Chernikov ifa_ifwithdstaddr(const struct sockaddr *addr, int fibnum)
1979df8bae1dSRodney W. Grimes {
19800b59d917SJonathan Lemon 	struct ifnet *ifp;
19810b59d917SJonathan Lemon 	struct ifaddr *ifa;
1982df8bae1dSRodney W. Grimes 
198397168be8SGleb Smirnoff 	NET_EPOCH_ASSERT();
19844f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
19850b59d917SJonathan Lemon 		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
19860b59d917SJonathan Lemon 			continue;
19872f308a34SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
19880cfee0c2SAlan Somers 			continue;
1989d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1990df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1991df8bae1dSRodney W. Grimes 				continue;
1992f0c04221SBjoern A. Zeeb 			if (ifa->ifa_dstaddr != NULL &&
1993ab5ed8a5SRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr)) {
19940b59d917SJonathan Lemon 				goto done;
1995df8bae1dSRodney W. Grimes 			}
19960b59d917SJonathan Lemon 		}
1997ab5ed8a5SRobert Watson 	}
19980b59d917SJonathan Lemon 	ifa = NULL;
19990b59d917SJonathan Lemon done:
20000b59d917SJonathan Lemon 	return (ifa);
2001df8bae1dSRodney W. Grimes }
2002df8bae1dSRodney W. Grimes 
2003df8bae1dSRodney W. Grimes /*
2004df8bae1dSRodney W. Grimes  * Find an interface on a specific network.  If many, choice
2005df8bae1dSRodney W. Grimes  * is most specific found.
2006df8bae1dSRodney W. Grimes  */
2007df8bae1dSRodney W. Grimes struct ifaddr *
2008441f9243SAlexander V. Chernikov ifa_ifwithnet(const struct sockaddr *addr, int ignore_ptp, int fibnum)
2009df8bae1dSRodney W. Grimes {
201072fd1b6aSDag-Erling Smørgrav 	struct ifnet *ifp;
201172fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
20128c0fec80SRobert Watson 	struct ifaddr *ifa_maybe = NULL;
2013df8bae1dSRodney W. Grimes 	u_int af = addr->sa_family;
2014441f9243SAlexander V. Chernikov 	const char *addr_data = addr->sa_data, *cplim;
2015df8bae1dSRodney W. Grimes 
201697168be8SGleb Smirnoff 	NET_EPOCH_ASSERT();
20177e2a6151SJulian Elischer 	/*
20187e2a6151SJulian Elischer 	 * AF_LINK addresses can be looked up directly by their index number,
20197e2a6151SJulian Elischer 	 * so do that if we can.
20207e2a6151SJulian Elischer 	 */
2021df8bae1dSRodney W. Grimes 	if (af == AF_LINK) {
2022441f9243SAlexander V. Chernikov 	    const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)addr;
2023603724d3SBjoern A. Zeeb 	    if (sdl->sdl_index && sdl->sdl_index <= V_if_index)
2024f9132cebSJonathan Lemon 		return (ifaddr_byindex(sdl->sdl_index));
2025df8bae1dSRodney W. Grimes 	}
20267e2a6151SJulian Elischer 
20277e2a6151SJulian Elischer 	/*
20288c0fec80SRobert Watson 	 * Scan though each interface, looking for ones that have addresses
202921ee61a6SGleb Smirnoff 	 * in this address family and the requested fib.
20307e2a6151SJulian Elischer 	 */
20314f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
20322f308a34SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
20330cfee0c2SAlan Somers 			continue;
2034d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2035441f9243SAlexander V. Chernikov 			const char *cp, *cp2, *cp3;
2036df8bae1dSRodney W. Grimes 
2037523a02aaSDavid Greenman 			if (ifa->ifa_addr->sa_family != af)
2038df8bae1dSRodney W. Grimes next:				continue;
20390ed6142bSQing Li 			if (af == AF_INET &&
20400ed6142bSQing Li 			    ifp->if_flags & IFF_POINTOPOINT && !ignore_ptp) {
20417e2a6151SJulian Elischer 				/*
20427e2a6151SJulian Elischer 				 * This is a bit broken as it doesn't
20437e2a6151SJulian Elischer 				 * take into account that the remote end may
20447e2a6151SJulian Elischer 				 * be a single node in the network we are
20457e2a6151SJulian Elischer 				 * looking for.
20467e2a6151SJulian Elischer 				 * The trouble is that we don't know the
20477e2a6151SJulian Elischer 				 * netmask for the remote end.
20487e2a6151SJulian Elischer 				 */
2049f0c04221SBjoern A. Zeeb 				if (ifa->ifa_dstaddr != NULL &&
2050ab5ed8a5SRobert Watson 				    sa_equal(addr, ifa->ifa_dstaddr)) {
20510b59d917SJonathan Lemon 					goto done;
2052ab5ed8a5SRobert Watson 				}
20533740e2adSDavid Greenman 			} else {
20547e2a6151SJulian Elischer 				/*
20557e2a6151SJulian Elischer 				 * Scan all the bits in the ifa's address.
20567e2a6151SJulian Elischer 				 * If a bit dissagrees with what we are
20577e2a6151SJulian Elischer 				 * looking for, mask it with the netmask
20587e2a6151SJulian Elischer 				 * to see if it really matters.
20597e2a6151SJulian Elischer 				 * (A byte at a time)
20607e2a6151SJulian Elischer 				 */
2061523a02aaSDavid Greenman 				if (ifa->ifa_netmask == 0)
2062523a02aaSDavid Greenman 					continue;
2063df8bae1dSRodney W. Grimes 				cp = addr_data;
2064df8bae1dSRodney W. Grimes 				cp2 = ifa->ifa_addr->sa_data;
2065df8bae1dSRodney W. Grimes 				cp3 = ifa->ifa_netmask->sa_data;
20667e2a6151SJulian Elischer 				cplim = ifa->ifa_netmask->sa_len
20677e2a6151SJulian Elischer 					+ (char *)ifa->ifa_netmask;
2068df8bae1dSRodney W. Grimes 				while (cp3 < cplim)
2069df8bae1dSRodney W. Grimes 					if ((*cp++ ^ *cp2++) & *cp3++)
20707e2a6151SJulian Elischer 						goto next; /* next address! */
20717e2a6151SJulian Elischer 				/*
20727e2a6151SJulian Elischer 				 * If the netmask of what we just found
20737e2a6151SJulian Elischer 				 * is more specific than what we had before
207424421c1cSGleb Smirnoff 				 * (if we had one), or if the virtual status
207524421c1cSGleb Smirnoff 				 * of new prefix is better than of the old one,
207624421c1cSGleb Smirnoff 				 * then remember the new one before continuing
207724421c1cSGleb Smirnoff 				 * to search for an even better one.
20787e2a6151SJulian Elischer 				 */
20798c0fec80SRobert Watson 				if (ifa_maybe == NULL ||
208024421c1cSGleb Smirnoff 				    ifa_preferred(ifa_maybe, ifa) ||
2081df8bae1dSRodney W. Grimes 				    rn_refines((caddr_t)ifa->ifa_netmask,
20828c0fec80SRobert Watson 				    (caddr_t)ifa_maybe->ifa_netmask)) {
2083df8bae1dSRodney W. Grimes 					ifa_maybe = ifa;
20848c0fec80SRobert Watson 				}
2085df8bae1dSRodney W. Grimes 			}
2086b2af64fdSDavid Greenman 		}
2087b2af64fdSDavid Greenman 	}
20880b59d917SJonathan Lemon 	ifa = ifa_maybe;
20898c0fec80SRobert Watson 	ifa_maybe = NULL;
20900b59d917SJonathan Lemon done:
20910b59d917SJonathan Lemon 	return (ifa);
2092df8bae1dSRodney W. Grimes }
2093df8bae1dSRodney W. Grimes 
2094df8bae1dSRodney W. Grimes /*
2095df8bae1dSRodney W. Grimes  * Find an interface address specific to an interface best matching
2096df8bae1dSRodney W. Grimes  * a given address.
2097df8bae1dSRodney W. Grimes  */
2098df8bae1dSRodney W. Grimes struct ifaddr *
2099441f9243SAlexander V. Chernikov ifaof_ifpforaddr(const struct sockaddr *addr, struct ifnet *ifp)
2100df8bae1dSRodney W. Grimes {
210172fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2102441f9243SAlexander V. Chernikov 	const char *cp, *cp2, *cp3;
210372fd1b6aSDag-Erling Smørgrav 	char *cplim;
21048c0fec80SRobert Watson 	struct ifaddr *ifa_maybe = NULL;
2105df8bae1dSRodney W. Grimes 	u_int af = addr->sa_family;
2106df8bae1dSRodney W. Grimes 
2107df8bae1dSRodney W. Grimes 	if (af >= AF_MAX)
2108cd292f12SBjoern A. Zeeb 		return (NULL);
21096573d758SMatt Macy 
211097168be8SGleb Smirnoff 	NET_EPOCH_ASSERT();
2111d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2112df8bae1dSRodney W. Grimes 		if (ifa->ifa_addr->sa_family != af)
2113df8bae1dSRodney W. Grimes 			continue;
21148c0fec80SRobert Watson 		if (ifa_maybe == NULL)
2115df8bae1dSRodney W. Grimes 			ifa_maybe = ifa;
2116df8bae1dSRodney W. Grimes 		if (ifa->ifa_netmask == 0) {
2117d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_addr) ||
2118d8d5b10eSRobert Watson 			    (ifa->ifa_dstaddr &&
2119d8d5b10eSRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr)))
21202defe5cdSJonathan Lemon 				goto done;
2121df8bae1dSRodney W. Grimes 			continue;
2122df8bae1dSRodney W. Grimes 		}
2123b2af64fdSDavid Greenman 		if (ifp->if_flags & IFF_POINTOPOINT) {
2124d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_dstaddr))
2125a8637146SJonathan Lemon 				goto done;
21263740e2adSDavid Greenman 		} else {
2127df8bae1dSRodney W. Grimes 			cp = addr->sa_data;
2128df8bae1dSRodney W. Grimes 			cp2 = ifa->ifa_addr->sa_data;
2129df8bae1dSRodney W. Grimes 			cp3 = ifa->ifa_netmask->sa_data;
2130df8bae1dSRodney W. Grimes 			cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
2131df8bae1dSRodney W. Grimes 			for (; cp3 < cplim; cp3++)
2132df8bae1dSRodney W. Grimes 				if ((*cp++ ^ *cp2++) & *cp3)
2133df8bae1dSRodney W. Grimes 					break;
2134df8bae1dSRodney W. Grimes 			if (cp3 == cplim)
21352defe5cdSJonathan Lemon 				goto done;
2136df8bae1dSRodney W. Grimes 		}
2137b2af64fdSDavid Greenman 	}
2138f9132cebSJonathan Lemon 	ifa = ifa_maybe;
2139f9132cebSJonathan Lemon done:
2140f9132cebSJonathan Lemon 	return (ifa);
2141df8bae1dSRodney W. Grimes }
2142df8bae1dSRodney W. Grimes 
214324421c1cSGleb Smirnoff /*
214424421c1cSGleb Smirnoff  * See whether new ifa is better than current one:
214524421c1cSGleb Smirnoff  * 1) A non-virtual one is preferred over virtual.
214624421c1cSGleb Smirnoff  * 2) A virtual in master state preferred over any other state.
214724421c1cSGleb Smirnoff  *
214824421c1cSGleb Smirnoff  * Used in several address selecting functions.
214924421c1cSGleb Smirnoff  */
215024421c1cSGleb Smirnoff int
215124421c1cSGleb Smirnoff ifa_preferred(struct ifaddr *cur, struct ifaddr *next)
215224421c1cSGleb Smirnoff {
215324421c1cSGleb Smirnoff 
215424421c1cSGleb Smirnoff 	return (cur->ifa_carp && (!next->ifa_carp ||
215524421c1cSGleb Smirnoff 	    ((*carp_master_p)(next) && !(*carp_master_p)(cur))));
215624421c1cSGleb Smirnoff }
215724421c1cSGleb Smirnoff 
215895fbe4d0SAlexander V. Chernikov struct sockaddr_dl *
215995fbe4d0SAlexander V. Chernikov link_alloc_sdl(size_t size, int flags)
216095fbe4d0SAlexander V. Chernikov {
216195fbe4d0SAlexander V. Chernikov 
216295fbe4d0SAlexander V. Chernikov 	return (malloc(size, M_TEMP, flags));
216395fbe4d0SAlexander V. Chernikov }
216495fbe4d0SAlexander V. Chernikov 
216595fbe4d0SAlexander V. Chernikov void
216695fbe4d0SAlexander V. Chernikov link_free_sdl(struct sockaddr *sa)
216795fbe4d0SAlexander V. Chernikov {
216895fbe4d0SAlexander V. Chernikov 	free(sa, M_TEMP);
216995fbe4d0SAlexander V. Chernikov }
217095fbe4d0SAlexander V. Chernikov 
217195fbe4d0SAlexander V. Chernikov /*
217295fbe4d0SAlexander V. Chernikov  * Fills in given sdl with interface basic info.
217395fbe4d0SAlexander V. Chernikov  * Returns pointer to filled sdl.
217495fbe4d0SAlexander V. Chernikov  */
217595fbe4d0SAlexander V. Chernikov struct sockaddr_dl *
217695fbe4d0SAlexander V. Chernikov link_init_sdl(struct ifnet *ifp, struct sockaddr *paddr, u_char iftype)
217795fbe4d0SAlexander V. Chernikov {
217895fbe4d0SAlexander V. Chernikov 	struct sockaddr_dl *sdl;
217995fbe4d0SAlexander V. Chernikov 
218095fbe4d0SAlexander V. Chernikov 	sdl = (struct sockaddr_dl *)paddr;
218195fbe4d0SAlexander V. Chernikov 	memset(sdl, 0, sizeof(struct sockaddr_dl));
218295fbe4d0SAlexander V. Chernikov 	sdl->sdl_len = sizeof(struct sockaddr_dl);
218395fbe4d0SAlexander V. Chernikov 	sdl->sdl_family = AF_LINK;
218495fbe4d0SAlexander V. Chernikov 	sdl->sdl_index = ifp->if_index;
218595fbe4d0SAlexander V. Chernikov 	sdl->sdl_type = iftype;
218695fbe4d0SAlexander V. Chernikov 
218795fbe4d0SAlexander V. Chernikov 	return (sdl);
218895fbe4d0SAlexander V. Chernikov }
218995fbe4d0SAlexander V. Chernikov 
2190df8bae1dSRodney W. Grimes /*
2191df8bae1dSRodney W. Grimes  * Mark an interface down and notify protocols of
2192df8bae1dSRodney W. Grimes  * the transition.
2193df8bae1dSRodney W. Grimes  */
21948614fb12SMax Laier static void
219572fd1b6aSDag-Erling Smørgrav if_unroute(struct ifnet *ifp, int flag, int fam)
2196df8bae1dSRodney W. Grimes {
219772fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2198b1e6a792SMark Johnston 	struct epoch_tracker et;
2199df8bae1dSRodney W. Grimes 
2200292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_unroute: flag != IFF_UP"));
2201292ee7beSRobert Watson 
2202e8c2601dSPoul-Henning Kamp 	ifp->if_flags &= ~flag;
220398b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
2204b1e6a792SMark Johnston 	NET_EPOCH_ENTER(et);
2205d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2206e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2207df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
2208b1e6a792SMark Johnston 	NET_EPOCH_EXIT(et);
2209db7f0b97SKip Macy 	ifp->if_qflush(ifp);
2210db7f0b97SKip Macy 
2211a9771948SGleb Smirnoff 	if (ifp->if_carp)
221254bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2213df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
2214df8bae1dSRodney W. Grimes }
2215df8bae1dSRodney W. Grimes 
2216df8bae1dSRodney W. Grimes /*
2217df8bae1dSRodney W. Grimes  * Mark an interface up and notify protocols of
2218df8bae1dSRodney W. Grimes  * the transition.
2219df8bae1dSRodney W. Grimes  */
22208614fb12SMax Laier static void
222172fd1b6aSDag-Erling Smørgrav if_route(struct ifnet *ifp, int flag, int fam)
2222df8bae1dSRodney W. Grimes {
222372fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2224b1e6a792SMark Johnston 	struct epoch_tracker et;
2225df8bae1dSRodney W. Grimes 
2226292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_route: flag != IFF_UP"));
2227292ee7beSRobert Watson 
2228e8c2601dSPoul-Henning Kamp 	ifp->if_flags |= flag;
222998b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
2230b1e6a792SMark Johnston 	NET_EPOCH_ENTER(et);
2231d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2232e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2233df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFUP, ifa->ifa_addr);
2234b1e6a792SMark Johnston 	NET_EPOCH_EXIT(et);
2235a9771948SGleb Smirnoff 	if (ifp->if_carp)
223654bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2237df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
223882cd038dSYoshinobu Inoue #ifdef INET6
223982cd038dSYoshinobu Inoue 	in6_if_up(ifp);
224082cd038dSYoshinobu Inoue #endif
2241df8bae1dSRodney W. Grimes }
2242df8bae1dSRodney W. Grimes 
2243a6fffd6cSBrooks Davis void	(*vlan_link_state_p)(struct ifnet *);	/* XXX: private from if_vlan */
224475ee267cSGleb Smirnoff void	(*vlan_trunk_cap_p)(struct ifnet *);		/* XXX: private from if_vlan */
2245e4cd31ddSJeff Roberson struct ifnet *(*vlan_trunkdev_p)(struct ifnet *);
2246e4cd31ddSJeff Roberson struct	ifnet *(*vlan_devat_p)(struct ifnet *, uint16_t);
2247e4cd31ddSJeff Roberson int	(*vlan_tag_p)(struct ifnet *, uint16_t *);
224832d2623aSNavdeep Parhar int	(*vlan_pcp_p)(struct ifnet *, uint16_t *);
2249e4cd31ddSJeff Roberson int	(*vlan_setcookie_p)(struct ifnet *, void *);
2250e4cd31ddSJeff Roberson void	*(*vlan_cookie_p)(struct ifnet *);
225194f5c9cfSSam Leffler 
225294f5c9cfSSam Leffler /*
225368a3482fSGleb Smirnoff  * Handle a change in the interface link state. To avoid LORs
225468a3482fSGleb Smirnoff  * between driver lock and upper layer locks, as well as possible
225568a3482fSGleb Smirnoff  * recursions, we post event to taskqueue, and all job
225668a3482fSGleb Smirnoff  * is done in static do_link_state_change().
225794f5c9cfSSam Leffler  */
225894f5c9cfSSam Leffler void
2259d6e82913SSteven Hartland if_link_state_change(struct ifnet *ifp, int link_state)
226094f5c9cfSSam Leffler {
2261d6e82913SSteven Hartland 	/* Return if state hasn't changed. */
2262d6e82913SSteven Hartland 	if (ifp->if_link_state == link_state)
22634d96314fSGleb Smirnoff 		return;
22644d96314fSGleb Smirnoff 
226594f5c9cfSSam Leffler 	ifp->if_link_state = link_state;
22664d96314fSGleb Smirnoff 
2267b8a6e03fSGleb Smirnoff 	/* XXXGL: reference ifp? */
226868a3482fSGleb Smirnoff 	taskqueue_enqueue(taskqueue_swi, &ifp->if_linktask);
226968a3482fSGleb Smirnoff }
227068a3482fSGleb Smirnoff 
227168a3482fSGleb Smirnoff static void
227268a3482fSGleb Smirnoff do_link_state_change(void *arg, int pending)
227368a3482fSGleb Smirnoff {
2274b8a6e03fSGleb Smirnoff 	struct ifnet *ifp;
2275b8a6e03fSGleb Smirnoff 	int link_state;
227668a3482fSGleb Smirnoff 
2277b8a6e03fSGleb Smirnoff 	ifp = arg;
2278b8a6e03fSGleb Smirnoff 	link_state = ifp->if_link_state;
2279b8a6e03fSGleb Smirnoff 
2280b8a6e03fSGleb Smirnoff 	CURVNET_SET(ifp->if_vnet);
228194f5c9cfSSam Leffler 	rt_ifmsg(ifp);
228275ee267cSGleb Smirnoff 	if (ifp->if_vlantrunk != NULL)
2283a6fffd6cSBrooks Davis 		(*vlan_link_state_p)(ifp);
22841c7899c7SGleb Smirnoff 
22851c7899c7SGleb Smirnoff 	if ((ifp->if_type == IFT_ETHER || ifp->if_type == IFT_L2VLAN) &&
2286833e8dc5SGleb Smirnoff 	    ifp->if_l2com != NULL)
22871c7899c7SGleb Smirnoff 		(*ng_ether_link_state_p)(ifp, link_state);
22884d96314fSGleb Smirnoff 	if (ifp->if_carp)
228954bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2290ddf32010SAndrew Thompson 	if (ifp->if_bridge)
22915c30b378SMatt Macy 		ifp->if_bridge_linkstate(ifp);
2292ddf32010SAndrew Thompson 	if (ifp->if_lagg)
2293d6e82913SSteven Hartland 		(*lagg_linkstate_p)(ifp, link_state);
22948f867517SAndrew Thompson 
229521ca7b57SMarko Zec 	if (IS_DEFAULT_VNET(curvnet))
22969d80a330SBrooks Davis 		devctl_notify("IFNET", ifp->if_xname,
229721ca7b57SMarko Zec 		    (link_state == LINK_STATE_UP) ? "LINK_UP" : "LINK_DOWN",
229821ca7b57SMarko Zec 		    NULL);
229968a3482fSGleb Smirnoff 	if (pending > 1)
230068a3482fSGleb Smirnoff 		if_printf(ifp, "%d link states coalesced\n", pending);
23015515c2e7SGleb Smirnoff 	if (log_link_state_change)
230220f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "link state changed to %s\n",
23038b02df24SGleb Smirnoff 		    (link_state == LINK_STATE_UP) ? "UP" : "DOWN" );
2304368bf0c2SSepherosa Ziehau 	EVENTHANDLER_INVOKE(ifnet_link_event, ifp, link_state);
23058b615593SMarko Zec 	CURVNET_RESTORE();
230694f5c9cfSSam Leffler }
230794f5c9cfSSam Leffler 
2308df8bae1dSRodney W. Grimes /*
2309e8c2601dSPoul-Henning Kamp  * Mark an interface down and notify protocols of
2310e8c2601dSPoul-Henning Kamp  * the transition.
2311e8c2601dSPoul-Henning Kamp  */
2312e8c2601dSPoul-Henning Kamp void
231372fd1b6aSDag-Erling Smørgrav if_down(struct ifnet *ifp)
2314e8c2601dSPoul-Henning Kamp {
2315e8c2601dSPoul-Henning Kamp 
231692a6859bSDexuan Cui 	EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_DOWN);
2317e8c2601dSPoul-Henning Kamp 	if_unroute(ifp, IFF_UP, AF_UNSPEC);
2318e8c2601dSPoul-Henning Kamp }
2319e8c2601dSPoul-Henning Kamp 
2320e8c2601dSPoul-Henning Kamp /*
2321e8c2601dSPoul-Henning Kamp  * Mark an interface up and notify protocols of
2322e8c2601dSPoul-Henning Kamp  * the transition.
2323e8c2601dSPoul-Henning Kamp  */
2324e8c2601dSPoul-Henning Kamp void
232572fd1b6aSDag-Erling Smørgrav if_up(struct ifnet *ifp)
2326e8c2601dSPoul-Henning Kamp {
2327e8c2601dSPoul-Henning Kamp 
2328e8c2601dSPoul-Henning Kamp 	if_route(ifp, IFF_UP, AF_UNSPEC);
232992a6859bSDexuan Cui 	EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_UP);
2330e8c2601dSPoul-Henning Kamp }
2331e8c2601dSPoul-Henning Kamp 
2332e8c2601dSPoul-Henning Kamp /*
2333df8bae1dSRodney W. Grimes  * Flush an interface queue.
2334df8bae1dSRodney W. Grimes  */
23357cc5b47fSKip Macy void
2336db7f0b97SKip Macy if_qflush(struct ifnet *ifp)
2337df8bae1dSRodney W. Grimes {
233872fd1b6aSDag-Erling Smørgrav 	struct mbuf *m, *n;
2339db7f0b97SKip Macy 	struct ifaltq *ifq;
2340df8bae1dSRodney W. Grimes 
2341db7f0b97SKip Macy 	ifq = &ifp->if_snd;
23427b21048cSMax Laier 	IFQ_LOCK(ifq);
234302b199f1SMax Laier #ifdef ALTQ
234402b199f1SMax Laier 	if (ALTQ_IS_ENABLED(ifq))
234502b199f1SMax Laier 		ALTQ_PURGE(ifq);
234602b199f1SMax Laier #endif
2347df8bae1dSRodney W. Grimes 	n = ifq->ifq_head;
2348155d72c4SPedro F. Giffuni 	while ((m = n) != NULL) {
2349c29a3321SKevin Lo 		n = m->m_nextpkt;
2350df8bae1dSRodney W. Grimes 		m_freem(m);
2351df8bae1dSRodney W. Grimes 	}
2352df8bae1dSRodney W. Grimes 	ifq->ifq_head = 0;
2353df8bae1dSRodney W. Grimes 	ifq->ifq_tail = 0;
2354df8bae1dSRodney W. Grimes 	ifq->ifq_len = 0;
23557b21048cSMax Laier 	IFQ_UNLOCK(ifq);
2356df8bae1dSRodney W. Grimes }
2357df8bae1dSRodney W. Grimes 
2358df8bae1dSRodney W. Grimes /*
23596064c5d3SRobert Watson  * Map interface name to interface structure pointer, with or without
23606064c5d3SRobert Watson  * returning a reference.
2361df8bae1dSRodney W. Grimes  */
2362df8bae1dSRodney W. Grimes struct ifnet *
23636064c5d3SRobert Watson ifunit_ref(const char *name)
23646064c5d3SRobert Watson {
2365a68cc388SGleb Smirnoff 	struct epoch_tracker et;
23666064c5d3SRobert Watson 	struct ifnet *ifp;
23676064c5d3SRobert Watson 
2368a68cc388SGleb Smirnoff 	NET_EPOCH_ENTER(et);
23694f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
23708bd015a1SRobert Watson 		if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0 &&
23718bd015a1SRobert Watson 		    !(ifp->if_flags & IFF_DYING))
23726064c5d3SRobert Watson 			break;
23736064c5d3SRobert Watson 	}
23746064c5d3SRobert Watson 	if (ifp != NULL)
23756064c5d3SRobert Watson 		if_ref(ifp);
2376a68cc388SGleb Smirnoff 	NET_EPOCH_EXIT(et);
23776064c5d3SRobert Watson 	return (ifp);
23786064c5d3SRobert Watson }
23796064c5d3SRobert Watson 
23806064c5d3SRobert Watson struct ifnet *
238130aad87dSBrooks Davis ifunit(const char *name)
2382df8bae1dSRodney W. Grimes {
2383a68cc388SGleb Smirnoff 	struct epoch_tracker et;
23848b7805e4SBoris Popov 	struct ifnet *ifp;
2385df8bae1dSRodney W. Grimes 
2386a68cc388SGleb Smirnoff 	NET_EPOCH_ENTER(et);
23874f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
238836c19a57SBrooks Davis 		if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0)
2389df8bae1dSRodney W. Grimes 			break;
2390df8bae1dSRodney W. Grimes 	}
2391a68cc388SGleb Smirnoff 	NET_EPOCH_EXIT(et);
2392df8bae1dSRodney W. Grimes 	return (ifp);
2393df8bae1dSRodney W. Grimes }
2394df8bae1dSRodney W. Grimes 
23958ad798aeSBrooks Davis void *
23968a4a4a43SBrooks Davis ifr_buffer_get_buffer(void *data)
239786d2ef16SBrooks Davis {
239886d2ef16SBrooks Davis 	union ifreq_union *ifrup;
239986d2ef16SBrooks Davis 
240086d2ef16SBrooks Davis 	ifrup = data;
240186d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24028a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
240386d2ef16SBrooks Davis 		return ((void *)(uintptr_t)
240486d2ef16SBrooks Davis 		    ifrup->ifr32.ifr_ifru.ifru_buffer.buffer);
240586d2ef16SBrooks Davis #endif
240686d2ef16SBrooks Davis 	return (ifrup->ifr.ifr_ifru.ifru_buffer.buffer);
240786d2ef16SBrooks Davis }
240886d2ef16SBrooks Davis 
240986d2ef16SBrooks Davis static void
24108a4a4a43SBrooks Davis ifr_buffer_set_buffer_null(void *data)
241186d2ef16SBrooks Davis {
241286d2ef16SBrooks Davis 	union ifreq_union *ifrup;
241386d2ef16SBrooks Davis 
241486d2ef16SBrooks Davis 	ifrup = data;
241586d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24168a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
241786d2ef16SBrooks Davis 		ifrup->ifr32.ifr_ifru.ifru_buffer.buffer = 0;
241886d2ef16SBrooks Davis 	else
241986d2ef16SBrooks Davis #endif
242086d2ef16SBrooks Davis 		ifrup->ifr.ifr_ifru.ifru_buffer.buffer = NULL;
242186d2ef16SBrooks Davis }
242286d2ef16SBrooks Davis 
24238ad798aeSBrooks Davis size_t
24248a4a4a43SBrooks Davis ifr_buffer_get_length(void *data)
242586d2ef16SBrooks Davis {
242686d2ef16SBrooks Davis 	union ifreq_union *ifrup;
242786d2ef16SBrooks Davis 
242886d2ef16SBrooks Davis 	ifrup = data;
242986d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24308a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
243186d2ef16SBrooks Davis 		return (ifrup->ifr32.ifr_ifru.ifru_buffer.length);
243286d2ef16SBrooks Davis #endif
243386d2ef16SBrooks Davis 	return (ifrup->ifr.ifr_ifru.ifru_buffer.length);
243486d2ef16SBrooks Davis }
243586d2ef16SBrooks Davis 
243686d2ef16SBrooks Davis static void
24378a4a4a43SBrooks Davis ifr_buffer_set_length(void *data, size_t len)
243886d2ef16SBrooks Davis {
243986d2ef16SBrooks Davis 	union ifreq_union *ifrup;
244086d2ef16SBrooks Davis 
244186d2ef16SBrooks Davis 	ifrup = data;
244286d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24438a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
244486d2ef16SBrooks Davis 		ifrup->ifr32.ifr_ifru.ifru_buffer.length = len;
244586d2ef16SBrooks Davis 	else
244686d2ef16SBrooks Davis #endif
244786d2ef16SBrooks Davis 		ifrup->ifr.ifr_ifru.ifru_buffer.length = len;
244886d2ef16SBrooks Davis }
244986d2ef16SBrooks Davis 
2450541d96aaSBrooks Davis void *
2451541d96aaSBrooks Davis ifr_data_get_ptr(void *ifrp)
2452541d96aaSBrooks Davis {
2453541d96aaSBrooks Davis 	union ifreq_union *ifrup;
2454541d96aaSBrooks Davis 
2455541d96aaSBrooks Davis 	ifrup = ifrp;
2456541d96aaSBrooks Davis #ifdef COMPAT_FREEBSD32
2457541d96aaSBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
2458541d96aaSBrooks Davis 		return ((void *)(uintptr_t)
2459541d96aaSBrooks Davis 		    ifrup->ifr32.ifr_ifru.ifru_data);
2460541d96aaSBrooks Davis #endif
2461541d96aaSBrooks Davis 		return (ifrup->ifr.ifr_ifru.ifru_data);
2462541d96aaSBrooks Davis }
2463541d96aaSBrooks Davis 
246482cd038dSYoshinobu Inoue /*
2465f13ad206SJonathan Lemon  * Hardware specific interface ioctls.
2466df8bae1dSRodney W. Grimes  */
24671687b1abSMichael Tuexen int
2468f13ad206SJonathan Lemon ifhwioctl(u_long cmd, struct ifnet *ifp, caddr_t data, struct thread *td)
2469df8bae1dSRodney W. Grimes {
2470f13ad206SJonathan Lemon 	struct ifreq *ifr;
2471cc5bb78bSSepherosa Ziehau 	int error = 0, do_ifup = 0;
2472292ee7beSRobert Watson 	int new_flags, temp_flags;
247336c19a57SBrooks Davis 	size_t namelen, onamelen;
2474215940b3SXin LI 	size_t descrlen;
2475215940b3SXin LI 	char *descrbuf, *odescrbuf;
247636c19a57SBrooks Davis 	char new_name[IFNAMSIZ];
24774fb3e0bbSRozhuk Ivan 	char old_name[IFNAMSIZ], strbuf[IFNAMSIZ + 8];
247836c19a57SBrooks Davis 	struct ifaddr *ifa;
247936c19a57SBrooks Davis 	struct sockaddr_dl *sdl;
2480df8bae1dSRodney W. Grimes 
2481df8bae1dSRodney W. Grimes 	ifr = (struct ifreq *)data;
248230aad87dSBrooks Davis 	switch (cmd) {
2483de593450SJonathan Lemon 	case SIOCGIFINDEX:
2484de593450SJonathan Lemon 		ifr->ifr_index = ifp->if_index;
2485de593450SJonathan Lemon 		break;
2486de593450SJonathan Lemon 
2487df8bae1dSRodney W. Grimes 	case SIOCGIFFLAGS:
2488292ee7beSRobert Watson 		temp_flags = ifp->if_flags | ifp->if_drv_flags;
2489292ee7beSRobert Watson 		ifr->ifr_flags = temp_flags & 0xffff;
2490292ee7beSRobert Watson 		ifr->ifr_flagshigh = temp_flags >> 16;
2491df8bae1dSRodney W. Grimes 		break;
2492df8bae1dSRodney W. Grimes 
2493016da741SJonathan Lemon 	case SIOCGIFCAP:
2494016da741SJonathan Lemon 		ifr->ifr_reqcap = ifp->if_capabilities;
2495016da741SJonathan Lemon 		ifr->ifr_curcap = ifp->if_capenable;
2496016da741SJonathan Lemon 		break;
2497016da741SJonathan Lemon 
2498c1aedfcbSEd Maste 	case SIOCGIFDATA:
2499c1aedfcbSEd Maste 	{
2500c1aedfcbSEd Maste 		struct if_data ifd;
2501c1aedfcbSEd Maste 
2502c1aedfcbSEd Maste 		/* Ensure uninitialised padding is not leaked. */
2503c1aedfcbSEd Maste 		memset(&ifd, 0, sizeof(ifd));
2504c1aedfcbSEd Maste 
2505c1aedfcbSEd Maste 		if_data_copy(ifp, &ifd);
2506c1aedfcbSEd Maste 		error = copyout(&ifd, ifr_data_get_ptr(ifr), sizeof(ifd));
2507c1aedfcbSEd Maste 		break;
2508c1aedfcbSEd Maste 	}
2509c1aedfcbSEd Maste 
25108f293a63SRobert Watson #ifdef MAC
25118f293a63SRobert Watson 	case SIOCGIFMAC:
251230d239bcSRobert Watson 		error = mac_ifnet_ioctl_get(td->td_ucred, ifr, ifp);
25138f293a63SRobert Watson 		break;
25148f293a63SRobert Watson #endif
25158f293a63SRobert Watson 
2516df8bae1dSRodney W. Grimes 	case SIOCGIFMETRIC:
2517df8bae1dSRodney W. Grimes 		ifr->ifr_metric = ifp->if_metric;
2518df8bae1dSRodney W. Grimes 		break;
2519df8bae1dSRodney W. Grimes 
2520a7028af7SDavid Greenman 	case SIOCGIFMTU:
2521a7028af7SDavid Greenman 		ifr->ifr_mtu = ifp->if_mtu;
2522a7028af7SDavid Greenman 		break;
2523a7028af7SDavid Greenman 
2524074c4a4eSGarrett Wollman 	case SIOCGIFPHYS:
2525e6485f73SGleb Smirnoff 		/* XXXGL: did this ever worked? */
2526e6485f73SGleb Smirnoff 		ifr->ifr_phys = 0;
2527074c4a4eSGarrett Wollman 		break;
2528074c4a4eSGarrett Wollman 
2529215940b3SXin LI 	case SIOCGIFDESCR:
2530215940b3SXin LI 		error = 0;
2531215940b3SXin LI 		sx_slock(&ifdescr_sx);
253257d84848SXin LI 		if (ifp->if_description == NULL)
2533215940b3SXin LI 			error = ENOMSG;
253457d84848SXin LI 		else {
2535215940b3SXin LI 			/* space for terminating nul */
2536215940b3SXin LI 			descrlen = strlen(ifp->if_description) + 1;
25378a4a4a43SBrooks Davis 			if (ifr_buffer_get_length(ifr) < descrlen)
25388a4a4a43SBrooks Davis 				ifr_buffer_set_buffer_null(ifr);
2539215940b3SXin LI 			else
2540215940b3SXin LI 				error = copyout(ifp->if_description,
25418a4a4a43SBrooks Davis 				    ifr_buffer_get_buffer(ifr), descrlen);
25428a4a4a43SBrooks Davis 			ifr_buffer_set_length(ifr, descrlen);
2543215940b3SXin LI 		}
2544215940b3SXin LI 		sx_sunlock(&ifdescr_sx);
2545215940b3SXin LI 		break;
2546215940b3SXin LI 
2547215940b3SXin LI 	case SIOCSIFDESCR:
2548215940b3SXin LI 		error = priv_check(td, PRIV_NET_SETIFDESCR);
2549215940b3SXin LI 		if (error)
2550215940b3SXin LI 			return (error);
2551215940b3SXin LI 
2552215940b3SXin LI 		/*
2553215940b3SXin LI 		 * Copy only (length-1) bytes to make sure that
2554215940b3SXin LI 		 * if_description is always nul terminated.  The
2555215940b3SXin LI 		 * length parameter is supposed to count the
2556215940b3SXin LI 		 * terminating nul in.
2557215940b3SXin LI 		 */
25588a4a4a43SBrooks Davis 		if (ifr_buffer_get_length(ifr) > ifdescr_maxlen)
2559215940b3SXin LI 			return (ENAMETOOLONG);
25608a4a4a43SBrooks Davis 		else if (ifr_buffer_get_length(ifr) == 0)
2561215940b3SXin LI 			descrbuf = NULL;
2562215940b3SXin LI 		else {
25638a4a4a43SBrooks Davis 			descrbuf = malloc(ifr_buffer_get_length(ifr),
256486d2ef16SBrooks Davis 			    M_IFDESCR, M_WAITOK | M_ZERO);
25658a4a4a43SBrooks Davis 			error = copyin(ifr_buffer_get_buffer(ifr), descrbuf,
25668a4a4a43SBrooks Davis 			    ifr_buffer_get_length(ifr) - 1);
2567215940b3SXin LI 			if (error) {
2568215940b3SXin LI 				free(descrbuf, M_IFDESCR);
2569215940b3SXin LI 				break;
2570215940b3SXin LI 			}
2571215940b3SXin LI 		}
2572215940b3SXin LI 
2573215940b3SXin LI 		sx_xlock(&ifdescr_sx);
2574215940b3SXin LI 		odescrbuf = ifp->if_description;
2575215940b3SXin LI 		ifp->if_description = descrbuf;
2576215940b3SXin LI 		sx_xunlock(&ifdescr_sx);
2577215940b3SXin LI 
2578215940b3SXin LI 		getmicrotime(&ifp->if_lastchange);
2579215940b3SXin LI 		free(odescrbuf, M_IFDESCR);
2580215940b3SXin LI 		break;
2581215940b3SXin LI 
258235fd7bc0SBjoern A. Zeeb 	case SIOCGIFFIB:
258335fd7bc0SBjoern A. Zeeb 		ifr->ifr_fib = ifp->if_fib;
258435fd7bc0SBjoern A. Zeeb 		break;
258535fd7bc0SBjoern A. Zeeb 
258635fd7bc0SBjoern A. Zeeb 	case SIOCSIFFIB:
258735fd7bc0SBjoern A. Zeeb 		error = priv_check(td, PRIV_NET_SETIFFIB);
258835fd7bc0SBjoern A. Zeeb 		if (error)
258935fd7bc0SBjoern A. Zeeb 			return (error);
259035fd7bc0SBjoern A. Zeeb 		if (ifr->ifr_fib >= rt_numfibs)
259135fd7bc0SBjoern A. Zeeb 			return (EINVAL);
259235fd7bc0SBjoern A. Zeeb 
259335fd7bc0SBjoern A. Zeeb 		ifp->if_fib = ifr->ifr_fib;
259435fd7bc0SBjoern A. Zeeb 		break;
259535fd7bc0SBjoern A. Zeeb 
2596df8bae1dSRodney W. Grimes 	case SIOCSIFFLAGS:
2597acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFFLAGS);
25989448326fSPoul-Henning Kamp 		if (error)
2599df8bae1dSRodney W. Grimes 			return (error);
2600292ee7beSRobert Watson 		/*
2601292ee7beSRobert Watson 		 * Currently, no driver owned flags pass the IFF_CANTCHANGE
2602292ee7beSRobert Watson 		 * check, so we don't need special handling here yet.
2603292ee7beSRobert Watson 		 */
260462f76486SMaxim Sobolev 		new_flags = (ifr->ifr_flags & 0xffff) |
260562f76486SMaxim Sobolev 		    (ifr->ifr_flagshigh << 16);
2606af50ea38SGleb Smirnoff 		if (ifp->if_flags & IFF_UP &&
260762f76486SMaxim Sobolev 		    (new_flags & IFF_UP) == 0) {
2608df8bae1dSRodney W. Grimes 			if_down(ifp);
260962f76486SMaxim Sobolev 		} else if (new_flags & IFF_UP &&
2610cf4b9371SPoul-Henning Kamp 		    (ifp->if_flags & IFF_UP) == 0) {
2611cc5bb78bSSepherosa Ziehau 			do_ifup = 1;
2612df8bae1dSRodney W. Grimes 		}
26137aebc5e8SYaroslav Tykhiy 		/* See if permanently promiscuous mode bit is about to flip */
26147aebc5e8SYaroslav Tykhiy 		if ((ifp->if_flags ^ new_flags) & IFF_PPROMISC) {
26157aebc5e8SYaroslav Tykhiy 			if (new_flags & IFF_PPROMISC)
26167aebc5e8SYaroslav Tykhiy 				ifp->if_flags |= IFF_PROMISC;
26177aebc5e8SYaroslav Tykhiy 			else if (ifp->if_pcount == 0)
26187aebc5e8SYaroslav Tykhiy 				ifp->if_flags &= ~IFF_PROMISC;
26196d07c157SNick Hibma 			if (log_promisc_mode_change)
262020f8d7bcSDag-Erling Smørgrav                                 if_printf(ifp, "permanently promiscuous mode %s\n",
26216d07c157SNick Hibma                                     ((new_flags & IFF_PPROMISC) ?
26226d07c157SNick Hibma                                      "enabled" : "disabled"));
26237aebc5e8SYaroslav Tykhiy 		}
2624df8bae1dSRodney W. Grimes 		ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
262562f76486SMaxim Sobolev 			(new_flags &~ IFF_CANTCHANGE);
262631302ebfSRobert Watson 		if (ifp->if_ioctl) {
2627df8bae1dSRodney W. Grimes 			(void) (*ifp->if_ioctl)(ifp, cmd, data);
262831302ebfSRobert Watson 		}
2629cc5bb78bSSepherosa Ziehau 		if (do_ifup)
2630cc5bb78bSSepherosa Ziehau 			if_up(ifp);
263198b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
2632df8bae1dSRodney W. Grimes 		break;
2633df8bae1dSRodney W. Grimes 
2634016da741SJonathan Lemon 	case SIOCSIFCAP:
2635acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFCAP);
2636016da741SJonathan Lemon 		if (error)
2637016da741SJonathan Lemon 			return (error);
2638efb4018bSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2639efb4018bSYaroslav Tykhiy 			return (EOPNOTSUPP);
2640016da741SJonathan Lemon 		if (ifr->ifr_reqcap & ~ifp->if_capabilities)
2641016da741SJonathan Lemon 			return (EINVAL);
2642efb4018bSYaroslav Tykhiy 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2643efb4018bSYaroslav Tykhiy 		if (error == 0)
2644efb4018bSYaroslav Tykhiy 			getmicrotime(&ifp->if_lastchange);
2645016da741SJonathan Lemon 		break;
2646016da741SJonathan Lemon 
26478f293a63SRobert Watson #ifdef MAC
26488f293a63SRobert Watson 	case SIOCSIFMAC:
264930d239bcSRobert Watson 		error = mac_ifnet_ioctl_set(td->td_ucred, ifr, ifp);
26508f293a63SRobert Watson 		break;
26518f293a63SRobert Watson #endif
26528f293a63SRobert Watson 
265336c19a57SBrooks Davis 	case SIOCSIFNAME:
2654acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFNAME);
2655acd3428bSRobert Watson 		if (error)
265636c19a57SBrooks Davis 			return (error);
2657541d96aaSBrooks Davis 		error = copyinstr(ifr_data_get_ptr(ifr), new_name, IFNAMSIZ,
2658541d96aaSBrooks Davis 		    NULL);
2659bc1470f1SBrooks Davis 		if (error != 0)
266036c19a57SBrooks Davis 			return (error);
2661bc1470f1SBrooks Davis 		if (new_name[0] == '\0')
2662bc1470f1SBrooks Davis 			return (EINVAL);
266340b1c921SKyle Evans 		if (strcmp(new_name, ifp->if_xname) == 0)
266440b1c921SKyle Evans 			break;
266536c19a57SBrooks Davis 		if (ifunit(new_name) != NULL)
266636c19a57SBrooks Davis 			return (EEXIST);
266736c19a57SBrooks Davis 
26685428776eSJohn Baldwin 		/*
26695428776eSJohn Baldwin 		 * XXX: Locking.  Nothing else seems to lock if_flags,
26705428776eSJohn Baldwin 		 * and there are numerous other races with the
26715428776eSJohn Baldwin 		 * ifunit() checks not being atomic with namespace
26725428776eSJohn Baldwin 		 * changes (renames, vmoves, if_attach, etc).
26735428776eSJohn Baldwin 		 */
26745428776eSJohn Baldwin 		ifp->if_flags |= IFF_RENAMING;
26755428776eSJohn Baldwin 
267636c19a57SBrooks Davis 		/* Announce the departure of the interface. */
267736c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
267852023244SMax Laier 		EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
267936c19a57SBrooks Davis 
268020f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "changing name to '%s'\n", new_name);
268171672bb6SBrooks Davis 
268267420bdaSGleb Smirnoff 		IF_ADDR_WLOCK(ifp);
26834fb3e0bbSRozhuk Ivan 		strlcpy(old_name, ifp->if_xname, sizeof(old_name));
268436c19a57SBrooks Davis 		strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname));
26854a0d6638SRuslan Ermilov 		ifa = ifp->if_addr;
268636c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_addr;
268736c19a57SBrooks Davis 		namelen = strlen(new_name);
268836c19a57SBrooks Davis 		onamelen = sdl->sdl_nlen;
268936c19a57SBrooks Davis 		/*
269036c19a57SBrooks Davis 		 * Move the address if needed.  This is safe because we
269136c19a57SBrooks Davis 		 * allocate space for a name of length IFNAMSIZ when we
269236c19a57SBrooks Davis 		 * create this in if_attach().
269336c19a57SBrooks Davis 		 */
269436c19a57SBrooks Davis 		if (namelen != onamelen) {
269536c19a57SBrooks Davis 			bcopy(sdl->sdl_data + onamelen,
269636c19a57SBrooks Davis 			    sdl->sdl_data + namelen, sdl->sdl_alen);
269736c19a57SBrooks Davis 		}
269836c19a57SBrooks Davis 		bcopy(new_name, sdl->sdl_data, namelen);
269936c19a57SBrooks Davis 		sdl->sdl_nlen = namelen;
270036c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_netmask;
270136c19a57SBrooks Davis 		bzero(sdl->sdl_data, onamelen);
270236c19a57SBrooks Davis 		while (namelen != 0)
270336c19a57SBrooks Davis 			sdl->sdl_data[--namelen] = 0xff;
270467420bdaSGleb Smirnoff 		IF_ADDR_WUNLOCK(ifp);
270536c19a57SBrooks Davis 
270625a4adceSMax Laier 		EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
270736c19a57SBrooks Davis 		/* Announce the return of the interface. */
270836c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
27095428776eSJohn Baldwin 
27105428776eSJohn Baldwin 		ifp->if_flags &= ~IFF_RENAMING;
27114fb3e0bbSRozhuk Ivan 
27124fb3e0bbSRozhuk Ivan 		snprintf(strbuf, sizeof(strbuf), "name=%s", new_name);
27134fb3e0bbSRozhuk Ivan 		devctl_notify("IFNET", old_name, "RENAME", strbuf);
271436c19a57SBrooks Davis 		break;
271536c19a57SBrooks Davis 
2716679e1390SJamie Gritton #ifdef VIMAGE
2717679e1390SJamie Gritton 	case SIOCSIFVNET:
2718679e1390SJamie Gritton 		error = priv_check(td, PRIV_NET_SETIFVNET);
2719679e1390SJamie Gritton 		if (error)
2720679e1390SJamie Gritton 			return (error);
2721be31e5e7SBjoern A. Zeeb 		error = if_vmove_loan(td, ifp, ifr->ifr_name, ifr->ifr_jid);
2722679e1390SJamie Gritton 		break;
2723679e1390SJamie Gritton #endif
2724679e1390SJamie Gritton 
2725df8bae1dSRodney W. Grimes 	case SIOCSIFMETRIC:
2726acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMETRIC);
27279448326fSPoul-Henning Kamp 		if (error)
2728df8bae1dSRodney W. Grimes 			return (error);
2729df8bae1dSRodney W. Grimes 		ifp->if_metric = ifr->ifr_metric;
273098b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
2731df8bae1dSRodney W. Grimes 		break;
2732df8bae1dSRodney W. Grimes 
2733074c4a4eSGarrett Wollman 	case SIOCSIFPHYS:
2734acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFPHYS);
2735e39a0280SGary Palmer 		if (error)
2736913e410eSYaroslav Tykhiy 			return (error);
2737913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2738913e410eSYaroslav Tykhiy 			return (EOPNOTSUPP);
2739e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2740e39a0280SGary Palmer 		if (error == 0)
274198b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2742913e410eSYaroslav Tykhiy 		break;
2743074c4a4eSGarrett Wollman 
2744a7028af7SDavid Greenman 	case SIOCSIFMTU:
274582cd038dSYoshinobu Inoue 	{
274682cd038dSYoshinobu Inoue 		u_long oldmtu = ifp->if_mtu;
274782cd038dSYoshinobu Inoue 
2748acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMTU);
27499448326fSPoul-Henning Kamp 		if (error)
2750a7028af7SDavid Greenman 			return (error);
2751aab3beeeSBrian Somers 		if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU)
275275ee03cbSDavid Greenman 			return (EINVAL);
2753f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
2754f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
275501ad0c00SKristof Provost 		/* Disallow MTU changes on bridge member interfaces. */
275601ad0c00SKristof Provost 		if (ifp->if_bridge)
275701ad0c00SKristof Provost 			return (EOPNOTSUPP);
2758e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
275948f71763SRuslan Ermilov 		if (error == 0) {
276098b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
276148f71763SRuslan Ermilov 			rt_ifmsg(ifp);
2762e5054602SMark Johnston #ifdef INET
27637790c8c1SConrad Meyer 			DEBUGNET_NOTIFY_MTU(ifp);
2764e5054602SMark Johnston #endif
276548f71763SRuslan Ermilov 		}
276682cd038dSYoshinobu Inoue 		/*
276782cd038dSYoshinobu Inoue 		 * If the link MTU changed, do network layer specific procedure.
276882cd038dSYoshinobu Inoue 		 */
276982cd038dSYoshinobu Inoue 		if (ifp->if_mtu != oldmtu) {
277082cd038dSYoshinobu Inoue #ifdef INET6
277182cd038dSYoshinobu Inoue 			nd6_setmtu(ifp);
277282cd038dSYoshinobu Inoue #endif
27737f948f12SAlexander V. Chernikov 			rt_updatemtu(ifp);
277482cd038dSYoshinobu Inoue 		}
2775f13ad206SJonathan Lemon 		break;
277682cd038dSYoshinobu Inoue 	}
2777a7028af7SDavid Greenman 
2778df8bae1dSRodney W. Grimes 	case SIOCADDMULTI:
2779df8bae1dSRodney W. Grimes 	case SIOCDELMULTI:
2780acd3428bSRobert Watson 		if (cmd == SIOCADDMULTI)
2781acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_ADDMULTI);
2782acd3428bSRobert Watson 		else
2783acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_DELMULTI);
27849448326fSPoul-Henning Kamp 		if (error)
2785df8bae1dSRodney W. Grimes 			return (error);
2786477180fbSGarrett Wollman 
2787477180fbSGarrett Wollman 		/* Don't allow group membership on non-multicast interfaces. */
2788477180fbSGarrett Wollman 		if ((ifp->if_flags & IFF_MULTICAST) == 0)
2789f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
2790477180fbSGarrett Wollman 
2791477180fbSGarrett Wollman 		/* Don't let users screw up protocols' entries. */
2792477180fbSGarrett Wollman 		if (ifr->ifr_addr.sa_family != AF_LINK)
2793f13ad206SJonathan Lemon 			return (EINVAL);
2794477180fbSGarrett Wollman 
2795477180fbSGarrett Wollman 		if (cmd == SIOCADDMULTI) {
2796a68cc388SGleb Smirnoff 			struct epoch_tracker et;
2797477180fbSGarrett Wollman 			struct ifmultiaddr *ifma;
2798ec002feeSBruce M Simpson 
2799ec002feeSBruce M Simpson 			/*
2800ec002feeSBruce M Simpson 			 * Userland is only permitted to join groups once
2801ec002feeSBruce M Simpson 			 * via the if_addmulti() KPI, because it cannot hold
2802ec002feeSBruce M Simpson 			 * struct ifmultiaddr * between calls. It may also
2803ec002feeSBruce M Simpson 			 * lose a race while we check if the membership
2804ec002feeSBruce M Simpson 			 * already exists.
2805ec002feeSBruce M Simpson 			 */
2806a68cc388SGleb Smirnoff 			NET_EPOCH_ENTER(et);
2807ec002feeSBruce M Simpson 			ifma = if_findmulti(ifp, &ifr->ifr_addr);
2808a68cc388SGleb Smirnoff 			NET_EPOCH_EXIT(et);
2809ec002feeSBruce M Simpson 			if (ifma != NULL)
2810ec002feeSBruce M Simpson 				error = EADDRINUSE;
2811ec002feeSBruce M Simpson 			else
2812477180fbSGarrett Wollman 				error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
2813477180fbSGarrett Wollman 		} else {
2814477180fbSGarrett Wollman 			error = if_delmulti(ifp, &ifr->ifr_addr);
2815477180fbSGarrett Wollman 		}
2816e39a0280SGary Palmer 		if (error == 0)
281798b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2818f13ad206SJonathan Lemon 		break;
2819df8bae1dSRodney W. Grimes 
282041b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR:
282141b3e8e5SJun-ichiro itojun Hagino 	case SIOCDIFPHYADDR:
282241b3e8e5SJun-ichiro itojun Hagino #ifdef INET6
282341b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR_IN6:
282441b3e8e5SJun-ichiro itojun Hagino #endif
2825a912e453SPeter Wemm 	case SIOCSIFMEDIA:
2826d7189ec6SJoerg Wunsch 	case SIOCSIFGENERIC:
2827acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_HWIOCTL);
2828a912e453SPeter Wemm 		if (error)
2829a912e453SPeter Wemm 			return (error);
2830f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
2831a912e453SPeter Wemm 			return (EOPNOTSUPP);
2832a912e453SPeter Wemm 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2833a912e453SPeter Wemm 		if (error == 0)
283498b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2835f13ad206SJonathan Lemon 		break;
2836a912e453SPeter Wemm 
2837413dd0baSPoul-Henning Kamp 	case SIOCGIFSTATUS:
283833841545SHajimu UMEMOTO 	case SIOCGIFPSRCADDR:
283933841545SHajimu UMEMOTO 	case SIOCGIFPDSTADDR:
2840a912e453SPeter Wemm 	case SIOCGIFMEDIA:
2841eb7e25b2SEric Joyner 	case SIOCGIFXMEDIA:
2842d7189ec6SJoerg Wunsch 	case SIOCGIFGENERIC:
28430f3af041SSepherosa Ziehau 	case SIOCGIFRSSKEY:
28440f3af041SSepherosa Ziehau 	case SIOCGIFRSSHASH:
2845247cf566SKonstantin Belousov 	case SIOCGIFDOWNREASON:
2846913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2847a912e453SPeter Wemm 			return (EOPNOTSUPP);
2848f13ad206SJonathan Lemon 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2849f13ad206SJonathan Lemon 		break;
2850a912e453SPeter Wemm 
2851b106252cSBill Paul 	case SIOCSIFLLADDR:
2852acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETLLADDR);
2853b106252cSBill Paul 		if (error)
2854b106252cSBill Paul 			return (error);
2855f13ad206SJonathan Lemon 		error = if_setlladdr(ifp,
285666ce51ceSArchie Cobbs 		    ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len);
2857f13ad206SJonathan Lemon 		break;
285866ce51ceSArchie Cobbs 
2859ddae5750SRavi Pokala 	case SIOCGHWADDR:
2860ddae5750SRavi Pokala 		error = if_gethwaddr(ifp, ifr);
2861ddae5750SRavi Pokala 		break;
2862ddae5750SRavi Pokala 
286301e9cbc4SJohn Baldwin 	case SIOCAIFGROUP:
2864acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_ADDIFGROUP);
28650dad3f0eSMax Laier 		if (error)
28660dad3f0eSMax Laier 			return (error);
286701e9cbc4SJohn Baldwin 		error = if_addgroup(ifp,
286801e9cbc4SJohn Baldwin 		    ((struct ifgroupreq *)data)->ifgr_group);
286901e9cbc4SJohn Baldwin 		if (error != 0)
28700dad3f0eSMax Laier 			return (error);
28710dad3f0eSMax Laier 		break;
28720dad3f0eSMax Laier 
287301e9cbc4SJohn Baldwin 	case SIOCGIFGROUP:
2874b8a6e03fSGleb Smirnoff 	{
2875b8a6e03fSGleb Smirnoff 		struct epoch_tracker et;
2876b8a6e03fSGleb Smirnoff 
2877b8a6e03fSGleb Smirnoff 		NET_EPOCH_ENTER(et);
2878b8a6e03fSGleb Smirnoff 		error = if_getgroup((struct ifgroupreq *)data, ifp);
2879b8a6e03fSGleb Smirnoff 		NET_EPOCH_EXIT(et);
2880756181b8SBrooks Davis 		break;
2881b8a6e03fSGleb Smirnoff 	}
28820dad3f0eSMax Laier 
288301e9cbc4SJohn Baldwin 	case SIOCDIFGROUP:
2884acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_DELIFGROUP);
28850dad3f0eSMax Laier 		if (error)
28860dad3f0eSMax Laier 			return (error);
288701e9cbc4SJohn Baldwin 		error = if_delgroup(ifp,
288801e9cbc4SJohn Baldwin 		    ((struct ifgroupreq *)data)->ifgr_group);
288901e9cbc4SJohn Baldwin 		if (error != 0)
28900dad3f0eSMax Laier 			return (error);
28910dad3f0eSMax Laier 		break;
28920dad3f0eSMax Laier 
2893df8bae1dSRodney W. Grimes 	default:
2894f13ad206SJonathan Lemon 		error = ENOIOCTL;
2895f13ad206SJonathan Lemon 		break;
2896f13ad206SJonathan Lemon 	}
2897f13ad206SJonathan Lemon 	return (error);
2898f13ad206SJonathan Lemon }
2899f13ad206SJonathan Lemon 
2900f13ad206SJonathan Lemon /*
2901f13ad206SJonathan Lemon  * Interface ioctls.
2902f13ad206SJonathan Lemon  */
2903f13ad206SJonathan Lemon int
290472fd1b6aSDag-Erling Smørgrav ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td)
2905f13ad206SJonathan Lemon {
29063edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
2907d17e0940SJohn Baldwin 	union {
2908d17e0940SJohn Baldwin 		struct ifconf ifc;
2909d61d98f4SJohn Baldwin 		struct ifdrv ifd;
291001e9cbc4SJohn Baldwin 		struct ifgroupreq ifgr;
29113edb7f4eSBrooks Davis 		struct ifmediareq ifmr;
2912d17e0940SJohn Baldwin 	} thunk;
2913d17e0940SJohn Baldwin 	u_long saved_cmd;
2914d17e0940SJohn Baldwin 	struct ifconf32 *ifc32;
2915d61d98f4SJohn Baldwin 	struct ifdrv32 *ifd32;
291601e9cbc4SJohn Baldwin 	struct ifgroupreq32 *ifgr32;
2917d17e0940SJohn Baldwin 	struct ifmediareq32 *ifmr32;
29182da19677SSean Bruno #endif
2919f13ad206SJonathan Lemon 	struct ifnet *ifp;
2920f13ad206SJonathan Lemon 	struct ifreq *ifr;
2921f13ad206SJonathan Lemon 	int error;
292262f76486SMaxim Sobolev 	int oif_flags;
292310108cb6SBjoern A. Zeeb #ifdef VIMAGE
292410108cb6SBjoern A. Zeeb 	bool shutdown;
292510108cb6SBjoern A. Zeeb #endif
2926f13ad206SJonathan Lemon 
29271fb51a12SBjoern A. Zeeb 	CURVNET_SET(so->so_vnet);
292889856f7eSBjoern A. Zeeb #ifdef VIMAGE
292989856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
293010108cb6SBjoern A. Zeeb 	shutdown = VNET_IS_SHUTTING_DOWN(so->so_vnet);
293110108cb6SBjoern A. Zeeb 	if (shutdown) {
293289856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
293389856f7eSBjoern A. Zeeb 		return (EBUSY);
293489856f7eSBjoern A. Zeeb 	}
293589856f7eSBjoern A. Zeeb #endif
293689856f7eSBjoern A. Zeeb 
2937d17e0940SJohn Baldwin #ifdef COMPAT_FREEBSD32
2938d17e0940SJohn Baldwin 	saved_cmd = cmd;
2939d17e0940SJohn Baldwin 	switch (cmd) {
2940d17e0940SJohn Baldwin 	case SIOCGIFCONF32:
2941d17e0940SJohn Baldwin 		ifc32 = (struct ifconf32 *)data;
2942d17e0940SJohn Baldwin 		thunk.ifc.ifc_len = ifc32->ifc_len;
2943d17e0940SJohn Baldwin 		thunk.ifc.ifc_buf = PTRIN(ifc32->ifc_buf);
2944d17e0940SJohn Baldwin 		data = (caddr_t)&thunk.ifc;
2945d17e0940SJohn Baldwin 		cmd = SIOCGIFCONF;
2946d17e0940SJohn Baldwin 		break;
2947d61d98f4SJohn Baldwin 	case SIOCGDRVSPEC32:
2948d61d98f4SJohn Baldwin 	case SIOCSDRVSPEC32:
2949d61d98f4SJohn Baldwin 		ifd32 = (struct ifdrv32 *)data;
2950d61d98f4SJohn Baldwin 		memcpy(thunk.ifd.ifd_name, ifd32->ifd_name,
2951d61d98f4SJohn Baldwin 		    sizeof(thunk.ifd.ifd_name));
2952d61d98f4SJohn Baldwin 		thunk.ifd.ifd_cmd = ifd32->ifd_cmd;
2953d61d98f4SJohn Baldwin 		thunk.ifd.ifd_len = ifd32->ifd_len;
2954d61d98f4SJohn Baldwin 		thunk.ifd.ifd_data = PTRIN(ifd32->ifd_data);
2955d61d98f4SJohn Baldwin 		data = (caddr_t)&thunk.ifd;
2956d61d98f4SJohn Baldwin 		cmd = _IOC_NEWTYPE(cmd, struct ifdrv);
2957d61d98f4SJohn Baldwin 		break;
295801e9cbc4SJohn Baldwin 	case SIOCAIFGROUP32:
295901e9cbc4SJohn Baldwin 	case SIOCGIFGROUP32:
296001e9cbc4SJohn Baldwin 	case SIOCDIFGROUP32:
296101e9cbc4SJohn Baldwin 	case SIOCGIFGMEMB32:
296201e9cbc4SJohn Baldwin 		ifgr32 = (struct ifgroupreq32 *)data;
296301e9cbc4SJohn Baldwin 		memcpy(thunk.ifgr.ifgr_name, ifgr32->ifgr_name,
296401e9cbc4SJohn Baldwin 		    sizeof(thunk.ifgr.ifgr_name));
296501e9cbc4SJohn Baldwin 		thunk.ifgr.ifgr_len = ifgr32->ifgr_len;
296601e9cbc4SJohn Baldwin 		switch (cmd) {
296701e9cbc4SJohn Baldwin 		case SIOCAIFGROUP32:
296801e9cbc4SJohn Baldwin 		case SIOCDIFGROUP32:
296901e9cbc4SJohn Baldwin 			memcpy(thunk.ifgr.ifgr_group, ifgr32->ifgr_group,
297001e9cbc4SJohn Baldwin 			    sizeof(thunk.ifgr.ifgr_group));
297101e9cbc4SJohn Baldwin 			break;
297201e9cbc4SJohn Baldwin 		case SIOCGIFGROUP32:
297301e9cbc4SJohn Baldwin 		case SIOCGIFGMEMB32:
297401e9cbc4SJohn Baldwin 			thunk.ifgr.ifgr_groups = PTRIN(ifgr32->ifgr_groups);
297501e9cbc4SJohn Baldwin 			break;
297601e9cbc4SJohn Baldwin 		}
297701e9cbc4SJohn Baldwin 		data = (caddr_t)&thunk.ifgr;
297801e9cbc4SJohn Baldwin 		cmd = _IOC_NEWTYPE(cmd, struct ifgroupreq);
297901e9cbc4SJohn Baldwin 		break;
2980d17e0940SJohn Baldwin 	case SIOCGIFMEDIA32:
2981d17e0940SJohn Baldwin 	case SIOCGIFXMEDIA32:
2982d17e0940SJohn Baldwin 		ifmr32 = (struct ifmediareq32 *)data;
2983d17e0940SJohn Baldwin 		memcpy(thunk.ifmr.ifm_name, ifmr32->ifm_name,
2984d17e0940SJohn Baldwin 		    sizeof(thunk.ifmr.ifm_name));
2985d17e0940SJohn Baldwin 		thunk.ifmr.ifm_current = ifmr32->ifm_current;
2986d17e0940SJohn Baldwin 		thunk.ifmr.ifm_mask = ifmr32->ifm_mask;
2987d17e0940SJohn Baldwin 		thunk.ifmr.ifm_status = ifmr32->ifm_status;
2988d17e0940SJohn Baldwin 		thunk.ifmr.ifm_active = ifmr32->ifm_active;
2989d17e0940SJohn Baldwin 		thunk.ifmr.ifm_count = ifmr32->ifm_count;
2990d17e0940SJohn Baldwin 		thunk.ifmr.ifm_ulist = PTRIN(ifmr32->ifm_ulist);
2991d17e0940SJohn Baldwin 		data = (caddr_t)&thunk.ifmr;
2992d17e0940SJohn Baldwin 		cmd = _IOC_NEWTYPE(cmd, struct ifmediareq);
2993d17e0940SJohn Baldwin 		break;
2994d17e0940SJohn Baldwin 	}
2995d17e0940SJohn Baldwin #endif
2996d17e0940SJohn Baldwin 
2997f13ad206SJonathan Lemon 	switch (cmd) {
2998f13ad206SJonathan Lemon 	case SIOCGIFCONF:
29991fb51a12SBjoern A. Zeeb 		error = ifconf(cmd, data);
3000b8a6e03fSGleb Smirnoff 		goto out_noref;
30019af74f3dSSergey Kandaurov 	}
30023edb7f4eSBrooks Davis 
30033edb7f4eSBrooks Davis 	ifr = (struct ifreq *)data;
3004f13ad206SJonathan Lemon 	switch (cmd) {
3005feb08d06SMarko Zec #ifdef VIMAGE
3006679e1390SJamie Gritton 	case SIOCSIFRVNET:
3007679e1390SJamie Gritton 		error = priv_check(td, PRIV_NET_SETIFVNET);
30081fb51a12SBjoern A. Zeeb 		if (error == 0)
30091fb51a12SBjoern A. Zeeb 			error = if_vmove_reclaim(td, ifr->ifr_name,
30101fb51a12SBjoern A. Zeeb 			    ifr->ifr_jid);
30113edb7f4eSBrooks Davis 		goto out_noref;
3012feb08d06SMarko Zec #endif
3013f13ad206SJonathan Lemon 	case SIOCIFCREATE:
30146b7330e2SSam Leffler 	case SIOCIFCREATE2:
3015acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFCREATE);
30161fb51a12SBjoern A. Zeeb 		if (error == 0)
30171fb51a12SBjoern A. Zeeb 			error = if_clone_create(ifr->ifr_name,
3018541d96aaSBrooks Davis 			    sizeof(ifr->ifr_name), cmd == SIOCIFCREATE2 ?
3019541d96aaSBrooks Davis 			    ifr_data_get_ptr(ifr) : NULL);
30203edb7f4eSBrooks Davis 		goto out_noref;
3021f13ad206SJonathan Lemon 	case SIOCIFDESTROY:
3022acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFDESTROY);
3023e133271fSKristof Provost 
3024e133271fSKristof Provost 		if (error == 0) {
30256d2a10d9SKristof Provost 			sx_xlock(&ifnet_detach_sxlock);
30261fb51a12SBjoern A. Zeeb 			error = if_clone_destroy(ifr->ifr_name);
30276d2a10d9SKristof Provost 			sx_xunlock(&ifnet_detach_sxlock);
3028e133271fSKristof Provost 		}
30293edb7f4eSBrooks Davis 		goto out_noref;
3030f13ad206SJonathan Lemon 
3031f13ad206SJonathan Lemon 	case SIOCIFGCLONERS:
30321fb51a12SBjoern A. Zeeb 		error = if_clone_list((struct if_clonereq *)data);
30333edb7f4eSBrooks Davis 		goto out_noref;
30343edb7f4eSBrooks Davis 
303501e9cbc4SJohn Baldwin 	case SIOCGIFGMEMB:
30361fb51a12SBjoern A. Zeeb 		error = if_getgroupmembers((struct ifgroupreq *)data);
30373edb7f4eSBrooks Davis 		goto out_noref;
30383edb7f4eSBrooks Davis 
303908b68b0eSGleb Smirnoff #if defined(INET) || defined(INET6)
304008b68b0eSGleb Smirnoff 	case SIOCSVH:
304108b68b0eSGleb Smirnoff 	case SIOCGVH:
304208b68b0eSGleb Smirnoff 		if (carp_ioctl_p == NULL)
304308b68b0eSGleb Smirnoff 			error = EPROTONOSUPPORT;
304408b68b0eSGleb Smirnoff 		else
304508b68b0eSGleb Smirnoff 			error = (*carp_ioctl_p)(ifr, cmd, td);
30463edb7f4eSBrooks Davis 		goto out_noref;
304708b68b0eSGleb Smirnoff #endif
3048f13ad206SJonathan Lemon 	}
3049f13ad206SJonathan Lemon 
30506064c5d3SRobert Watson 	ifp = ifunit_ref(ifr->ifr_name);
30511fb51a12SBjoern A. Zeeb 	if (ifp == NULL) {
30523edb7f4eSBrooks Davis 		error = ENXIO;
30533edb7f4eSBrooks Davis 		goto out_noref;
30541fb51a12SBjoern A. Zeeb 	}
3055f13ad206SJonathan Lemon 
3056f13ad206SJonathan Lemon 	error = ifhwioctl(cmd, ifp, data, td);
30573edb7f4eSBrooks Davis 	if (error != ENOIOCTL)
30583edb7f4eSBrooks Davis 		goto out_ref;
3059f13ad206SJonathan Lemon 
306082cd038dSYoshinobu Inoue 	oif_flags = ifp->if_flags;
30616064c5d3SRobert Watson 	if (so->so_proto == NULL) {
30623edb7f4eSBrooks Davis 		error = EOPNOTSUPP;
30633edb7f4eSBrooks Davis 		goto out_ref;
30646064c5d3SRobert Watson 	}
30651a05c762SDag-Erling Smørgrav 
30661a05c762SDag-Erling Smørgrav 	/*
30671a05c762SDag-Erling Smørgrav 	 * Pass the request on to the socket control method, and if the
30681a05c762SDag-Erling Smørgrav 	 * latter returns EOPNOTSUPP, directly to the interface.
30691a05c762SDag-Erling Smørgrav 	 *
30701a05c762SDag-Erling Smørgrav 	 * Make an exception for the legacy SIOCSIF* requests.  Drivers
30711a05c762SDag-Erling Smørgrav 	 * trust SIOCSIFADDR et al to come from an already privileged
30721a05c762SDag-Erling Smørgrav 	 * layer, and do not perform any credentials checks or input
30731a05c762SDag-Erling Smørgrav 	 * validation.
30741a05c762SDag-Erling Smørgrav 	 */
30755fb009bdSGleb Smirnoff 	error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data,
3076b40ce416SJulian Elischer 	    ifp, td));
30771a05c762SDag-Erling Smørgrav 	if (error == EOPNOTSUPP && ifp != NULL && ifp->if_ioctl != NULL &&
30781a05c762SDag-Erling Smørgrav 	    cmd != SIOCSIFADDR && cmd != SIOCSIFBRDADDR &&
30791a05c762SDag-Erling Smørgrav 	    cmd != SIOCSIFDSTADDR && cmd != SIOCSIFNETMASK)
3080bc3977f1SJamie Gritton 		error = (*ifp->if_ioctl)(ifp, cmd, data);
308182cd038dSYoshinobu Inoue 
308282cd038dSYoshinobu Inoue 	if ((oif_flags ^ ifp->if_flags) & IFF_UP) {
308382cd038dSYoshinobu Inoue #ifdef INET6
3084c9b652e3SAndre Oppermann 		if (ifp->if_flags & IFF_UP)
308582cd038dSYoshinobu Inoue 			in6_if_up(ifp);
308682cd038dSYoshinobu Inoue #endif
3087df8bae1dSRodney W. Grimes 	}
30883edb7f4eSBrooks Davis 
30893edb7f4eSBrooks Davis out_ref:
30906064c5d3SRobert Watson 	if_rele(ifp);
30913edb7f4eSBrooks Davis out_noref:
3092d17e0940SJohn Baldwin 	CURVNET_RESTORE();
30933edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
3094d17e0940SJohn Baldwin 	if (error != 0)
3095d17e0940SJohn Baldwin 		return (error);
3096d17e0940SJohn Baldwin 	switch (saved_cmd) {
3097d17e0940SJohn Baldwin 	case SIOCGIFCONF32:
3098d17e0940SJohn Baldwin 		ifc32->ifc_len = thunk.ifc.ifc_len;
3099d17e0940SJohn Baldwin 		break;
3100d61d98f4SJohn Baldwin 	case SIOCGDRVSPEC32:
3101d61d98f4SJohn Baldwin 		/*
3102d61d98f4SJohn Baldwin 		 * SIOCGDRVSPEC is IOWR, but nothing actually touches
3103d61d98f4SJohn Baldwin 		 * the struct so just assert that ifd_len (the only
3104d61d98f4SJohn Baldwin 		 * field it might make sense to update) hasn't
3105d61d98f4SJohn Baldwin 		 * changed.
3106d61d98f4SJohn Baldwin 		 */
3107d61d98f4SJohn Baldwin 		KASSERT(thunk.ifd.ifd_len == ifd32->ifd_len,
3108d61d98f4SJohn Baldwin 		    ("ifd_len was updated %u -> %zu", ifd32->ifd_len,
3109d61d98f4SJohn Baldwin 			thunk.ifd.ifd_len));
3110d61d98f4SJohn Baldwin 		break;
311101e9cbc4SJohn Baldwin 	case SIOCGIFGROUP32:
311201e9cbc4SJohn Baldwin 	case SIOCGIFGMEMB32:
311301e9cbc4SJohn Baldwin 		ifgr32->ifgr_len = thunk.ifgr.ifgr_len;
311401e9cbc4SJohn Baldwin 		break;
3115d17e0940SJohn Baldwin 	case SIOCGIFMEDIA32:
3116d17e0940SJohn Baldwin 	case SIOCGIFXMEDIA32:
3117d17e0940SJohn Baldwin 		ifmr32->ifm_current = thunk.ifmr.ifm_current;
3118d17e0940SJohn Baldwin 		ifmr32->ifm_mask = thunk.ifmr.ifm_mask;
3119d17e0940SJohn Baldwin 		ifmr32->ifm_status = thunk.ifmr.ifm_status;
3120d17e0940SJohn Baldwin 		ifmr32->ifm_active = thunk.ifmr.ifm_active;
3121d17e0940SJohn Baldwin 		ifmr32->ifm_count = thunk.ifmr.ifm_count;
3122d17e0940SJohn Baldwin 		break;
31233edb7f4eSBrooks Davis 	}
31243edb7f4eSBrooks Davis #endif
3125df8bae1dSRodney W. Grimes 	return (error);
3126df8bae1dSRodney W. Grimes }
3127df8bae1dSRodney W. Grimes 
3128df8bae1dSRodney W. Grimes /*
3129292ee7beSRobert Watson  * The code common to handling reference counted flags,
31301a3b6859SYaroslav Tykhiy  * e.g., in ifpromisc() and if_allmulti().
3131b5c8bd59SYaroslav Tykhiy  * The "pflag" argument can specify a permanent mode flag to check,
31321a3b6859SYaroslav Tykhiy  * such as IFF_PPROMISC for promiscuous mode; should be 0 if none.
3133292ee7beSRobert Watson  *
3134292ee7beSRobert Watson  * Only to be used on stack-owned flags, not driver-owned flags.
31351a3b6859SYaroslav Tykhiy  */
31361a3b6859SYaroslav Tykhiy static int
31371a3b6859SYaroslav Tykhiy if_setflag(struct ifnet *ifp, int flag, int pflag, int *refcount, int onswitch)
31381a3b6859SYaroslav Tykhiy {
31391a3b6859SYaroslav Tykhiy 	struct ifreq ifr;
31401a3b6859SYaroslav Tykhiy 	int error;
31411a3b6859SYaroslav Tykhiy 	int oldflags, oldcount;
31421a3b6859SYaroslav Tykhiy 
31431a3b6859SYaroslav Tykhiy 	/* Sanity checks to catch programming errors */
3144b5c8bd59SYaroslav Tykhiy 	KASSERT((flag & (IFF_DRV_OACTIVE|IFF_DRV_RUNNING)) == 0,
3145b5c8bd59SYaroslav Tykhiy 	    ("%s: setting driver-owned flag %d", __func__, flag));
3146b5c8bd59SYaroslav Tykhiy 
3147b5c8bd59SYaroslav Tykhiy 	if (onswitch)
3148b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount >= 0,
3149b5c8bd59SYaroslav Tykhiy 		    ("%s: increment negative refcount %d for flag %d",
3150b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
3151b5c8bd59SYaroslav Tykhiy 	else
3152b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount > 0,
3153b5c8bd59SYaroslav Tykhiy 		    ("%s: decrement non-positive refcount %d for flag %d",
3154b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
31551a3b6859SYaroslav Tykhiy 
31561a3b6859SYaroslav Tykhiy 	/* In case this mode is permanent, just touch refcount */
31571a3b6859SYaroslav Tykhiy 	if (ifp->if_flags & pflag) {
31581a3b6859SYaroslav Tykhiy 		*refcount += onswitch ? 1 : -1;
31591a3b6859SYaroslav Tykhiy 		return (0);
31601a3b6859SYaroslav Tykhiy 	}
31611a3b6859SYaroslav Tykhiy 
31621a3b6859SYaroslav Tykhiy 	/* Save ifnet parameters for if_ioctl() may fail */
31631a3b6859SYaroslav Tykhiy 	oldcount = *refcount;
31641a3b6859SYaroslav Tykhiy 	oldflags = ifp->if_flags;
31651a3b6859SYaroslav Tykhiy 
31661a3b6859SYaroslav Tykhiy 	/*
31671a3b6859SYaroslav Tykhiy 	 * See if we aren't the only and touching refcount is enough.
31681a3b6859SYaroslav Tykhiy 	 * Actually toggle interface flag if we are the first or last.
31691a3b6859SYaroslav Tykhiy 	 */
31701a3b6859SYaroslav Tykhiy 	if (onswitch) {
31711a3b6859SYaroslav Tykhiy 		if ((*refcount)++)
31721a3b6859SYaroslav Tykhiy 			return (0);
31731a3b6859SYaroslav Tykhiy 		ifp->if_flags |= flag;
31741a3b6859SYaroslav Tykhiy 	} else {
31751a3b6859SYaroslav Tykhiy 		if (--(*refcount))
31761a3b6859SYaroslav Tykhiy 			return (0);
31771a3b6859SYaroslav Tykhiy 		ifp->if_flags &= ~flag;
31781a3b6859SYaroslav Tykhiy 	}
31791a3b6859SYaroslav Tykhiy 
31801a3b6859SYaroslav Tykhiy 	/* Call down the driver since we've changed interface flags */
31811a3b6859SYaroslav Tykhiy 	if (ifp->if_ioctl == NULL) {
31821a3b6859SYaroslav Tykhiy 		error = EOPNOTSUPP;
31831a3b6859SYaroslav Tykhiy 		goto recover;
31841a3b6859SYaroslav Tykhiy 	}
31851a3b6859SYaroslav Tykhiy 	ifr.ifr_flags = ifp->if_flags & 0xffff;
31861a3b6859SYaroslav Tykhiy 	ifr.ifr_flagshigh = ifp->if_flags >> 16;
31871a3b6859SYaroslav Tykhiy 	error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
31881a3b6859SYaroslav Tykhiy 	if (error)
31891a3b6859SYaroslav Tykhiy 		goto recover;
31901a3b6859SYaroslav Tykhiy 	/* Notify userland that interface flags have changed */
31911a3b6859SYaroslav Tykhiy 	rt_ifmsg(ifp);
31921a3b6859SYaroslav Tykhiy 	return (0);
31931a3b6859SYaroslav Tykhiy 
31941a3b6859SYaroslav Tykhiy recover:
31951a3b6859SYaroslav Tykhiy 	/* Recover after driver error */
31961a3b6859SYaroslav Tykhiy 	*refcount = oldcount;
31971a3b6859SYaroslav Tykhiy 	ifp->if_flags = oldflags;
31981a3b6859SYaroslav Tykhiy 	return (error);
31991a3b6859SYaroslav Tykhiy }
32001a3b6859SYaroslav Tykhiy 
32011a3b6859SYaroslav Tykhiy /*
3202963e4c2aSGarrett Wollman  * Set/clear promiscuous mode on interface ifp based on the truth value
3203963e4c2aSGarrett Wollman  * of pswitch.  The calls are reference counted so that only the first
3204963e4c2aSGarrett Wollman  * "on" request actually has an effect, as does the final "off" request.
3205963e4c2aSGarrett Wollman  * Results are undefined if the "off" and "on" requests are not matched.
3206963e4c2aSGarrett Wollman  */
3207963e4c2aSGarrett Wollman int
320872fd1b6aSDag-Erling Smørgrav ifpromisc(struct ifnet *ifp, int pswitch)
3209963e4c2aSGarrett Wollman {
32104a26224cSGarrett Wollman 	int error;
32111a3b6859SYaroslav Tykhiy 	int oldflags = ifp->if_flags;
3212963e4c2aSGarrett Wollman 
32131a3b6859SYaroslav Tykhiy 	error = if_setflag(ifp, IFF_PROMISC, IFF_PPROMISC,
32141a3b6859SYaroslav Tykhiy 			   &ifp->if_pcount, pswitch);
32151a3b6859SYaroslav Tykhiy 	/* If promiscuous mode status has changed, log a message */
32166d07c157SNick Hibma 	if (error == 0 && ((ifp->if_flags ^ oldflags) & IFF_PROMISC) &&
32176d07c157SNick Hibma             log_promisc_mode_change)
321820f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "promiscuous mode %s\n",
32194f3c11a6SBill Fenner 		    (ifp->if_flags & IFF_PROMISC) ? "enabled" : "disabled");
32201a3b6859SYaroslav Tykhiy 	return (error);
3221963e4c2aSGarrett Wollman }
3222963e4c2aSGarrett Wollman 
3223963e4c2aSGarrett Wollman /*
3224df8bae1dSRodney W. Grimes  * Return interface configuration
3225df8bae1dSRodney W. Grimes  * of system.  List may be used
3226df8bae1dSRodney W. Grimes  * in later ioctl's (above) to get
3227df8bae1dSRodney W. Grimes  * other information.
3228df8bae1dSRodney W. Grimes  */
3229df8bae1dSRodney W. Grimes /*ARGSUSED*/
32303bda9f9bSPoul-Henning Kamp static int
323172fd1b6aSDag-Erling Smørgrav ifconf(u_long cmd, caddr_t data)
3232df8bae1dSRodney W. Grimes {
32330b59d917SJonathan Lemon 	struct ifconf *ifc = (struct ifconf *)data;
32340b59d917SJonathan Lemon 	struct ifnet *ifp;
32350b59d917SJonathan Lemon 	struct ifaddr *ifa;
32364dcf2bbbSBrooks Davis 	struct ifreq ifr;
32374dcf2bbbSBrooks Davis 	struct sbuf *sb;
32384dcf2bbbSBrooks Davis 	int error, full = 0, valid_len, max_len;
3239df8bae1dSRodney W. Grimes 
3240cd853791SKonstantin Belousov 	/* Limit initial buffer size to maxphys to avoid DoS from userspace. */
3241cd853791SKonstantin Belousov 	max_len = maxphys - 1;
32424dcf2bbbSBrooks Davis 
3243b0b4b28bSXin LI 	/* Prevent hostile input from being able to crash the system */
3244b0b4b28bSXin LI 	if (ifc->ifc_len <= 0)
3245b0b4b28bSXin LI 		return (EINVAL);
3246b0b4b28bSXin LI 
32474dcf2bbbSBrooks Davis again:
32484dcf2bbbSBrooks Davis 	if (ifc->ifc_len <= max_len) {
32494dcf2bbbSBrooks Davis 		max_len = ifc->ifc_len;
32504dcf2bbbSBrooks Davis 		full = 1;
32514dcf2bbbSBrooks Davis 	}
32524dcf2bbbSBrooks Davis 	sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
32534dcf2bbbSBrooks Davis 	max_len = 0;
32544dcf2bbbSBrooks Davis 	valid_len = 0;
32554dcf2bbbSBrooks Davis 
325677dfcdc4SRobert Watson 	IFNET_RLOCK();
32574f6c66ccSMatt Macy 	CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
3258a68cc388SGleb Smirnoff 		struct epoch_tracker et;
32599bf40edeSBrooks Davis 		int addrs;
32602624cf89SGarrett Wollman 
3261fbd24c5eSColin Percival 		/*
32622443045fSBrooks Davis 		 * Zero the ifr to make sure we don't disclose the contents
32632443045fSBrooks Davis 		 * of the stack.
3264fbd24c5eSColin Percival 		 */
32652443045fSBrooks Davis 		memset(&ifr, 0, sizeof(ifr));
3266fbd24c5eSColin Percival 
32679bf40edeSBrooks Davis 		if (strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name))
326862313e4cSSam Leffler 		    >= sizeof(ifr.ifr_name)) {
326962313e4cSSam Leffler 			sbuf_delete(sb);
327062313e4cSSam Leffler 			IFNET_RUNLOCK();
32714dcf2bbbSBrooks Davis 			return (ENAMETOOLONG);
327262313e4cSSam Leffler 		}
32732624cf89SGarrett Wollman 
327475c13541SPoul-Henning Kamp 		addrs = 0;
3275a68cc388SGleb Smirnoff 		NET_EPOCH_ENTER(et);
3276d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
32772defe5cdSJonathan Lemon 			struct sockaddr *sa = ifa->ifa_addr;
32782defe5cdSJonathan Lemon 
3279b89e82ddSJamie Gritton 			if (prison_if(curthread->td_ucred, sa) != 0)
328075c13541SPoul-Henning Kamp 				continue;
328175c13541SPoul-Henning Kamp 			addrs++;
3282df8bae1dSRodney W. Grimes 			if (sa->sa_len <= sizeof(*sa)) {
3283e7fdc72eSBrooks Davis 				if (sa->sa_len < sizeof(*sa)) {
3284e7fdc72eSBrooks Davis 					memset(&ifr.ifr_ifru.ifru_addr, 0,
3285e7fdc72eSBrooks Davis 					    sizeof(ifr.ifr_ifru.ifru_addr));
3286e7fdc72eSBrooks Davis 					memcpy(&ifr.ifr_ifru.ifru_addr, sa,
3287e7fdc72eSBrooks Davis 					    sa->sa_len);
3288e7fdc72eSBrooks Davis 				} else
3289e7fdc72eSBrooks Davis 					ifr.ifr_ifru.ifru_addr = *sa;
32904dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr, sizeof(ifr));
32914dcf2bbbSBrooks Davis 				max_len += sizeof(ifr);
3292df8bae1dSRodney W. Grimes 			} else {
32934dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr,
32944dcf2bbbSBrooks Davis 				    offsetof(struct ifreq, ifr_addr));
32954dcf2bbbSBrooks Davis 				max_len += offsetof(struct ifreq, ifr_addr);
32964dcf2bbbSBrooks Davis 				sbuf_bcat(sb, sa, sa->sa_len);
32974dcf2bbbSBrooks Davis 				max_len += sa->sa_len;
3298df8bae1dSRodney W. Grimes 			}
32994dcf2bbbSBrooks Davis 
33004d369413SMatthew D Fleming 			if (sbuf_error(sb) == 0)
33014dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
3302df8bae1dSRodney W. Grimes 		}
3303a68cc388SGleb Smirnoff 		NET_EPOCH_EXIT(et);
33044dcf2bbbSBrooks Davis 		if (addrs == 0) {
33054dcf2bbbSBrooks Davis 			sbuf_bcat(sb, &ifr, sizeof(ifr));
33064dcf2bbbSBrooks Davis 			max_len += sizeof(ifr);
33074dcf2bbbSBrooks Davis 
33084d369413SMatthew D Fleming 			if (sbuf_error(sb) == 0)
33094dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
331075c13541SPoul-Henning Kamp 		}
3311df8bae1dSRodney W. Grimes 	}
3312b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
33134dcf2bbbSBrooks Davis 
33144dcf2bbbSBrooks Davis 	/*
33154dcf2bbbSBrooks Davis 	 * If we didn't allocate enough space (uncommon), try again.  If
33164dcf2bbbSBrooks Davis 	 * we have already allocated as much space as we are allowed,
33174dcf2bbbSBrooks Davis 	 * return what we've got.
33184dcf2bbbSBrooks Davis 	 */
33194dcf2bbbSBrooks Davis 	if (valid_len != max_len && !full) {
33204dcf2bbbSBrooks Davis 		sbuf_delete(sb);
33214dcf2bbbSBrooks Davis 		goto again;
33224dcf2bbbSBrooks Davis 	}
33234dcf2bbbSBrooks Davis 
33244dcf2bbbSBrooks Davis 	ifc->ifc_len = valid_len;
33255ed8cedcSBrian Feldman 	sbuf_finish(sb);
33264dcf2bbbSBrooks Davis 	error = copyout(sbuf_data(sb), ifc->ifc_req, ifc->ifc_len);
33274dcf2bbbSBrooks Davis 	sbuf_delete(sb);
3328df8bae1dSRodney W. Grimes 	return (error);
3329df8bae1dSRodney W. Grimes }
3330df8bae1dSRodney W. Grimes 
33311158dfb7SGarrett Wollman /*
33328b25904eSGleb Smirnoff  * Just like ifpromisc(), but for all-multicast-reception mode.
33331158dfb7SGarrett Wollman  */
33341158dfb7SGarrett Wollman int
333572fd1b6aSDag-Erling Smørgrav if_allmulti(struct ifnet *ifp, int onswitch)
33361158dfb7SGarrett Wollman {
33371158dfb7SGarrett Wollman 
33381a3b6859SYaroslav Tykhiy 	return (if_setflag(ifp, IFF_ALLMULTI, 0, &ifp->if_amcount, onswitch));
33391158dfb7SGarrett Wollman }
33401158dfb7SGarrett Wollman 
33415896d124SBruce M Simpson struct ifmultiaddr *
3342441f9243SAlexander V. Chernikov if_findmulti(struct ifnet *ifp, const struct sockaddr *sa)
33431158dfb7SGarrett Wollman {
33441158dfb7SGarrett Wollman 	struct ifmultiaddr *ifma;
33451158dfb7SGarrett Wollman 
3346c3b31afdSRobert Watson 	IF_ADDR_LOCK_ASSERT(ifp);
3347c3b31afdSRobert Watson 
3348d7c5a620SMatt Macy 	CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
334940d8a302SBruce M Simpson 		if (sa->sa_family == AF_LINK) {
335040d8a302SBruce M Simpson 			if (sa_dl_equal(ifma->ifma_addr, sa))
335140d8a302SBruce M Simpson 				break;
335240d8a302SBruce M Simpson 		} else {
3353c3b31afdSRobert Watson 			if (sa_equal(ifma->ifma_addr, sa))
3354c3b31afdSRobert Watson 				break;
33551158dfb7SGarrett Wollman 		}
335640d8a302SBruce M Simpson 	}
3357c3b31afdSRobert Watson 
3358c3b31afdSRobert Watson 	return ifma;
335957af7922SJulian Elischer }
33601158dfb7SGarrett Wollman 
33611158dfb7SGarrett Wollman /*
3362c3b31afdSRobert Watson  * Allocate a new ifmultiaddr and initialize based on passed arguments.  We
3363c3b31afdSRobert Watson  * make copies of passed sockaddrs.  The ifmultiaddr will not be added to
3364c3b31afdSRobert Watson  * the ifnet multicast address list here, so the caller must do that and
3365c3b31afdSRobert Watson  * other setup work (such as notifying the device driver).  The reference
3366c3b31afdSRobert Watson  * count is initialized to 1.
33671158dfb7SGarrett Wollman  */
3368c3b31afdSRobert Watson static struct ifmultiaddr *
3369c3b31afdSRobert Watson if_allocmulti(struct ifnet *ifp, struct sockaddr *sa, struct sockaddr *llsa,
3370c3b31afdSRobert Watson     int mflags)
3371c3b31afdSRobert Watson {
3372c3b31afdSRobert Watson 	struct ifmultiaddr *ifma;
3373c3b31afdSRobert Watson 	struct sockaddr *dupsa;
3374c3b31afdSRobert Watson 
33751ede983cSDag-Erling Smørgrav 	ifma = malloc(sizeof *ifma, M_IFMADDR, mflags |
3376c3b31afdSRobert Watson 	    M_ZERO);
3377c3b31afdSRobert Watson 	if (ifma == NULL)
3378c3b31afdSRobert Watson 		return (NULL);
3379c3b31afdSRobert Watson 
33801ede983cSDag-Erling Smørgrav 	dupsa = malloc(sa->sa_len, M_IFMADDR, mflags);
3381c3b31afdSRobert Watson 	if (dupsa == NULL) {
33821ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
3383c3b31afdSRobert Watson 		return (NULL);
33841158dfb7SGarrett Wollman 	}
33851158dfb7SGarrett Wollman 	bcopy(sa, dupsa, sa->sa_len);
33861158dfb7SGarrett Wollman 	ifma->ifma_addr = dupsa;
3387c3b31afdSRobert Watson 
33881158dfb7SGarrett Wollman 	ifma->ifma_ifp = ifp;
33891158dfb7SGarrett Wollman 	ifma->ifma_refcount = 1;
3390d4d22970SGleb Smirnoff 	ifma->ifma_protospec = NULL;
3391c3b31afdSRobert Watson 
3392c3b31afdSRobert Watson 	if (llsa == NULL) {
3393c3b31afdSRobert Watson 		ifma->ifma_lladdr = NULL;
3394c3b31afdSRobert Watson 		return (ifma);
3395c3b31afdSRobert Watson 	}
3396c3b31afdSRobert Watson 
33971ede983cSDag-Erling Smørgrav 	dupsa = malloc(llsa->sa_len, M_IFMADDR, mflags);
3398c3b31afdSRobert Watson 	if (dupsa == NULL) {
33991ede983cSDag-Erling Smørgrav 		free(ifma->ifma_addr, M_IFMADDR);
34001ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
3401c3b31afdSRobert Watson 		return (NULL);
3402c3b31afdSRobert Watson 	}
3403c3b31afdSRobert Watson 	bcopy(llsa, dupsa, llsa->sa_len);
3404c3b31afdSRobert Watson 	ifma->ifma_lladdr = dupsa;
3405c3b31afdSRobert Watson 
3406c3b31afdSRobert Watson 	return (ifma);
3407c3b31afdSRobert Watson }
3408373f88edSGarrett Wollman 
34091158dfb7SGarrett Wollman /*
3410c3b31afdSRobert Watson  * if_freemulti: free ifmultiaddr structure and possibly attached related
3411c3b31afdSRobert Watson  * addresses.  The caller is responsible for implementing reference
3412c3b31afdSRobert Watson  * counting, notifying the driver, handling routing messages, and releasing
3413c3b31afdSRobert Watson  * any dependent link layer state.
34141158dfb7SGarrett Wollman  */
3415b6f6f880SMatt Macy #ifdef MCAST_VERBOSE
3416b6f6f880SMatt Macy extern void kdb_backtrace(void);
3417b6f6f880SMatt Macy #endif
3418d7c5a620SMatt Macy static void
3419d7c5a620SMatt Macy if_freemulti_internal(struct ifmultiaddr *ifma)
3420c3b31afdSRobert Watson {
3421c3b31afdSRobert Watson 
3422ec002feeSBruce M Simpson 	KASSERT(ifma->ifma_refcount == 0, ("if_freemulti: refcount %d",
3423c3b31afdSRobert Watson 	    ifma->ifma_refcount));
3424c3b31afdSRobert Watson 
3425c3b31afdSRobert Watson 	if (ifma->ifma_lladdr != NULL)
34261ede983cSDag-Erling Smørgrav 		free(ifma->ifma_lladdr, M_IFMADDR);
3427b6f6f880SMatt Macy #ifdef MCAST_VERBOSE
3428b6f6f880SMatt Macy 	kdb_backtrace();
3429b6f6f880SMatt Macy 	printf("%s freeing ifma: %p\n", __func__, ifma);
3430b6f6f880SMatt Macy #endif
34311ede983cSDag-Erling Smørgrav 	free(ifma->ifma_addr, M_IFMADDR);
34321ede983cSDag-Erling Smørgrav 	free(ifma, M_IFMADDR);
3433c3b31afdSRobert Watson }
3434c3b31afdSRobert Watson 
3435d7c5a620SMatt Macy static void
3436d7c5a620SMatt Macy if_destroymulti(epoch_context_t ctx)
3437d7c5a620SMatt Macy {
3438d7c5a620SMatt Macy 	struct ifmultiaddr *ifma;
3439d7c5a620SMatt Macy 
3440d7c5a620SMatt Macy 	ifma = __containerof(ctx, struct ifmultiaddr, ifma_epoch_ctx);
3441d7c5a620SMatt Macy 	if_freemulti_internal(ifma);
3442d7c5a620SMatt Macy }
3443d7c5a620SMatt Macy 
3444d7c5a620SMatt Macy void
3445d7c5a620SMatt Macy if_freemulti(struct ifmultiaddr *ifma)
3446d7c5a620SMatt Macy {
3447d7c5a620SMatt Macy 	KASSERT(ifma->ifma_refcount == 0, ("if_freemulti_epoch: refcount %d",
3448d7c5a620SMatt Macy 	    ifma->ifma_refcount));
3449d7c5a620SMatt Macy 
34502a4bd982SGleb Smirnoff 	NET_EPOCH_CALL(if_destroymulti, &ifma->ifma_epoch_ctx);
3451d7c5a620SMatt Macy }
3452d7c5a620SMatt Macy 
3453c3b31afdSRobert Watson /*
3454c3b31afdSRobert Watson  * Register an additional multicast address with a network interface.
3455c3b31afdSRobert Watson  *
3456c3b31afdSRobert Watson  * - If the address is already present, bump the reference count on the
3457c3b31afdSRobert Watson  *   address and return.
3458c3b31afdSRobert Watson  * - If the address is not link-layer, look up a link layer address.
3459c3b31afdSRobert Watson  * - Allocate address structures for one or both addresses, and attach to the
3460c3b31afdSRobert Watson  *   multicast address list on the interface.  If automatically adding a link
3461c3b31afdSRobert Watson  *   layer address, the protocol address will own a reference to the link
3462c3b31afdSRobert Watson  *   layer address, to be freed when it is freed.
3463c3b31afdSRobert Watson  * - Notify the network device driver of an addition to the multicast address
3464c3b31afdSRobert Watson  *   list.
3465c3b31afdSRobert Watson  *
3466c3b31afdSRobert Watson  * 'sa' points to caller-owned memory with the desired multicast address.
3467c3b31afdSRobert Watson  *
3468c3b31afdSRobert Watson  * 'retifma' will be used to return a pointer to the resulting multicast
3469c3b31afdSRobert Watson  * address reference, if desired.
3470c3b31afdSRobert Watson  */
3471c3b31afdSRobert Watson int
3472c3b31afdSRobert Watson if_addmulti(struct ifnet *ifp, struct sockaddr *sa,
3473c3b31afdSRobert Watson     struct ifmultiaddr **retifma)
3474c3b31afdSRobert Watson {
3475c3b31afdSRobert Watson 	struct ifmultiaddr *ifma, *ll_ifma;
3476c3b31afdSRobert Watson 	struct sockaddr *llsa;
347795fbe4d0SAlexander V. Chernikov 	struct sockaddr_dl sdl;
3478c3b31afdSRobert Watson 	int error;
3479c3b31afdSRobert Watson 
3480f3e1324bSStephen Hurd #ifdef INET
3481f3e1324bSStephen Hurd 	IN_MULTI_LIST_UNLOCK_ASSERT();
3482f3e1324bSStephen Hurd #endif
3483f3e1324bSStephen Hurd #ifdef INET6
3484f3e1324bSStephen Hurd 	IN6_MULTI_LIST_UNLOCK_ASSERT();
3485f3e1324bSStephen Hurd #endif
3486c3b31afdSRobert Watson 	/*
3487c3b31afdSRobert Watson 	 * If the address is already present, return a new reference to it;
3488c3b31afdSRobert Watson 	 * otherwise, allocate storage and set up a new address.
3489c3b31afdSRobert Watson 	 */
3490137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
3491c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
3492c3b31afdSRobert Watson 	if (ifma != NULL) {
3493c3b31afdSRobert Watson 		ifma->ifma_refcount++;
3494c3b31afdSRobert Watson 		if (retifma != NULL)
3495c3b31afdSRobert Watson 			*retifma = ifma;
3496137f91e8SJohn Baldwin 		IF_ADDR_WUNLOCK(ifp);
3497c3b31afdSRobert Watson 		return (0);
3498c3b31afdSRobert Watson 	}
3499c3b31afdSRobert Watson 
3500c3b31afdSRobert Watson 	/*
3501c3b31afdSRobert Watson 	 * The address isn't already present; resolve the protocol address
3502c3b31afdSRobert Watson 	 * into a link layer address, and then look that up, bump its
350395fbe4d0SAlexander V. Chernikov 	 * refcount or allocate an ifma for that also.
350495fbe4d0SAlexander V. Chernikov 	 * Most link layer resolving functions returns address data which
350595fbe4d0SAlexander V. Chernikov 	 * fits inside default sockaddr_dl structure. However callback
350695fbe4d0SAlexander V. Chernikov 	 * can allocate another sockaddr structure, in that case we need to
350795fbe4d0SAlexander V. Chernikov 	 * free it later.
3508c3b31afdSRobert Watson 	 */
3509c3b31afdSRobert Watson 	llsa = NULL;
3510c3b31afdSRobert Watson 	ll_ifma = NULL;
3511c3b31afdSRobert Watson 	if (ifp->if_resolvemulti != NULL) {
351295fbe4d0SAlexander V. Chernikov 		/* Provide called function with buffer size information */
351395fbe4d0SAlexander V. Chernikov 		sdl.sdl_len = sizeof(sdl);
351495fbe4d0SAlexander V. Chernikov 		llsa = (struct sockaddr *)&sdl;
3515c3b31afdSRobert Watson 		error = ifp->if_resolvemulti(ifp, &llsa, sa);
3516c3b31afdSRobert Watson 		if (error)
3517c3b31afdSRobert Watson 			goto unlock_out;
3518c3b31afdSRobert Watson 	}
3519c3b31afdSRobert Watson 
3520c3b31afdSRobert Watson 	/*
3521c3b31afdSRobert Watson 	 * Allocate the new address.  Don't hook it up yet, as we may also
3522c3b31afdSRobert Watson 	 * need to allocate a link layer multicast address.
3523c3b31afdSRobert Watson 	 */
3524c3b31afdSRobert Watson 	ifma = if_allocmulti(ifp, sa, llsa, M_NOWAIT);
3525c3b31afdSRobert Watson 	if (ifma == NULL) {
3526c3b31afdSRobert Watson 		error = ENOMEM;
3527c3b31afdSRobert Watson 		goto free_llsa_out;
3528c3b31afdSRobert Watson 	}
3529c3b31afdSRobert Watson 
3530c3b31afdSRobert Watson 	/*
3531c3b31afdSRobert Watson 	 * If a link layer address is found, we'll need to see if it's
3532c3b31afdSRobert Watson 	 * already present in the address list, or allocate is as well.
3533c3b31afdSRobert Watson 	 * When this block finishes, the link layer address will be on the
3534c3b31afdSRobert Watson 	 * list.
3535c3b31afdSRobert Watson 	 */
3536c3b31afdSRobert Watson 	if (llsa != NULL) {
3537c3b31afdSRobert Watson 		ll_ifma = if_findmulti(ifp, llsa);
3538c3b31afdSRobert Watson 		if (ll_ifma == NULL) {
3539c3b31afdSRobert Watson 			ll_ifma = if_allocmulti(ifp, llsa, NULL, M_NOWAIT);
3540c3b31afdSRobert Watson 			if (ll_ifma == NULL) {
3541ec002feeSBruce M Simpson 				--ifma->ifma_refcount;
3542c3b31afdSRobert Watson 				if_freemulti(ifma);
3543c3b31afdSRobert Watson 				error = ENOMEM;
3544c3b31afdSRobert Watson 				goto free_llsa_out;
3545c3b31afdSRobert Watson 			}
3546f9be0386SMatt Macy 			ll_ifma->ifma_flags |= IFMA_F_ENQUEUED;
3547d7c5a620SMatt Macy 			CK_STAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ll_ifma,
3548c3b31afdSRobert Watson 			    ifma_link);
3549c3b31afdSRobert Watson 		} else
3550c3b31afdSRobert Watson 			ll_ifma->ifma_refcount++;
3551ec002feeSBruce M Simpson 		ifma->ifma_llifma = ll_ifma;
3552c3b31afdSRobert Watson 	}
3553c3b31afdSRobert Watson 
3554c3b31afdSRobert Watson 	/*
3555c3b31afdSRobert Watson 	 * We now have a new multicast address, ifma, and possibly a new or
3556c3b31afdSRobert Watson 	 * referenced link layer address.  Add the primary address to the
3557c3b31afdSRobert Watson 	 * ifnet address list.
3558c3b31afdSRobert Watson 	 */
3559f9be0386SMatt Macy 	ifma->ifma_flags |= IFMA_F_ENQUEUED;
3560d7c5a620SMatt Macy 	CK_STAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
3561c3b31afdSRobert Watson 
356213990766SJonathan Mini 	if (retifma != NULL)
3563373f88edSGarrett Wollman 		*retifma = ifma;
35641158dfb7SGarrett Wollman 
3565c3b31afdSRobert Watson 	/*
3566c3b31afdSRobert Watson 	 * Must generate the message while holding the lock so that 'ifma'
3567c3b31afdSRobert Watson 	 * pointer is still valid.
3568c3b31afdSRobert Watson 	 */
3569c3b31afdSRobert Watson 	rt_newmaddrmsg(RTM_NEWMADDR, ifma);
3570137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3571c3b31afdSRobert Watson 
35721158dfb7SGarrett Wollman 	/*
35731158dfb7SGarrett Wollman 	 * We are certain we have added something, so call down to the
35741158dfb7SGarrett Wollman 	 * interface to let them know about it.
35751158dfb7SGarrett Wollman 	 */
35762432c31cSRobert Watson 	if (ifp->if_ioctl != NULL) {
35770839aa5cSGleb Smirnoff 		if (THREAD_CAN_SLEEP())
35781a3b6859SYaroslav Tykhiy 			(void )(*ifp->if_ioctl)(ifp, SIOCADDMULTI, 0);
35790839aa5cSGleb Smirnoff 		else
35800839aa5cSGleb Smirnoff 			taskqueue_enqueue(taskqueue_swi, &ifp->if_addmultitask);
35811a3b6859SYaroslav Tykhiy 	}
35821158dfb7SGarrett Wollman 
358395fbe4d0SAlexander V. Chernikov 	if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
358495fbe4d0SAlexander V. Chernikov 		link_free_sdl(llsa);
3585c3b31afdSRobert Watson 
3586c3b31afdSRobert Watson 	return (0);
3587c3b31afdSRobert Watson 
3588c3b31afdSRobert Watson free_llsa_out:
358995fbe4d0SAlexander V. Chernikov 	if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
359095fbe4d0SAlexander V. Chernikov 		link_free_sdl(llsa);
3591c3b31afdSRobert Watson 
3592c3b31afdSRobert Watson unlock_out:
3593137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3594c3b31afdSRobert Watson 	return (error);
35951158dfb7SGarrett Wollman }
35961158dfb7SGarrett Wollman 
35970839aa5cSGleb Smirnoff static void
35980839aa5cSGleb Smirnoff if_siocaddmulti(void *arg, int pending)
35990839aa5cSGleb Smirnoff {
36000839aa5cSGleb Smirnoff 	struct ifnet *ifp;
36010839aa5cSGleb Smirnoff 
36020839aa5cSGleb Smirnoff 	ifp = arg;
36030839aa5cSGleb Smirnoff #ifdef DIAGNOSTIC
36040839aa5cSGleb Smirnoff 	if (pending > 1)
36050839aa5cSGleb Smirnoff 		if_printf(ifp, "%d SIOCADDMULTI coalesced\n", pending);
36060839aa5cSGleb Smirnoff #endif
36079352fab6SGleb Smirnoff 	CURVNET_SET(ifp->if_vnet);
36080839aa5cSGleb Smirnoff 	(void )(*ifp->if_ioctl)(ifp, SIOCADDMULTI, 0);
36099352fab6SGleb Smirnoff 	CURVNET_RESTORE();
36100839aa5cSGleb Smirnoff }
36110839aa5cSGleb Smirnoff 
36121158dfb7SGarrett Wollman /*
3613ec002feeSBruce M Simpson  * Delete a multicast group membership by network-layer group address.
3614ec002feeSBruce M Simpson  *
3615ec002feeSBruce M Simpson  * Returns ENOENT if the entry could not be found. If ifp no longer
3616ec002feeSBruce M Simpson  * exists, results are undefined. This entry point should only be used
3617ec002feeSBruce M Simpson  * from subsystems which do appropriate locking to hold ifp for the
3618ec002feeSBruce M Simpson  * duration of the call.
3619ec002feeSBruce M Simpson  * Network-layer protocol domains must use if_delmulti_ifma().
36201158dfb7SGarrett Wollman  */
36211158dfb7SGarrett Wollman int
362272fd1b6aSDag-Erling Smørgrav if_delmulti(struct ifnet *ifp, struct sockaddr *sa)
36231158dfb7SGarrett Wollman {
3624ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
3625ec002feeSBruce M Simpson 	int lastref;
3626ec002feeSBruce M Simpson 
3627416a1d1eSGleb Smirnoff 	KASSERT(ifp, ("%s: NULL ifp", __func__));
36281158dfb7SGarrett Wollman 
3629137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
3630ec002feeSBruce M Simpson 	lastref = 0;
3631c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
3632ec002feeSBruce M Simpson 	if (ifma != NULL)
3633ec002feeSBruce M Simpson 		lastref = if_delmulti_locked(ifp, ifma, 0);
3634137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3635c3b31afdSRobert Watson 
3636ec002feeSBruce M Simpson 	if (ifma == NULL)
3637ec002feeSBruce M Simpson 		return (ENOENT);
3638ec002feeSBruce M Simpson 
3639ec002feeSBruce M Simpson 	if (lastref && ifp->if_ioctl != NULL) {
36401a3b6859SYaroslav Tykhiy 		(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
364131302ebfSRobert Watson 	}
36421158dfb7SGarrett Wollman 
3643ec002feeSBruce M Simpson 	return (0);
3644ec002feeSBruce M Simpson }
3645ec002feeSBruce M Simpson 
3646ec002feeSBruce M Simpson /*
364793ec7edcSShteryana Shopova  * Delete all multicast group membership for an interface.
364893ec7edcSShteryana Shopova  * Should be used to quickly flush all multicast filters.
364993ec7edcSShteryana Shopova  */
365093ec7edcSShteryana Shopova void
365193ec7edcSShteryana Shopova if_delallmulti(struct ifnet *ifp)
365293ec7edcSShteryana Shopova {
365393ec7edcSShteryana Shopova 	struct ifmultiaddr *ifma;
365493ec7edcSShteryana Shopova 	struct ifmultiaddr *next;
365593ec7edcSShteryana Shopova 
3656137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
3657d7c5a620SMatt Macy 	CK_STAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
365893ec7edcSShteryana Shopova 		if_delmulti_locked(ifp, ifma, 0);
3659137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
366093ec7edcSShteryana Shopova }
366193ec7edcSShteryana Shopova 
3662b6f6f880SMatt Macy void
3663b6f6f880SMatt Macy if_delmulti_ifma(struct ifmultiaddr *ifma)
3664b6f6f880SMatt Macy {
3665b6f6f880SMatt Macy 	if_delmulti_ifma_flags(ifma, 0);
3666b6f6f880SMatt Macy }
3667b6f6f880SMatt Macy 
366893ec7edcSShteryana Shopova /*
3669ec002feeSBruce M Simpson  * Delete a multicast group membership by group membership pointer.
3670ec002feeSBruce M Simpson  * Network-layer protocol domains must use this routine.
3671ec002feeSBruce M Simpson  *
3672e5adda3dSRobert Watson  * It is safe to call this routine if the ifp disappeared.
3673ec002feeSBruce M Simpson  */
3674ec002feeSBruce M Simpson void
3675b6f6f880SMatt Macy if_delmulti_ifma_flags(struct ifmultiaddr *ifma, int flags)
3676ec002feeSBruce M Simpson {
3677ec002feeSBruce M Simpson 	struct ifnet *ifp;
3678ec002feeSBruce M Simpson 	int lastref;
3679b6f6f880SMatt Macy 	MCDPRINTF("%s freeing ifma: %p\n", __func__, ifma);
3680f3e1324bSStephen Hurd #ifdef INET
3681f3e1324bSStephen Hurd 	IN_MULTI_LIST_UNLOCK_ASSERT();
3682f3e1324bSStephen Hurd #endif
3683ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
3684ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
3685ec002feeSBruce M Simpson 	if (ifp == NULL) {
3686ec002feeSBruce M Simpson 		printf("%s: ifma_ifp seems to be detached\n", __func__);
3687ec002feeSBruce M Simpson 	} else {
3688e9dc46ccSGleb Smirnoff 		struct epoch_tracker et;
3689ec002feeSBruce M Simpson 		struct ifnet *oifp;
3690ec002feeSBruce M Simpson 
3691e9dc46ccSGleb Smirnoff 		NET_EPOCH_ENTER(et);
36924f6c66ccSMatt Macy 		CK_STAILQ_FOREACH(oifp, &V_ifnet, if_link)
3693ec002feeSBruce M Simpson 			if (ifp == oifp)
3694ec002feeSBruce M Simpson 				break;
3695e9dc46ccSGleb Smirnoff 		NET_EPOCH_EXIT(et);
36961ebec5faSMatt Macy 		if (ifp != oifp)
3697ec002feeSBruce M Simpson 			ifp = NULL;
3698ec002feeSBruce M Simpson 	}
3699ec002feeSBruce M Simpson #endif
3700ec002feeSBruce M Simpson 	/*
3701ec002feeSBruce M Simpson 	 * If and only if the ifnet instance exists: Acquire the address lock.
3702ec002feeSBruce M Simpson 	 */
3703ec002feeSBruce M Simpson 	if (ifp != NULL)
3704137f91e8SJohn Baldwin 		IF_ADDR_WLOCK(ifp);
3705ec002feeSBruce M Simpson 
3706b6f6f880SMatt Macy 	lastref = if_delmulti_locked(ifp, ifma, flags);
3707ec002feeSBruce M Simpson 
3708ec002feeSBruce M Simpson 	if (ifp != NULL) {
3709ec002feeSBruce M Simpson 		/*
3710ec002feeSBruce M Simpson 		 * If and only if the ifnet instance exists:
3711ec002feeSBruce M Simpson 		 *  Release the address lock.
3712ec002feeSBruce M Simpson 		 *  If the group was left: update the hardware hash filter.
3713ec002feeSBruce M Simpson 		 */
3714137f91e8SJohn Baldwin 		IF_ADDR_WUNLOCK(ifp);
3715ec002feeSBruce M Simpson 		if (lastref && ifp->if_ioctl != NULL) {
3716ec002feeSBruce M Simpson 			(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
3717ec002feeSBruce M Simpson 		}
3718ec002feeSBruce M Simpson 	}
3719ec002feeSBruce M Simpson }
3720ec002feeSBruce M Simpson 
3721ec002feeSBruce M Simpson /*
3722ec002feeSBruce M Simpson  * Perform deletion of network-layer and/or link-layer multicast address.
3723ec002feeSBruce M Simpson  *
3724ec002feeSBruce M Simpson  * Return 0 if the reference count was decremented.
3725ec002feeSBruce M Simpson  * Return 1 if the final reference was released, indicating that the
3726ec002feeSBruce M Simpson  * hardware hash filter should be reprogrammed.
3727ec002feeSBruce M Simpson  */
3728ec002feeSBruce M Simpson static int
3729ec002feeSBruce M Simpson if_delmulti_locked(struct ifnet *ifp, struct ifmultiaddr *ifma, int detaching)
3730ec002feeSBruce M Simpson {
3731ec002feeSBruce M Simpson 	struct ifmultiaddr *ll_ifma;
3732ec002feeSBruce M Simpson 
3733ec002feeSBruce M Simpson 	if (ifp != NULL && ifma->ifma_ifp != NULL) {
3734ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_ifp == ifp,
3735ec002feeSBruce M Simpson 		    ("%s: inconsistent ifp %p", __func__, ifp));
3736137f91e8SJohn Baldwin 		IF_ADDR_WLOCK_ASSERT(ifp);
3737ec002feeSBruce M Simpson 	}
3738ec002feeSBruce M Simpson 
3739ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
3740b6f6f880SMatt Macy 	MCDPRINTF("%s freeing %p from %s \n", __func__, ifma, ifp ? ifp->if_xname : "");
3741ec002feeSBruce M Simpson 
3742ec002feeSBruce M Simpson 	/*
3743ec002feeSBruce M Simpson 	 * If the ifnet is detaching, null out references to ifnet,
3744ec002feeSBruce M Simpson 	 * so that upper protocol layers will notice, and not attempt
374575ae0c01SBruce M Simpson 	 * to obtain locks for an ifnet which no longer exists. The
374675ae0c01SBruce M Simpson 	 * routing socket announcement must happen before the ifnet
374775ae0c01SBruce M Simpson 	 * instance is detached from the system.
3748ec002feeSBruce M Simpson 	 */
3749ec002feeSBruce M Simpson 	if (detaching) {
3750ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
3751ec002feeSBruce M Simpson 		printf("%s: detaching ifnet instance %p\n", __func__, ifp);
3752ec002feeSBruce M Simpson #endif
375375ae0c01SBruce M Simpson 		/*
375475ae0c01SBruce M Simpson 		 * ifp may already be nulled out if we are being reentered
375575ae0c01SBruce M Simpson 		 * to delete the ll_ifma.
375675ae0c01SBruce M Simpson 		 */
375775ae0c01SBruce M Simpson 		if (ifp != NULL) {
375875ae0c01SBruce M Simpson 			rt_newmaddrmsg(RTM_DELMADDR, ifma);
3759ec002feeSBruce M Simpson 			ifma->ifma_ifp = NULL;
3760ec002feeSBruce M Simpson 		}
376175ae0c01SBruce M Simpson 	}
3762ec002feeSBruce M Simpson 
3763ec002feeSBruce M Simpson 	if (--ifma->ifma_refcount > 0)
37641158dfb7SGarrett Wollman 		return 0;
3765ec002feeSBruce M Simpson 
3766f9be0386SMatt Macy 	if (ifp != NULL && detaching == 0 && (ifma->ifma_flags & IFMA_F_ENQUEUED)) {
3767d7c5a620SMatt Macy 		CK_STAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifmultiaddr, ifma_link);
3768f9be0386SMatt Macy 		ifma->ifma_flags &= ~IFMA_F_ENQUEUED;
3769f9be0386SMatt Macy 	}
3770ec002feeSBruce M Simpson 	/*
3771ec002feeSBruce M Simpson 	 * If this ifma is a network-layer ifma, a link-layer ifma may
3772ec002feeSBruce M Simpson 	 * have been associated with it. Release it first if so.
3773ec002feeSBruce M Simpson 	 */
3774ec002feeSBruce M Simpson 	ll_ifma = ifma->ifma_llifma;
3775ec002feeSBruce M Simpson 	if (ll_ifma != NULL) {
3776ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_lladdr != NULL,
3777ec002feeSBruce M Simpson 		    ("%s: llifma w/o lladdr", __func__));
3778ec002feeSBruce M Simpson 		if (detaching)
3779ec002feeSBruce M Simpson 			ll_ifma->ifma_ifp = NULL;	/* XXX */
3780ec002feeSBruce M Simpson 		if (--ll_ifma->ifma_refcount == 0) {
3781ec002feeSBruce M Simpson 			if (ifp != NULL) {
3782f9be0386SMatt Macy 				if (ll_ifma->ifma_flags & IFMA_F_ENQUEUED) {
3783d7c5a620SMatt Macy 					CK_STAILQ_REMOVE(&ifp->if_multiaddrs, ll_ifma, ifmultiaddr,
3784ec002feeSBruce M Simpson 						ifma_link);
378577ad07b6SMatt Macy 					ll_ifma->ifma_flags &= ~IFMA_F_ENQUEUED;
3786f9be0386SMatt Macy 				}
3787ec002feeSBruce M Simpson 			}
3788ec002feeSBruce M Simpson 			if_freemulti(ll_ifma);
3789ec002feeSBruce M Simpson 		}
3790ec002feeSBruce M Simpson 	}
3791b6f6f880SMatt Macy #ifdef INVARIANTS
3792b6f6f880SMatt Macy 	if (ifp) {
3793b6f6f880SMatt Macy 		struct ifmultiaddr *ifmatmp;
3794ec002feeSBruce M Simpson 
3795d7c5a620SMatt Macy 		CK_STAILQ_FOREACH(ifmatmp, &ifp->if_multiaddrs, ifma_link)
3796b6f6f880SMatt Macy 			MPASS(ifma != ifmatmp);
3797b6f6f880SMatt Macy 	}
3798b6f6f880SMatt Macy #endif
3799ec002feeSBruce M Simpson 	if_freemulti(ifma);
3800ec002feeSBruce M Simpson 	/*
3801ec002feeSBruce M Simpson 	 * The last reference to this instance of struct ifmultiaddr
3802ec002feeSBruce M Simpson 	 * was released; the hardware should be notified of this change.
3803ec002feeSBruce M Simpson 	 */
3804ec002feeSBruce M Simpson 	return 1;
38051158dfb7SGarrett Wollman }
38061158dfb7SGarrett Wollman 
380766ce51ceSArchie Cobbs /*
380866ce51ceSArchie Cobbs  * Set the link layer address on an interface.
380966ce51ceSArchie Cobbs  *
381066ce51ceSArchie Cobbs  * At this time we only support certain types of interfaces,
381166ce51ceSArchie Cobbs  * and we don't allow the length of the address to change.
3812bb3d23fdSAlexander V. Chernikov  *
3813bb3d23fdSAlexander V. Chernikov  * Set noinline to be dtrace-friendly
381466ce51ceSArchie Cobbs  */
3815bb3d23fdSAlexander V. Chernikov __noinline int
381666ce51ceSArchie Cobbs if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len)
381766ce51ceSArchie Cobbs {
381866ce51ceSArchie Cobbs 	struct sockaddr_dl *sdl;
381966ce51ceSArchie Cobbs 	struct ifaddr *ifa;
3820d637e989SPeter Wemm 	struct ifreq ifr;
382166ce51ceSArchie Cobbs 
38224a0d6638SRuslan Ermilov 	ifa = ifp->if_addr;
38231e80e4f2SGleb Smirnoff 	if (ifa == NULL)
38241e80e4f2SGleb Smirnoff 		return (EINVAL);
38254f6c66ccSMatt Macy 
382666ce51ceSArchie Cobbs 	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
38271e80e4f2SGleb Smirnoff 	if (sdl == NULL)
38281e80e4f2SGleb Smirnoff 		return (EINVAL);
38291e80e4f2SGleb Smirnoff 
38301e80e4f2SGleb Smirnoff 	if (len != sdl->sdl_alen)	/* don't allow length to change */
38311e80e4f2SGleb Smirnoff 		return (EINVAL);
38321e80e4f2SGleb Smirnoff 
383366ce51ceSArchie Cobbs 	switch (ifp->if_type) {
3834d09ed26fSRuslan Ermilov 	case IFT_ETHER:
383566ce51ceSArchie Cobbs 	case IFT_XETHER:
3836b7bffa71SYaroslav Tykhiy 	case IFT_L2VLAN:
38378f867517SAndrew Thompson 	case IFT_BRIDGE:
3838b47888ceSAndrew Thompson 	case IFT_IEEE8023ADLAG:
383966ce51ceSArchie Cobbs 		bcopy(lladdr, LLADDR(sdl), len);
384066ce51ceSArchie Cobbs 		break;
384166ce51ceSArchie Cobbs 	default:
38421e80e4f2SGleb Smirnoff 		return (ENODEV);
384366ce51ceSArchie Cobbs 	}
38443baaf297SRobert Watson 
384566ce51ceSArchie Cobbs 	/*
384666ce51ceSArchie Cobbs 	 * If the interface is already up, we need
384766ce51ceSArchie Cobbs 	 * to re-init it in order to reprogram its
384866ce51ceSArchie Cobbs 	 * address filter.
384966ce51ceSArchie Cobbs 	 */
385066ce51ceSArchie Cobbs 	if ((ifp->if_flags & IFF_UP) != 0) {
38511a3b6859SYaroslav Tykhiy 		if (ifp->if_ioctl) {
385266ce51ceSArchie Cobbs 			ifp->if_flags &= ~IFF_UP;
385362f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
385462f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
3855ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
385666ce51ceSArchie Cobbs 			ifp->if_flags |= IFF_UP;
385762f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
385862f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
3859ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
38601a3b6859SYaroslav Tykhiy 		}
386166ce51ceSArchie Cobbs 	}
38628ad43f2dSAlexander V. Chernikov 	EVENTHANDLER_INVOKE(iflladdr_event, ifp);
38631e80e4f2SGleb Smirnoff 
386491d6c9b9SMatt Macy 	return (0);
386566ce51ceSArchie Cobbs }
386666ce51ceSArchie Cobbs 
38679bf40edeSBrooks Davis /*
38684fb3a820SAlexander V. Chernikov  * Compat function for handling basic encapsulation requests.
38694fb3a820SAlexander V. Chernikov  * Not converted stacks (FDDI, IB, ..) supports traditional
38704fb3a820SAlexander V. Chernikov  * output model: ARP (and other similar L2 protocols) are handled
38714fb3a820SAlexander V. Chernikov  * inside output routine, arpresolve/nd6_resolve() returns MAC
38724fb3a820SAlexander V. Chernikov  * address instead of full prepend.
38734fb3a820SAlexander V. Chernikov  *
38744fb3a820SAlexander V. Chernikov  * This function creates calculated header==MAC for IPv4/IPv6 and
38754fb3a820SAlexander V. Chernikov  * returns EAFNOSUPPORT (which is then handled in ARP code) for other
38764fb3a820SAlexander V. Chernikov  * address families.
38774fb3a820SAlexander V. Chernikov  */
38784fb3a820SAlexander V. Chernikov static int
38794fb3a820SAlexander V. Chernikov if_requestencap_default(struct ifnet *ifp, struct if_encap_req *req)
38804fb3a820SAlexander V. Chernikov {
38814fb3a820SAlexander V. Chernikov 
38824fb3a820SAlexander V. Chernikov 	if (req->rtype != IFENCAP_LL)
38834fb3a820SAlexander V. Chernikov 		return (EOPNOTSUPP);
38844fb3a820SAlexander V. Chernikov 
38854fb3a820SAlexander V. Chernikov 	if (req->bufsize < req->lladdr_len)
38864fb3a820SAlexander V. Chernikov 		return (ENOMEM);
38874fb3a820SAlexander V. Chernikov 
38884fb3a820SAlexander V. Chernikov 	switch (req->family) {
38894fb3a820SAlexander V. Chernikov 	case AF_INET:
38904fb3a820SAlexander V. Chernikov 	case AF_INET6:
38914fb3a820SAlexander V. Chernikov 		break;
38924fb3a820SAlexander V. Chernikov 	default:
38934fb3a820SAlexander V. Chernikov 		return (EAFNOSUPPORT);
38944fb3a820SAlexander V. Chernikov 	}
38954fb3a820SAlexander V. Chernikov 
38964fb3a820SAlexander V. Chernikov 	/* Copy lladdr to storage as is */
38974fb3a820SAlexander V. Chernikov 	memmove(req->buf, req->lladdr, req->lladdr_len);
38984fb3a820SAlexander V. Chernikov 	req->bufsize = req->lladdr_len;
38994fb3a820SAlexander V. Chernikov 	req->lladdr_off = 0;
39004fb3a820SAlexander V. Chernikov 
39014fb3a820SAlexander V. Chernikov 	return (0);
39024fb3a820SAlexander V. Chernikov }
39034fb3a820SAlexander V. Chernikov 
39044fb3a820SAlexander V. Chernikov /*
390598a8fdf6SAndrey V. Elsukov  * Tunnel interfaces can nest, also they may cause infinite recursion
390698a8fdf6SAndrey V. Elsukov  * calls when misconfigured. We'll prevent this by detecting loops.
390798a8fdf6SAndrey V. Elsukov  * High nesting level may cause stack exhaustion. We'll prevent this
390898a8fdf6SAndrey V. Elsukov  * by introducing upper limit.
390998a8fdf6SAndrey V. Elsukov  *
391098a8fdf6SAndrey V. Elsukov  * Return 0, if tunnel nesting count is equal or less than limit.
391198a8fdf6SAndrey V. Elsukov  */
391298a8fdf6SAndrey V. Elsukov int
391398a8fdf6SAndrey V. Elsukov if_tunnel_check_nesting(struct ifnet *ifp, struct mbuf *m, uint32_t cookie,
391498a8fdf6SAndrey V. Elsukov     int limit)
391598a8fdf6SAndrey V. Elsukov {
391698a8fdf6SAndrey V. Elsukov 	struct m_tag *mtag;
391798a8fdf6SAndrey V. Elsukov 	int count;
391898a8fdf6SAndrey V. Elsukov 
391998a8fdf6SAndrey V. Elsukov 	count = 1;
392098a8fdf6SAndrey V. Elsukov 	mtag = NULL;
392198a8fdf6SAndrey V. Elsukov 	while ((mtag = m_tag_locate(m, cookie, 0, mtag)) != NULL) {
392298a8fdf6SAndrey V. Elsukov 		if (*(struct ifnet **)(mtag + 1) == ifp) {
392398a8fdf6SAndrey V. Elsukov 			log(LOG_NOTICE, "%s: loop detected\n", if_name(ifp));
392498a8fdf6SAndrey V. Elsukov 			return (EIO);
392598a8fdf6SAndrey V. Elsukov 		}
392698a8fdf6SAndrey V. Elsukov 		count++;
392798a8fdf6SAndrey V. Elsukov 	}
392898a8fdf6SAndrey V. Elsukov 	if (count > limit) {
392998a8fdf6SAndrey V. Elsukov 		log(LOG_NOTICE,
393098a8fdf6SAndrey V. Elsukov 		    "%s: if_output recursively called too many times(%d)\n",
393198a8fdf6SAndrey V. Elsukov 		    if_name(ifp), count);
393298a8fdf6SAndrey V. Elsukov 		return (EIO);
393398a8fdf6SAndrey V. Elsukov 	}
393498a8fdf6SAndrey V. Elsukov 	mtag = m_tag_alloc(cookie, 0, sizeof(struct ifnet *), M_NOWAIT);
393598a8fdf6SAndrey V. Elsukov 	if (mtag == NULL)
393698a8fdf6SAndrey V. Elsukov 		return (ENOMEM);
393798a8fdf6SAndrey V. Elsukov 	*(struct ifnet **)(mtag + 1) = ifp;
393898a8fdf6SAndrey V. Elsukov 	m_tag_prepend(m, mtag);
393998a8fdf6SAndrey V. Elsukov 	return (0);
394098a8fdf6SAndrey V. Elsukov }
394198a8fdf6SAndrey V. Elsukov 
394298a8fdf6SAndrey V. Elsukov /*
3943ddae5750SRavi Pokala  * Get the link layer address that was read from the hardware at attach.
3944ddae5750SRavi Pokala  *
3945ddae5750SRavi Pokala  * This is only set by Ethernet NICs (IFT_ETHER), but laggX interfaces re-type
3946ddae5750SRavi Pokala  * their component interfaces as IFT_IEEE8023ADLAG.
3947ddae5750SRavi Pokala  */
3948ddae5750SRavi Pokala int
3949ddae5750SRavi Pokala if_gethwaddr(struct ifnet *ifp, struct ifreq *ifr)
3950ddae5750SRavi Pokala {
3951ddae5750SRavi Pokala 
3952ddae5750SRavi Pokala 	if (ifp->if_hw_addr == NULL)
3953ddae5750SRavi Pokala 		return (ENODEV);
3954ddae5750SRavi Pokala 
3955ddae5750SRavi Pokala 	switch (ifp->if_type) {
3956ddae5750SRavi Pokala 	case IFT_ETHER:
3957ddae5750SRavi Pokala 	case IFT_IEEE8023ADLAG:
3958ddae5750SRavi Pokala 		bcopy(ifp->if_hw_addr, ifr->ifr_addr.sa_data, ifp->if_addrlen);
3959ddae5750SRavi Pokala 		return (0);
3960ddae5750SRavi Pokala 	default:
3961ddae5750SRavi Pokala 		return (ENODEV);
3962ddae5750SRavi Pokala 	}
3963ddae5750SRavi Pokala }
3964ddae5750SRavi Pokala 
3965ddae5750SRavi Pokala /*
39669bf40edeSBrooks Davis  * The name argument must be a pointer to storage which will last as
39679bf40edeSBrooks Davis  * long as the interface does.  For physical devices, the result of
39689bf40edeSBrooks Davis  * device_get_name(dev) is a good choice and for pseudo-devices a
39699bf40edeSBrooks Davis  * static string works well.
39709bf40edeSBrooks Davis  */
39719bf40edeSBrooks Davis void
39729bf40edeSBrooks Davis if_initname(struct ifnet *ifp, const char *name, int unit)
39739bf40edeSBrooks Davis {
39749bf40edeSBrooks Davis 	ifp->if_dname = name;
39759bf40edeSBrooks Davis 	ifp->if_dunit = unit;
39769bf40edeSBrooks Davis 	if (unit != IF_DUNIT_NONE)
39779bf40edeSBrooks Davis 		snprintf(ifp->if_xname, IFNAMSIZ, "%s%d", name, unit);
39789bf40edeSBrooks Davis 	else
39799bf40edeSBrooks Davis 		strlcpy(ifp->if_xname, name, IFNAMSIZ);
39809bf40edeSBrooks Davis }
39819bf40edeSBrooks Davis 
398225bfa448SAdrian Chadd static int
398325bfa448SAdrian Chadd if_vlog(struct ifnet *ifp, int pri, const char *fmt, va_list ap)
398425bfa448SAdrian Chadd {
398525bfa448SAdrian Chadd 	char if_fmt[256];
398625bfa448SAdrian Chadd 
398725bfa448SAdrian Chadd 	snprintf(if_fmt, sizeof(if_fmt), "%s: %s", ifp->if_xname, fmt);
398825bfa448SAdrian Chadd 	vlog(pri, if_fmt, ap);
398925bfa448SAdrian Chadd 	return (0);
399025bfa448SAdrian Chadd }
399125bfa448SAdrian Chadd 
399225bfa448SAdrian Chadd 
3993fa882e87SBrooks Davis int
3994fa882e87SBrooks Davis if_printf(struct ifnet *ifp, const char *fmt, ...)
3995fa882e87SBrooks Davis {
3996fa882e87SBrooks Davis 	va_list ap;
3997fa882e87SBrooks Davis 
3998fa882e87SBrooks Davis 	va_start(ap, fmt);
399925bfa448SAdrian Chadd 	if_vlog(ifp, LOG_INFO, fmt, ap);
400025bfa448SAdrian Chadd 	va_end(ap);
400125bfa448SAdrian Chadd 	return (0);
400225bfa448SAdrian Chadd }
400325bfa448SAdrian Chadd 
400425bfa448SAdrian Chadd int
400525bfa448SAdrian Chadd if_log(struct ifnet *ifp, int pri, const char *fmt, ...)
400625bfa448SAdrian Chadd {
400725bfa448SAdrian Chadd 	va_list ap;
400825bfa448SAdrian Chadd 
400925bfa448SAdrian Chadd 	va_start(ap, fmt);
401025bfa448SAdrian Chadd 	if_vlog(ifp, pri, fmt, ap);
4011fa882e87SBrooks Davis 	va_end(ap);
401220f8d7bcSDag-Erling Smørgrav 	return (0);
4013fa882e87SBrooks Davis }
4014fa882e87SBrooks Davis 
4015af5e59bfSRobert Watson void
4016af5e59bfSRobert Watson if_start(struct ifnet *ifp)
4017af5e59bfSRobert Watson {
4018af5e59bfSRobert Watson 
4019af5e59bfSRobert Watson 	(*(ifp)->if_start)(ifp);
4020af5e59bfSRobert Watson }
4021af5e59bfSRobert Watson 
4022db7f0b97SKip Macy /*
4023db7f0b97SKip Macy  * Backwards compatibility interface for drivers
4024db7f0b97SKip Macy  * that have not implemented it
4025db7f0b97SKip Macy  */
4026db7f0b97SKip Macy static int
4027db7f0b97SKip Macy if_transmit(struct ifnet *ifp, struct mbuf *m)
4028db7f0b97SKip Macy {
4029db7f0b97SKip Macy 	int error;
4030db7f0b97SKip Macy 
4031db7f0b97SKip Macy 	IFQ_HANDOFF(ifp, m, error);
4032db7f0b97SKip Macy 	return (error);
4033db7f0b97SKip Macy }
4034db7f0b97SKip Macy 
4035b57d9721SAndrey V. Elsukov static void
4036b57d9721SAndrey V. Elsukov if_input_default(struct ifnet *ifp __unused, struct mbuf *m)
4037b57d9721SAndrey V. Elsukov {
4038b57d9721SAndrey V. Elsukov 
4039b57d9721SAndrey V. Elsukov 	m_freem(m);
4040b57d9721SAndrey V. Elsukov }
4041b57d9721SAndrey V. Elsukov 
40420b762445SRobert Watson int
40430b762445SRobert Watson if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp, int adjust)
40440b762445SRobert Watson {
40450b762445SRobert Watson 	int active = 0;
40460b762445SRobert Watson 
40470b762445SRobert Watson 	IF_LOCK(ifq);
40480b762445SRobert Watson 	if (_IF_QFULL(ifq)) {
40490b762445SRobert Watson 		IF_UNLOCK(ifq);
4050112f50ffSGleb Smirnoff 		if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
40510b762445SRobert Watson 		m_freem(m);
40520b762445SRobert Watson 		return (0);
40530b762445SRobert Watson 	}
40540b762445SRobert Watson 	if (ifp != NULL) {
4055112f50ffSGleb Smirnoff 		if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len + adjust);
40560b762445SRobert Watson 		if (m->m_flags & (M_BCAST|M_MCAST))
4057112f50ffSGleb Smirnoff 			if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
4058292ee7beSRobert Watson 		active = ifp->if_drv_flags & IFF_DRV_OACTIVE;
40590b762445SRobert Watson 	}
40600b762445SRobert Watson 	_IF_ENQUEUE(ifq, m);
40610b762445SRobert Watson 	IF_UNLOCK(ifq);
40620b762445SRobert Watson 	if (ifp != NULL && !active)
4063e5adda3dSRobert Watson 		(*(ifp)->if_start)(ifp);
40640b762445SRobert Watson 	return (1);
40650b762445SRobert Watson }
4066fc74a9f9SBrooks Davis 
4067fc74a9f9SBrooks Davis void
4068fc74a9f9SBrooks Davis if_register_com_alloc(u_char type,
4069fc74a9f9SBrooks Davis     if_com_alloc_t *a, if_com_free_t *f)
4070fc74a9f9SBrooks Davis {
4071fc74a9f9SBrooks Davis 
4072fc74a9f9SBrooks Davis 	KASSERT(if_com_alloc[type] == NULL,
4073fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d already registered", type));
4074fc74a9f9SBrooks Davis 	KASSERT(if_com_free[type] == NULL,
4075fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d free already registered", type));
4076fc74a9f9SBrooks Davis 
4077fc74a9f9SBrooks Davis 	if_com_alloc[type] = a;
4078fc74a9f9SBrooks Davis 	if_com_free[type] = f;
4079fc74a9f9SBrooks Davis }
4080fc74a9f9SBrooks Davis 
4081fc74a9f9SBrooks Davis void
4082fc74a9f9SBrooks Davis if_deregister_com_alloc(u_char type)
4083fc74a9f9SBrooks Davis {
4084fc74a9f9SBrooks Davis 
4085affcaf78SMax Khon 	KASSERT(if_com_alloc[type] != NULL,
4086fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d not registered", type));
4087affcaf78SMax Khon 	KASSERT(if_com_free[type] != NULL,
4088fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d free not registered", type));
4089092f3f08STai-hwa Liang 
4090092f3f08STai-hwa Liang 	/*
4091092f3f08STai-hwa Liang 	 * Ensure all pending EPOCH(9) callbacks have been executed. This
4092092f3f08STai-hwa Liang 	 * fixes issues about late invocation of if_destroy(), which leads
4093092f3f08STai-hwa Liang 	 * to memory leak from if_com_alloc[type] allocated if_l2com.
4094092f3f08STai-hwa Liang 	 */
4095092f3f08STai-hwa Liang 	epoch_drain_callbacks(net_epoch_preempt);
4096092f3f08STai-hwa Liang 
4097fc74a9f9SBrooks Davis 	if_com_alloc[type] = NULL;
4098fc74a9f9SBrooks Davis 	if_com_free[type] = NULL;
4099fc74a9f9SBrooks Davis }
410062d76917SMarcel Moolenaar 
410162d76917SMarcel Moolenaar /* API for driver access to network stack owned ifnet.*/
410262d76917SMarcel Moolenaar uint64_t
410309a8241fSGleb Smirnoff if_setbaudrate(struct ifnet *ifp, uint64_t baudrate)
410462d76917SMarcel Moolenaar {
410562d76917SMarcel Moolenaar 	uint64_t oldbrate;
410662d76917SMarcel Moolenaar 
410762d76917SMarcel Moolenaar 	oldbrate = ifp->if_baudrate;
410862d76917SMarcel Moolenaar 	ifp->if_baudrate = baudrate;
410962d76917SMarcel Moolenaar 	return (oldbrate);
411062d76917SMarcel Moolenaar }
411162d76917SMarcel Moolenaar 
411262d76917SMarcel Moolenaar uint64_t
411362d76917SMarcel Moolenaar if_getbaudrate(if_t ifp)
411462d76917SMarcel Moolenaar {
411562d76917SMarcel Moolenaar 
411662d76917SMarcel Moolenaar 	return (((struct ifnet *)ifp)->if_baudrate);
411762d76917SMarcel Moolenaar }
411862d76917SMarcel Moolenaar 
411962d76917SMarcel Moolenaar int
412062d76917SMarcel Moolenaar if_setcapabilities(if_t ifp, int capabilities)
412162d76917SMarcel Moolenaar {
412262d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities = capabilities;
412362d76917SMarcel Moolenaar 	return (0);
412462d76917SMarcel Moolenaar }
412562d76917SMarcel Moolenaar 
412662d76917SMarcel Moolenaar int
412762d76917SMarcel Moolenaar if_setcapabilitiesbit(if_t ifp, int setbit, int clearbit)
412862d76917SMarcel Moolenaar {
412962d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities |= setbit;
413062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities &= ~clearbit;
413162d76917SMarcel Moolenaar 
413262d76917SMarcel Moolenaar 	return (0);
413362d76917SMarcel Moolenaar }
413462d76917SMarcel Moolenaar 
413562d76917SMarcel Moolenaar int
413662d76917SMarcel Moolenaar if_getcapabilities(if_t ifp)
413762d76917SMarcel Moolenaar {
413862d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_capabilities;
413962d76917SMarcel Moolenaar }
414062d76917SMarcel Moolenaar 
414162d76917SMarcel Moolenaar int
414262d76917SMarcel Moolenaar if_setcapenable(if_t ifp, int capabilities)
414362d76917SMarcel Moolenaar {
414462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capenable = capabilities;
414562d76917SMarcel Moolenaar 	return (0);
414662d76917SMarcel Moolenaar }
414762d76917SMarcel Moolenaar 
414862d76917SMarcel Moolenaar int
414962d76917SMarcel Moolenaar if_setcapenablebit(if_t ifp, int setcap, int clearcap)
415062d76917SMarcel Moolenaar {
415162d76917SMarcel Moolenaar 	if(setcap)
415262d76917SMarcel Moolenaar 		((struct ifnet *)ifp)->if_capenable |= setcap;
415362d76917SMarcel Moolenaar 	if(clearcap)
415462d76917SMarcel Moolenaar 		((struct ifnet *)ifp)->if_capenable &= ~clearcap;
415562d76917SMarcel Moolenaar 
415662d76917SMarcel Moolenaar 	return (0);
415762d76917SMarcel Moolenaar }
415862d76917SMarcel Moolenaar 
415962d76917SMarcel Moolenaar const char *
416062d76917SMarcel Moolenaar if_getdname(if_t ifp)
416162d76917SMarcel Moolenaar {
416262d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_dname;
416362d76917SMarcel Moolenaar }
416462d76917SMarcel Moolenaar 
416562d76917SMarcel Moolenaar int
416662d76917SMarcel Moolenaar if_togglecapenable(if_t ifp, int togglecap)
416762d76917SMarcel Moolenaar {
416862d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capenable ^= togglecap;
416962d76917SMarcel Moolenaar 	return (0);
417062d76917SMarcel Moolenaar }
417162d76917SMarcel Moolenaar 
417262d76917SMarcel Moolenaar int
417362d76917SMarcel Moolenaar if_getcapenable(if_t ifp)
417462d76917SMarcel Moolenaar {
417562d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_capenable;
417662d76917SMarcel Moolenaar }
417762d76917SMarcel Moolenaar 
417862d76917SMarcel Moolenaar /*
417962d76917SMarcel Moolenaar  * This is largely undesirable because it ties ifnet to a device, but does
418062d76917SMarcel Moolenaar  * provide flexiblity for an embedded product vendor. Should be used with
418162d76917SMarcel Moolenaar  * the understanding that it violates the interface boundaries, and should be
418262d76917SMarcel Moolenaar  * a last resort only.
418362d76917SMarcel Moolenaar  */
418462d76917SMarcel Moolenaar int
418562d76917SMarcel Moolenaar if_setdev(if_t ifp, void *dev)
418662d76917SMarcel Moolenaar {
418762d76917SMarcel Moolenaar 	return (0);
418862d76917SMarcel Moolenaar }
418962d76917SMarcel Moolenaar 
419062d76917SMarcel Moolenaar int
419162d76917SMarcel Moolenaar if_setdrvflagbits(if_t ifp, int set_flags, int clear_flags)
419262d76917SMarcel Moolenaar {
419362d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags |= set_flags;
419462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags &= ~clear_flags;
419562d76917SMarcel Moolenaar 
419662d76917SMarcel Moolenaar 	return (0);
419762d76917SMarcel Moolenaar }
419862d76917SMarcel Moolenaar 
419962d76917SMarcel Moolenaar int
420062d76917SMarcel Moolenaar if_getdrvflags(if_t ifp)
420162d76917SMarcel Moolenaar {
420262d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_drv_flags;
420362d76917SMarcel Moolenaar }
420462d76917SMarcel Moolenaar 
420562d76917SMarcel Moolenaar int
420662d76917SMarcel Moolenaar if_setdrvflags(if_t ifp, int flags)
420762d76917SMarcel Moolenaar {
420862d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags = flags;
420962d76917SMarcel Moolenaar 	return (0);
421062d76917SMarcel Moolenaar }
421162d76917SMarcel Moolenaar 
421262d76917SMarcel Moolenaar int
421362d76917SMarcel Moolenaar if_setflags(if_t ifp, int flags)
421462d76917SMarcel Moolenaar {
4215e87c4940SGleb Smirnoff 
4216e87c4940SGleb Smirnoff 	ifp->if_flags = flags;
421762d76917SMarcel Moolenaar 	return (0);
421862d76917SMarcel Moolenaar }
421962d76917SMarcel Moolenaar 
422062d76917SMarcel Moolenaar int
422162d76917SMarcel Moolenaar if_setflagbits(if_t ifp, int set, int clear)
422262d76917SMarcel Moolenaar {
422362d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_flags |= set;
422462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_flags &= ~clear;
422562d76917SMarcel Moolenaar 
422662d76917SMarcel Moolenaar 	return (0);
422762d76917SMarcel Moolenaar }
422862d76917SMarcel Moolenaar 
422962d76917SMarcel Moolenaar int
423062d76917SMarcel Moolenaar if_getflags(if_t ifp)
423162d76917SMarcel Moolenaar {
423262d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_flags;
423362d76917SMarcel Moolenaar }
423462d76917SMarcel Moolenaar 
423562d76917SMarcel Moolenaar int
423662d76917SMarcel Moolenaar if_clearhwassist(if_t ifp)
423762d76917SMarcel Moolenaar {
423862d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist = 0;
423962d76917SMarcel Moolenaar 	return (0);
424062d76917SMarcel Moolenaar }
424162d76917SMarcel Moolenaar 
424262d76917SMarcel Moolenaar int
424362d76917SMarcel Moolenaar if_sethwassistbits(if_t ifp, int toset, int toclear)
424462d76917SMarcel Moolenaar {
424562d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist |= toset;
424662d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist &= ~toclear;
424762d76917SMarcel Moolenaar 
424862d76917SMarcel Moolenaar 	return (0);
424962d76917SMarcel Moolenaar }
425062d76917SMarcel Moolenaar 
425162d76917SMarcel Moolenaar int
425262d76917SMarcel Moolenaar if_sethwassist(if_t ifp, int hwassist_bit)
425362d76917SMarcel Moolenaar {
425462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist = hwassist_bit;
425562d76917SMarcel Moolenaar 	return (0);
425662d76917SMarcel Moolenaar }
425762d76917SMarcel Moolenaar 
425862d76917SMarcel Moolenaar int
425962d76917SMarcel Moolenaar if_gethwassist(if_t ifp)
426062d76917SMarcel Moolenaar {
426162d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_hwassist;
426262d76917SMarcel Moolenaar }
426362d76917SMarcel Moolenaar 
426462d76917SMarcel Moolenaar int
426562d76917SMarcel Moolenaar if_setmtu(if_t ifp, int mtu)
426662d76917SMarcel Moolenaar {
426762d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_mtu = mtu;
426862d76917SMarcel Moolenaar 	return (0);
426962d76917SMarcel Moolenaar }
427062d76917SMarcel Moolenaar 
427162d76917SMarcel Moolenaar int
427262d76917SMarcel Moolenaar if_getmtu(if_t ifp)
427362d76917SMarcel Moolenaar {
427462d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_mtu;
427562d76917SMarcel Moolenaar }
427662d76917SMarcel Moolenaar 
427762d76917SMarcel Moolenaar int
42781a75e3b2SAlexander V. Chernikov if_getmtu_family(if_t ifp, int family)
42791a75e3b2SAlexander V. Chernikov {
42801a75e3b2SAlexander V. Chernikov 	struct domain *dp;
42811a75e3b2SAlexander V. Chernikov 
42821a75e3b2SAlexander V. Chernikov 	for (dp = domains; dp; dp = dp->dom_next) {
42831a75e3b2SAlexander V. Chernikov 		if (dp->dom_family == family && dp->dom_ifmtu != NULL)
42841a75e3b2SAlexander V. Chernikov 			return (dp->dom_ifmtu((struct ifnet *)ifp));
42851a75e3b2SAlexander V. Chernikov 	}
42861a75e3b2SAlexander V. Chernikov 
42871a75e3b2SAlexander V. Chernikov 	return (((struct ifnet *)ifp)->if_mtu);
42881a75e3b2SAlexander V. Chernikov }
42891a75e3b2SAlexander V. Chernikov 
4290826857c8SGleb Smirnoff /*
4291826857c8SGleb Smirnoff  * Methods for drivers to access interface unicast and multicast
4292826857c8SGleb Smirnoff  * link level addresses.  Driver shall not know 'struct ifaddr' neither
4293826857c8SGleb Smirnoff  * 'struct ifmultiaddr'.
4294826857c8SGleb Smirnoff  */
4295826857c8SGleb Smirnoff u_int
4296fb3fc771SGleb Smirnoff if_lladdr_count(if_t ifp)
4297fb3fc771SGleb Smirnoff {
4298fb3fc771SGleb Smirnoff 	struct epoch_tracker et;
4299fb3fc771SGleb Smirnoff 	struct ifaddr *ifa;
4300fb3fc771SGleb Smirnoff 	u_int count;
4301fb3fc771SGleb Smirnoff 
4302fb3fc771SGleb Smirnoff 	count = 0;
4303fb3fc771SGleb Smirnoff 	NET_EPOCH_ENTER(et);
4304fb3fc771SGleb Smirnoff 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
4305fb3fc771SGleb Smirnoff 		if (ifa->ifa_addr->sa_family == AF_LINK)
4306fb3fc771SGleb Smirnoff 			count++;
4307fb3fc771SGleb Smirnoff 	NET_EPOCH_EXIT(et);
4308fb3fc771SGleb Smirnoff 
4309fb3fc771SGleb Smirnoff 	return (count);
4310fb3fc771SGleb Smirnoff }
4311fb3fc771SGleb Smirnoff 
4312fb3fc771SGleb Smirnoff u_int
4313826857c8SGleb Smirnoff if_foreach_lladdr(if_t ifp, iflladdr_cb_t cb, void *cb_arg)
4314826857c8SGleb Smirnoff {
4315826857c8SGleb Smirnoff 	struct epoch_tracker et;
4316826857c8SGleb Smirnoff 	struct ifaddr *ifa;
4317826857c8SGleb Smirnoff 	u_int count;
4318826857c8SGleb Smirnoff 
4319826857c8SGleb Smirnoff 	MPASS(cb);
4320826857c8SGleb Smirnoff 
4321826857c8SGleb Smirnoff 	count = 0;
4322826857c8SGleb Smirnoff 	NET_EPOCH_ENTER(et);
4323826857c8SGleb Smirnoff 	CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
4324826857c8SGleb Smirnoff 		if (ifa->ifa_addr->sa_family != AF_LINK)
4325826857c8SGleb Smirnoff 			continue;
4326826857c8SGleb Smirnoff 		count += (*cb)(cb_arg, (struct sockaddr_dl *)ifa->ifa_addr,
4327826857c8SGleb Smirnoff 		    count);
4328826857c8SGleb Smirnoff 	}
4329826857c8SGleb Smirnoff 	NET_EPOCH_EXIT(et);
4330826857c8SGleb Smirnoff 
4331826857c8SGleb Smirnoff 	return (count);
4332826857c8SGleb Smirnoff }
4333826857c8SGleb Smirnoff 
4334826857c8SGleb Smirnoff u_int
4335fb3fc771SGleb Smirnoff if_llmaddr_count(if_t ifp)
4336fb3fc771SGleb Smirnoff {
4337fb3fc771SGleb Smirnoff 	struct epoch_tracker et;
4338fb3fc771SGleb Smirnoff 	struct ifmultiaddr *ifma;
4339fb3fc771SGleb Smirnoff 	int count;
4340fb3fc771SGleb Smirnoff 
4341fb3fc771SGleb Smirnoff 	count = 0;
4342fb3fc771SGleb Smirnoff 	NET_EPOCH_ENTER(et);
4343fb3fc771SGleb Smirnoff 	CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
4344fb3fc771SGleb Smirnoff 		if (ifma->ifma_addr->sa_family == AF_LINK)
4345fb3fc771SGleb Smirnoff 			count++;
4346fb3fc771SGleb Smirnoff 	NET_EPOCH_EXIT(et);
4347fb3fc771SGleb Smirnoff 
4348fb3fc771SGleb Smirnoff 	return (count);
4349fb3fc771SGleb Smirnoff }
4350fb3fc771SGleb Smirnoff 
4351fb3fc771SGleb Smirnoff u_int
4352826857c8SGleb Smirnoff if_foreach_llmaddr(if_t ifp, iflladdr_cb_t cb, void *cb_arg)
4353826857c8SGleb Smirnoff {
4354826857c8SGleb Smirnoff 	struct epoch_tracker et;
4355826857c8SGleb Smirnoff 	struct ifmultiaddr *ifma;
4356826857c8SGleb Smirnoff 	u_int count;
4357826857c8SGleb Smirnoff 
4358826857c8SGleb Smirnoff 	MPASS(cb);
4359826857c8SGleb Smirnoff 
4360826857c8SGleb Smirnoff 	count = 0;
4361826857c8SGleb Smirnoff 	NET_EPOCH_ENTER(et);
4362826857c8SGleb Smirnoff 	CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
4363826857c8SGleb Smirnoff 		if (ifma->ifma_addr->sa_family != AF_LINK)
4364826857c8SGleb Smirnoff 			continue;
4365826857c8SGleb Smirnoff 		count += (*cb)(cb_arg, (struct sockaddr_dl *)ifma->ifma_addr,
4366826857c8SGleb Smirnoff 		    count);
4367826857c8SGleb Smirnoff 	}
4368826857c8SGleb Smirnoff 	NET_EPOCH_EXIT(et);
4369826857c8SGleb Smirnoff 
4370826857c8SGleb Smirnoff 	return (count);
4371826857c8SGleb Smirnoff }
4372826857c8SGleb Smirnoff 
43731a75e3b2SAlexander V. Chernikov int
437462d76917SMarcel Moolenaar if_setsoftc(if_t ifp, void *softc)
437562d76917SMarcel Moolenaar {
437662d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_softc = softc;
437762d76917SMarcel Moolenaar 	return (0);
437862d76917SMarcel Moolenaar }
437962d76917SMarcel Moolenaar 
438062d76917SMarcel Moolenaar void *
438162d76917SMarcel Moolenaar if_getsoftc(if_t ifp)
438262d76917SMarcel Moolenaar {
438362d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_softc;
438462d76917SMarcel Moolenaar }
438562d76917SMarcel Moolenaar 
438662d76917SMarcel Moolenaar void
438762d76917SMarcel Moolenaar if_setrcvif(struct mbuf *m, if_t ifp)
438862d76917SMarcel Moolenaar {
4389fb3bc596SJohn Baldwin 
4390fb3bc596SJohn Baldwin 	MPASS((m->m_pkthdr.csum_flags & CSUM_SND_TAG) == 0);
439162d76917SMarcel Moolenaar 	m->m_pkthdr.rcvif = (struct ifnet *)ifp;
439262d76917SMarcel Moolenaar }
439362d76917SMarcel Moolenaar 
439462d76917SMarcel Moolenaar void
439562d76917SMarcel Moolenaar if_setvtag(struct mbuf *m, uint16_t tag)
439662d76917SMarcel Moolenaar {
439762d76917SMarcel Moolenaar 	m->m_pkthdr.ether_vtag = tag;
439862d76917SMarcel Moolenaar }
439962d76917SMarcel Moolenaar 
440062d76917SMarcel Moolenaar uint16_t
440162d76917SMarcel Moolenaar if_getvtag(struct mbuf *m)
440262d76917SMarcel Moolenaar {
440362d76917SMarcel Moolenaar 
440462d76917SMarcel Moolenaar 	return (m->m_pkthdr.ether_vtag);
440562d76917SMarcel Moolenaar }
440662d76917SMarcel Moolenaar 
440762d76917SMarcel Moolenaar int
440862d76917SMarcel Moolenaar if_sendq_empty(if_t ifp)
440962d76917SMarcel Moolenaar {
441062d76917SMarcel Moolenaar 	return IFQ_DRV_IS_EMPTY(&((struct ifnet *)ifp)->if_snd);
441162d76917SMarcel Moolenaar }
441262d76917SMarcel Moolenaar 
441362d76917SMarcel Moolenaar struct ifaddr *
441462d76917SMarcel Moolenaar if_getifaddr(if_t ifp)
441562d76917SMarcel Moolenaar {
441662d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_addr;
441762d76917SMarcel Moolenaar }
441862d76917SMarcel Moolenaar 
441962d76917SMarcel Moolenaar int
442062d76917SMarcel Moolenaar if_getamcount(if_t ifp)
442162d76917SMarcel Moolenaar {
442262d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_amcount;
442362d76917SMarcel Moolenaar }
442462d76917SMarcel Moolenaar 
442562d76917SMarcel Moolenaar int
442662d76917SMarcel Moolenaar if_setsendqready(if_t ifp)
442762d76917SMarcel Moolenaar {
442862d76917SMarcel Moolenaar 	IFQ_SET_READY(&((struct ifnet *)ifp)->if_snd);
442962d76917SMarcel Moolenaar 	return (0);
443062d76917SMarcel Moolenaar }
443162d76917SMarcel Moolenaar 
443262d76917SMarcel Moolenaar int
443362d76917SMarcel Moolenaar if_setsendqlen(if_t ifp, int tx_desc_count)
443462d76917SMarcel Moolenaar {
443562d76917SMarcel Moolenaar 	IFQ_SET_MAXLEN(&((struct ifnet *)ifp)->if_snd, tx_desc_count);
443662d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_snd.ifq_drv_maxlen = tx_desc_count;
443762d76917SMarcel Moolenaar 
443862d76917SMarcel Moolenaar 	return (0);
443962d76917SMarcel Moolenaar }
444062d76917SMarcel Moolenaar 
444162d76917SMarcel Moolenaar int
444262d76917SMarcel Moolenaar if_vlantrunkinuse(if_t ifp)
444362d76917SMarcel Moolenaar {
444462d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_vlantrunk != NULL?1:0;
444562d76917SMarcel Moolenaar }
444662d76917SMarcel Moolenaar 
444762d76917SMarcel Moolenaar int
444862d76917SMarcel Moolenaar if_input(if_t ifp, struct mbuf* sendmp)
444962d76917SMarcel Moolenaar {
445062d76917SMarcel Moolenaar 	(*((struct ifnet *)ifp)->if_input)((struct ifnet *)ifp, sendmp);
445162d76917SMarcel Moolenaar 	return (0);
445262d76917SMarcel Moolenaar 
445362d76917SMarcel Moolenaar }
445462d76917SMarcel Moolenaar 
445562d76917SMarcel Moolenaar struct mbuf *
445662d76917SMarcel Moolenaar if_dequeue(if_t ifp)
445762d76917SMarcel Moolenaar {
445862d76917SMarcel Moolenaar 	struct mbuf *m;
445962d76917SMarcel Moolenaar 	IFQ_DRV_DEQUEUE(&((struct ifnet *)ifp)->if_snd, m);
446062d76917SMarcel Moolenaar 
446162d76917SMarcel Moolenaar 	return (m);
446262d76917SMarcel Moolenaar }
446362d76917SMarcel Moolenaar 
446462d76917SMarcel Moolenaar int
446562d76917SMarcel Moolenaar if_sendq_prepend(if_t ifp, struct mbuf *m)
446662d76917SMarcel Moolenaar {
446762d76917SMarcel Moolenaar 	IFQ_DRV_PREPEND(&((struct ifnet *)ifp)->if_snd, m);
446862d76917SMarcel Moolenaar 	return (0);
446962d76917SMarcel Moolenaar }
447062d76917SMarcel Moolenaar 
447162d76917SMarcel Moolenaar int
447262d76917SMarcel Moolenaar if_setifheaderlen(if_t ifp, int len)
447362d76917SMarcel Moolenaar {
4474e6485f73SGleb Smirnoff 	((struct ifnet *)ifp)->if_hdrlen = len;
447562d76917SMarcel Moolenaar 	return (0);
447662d76917SMarcel Moolenaar }
447762d76917SMarcel Moolenaar 
447862d76917SMarcel Moolenaar caddr_t
447962d76917SMarcel Moolenaar if_getlladdr(if_t ifp)
448062d76917SMarcel Moolenaar {
448162d76917SMarcel Moolenaar 	return (IF_LLADDR((struct ifnet *)ifp));
448262d76917SMarcel Moolenaar }
448362d76917SMarcel Moolenaar 
448462d76917SMarcel Moolenaar void *
448562d76917SMarcel Moolenaar if_gethandle(u_char type)
448662d76917SMarcel Moolenaar {
448762d76917SMarcel Moolenaar 	return (if_alloc(type));
448862d76917SMarcel Moolenaar }
448962d76917SMarcel Moolenaar 
449062d76917SMarcel Moolenaar void
449162d76917SMarcel Moolenaar if_bpfmtap(if_t ifh, struct mbuf *m)
449262d76917SMarcel Moolenaar {
449362d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
449462d76917SMarcel Moolenaar 
449562d76917SMarcel Moolenaar 	BPF_MTAP(ifp, m);
449662d76917SMarcel Moolenaar }
449762d76917SMarcel Moolenaar 
449862d76917SMarcel Moolenaar void
449962d76917SMarcel Moolenaar if_etherbpfmtap(if_t ifh, struct mbuf *m)
450062d76917SMarcel Moolenaar {
450162d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
450262d76917SMarcel Moolenaar 
450362d76917SMarcel Moolenaar 	ETHER_BPF_MTAP(ifp, m);
450462d76917SMarcel Moolenaar }
450562d76917SMarcel Moolenaar 
450662d76917SMarcel Moolenaar void
450762d76917SMarcel Moolenaar if_vlancap(if_t ifh)
450862d76917SMarcel Moolenaar {
450962d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
451062d76917SMarcel Moolenaar 	VLAN_CAPABILITIES(ifp);
451162d76917SMarcel Moolenaar }
451262d76917SMarcel Moolenaar 
4513d0b2cad1SStephen J. Kiernan int
4514d0b2cad1SStephen J. Kiernan if_sethwtsomax(if_t ifp, u_int if_hw_tsomax)
4515d0b2cad1SStephen J. Kiernan {
4516d0b2cad1SStephen J. Kiernan 
4517d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomax = if_hw_tsomax;
4518d0b2cad1SStephen J. Kiernan         return (0);
4519d0b2cad1SStephen J. Kiernan }
4520d0b2cad1SStephen J. Kiernan 
4521d0b2cad1SStephen J. Kiernan int
4522d0b2cad1SStephen J. Kiernan if_sethwtsomaxsegcount(if_t ifp, u_int if_hw_tsomaxsegcount)
4523d0b2cad1SStephen J. Kiernan {
4524d0b2cad1SStephen J. Kiernan 
4525d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomaxsegcount = if_hw_tsomaxsegcount;
4526d0b2cad1SStephen J. Kiernan         return (0);
4527d0b2cad1SStephen J. Kiernan }
4528d0b2cad1SStephen J. Kiernan 
4529d0b2cad1SStephen J. Kiernan int
4530d0b2cad1SStephen J. Kiernan if_sethwtsomaxsegsize(if_t ifp, u_int if_hw_tsomaxsegsize)
4531d0b2cad1SStephen J. Kiernan {
4532d0b2cad1SStephen J. Kiernan 
4533d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomaxsegsize = if_hw_tsomaxsegsize;
4534d0b2cad1SStephen J. Kiernan         return (0);
4535d0b2cad1SStephen J. Kiernan }
4536d0b2cad1SStephen J. Kiernan 
4537d0b2cad1SStephen J. Kiernan u_int
4538d0b2cad1SStephen J. Kiernan if_gethwtsomax(if_t ifp)
4539d0b2cad1SStephen J. Kiernan {
4540d0b2cad1SStephen J. Kiernan 
4541d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomax);
4542d0b2cad1SStephen J. Kiernan }
4543d0b2cad1SStephen J. Kiernan 
4544d0b2cad1SStephen J. Kiernan u_int
4545d0b2cad1SStephen J. Kiernan if_gethwtsomaxsegcount(if_t ifp)
4546d0b2cad1SStephen J. Kiernan {
4547d0b2cad1SStephen J. Kiernan 
4548d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomaxsegcount);
4549d0b2cad1SStephen J. Kiernan }
4550d0b2cad1SStephen J. Kiernan 
4551d0b2cad1SStephen J. Kiernan u_int
4552d0b2cad1SStephen J. Kiernan if_gethwtsomaxsegsize(if_t ifp)
4553d0b2cad1SStephen J. Kiernan {
4554d0b2cad1SStephen J. Kiernan 
4555d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomaxsegsize);
4556d0b2cad1SStephen J. Kiernan }
4557d0b2cad1SStephen J. Kiernan 
455862d76917SMarcel Moolenaar void
455962d76917SMarcel Moolenaar if_setinitfn(if_t ifp, void (*init_fn)(void *))
456062d76917SMarcel Moolenaar {
456162d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_init = init_fn;
456262d76917SMarcel Moolenaar }
456362d76917SMarcel Moolenaar 
456462d76917SMarcel Moolenaar void
456509a8241fSGleb Smirnoff if_setioctlfn(if_t ifp, int (*ioctl_fn)(if_t, u_long, caddr_t))
456662d76917SMarcel Moolenaar {
456762d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_ioctl = (void *)ioctl_fn;
456862d76917SMarcel Moolenaar }
456962d76917SMarcel Moolenaar 
457062d76917SMarcel Moolenaar void
457109a8241fSGleb Smirnoff if_setstartfn(if_t ifp, void (*start_fn)(if_t))
457262d76917SMarcel Moolenaar {
457362d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_start = (void *)start_fn;
457462d76917SMarcel Moolenaar }
457562d76917SMarcel Moolenaar 
457662d76917SMarcel Moolenaar void
457762d76917SMarcel Moolenaar if_settransmitfn(if_t ifp, if_transmit_fn_t start_fn)
457862d76917SMarcel Moolenaar {
457962d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_transmit = start_fn;
458062d76917SMarcel Moolenaar }
458162d76917SMarcel Moolenaar 
458262d76917SMarcel Moolenaar void if_setqflushfn(if_t ifp, if_qflush_fn_t flush_fn)
458362d76917SMarcel Moolenaar {
458462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_qflush = flush_fn;
458562d76917SMarcel Moolenaar 
458662d76917SMarcel Moolenaar }
458762d76917SMarcel Moolenaar 
458835853c2cSGleb Smirnoff void
458935853c2cSGleb Smirnoff if_setgetcounterfn(if_t ifp, if_get_counter_t fn)
459035853c2cSGleb Smirnoff {
459135853c2cSGleb Smirnoff 
459235853c2cSGleb Smirnoff 	ifp->if_get_counter = fn;
459335853c2cSGleb Smirnoff }
459435853c2cSGleb Smirnoff 
459562d76917SMarcel Moolenaar /* Revisit these - These are inline functions originally. */
459662d76917SMarcel Moolenaar int
459762d76917SMarcel Moolenaar drbr_inuse_drv(if_t ifh, struct buf_ring *br)
459862d76917SMarcel Moolenaar {
4599966ab68dSDimitry Andric 	return drbr_inuse(ifh, br);
460062d76917SMarcel Moolenaar }
460162d76917SMarcel Moolenaar 
460262d76917SMarcel Moolenaar struct mbuf*
460362d76917SMarcel Moolenaar drbr_dequeue_drv(if_t ifh, struct buf_ring *br)
460462d76917SMarcel Moolenaar {
460562d76917SMarcel Moolenaar 	return drbr_dequeue(ifh, br);
460662d76917SMarcel Moolenaar }
460762d76917SMarcel Moolenaar 
460862d76917SMarcel Moolenaar int
460962d76917SMarcel Moolenaar drbr_needs_enqueue_drv(if_t ifh, struct buf_ring *br)
461062d76917SMarcel Moolenaar {
461162d76917SMarcel Moolenaar 	return drbr_needs_enqueue(ifh, br);
461262d76917SMarcel Moolenaar }
461362d76917SMarcel Moolenaar 
461462d76917SMarcel Moolenaar int
461562d76917SMarcel Moolenaar drbr_enqueue_drv(if_t ifh, struct buf_ring *br, struct mbuf *m)
461662d76917SMarcel Moolenaar {
461762d76917SMarcel Moolenaar 	return drbr_enqueue(ifh, br, m);
461862d76917SMarcel Moolenaar 
461962d76917SMarcel Moolenaar }
4620