xref: /freebsd/sys/net/if.c (revision d71e30de40a3503bb178decad4e04aafb43839af)
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 
35cfa1ca9dSYoshinobu Inoue #include "opt_inet6.h"
360d0f9d1eSYoshinobu Inoue #include "opt_inet.h"
375591b823SEivind Eklund 
38df8bae1dSRodney W. Grimes #include <sys/param.h>
394dcf2bbbSBrooks Davis #include <sys/types.h>
40f13ad206SJonathan Lemon #include <sys/conf.h>
414d1d4912SBruce Evans #include <sys/malloc.h>
424dcf2bbbSBrooks Davis #include <sys/sbuf.h>
43d2b4566aSJonathan Lemon #include <sys/bus.h>
44df8bae1dSRodney W. Grimes #include <sys/mbuf.h>
45df8bae1dSRodney W. Grimes #include <sys/systm.h>
46acd3428bSRobert Watson #include <sys/priv.h>
47df8bae1dSRodney W. Grimes #include <sys/proc.h>
48df8bae1dSRodney W. Grimes #include <sys/socket.h>
49df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
50df8bae1dSRodney W. Grimes #include <sys/protosw.h>
51df8bae1dSRodney W. Grimes #include <sys/kernel.h>
52653735c4SBjoern A. Zeeb #include <sys/lock.h>
5327d37320SRobert Watson #include <sys/refcount.h>
5421ca7b57SMarko Zec #include <sys/module.h>
55653735c4SBjoern A. Zeeb #include <sys/rwlock.h>
5651a53488SBruce Evans #include <sys/sockio.h>
57963e4c2aSGarrett Wollman #include <sys/syslog.h>
58602d513cSGarrett Wollman #include <sys/sysctl.h>
5986d2ef16SBrooks Davis #include <sys/sysent.h>
60af5e59bfSRobert Watson #include <sys/taskqueue.h>
6131b1bfe1SHajimu UMEMOTO #include <sys/domain.h>
6291421ba2SRobert Watson #include <sys/jail.h>
6335fd7bc0SBjoern A. Zeeb #include <sys/priv.h>
6435fd7bc0SBjoern A. Zeeb 
65fa882e87SBrooks Davis #include <machine/stdarg.h>
666e6b3f7cSQing Li #include <vm/uma.h>
67df8bae1dSRodney W. Grimes 
6862d76917SMarcel Moolenaar #include <net/bpf.h>
6962d76917SMarcel Moolenaar #include <net/ethernet.h>
70df8bae1dSRodney W. Grimes #include <net/if.h>
715a97c9d4SBjoern A. Zeeb #include <net/if_arp.h>
72f889d2efSBrooks Davis #include <net/if_clone.h>
73df8bae1dSRodney W. Grimes #include <net/if_dl.h>
7466ce51ceSArchie Cobbs #include <net/if_types.h>
7530aad87dSBrooks Davis #include <net/if_var.h>
7662d76917SMarcel Moolenaar #include <net/if_media.h>
7762d76917SMarcel Moolenaar #include <net/if_vlan_var.h>
789448326fSPoul-Henning Kamp #include <net/radix.h>
795500d3beSWarner Losh #include <net/route.h>
804b79449eSBjoern A. Zeeb #include <net/vnet.h>
81df8bae1dSRodney W. Grimes 
820d0f9d1eSYoshinobu Inoue #if defined(INET) || defined(INET6)
83209579aeSRick Macklem #include <net/ethernet.h>
8482cd038dSYoshinobu Inoue #include <netinet/in.h>
850d0f9d1eSYoshinobu Inoue #include <netinet/in_var.h>
863c914c54SAndre Oppermann #include <netinet/ip.h>
879963e8a5SWill Andrews #include <netinet/ip_carp.h>
883c914c54SAndre Oppermann #ifdef INET
893c914c54SAndre Oppermann #include <netinet/if_ether.h>
90e5054602SMark Johnston #include <netinet/netdump/netdump.h>
913c914c54SAndre Oppermann #endif /* INET */
923411310dSYoshinobu Inoue #ifdef INET6
93978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_var.h>
94978ee2edSJun-ichiro itojun Hagino #include <netinet6/in6_ifattach.h>
953c914c54SAndre Oppermann #endif /* INET6 */
963c914c54SAndre Oppermann #endif /* INET || INET6 */
9782cd038dSYoshinobu Inoue 
98aed55708SRobert Watson #include <security/mac/mac_framework.h>
99aed55708SRobert Watson 
1008708f1bdSBrooks Davis /*
1018708f1bdSBrooks Davis  * Consumers of struct ifreq such as tcpdump assume no pad between ifr_name
1028708f1bdSBrooks Davis  * and ifr_ifru when it is used in SIOCGIFCONF.
1038708f1bdSBrooks Davis  */
1048708f1bdSBrooks Davis _Static_assert(sizeof(((struct ifreq *)0)->ifr_name) ==
1058708f1bdSBrooks Davis     offsetof(struct ifreq, ifr_ifru), "gap between ifr_name and ifr_ifru");
1068708f1bdSBrooks Davis 
107*d71e30deSMatt Macy __read_mostly epoch_t net_epoch_preempt;
108*d71e30deSMatt Macy __read_mostly epoch_t net_epoch;
1099af74f3dSSergey Kandaurov #ifdef COMPAT_FREEBSD32
1109af74f3dSSergey Kandaurov #include <sys/mount.h>
1119af74f3dSSergey Kandaurov #include <compat/freebsd32/freebsd32.h>
11286d2ef16SBrooks Davis 
11386d2ef16SBrooks Davis struct ifreq_buffer32 {
11486d2ef16SBrooks Davis 	uint32_t	length;		/* (size_t) */
11586d2ef16SBrooks Davis 	uint32_t	buffer;		/* (void *) */
11686d2ef16SBrooks Davis };
11786d2ef16SBrooks Davis 
11886d2ef16SBrooks Davis /*
11986d2ef16SBrooks Davis  * Interface request structure used for socket
12086d2ef16SBrooks Davis  * ioctl's.  All interface ioctl's must have parameter
12186d2ef16SBrooks Davis  * definitions which begin with ifr_name.  The
12286d2ef16SBrooks Davis  * remainder may be interface specific.
12386d2ef16SBrooks Davis  */
12486d2ef16SBrooks Davis struct ifreq32 {
12586d2ef16SBrooks Davis 	char	ifr_name[IFNAMSIZ];		/* if name, e.g. "en0" */
12686d2ef16SBrooks Davis 	union {
12786d2ef16SBrooks Davis 		struct sockaddr	ifru_addr;
12886d2ef16SBrooks Davis 		struct sockaddr	ifru_dstaddr;
12986d2ef16SBrooks Davis 		struct sockaddr	ifru_broadaddr;
13086d2ef16SBrooks Davis 		struct ifreq_buffer32 ifru_buffer;
13186d2ef16SBrooks Davis 		short		ifru_flags[2];
13286d2ef16SBrooks Davis 		short		ifru_index;
13386d2ef16SBrooks Davis 		int		ifru_jid;
13486d2ef16SBrooks Davis 		int		ifru_metric;
13586d2ef16SBrooks Davis 		int		ifru_mtu;
13686d2ef16SBrooks Davis 		int		ifru_phys;
13786d2ef16SBrooks Davis 		int		ifru_media;
13886d2ef16SBrooks Davis 		uint32_t	ifru_data;
13986d2ef16SBrooks Davis 		int		ifru_cap[2];
14086d2ef16SBrooks Davis 		u_int		ifru_fib;
14186d2ef16SBrooks Davis 		u_char		ifru_vlan_pcp;
14286d2ef16SBrooks Davis 	} ifr_ifru;
14386d2ef16SBrooks Davis };
14486d2ef16SBrooks Davis CTASSERT(sizeof(struct ifreq) == sizeof(struct ifreq32));
14586d2ef16SBrooks Davis CTASSERT(__offsetof(struct ifreq, ifr_ifru) ==
14686d2ef16SBrooks Davis     __offsetof(struct ifreq32, ifr_ifru));
147756181b8SBrooks Davis 
148756181b8SBrooks Davis struct ifgroupreq32 {
149756181b8SBrooks Davis 	char	ifgr_name[IFNAMSIZ];
150756181b8SBrooks Davis 	u_int	ifgr_len;
151756181b8SBrooks Davis 	union {
152756181b8SBrooks Davis 		char		ifgru_group[IFNAMSIZ];
153756181b8SBrooks Davis 		uint32_t	ifgru_groups;
154756181b8SBrooks Davis 	} ifgr_ifgru;
155756181b8SBrooks Davis };
1563edb7f4eSBrooks Davis 
1573edb7f4eSBrooks Davis struct ifmediareq32 {
1583edb7f4eSBrooks Davis 	char		ifm_name[IFNAMSIZ];
1593edb7f4eSBrooks Davis 	int		ifm_current;
1603edb7f4eSBrooks Davis 	int		ifm_mask;
1613edb7f4eSBrooks Davis 	int		ifm_status;
1623edb7f4eSBrooks Davis 	int		ifm_active;
1633edb7f4eSBrooks Davis 	int		ifm_count;
1643edb7f4eSBrooks Davis 	uint32_t	ifm_ulist;	/* (int *) */
1653edb7f4eSBrooks Davis };
1663edb7f4eSBrooks Davis #define	SIOCGIFMEDIA32	_IOC_NEWTYPE(SIOCGIFMEDIA, struct ifmediareq32)
1673edb7f4eSBrooks Davis #define	SIOCGIFXMEDIA32	_IOC_NEWTYPE(SIOCGIFXMEDIA, struct ifmediareq32)
1683edb7f4eSBrooks Davis 
169756181b8SBrooks Davis #define	_CASE_IOC_IFGROUPREQ_32(cmd)				\
170756181b8SBrooks Davis     case _IOC_NEWTYPE((cmd), struct ifgroupreq32):
1713edb7f4eSBrooks Davis #else /* !COMPAT_FREEBSD32 */
172756181b8SBrooks Davis #define _CASE_IOC_IFGROUPREQ_32(cmd)
1733edb7f4eSBrooks Davis #endif /* !COMPAT_FREEBSD32 */
174756181b8SBrooks Davis 
175756181b8SBrooks Davis #define CASE_IOC_IFGROUPREQ(cmd)	\
176756181b8SBrooks Davis     _CASE_IOC_IFGROUPREQ_32(cmd)	\
177756181b8SBrooks Davis     case (cmd)
1789af74f3dSSergey Kandaurov 
17986d2ef16SBrooks Davis union ifreq_union {
18086d2ef16SBrooks Davis 	struct ifreq	ifr;
18186d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
18286d2ef16SBrooks Davis 	struct ifreq32	ifr32;
18386d2ef16SBrooks Davis #endif
18486d2ef16SBrooks Davis };
18586d2ef16SBrooks Davis 
186756181b8SBrooks Davis union ifgroupreq_union {
187756181b8SBrooks Davis 	struct ifgroupreq ifgr;
188756181b8SBrooks Davis #ifdef COMPAT_FREEBSD32
189756181b8SBrooks Davis 	struct ifgroupreq32 ifgr32;
190756181b8SBrooks Davis #endif
191756181b8SBrooks Davis };
192756181b8SBrooks Davis 
1935515c2e7SGleb Smirnoff SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers");
1945515c2e7SGleb Smirnoff SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management");
1955515c2e7SGleb Smirnoff 
196f88910cdSMatthew D Fleming SYSCTL_INT(_net_link, OID_AUTO, ifqmaxlen, CTLFLAG_RDTUN,
197e50d35e6SMaxim Sobolev     &ifqmaxlen, 0, "max send queue size");
198e50d35e6SMaxim Sobolev 
1995515c2e7SGleb Smirnoff /* Log link state change events */
2005515c2e7SGleb Smirnoff static int log_link_state_change = 1;
2015515c2e7SGleb Smirnoff 
2025515c2e7SGleb Smirnoff SYSCTL_INT(_net_link, OID_AUTO, log_link_state_change, CTLFLAG_RW,
2035515c2e7SGleb Smirnoff 	&log_link_state_change, 0,
2045515c2e7SGleb Smirnoff 	"log interface link state change events");
2055515c2e7SGleb Smirnoff 
2066d07c157SNick Hibma /* Log promiscuous mode change events */
2076d07c157SNick Hibma static int log_promisc_mode_change = 1;
2086d07c157SNick Hibma 
209dbd2ee46SNick Hibma SYSCTL_INT(_net_link, OID_AUTO, log_promisc_mode_change, CTLFLAG_RDTUN,
2106d07c157SNick Hibma 	&log_promisc_mode_change, 1,
2116d07c157SNick Hibma 	"log promiscuous mode change events");
2126d07c157SNick Hibma 
213215940b3SXin LI /* Interface description */
214215940b3SXin LI static unsigned int ifdescr_maxlen = 1024;
215215940b3SXin LI SYSCTL_UINT(_net, OID_AUTO, ifdescr_maxlen, CTLFLAG_RW,
216215940b3SXin LI 	&ifdescr_maxlen, 0,
217215940b3SXin LI 	"administrative maximum length for interface description");
218215940b3SXin LI 
219d745c852SEd Schouten static MALLOC_DEFINE(M_IFDESCR, "ifdescr", "ifnet descriptions");
220215940b3SXin LI 
221215940b3SXin LI /* global sx for non-critical path ifdescr */
222215940b3SXin LI static struct sx ifdescr_sx;
223215940b3SXin LI SX_SYSINIT(ifdescr_sx, &ifdescr_sx, "ifnet descr");
224215940b3SXin LI 
2251c7899c7SGleb Smirnoff void	(*ng_ether_link_state_p)(struct ifnet *ifp, int state);
226d6e82913SSteven Hartland void	(*lagg_linkstate_p)(struct ifnet *ifp, int state);
2279963e8a5SWill Andrews /* These are external hooks for CARP. */
22854bfbd51SWill Andrews void	(*carp_linkstate_p)(struct ifnet *ifp);
229f08535f8SGleb Smirnoff void	(*carp_demote_adj_p)(int, char *);
23024421c1cSGleb Smirnoff int	(*carp_master_p)(struct ifaddr *);
2319963e8a5SWill Andrews #if defined(INET) || defined(INET6)
23208b68b0eSGleb Smirnoff int	(*carp_forus_p)(struct ifnet *ifp, u_char *dhost);
2339963e8a5SWill Andrews int	(*carp_output_p)(struct ifnet *ifp, struct mbuf *m,
23447e8d432SGleb Smirnoff     const struct sockaddr *sa);
23508b68b0eSGleb Smirnoff int	(*carp_ioctl_p)(struct ifreq *, u_long, struct thread *);
23608b68b0eSGleb Smirnoff int	(*carp_attach_p)(struct ifaddr *, int);
237338e227aSLuiz Otavio O Souza void	(*carp_detach_p)(struct ifaddr *, bool);
2389963e8a5SWill Andrews #endif
2399963e8a5SWill Andrews #ifdef INET
24008b68b0eSGleb Smirnoff int	(*carp_iamatch_p)(struct ifaddr *, uint8_t **);
2419963e8a5SWill Andrews #endif
2429963e8a5SWill Andrews #ifdef INET6
2439963e8a5SWill Andrews struct ifaddr *(*carp_iamatch6_p)(struct ifnet *ifp, struct in6_addr *taddr6);
2449963e8a5SWill Andrews caddr_t	(*carp_macmatch6_p)(struct ifnet *ifp, struct mbuf *m,
2459963e8a5SWill Andrews     const struct in6_addr *taddr);
2469963e8a5SWill Andrews #endif
2471c7899c7SGleb Smirnoff 
2484cb655c0SMax Laier struct mbuf *(*tbr_dequeue_ptr)(struct ifaltq *, int) = NULL;
2494cb655c0SMax Laier 
250ec002feeSBruce M Simpson /*
251ec002feeSBruce M Simpson  * XXX: Style; these should be sorted alphabetically, and unprototyped
252ec002feeSBruce M Simpson  * static functions should be prototyped. Currently they are sorted by
253ec002feeSBruce M Simpson  * declaration order.
254ec002feeSBruce M Simpson  */
25531b1bfe1SHajimu UMEMOTO static void	if_attachdomain(void *);
25631b1bfe1SHajimu UMEMOTO static void	if_attachdomain1(struct ifnet *);
2570b59d917SJonathan Lemon static int	ifconf(u_long, caddr_t);
2588e937462SRobert Watson static void	if_grow(void);
259b57d9721SAndrey V. Elsukov static void	if_input_default(struct ifnet *, struct mbuf *);
2604fb3a820SAlexander V. Chernikov static int	if_requestencap_default(struct ifnet *, struct if_encap_req *);
2618614fb12SMax Laier static void	if_route(struct ifnet *, int flag, int fam);
2621a3b6859SYaroslav Tykhiy static int	if_setflag(struct ifnet *, int, int, int *, int);
263db7f0b97SKip Macy static int	if_transmit(struct ifnet *ifp, struct mbuf *m);
2648614fb12SMax Laier static void	if_unroute(struct ifnet *, int flag, int fam);
2658071913dSRuslan Ermilov static void	link_rtrequest(int, struct rtentry *, struct rt_addrinfo *);
266f13ad206SJonathan Lemon static int	ifhwioctl(u_long, struct ifnet *, caddr_t, struct thread *);
267ec002feeSBruce M Simpson static int	if_delmulti_locked(struct ifnet *, struct ifmultiaddr *, int);
26868a3482fSGleb Smirnoff static void	do_link_state_change(void *, int);
2690dad3f0eSMax Laier static int	if_getgroup(struct ifgroupreq *, struct ifnet *);
2700dad3f0eSMax Laier static int	if_getgroupmembers(struct ifgroupreq *);
2718623f9fdSMax Laier static void	if_delgroups(struct ifnet *);
272c92a456bSHiroki Sato static void	if_attach_internal(struct ifnet *, int, struct if_clone *);
273f501e6f1SBjoern A. Zeeb static int	if_detach_internal(struct ifnet *, int, struct if_clone **);
274ad4e9116SBjoern A. Zeeb #ifdef VIMAGE
275ad4e9116SBjoern A. Zeeb static void	if_vmove(struct ifnet *, struct vnet *);
276ad4e9116SBjoern A. Zeeb #endif
277db7f0b97SKip Macy 
27882cd038dSYoshinobu Inoue #ifdef INET6
27982cd038dSYoshinobu Inoue /*
28082cd038dSYoshinobu Inoue  * XXX: declare here to avoid to include many inet6 related files..
28182cd038dSYoshinobu Inoue  * should be more generalized?
28282cd038dSYoshinobu Inoue  */
283929ddbbbSAlfred Perlstein extern void	nd6_setmtu(struct ifnet *);
28482cd038dSYoshinobu Inoue #endif
28582cd038dSYoshinobu Inoue 
286ef91a976SAndrey V. Elsukov /* ipsec helper hooks */
287ef91a976SAndrey V. Elsukov VNET_DEFINE(struct hhook_head *, ipsec_hhh_in[HHOOK_IPSEC_COUNT]);
288ef91a976SAndrey V. Elsukov VNET_DEFINE(struct hhook_head *, ipsec_hhh_out[HHOOK_IPSEC_COUNT]);
289ef91a976SAndrey V. Elsukov 
29082cea7e6SBjoern A. Zeeb VNET_DEFINE(int, if_index);
29182cea7e6SBjoern A. Zeeb int	ifqmaxlen = IFQ_MAXLEN;
292eddfbb76SRobert Watson VNET_DEFINE(struct ifnethead, ifnet);	/* depend on static init XXX */
293eddfbb76SRobert Watson VNET_DEFINE(struct ifgrouphead, ifg_head);
29482cea7e6SBjoern A. Zeeb 
2953e288e62SDimitry Andric static VNET_DEFINE(int, if_indexlim) = 8;
296eddfbb76SRobert Watson 
29777dfcdc4SRobert Watson /* Table of ifnet by index. */
298e6abef09SGleb Smirnoff VNET_DEFINE(struct ifnet **, ifindex_table);
299eddfbb76SRobert Watson 
3001e77c105SRobert Watson #define	V_if_indexlim		VNET(if_indexlim)
3011e77c105SRobert Watson #define	V_ifindex_table		VNET(ifindex_table)
30244e33a07SMarko Zec 
30377dfcdc4SRobert Watson /*
30477dfcdc4SRobert Watson  * The global network interface list (V_ifnet) and related state (such as
30577dfcdc4SRobert Watson  * if_index, if_indexlim, and ifindex_table) are protected by an sxlock and
30677dfcdc4SRobert Watson  * an rwlock.  Either may be acquired shared to stablize the list, but both
30777dfcdc4SRobert Watson  * must be acquired writable to modify the list.  This model allows us to
30877dfcdc4SRobert Watson  * both stablize the interface list during interrupt thread processing, but
30977dfcdc4SRobert Watson  * also to stablize it over long-running ioctls, without introducing priority
31077dfcdc4SRobert Watson  * inversions and deadlocks.
31177dfcdc4SRobert Watson  */
312f89d4c3aSAndre Oppermann struct rwlock ifnet_rwlock;
3134ea05db8SGleb Smirnoff RW_SYSINIT_FLAGS(ifnet_rw, &ifnet_rwlock, "ifnet_rw", RW_RECURSE);
31477dfcdc4SRobert Watson struct sx ifnet_sxlock;
3154ea05db8SGleb Smirnoff SX_SYSINIT_FLAGS(ifnet_sx, &ifnet_sxlock, "ifnet_sx", SX_RECURSE);
31677dfcdc4SRobert Watson 
317ed2dabfcSRobert Watson /*
318ed2dabfcSRobert Watson  * The allocation of network interfaces is a rather non-atomic affair; we
319ed2dabfcSRobert Watson  * need to select an index before we are ready to expose the interface for
320ed2dabfcSRobert Watson  * use, so will use this pointer value to indicate reservation.
321ed2dabfcSRobert Watson  */
322ed2dabfcSRobert Watson #define	IFNET_HOLD	(void *)(uintptr_t)(-1)
323ed2dabfcSRobert Watson 
324fc74a9f9SBrooks Davis static	if_com_alloc_t *if_com_alloc[256];
325fc74a9f9SBrooks Davis static	if_com_free_t *if_com_free[256];
3260b59d917SJonathan Lemon 
327d745c852SEd Schouten static MALLOC_DEFINE(M_IFNET, "ifnet", "interface internals");
3280b59d917SJonathan Lemon MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address");
3290b59d917SJonathan Lemon MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address");
33030aad87dSBrooks Davis 
33121ca7b57SMarko Zec struct ifnet *
332d24c444cSKip Macy ifnet_byindex_locked(u_short idx)
33302f4879dSRobert Watson {
33402f4879dSRobert Watson 
33527d37320SRobert Watson 	if (idx > V_if_index)
33627d37320SRobert Watson 		return (NULL);
337e6abef09SGleb Smirnoff 	if (V_ifindex_table[idx] == IFNET_HOLD)
338ed2dabfcSRobert Watson 		return (NULL);
339e6abef09SGleb Smirnoff 	return (V_ifindex_table[idx]);
340d24c444cSKip Macy }
341d24c444cSKip Macy 
342d24c444cSKip Macy struct ifnet *
343d24c444cSKip Macy ifnet_byindex(u_short idx)
344d24c444cSKip Macy {
345d24c444cSKip Macy 	struct ifnet *ifp;
346d24c444cSKip Macy 
34777dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
348d24c444cSKip Macy 	ifp = ifnet_byindex_locked(idx);
34977dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
35002f4879dSRobert Watson 	return (ifp);
35102f4879dSRobert Watson }
35202f4879dSRobert Watson 
35327d37320SRobert Watson struct ifnet *
35427d37320SRobert Watson ifnet_byindex_ref(u_short idx)
35527d37320SRobert Watson {
35627d37320SRobert Watson 	struct ifnet *ifp;
35727d37320SRobert Watson 
35877dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
35927d37320SRobert Watson 	ifp = ifnet_byindex_locked(idx);
360242a8e72SRobert Watson 	if (ifp == NULL || (ifp->if_flags & IFF_DYING)) {
36177dfcdc4SRobert Watson 		IFNET_RUNLOCK_NOSLEEP();
36227d37320SRobert Watson 		return (NULL);
36327d37320SRobert Watson 	}
36427d37320SRobert Watson 	if_ref(ifp);
36577dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
36627d37320SRobert Watson 	return (ifp);
36727d37320SRobert Watson }
36827d37320SRobert Watson 
36961f6986bSRobert Watson /*
37061f6986bSRobert Watson  * Allocate an ifindex array entry; return 0 on success or an error on
37161f6986bSRobert Watson  * failure.
37261f6986bSRobert Watson  */
373f4507b71SGleb Smirnoff static u_short
374f4507b71SGleb Smirnoff ifindex_alloc(void)
37561f6986bSRobert Watson {
37661f6986bSRobert Watson 	u_short idx;
37761f6986bSRobert Watson 
37861f6986bSRobert Watson 	IFNET_WLOCK_ASSERT();
3795f3b301aSJohn Baldwin retry:
38061f6986bSRobert Watson 	/*
381ed2dabfcSRobert Watson 	 * Try to find an empty slot below V_if_index.  If we fail, take the
38261f6986bSRobert Watson 	 * next slot.
38361f6986bSRobert Watson 	 */
38461f6986bSRobert Watson 	for (idx = 1; idx <= V_if_index; idx++) {
385e6abef09SGleb Smirnoff 		if (V_ifindex_table[idx] == NULL)
38661f6986bSRobert Watson 			break;
38761f6986bSRobert Watson 	}
38861f6986bSRobert Watson 
38961f6986bSRobert Watson 	/* Catch if_index overflow. */
3905f3b301aSJohn Baldwin 	if (idx >= V_if_indexlim) {
3915f3b301aSJohn Baldwin 		if_grow();
3925f3b301aSJohn Baldwin 		goto retry;
3935f3b301aSJohn Baldwin 	}
39461f6986bSRobert Watson 	if (idx > V_if_index)
39561f6986bSRobert Watson 		V_if_index = idx;
396f4507b71SGleb Smirnoff 	return (idx);
39761f6986bSRobert Watson }
39861f6986bSRobert Watson 
399e0c14af9SMarko Zec static void
400ed2dabfcSRobert Watson ifindex_free_locked(u_short idx)
401ed2dabfcSRobert Watson {
402ed2dabfcSRobert Watson 
403ed2dabfcSRobert Watson 	IFNET_WLOCK_ASSERT();
404ed2dabfcSRobert Watson 
405e6abef09SGleb Smirnoff 	V_ifindex_table[idx] = NULL;
406ed2dabfcSRobert Watson 	while (V_if_index > 0 &&
407e6abef09SGleb Smirnoff 	    V_ifindex_table[V_if_index] == NULL)
408ed2dabfcSRobert Watson 		V_if_index--;
409ed2dabfcSRobert Watson }
410ed2dabfcSRobert Watson 
411ed2dabfcSRobert Watson static void
412ed2dabfcSRobert Watson ifindex_free(u_short idx)
413ed2dabfcSRobert Watson {
414ed2dabfcSRobert Watson 
415ed2dabfcSRobert Watson 	IFNET_WLOCK();
416ed2dabfcSRobert Watson 	ifindex_free_locked(idx);
417ed2dabfcSRobert Watson 	IFNET_WUNLOCK();
418ed2dabfcSRobert Watson }
419ed2dabfcSRobert Watson 
420ed2dabfcSRobert Watson static void
42177dfcdc4SRobert Watson ifnet_setbyindex_locked(u_short idx, struct ifnet *ifp)
42202f4879dSRobert Watson {
42302f4879dSRobert Watson 
42402f4879dSRobert Watson 	IFNET_WLOCK_ASSERT();
42502f4879dSRobert Watson 
426e6abef09SGleb Smirnoff 	V_ifindex_table[idx] = ifp;
42702f4879dSRobert Watson }
42802f4879dSRobert Watson 
42977dfcdc4SRobert Watson static void
43077dfcdc4SRobert Watson ifnet_setbyindex(u_short idx, struct ifnet *ifp)
43177dfcdc4SRobert Watson {
43277dfcdc4SRobert Watson 
43377dfcdc4SRobert Watson 	IFNET_WLOCK();
43477dfcdc4SRobert Watson 	ifnet_setbyindex_locked(idx, ifp);
43577dfcdc4SRobert Watson 	IFNET_WUNLOCK();
43677dfcdc4SRobert Watson }
43777dfcdc4SRobert Watson 
43802f4879dSRobert Watson struct ifaddr *
43902f4879dSRobert Watson ifaddr_byindex(u_short idx)
44002f4879dSRobert Watson {
44122a93840SMarko Zec 	struct ifnet *ifp;
44222a93840SMarko Zec 	struct ifaddr *ifa = NULL;
44302f4879dSRobert Watson 
44477dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
44522a93840SMarko Zec 	ifp = ifnet_byindex_locked(idx);
44622a93840SMarko Zec 	if (ifp != NULL && (ifa = ifp->if_addr) != NULL)
4478c0fec80SRobert Watson 		ifa_ref(ifa);
44877dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
44902f4879dSRobert Watson 	return (ifa);
45002f4879dSRobert Watson }
45102f4879dSRobert Watson 
452df8bae1dSRodney W. Grimes /*
453df8bae1dSRodney W. Grimes  * Network interface utility routines.
454df8bae1dSRodney W. Grimes  *
455df8bae1dSRodney W. Grimes  * Routines with ifa_ifwith* names take sockaddr *'s as
456df8bae1dSRodney W. Grimes  * parameters.
457df8bae1dSRodney W. Grimes  */
458a45cbf12SBrooks Davis 
459f9132cebSJonathan Lemon static void
460d0728d71SRobert Watson vnet_if_init(const void *unused __unused)
4611ed81b73SMarko Zec {
46244e33a07SMarko Zec 
463603724d3SBjoern A. Zeeb 	TAILQ_INIT(&V_ifnet);
464603724d3SBjoern A. Zeeb 	TAILQ_INIT(&V_ifg_head);
4655f3b301aSJohn Baldwin 	IFNET_WLOCK();
466f9132cebSJonathan Lemon 	if_grow();				/* create initial table */
4675f3b301aSJohn Baldwin 	IFNET_WUNLOCK();
468d0728d71SRobert Watson 	vnet_if_clone_init();
469f9132cebSJonathan Lemon }
4705f3b301aSJohn Baldwin VNET_SYSINIT(vnet_if_init, SI_SUB_INIT_IF, SI_ORDER_SECOND, vnet_if_init,
471d0728d71SRobert Watson     NULL);
472d0728d71SRobert Watson 
473bc29160dSMarko Zec #ifdef VIMAGE
474d0728d71SRobert Watson static void
475d0728d71SRobert Watson vnet_if_uninit(const void *unused __unused)
476bc29160dSMarko Zec {
477bc29160dSMarko Zec 
4780028e524SBjoern A. Zeeb 	VNET_ASSERT(TAILQ_EMPTY(&V_ifnet), ("%s:%d tailq &V_ifnet=%p "
4790028e524SBjoern A. Zeeb 	    "not empty", __func__, __LINE__, &V_ifnet));
4800028e524SBjoern A. Zeeb 	VNET_ASSERT(TAILQ_EMPTY(&V_ifg_head), ("%s:%d tailq &V_ifg_head=%p "
4810028e524SBjoern A. Zeeb 	    "not empty", __func__, __LINE__, &V_ifg_head));
482bc29160dSMarko Zec 
483bc29160dSMarko Zec 	free((caddr_t)V_ifindex_table, M_IFNET);
484bc29160dSMarko Zec }
485d0728d71SRobert Watson VNET_SYSUNINIT(vnet_if_uninit, SI_SUB_INIT_IF, SI_ORDER_FIRST,
486d0728d71SRobert Watson     vnet_if_uninit, NULL);
487ad4e9116SBjoern A. Zeeb 
488ad4e9116SBjoern A. Zeeb static void
489ad4e9116SBjoern A. Zeeb vnet_if_return(const void *unused __unused)
490ad4e9116SBjoern A. Zeeb {
491ad4e9116SBjoern A. Zeeb 	struct ifnet *ifp, *nifp;
492ad4e9116SBjoern A. Zeeb 
493ad4e9116SBjoern A. Zeeb 	/* Return all inherited interfaces to their parent vnets. */
494ad4e9116SBjoern A. Zeeb 	TAILQ_FOREACH_SAFE(ifp, &V_ifnet, if_link, nifp) {
495ad4e9116SBjoern A. Zeeb 		if (ifp->if_home_vnet != ifp->if_vnet)
496ad4e9116SBjoern A. Zeeb 			if_vmove(ifp, ifp->if_home_vnet);
497ad4e9116SBjoern A. Zeeb 	}
498ad4e9116SBjoern A. Zeeb }
499ad4e9116SBjoern A. Zeeb VNET_SYSUNINIT(vnet_if_return, SI_SUB_VNET_DONE, SI_ORDER_ANY,
500ad4e9116SBjoern A. Zeeb     vnet_if_return, NULL);
501bc29160dSMarko Zec #endif
502bc29160dSMarko Zec 
5038e937462SRobert Watson static void
504f9132cebSJonathan Lemon if_grow(void)
505f9132cebSJonathan Lemon {
5065f3b301aSJohn Baldwin 	int oldlim;
507f9132cebSJonathan Lemon 	u_int n;
508e6abef09SGleb Smirnoff 	struct ifnet **e;
509f9132cebSJonathan Lemon 
5105f3b301aSJohn Baldwin 	IFNET_WLOCK_ASSERT();
5115f3b301aSJohn Baldwin 	oldlim = V_if_indexlim;
5125f3b301aSJohn Baldwin 	IFNET_WUNLOCK();
5135f3b301aSJohn Baldwin 	n = (oldlim << 1) * sizeof(*e);
514fc74a9f9SBrooks Davis 	e = malloc(n, M_IFNET, M_WAITOK | M_ZERO);
5155f3b301aSJohn Baldwin 	IFNET_WLOCK();
5165f3b301aSJohn Baldwin 	if (V_if_indexlim != oldlim) {
5175f3b301aSJohn Baldwin 		free(e, M_IFNET);
5185f3b301aSJohn Baldwin 		return;
5195f3b301aSJohn Baldwin 	}
520603724d3SBjoern A. Zeeb 	if (V_ifindex_table != NULL) {
521603724d3SBjoern A. Zeeb 		memcpy((caddr_t)e, (caddr_t)V_ifindex_table, n/2);
522603724d3SBjoern A. Zeeb 		free((caddr_t)V_ifindex_table, M_IFNET);
523f9132cebSJonathan Lemon 	}
5245f3b301aSJohn Baldwin 	V_if_indexlim <<= 1;
525603724d3SBjoern A. Zeeb 	V_ifindex_table = e;
526f9132cebSJonathan Lemon }
527f9132cebSJonathan Lemon 
528df8bae1dSRodney W. Grimes /*
529a45cbf12SBrooks Davis  * Allocate a struct ifnet and an index for an interface.  A layer 2
530a45cbf12SBrooks Davis  * common structure will also be allocated if an allocation routine is
531a45cbf12SBrooks Davis  * registered for the passed type.
532fc74a9f9SBrooks Davis  */
533fc74a9f9SBrooks Davis struct ifnet *
534fc74a9f9SBrooks Davis if_alloc(u_char type)
535fc74a9f9SBrooks Davis {
536fc74a9f9SBrooks Davis 	struct ifnet *ifp;
53761f6986bSRobert Watson 	u_short idx;
538fc74a9f9SBrooks Davis 
539fc74a9f9SBrooks Davis 	ifp = malloc(sizeof(struct ifnet), M_IFNET, M_WAITOK|M_ZERO);
54061f6986bSRobert Watson 	IFNET_WLOCK();
541f4507b71SGleb Smirnoff 	idx = ifindex_alloc();
542ed2dabfcSRobert Watson 	ifnet_setbyindex_locked(idx, IFNET_HOLD);
54361f6986bSRobert Watson 	IFNET_WUNLOCK();
54461f6986bSRobert Watson 	ifp->if_index = idx;
545fc74a9f9SBrooks Davis 	ifp->if_type = type;
54627d37320SRobert Watson 	ifp->if_alloctype = type;
547a29c7aebSBjoern A. Zeeb #ifdef VIMAGE
548a29c7aebSBjoern A. Zeeb 	ifp->if_vnet = curvnet;
549a29c7aebSBjoern A. Zeeb #endif
550fc74a9f9SBrooks Davis 	if (if_com_alloc[type] != NULL) {
551fc74a9f9SBrooks Davis 		ifp->if_l2com = if_com_alloc[type](type, ifp);
55228ef2db4SBrooks Davis 		if (ifp->if_l2com == NULL) {
553fc74a9f9SBrooks Davis 			free(ifp, M_IFNET);
554ed2dabfcSRobert Watson 			ifindex_free(idx);
55528ef2db4SBrooks Davis 			return (NULL);
55628ef2db4SBrooks Davis 		}
557fc74a9f9SBrooks Davis 	}
55827d37320SRobert Watson 
55927d37320SRobert Watson 	IF_ADDR_LOCK_INIT(ifp);
560d6f157eaSRobert Watson 	TASK_INIT(&ifp->if_linktask, 0, do_link_state_change, ifp);
561d6f157eaSRobert Watson 	ifp->if_afdata_initialized = 0;
562e0c14af9SMarko Zec 	IF_AFDATA_LOCK_INIT(ifp);
563d6f157eaSRobert Watson 	TAILQ_INIT(&ifp->if_addrhead);
564d6f157eaSRobert Watson 	TAILQ_INIT(&ifp->if_multiaddrs);
565d6f157eaSRobert Watson 	TAILQ_INIT(&ifp->if_groups);
566d6f157eaSRobert Watson #ifdef MAC
567d6f157eaSRobert Watson 	mac_ifnet_init(ifp);
568d6f157eaSRobert Watson #endif
569d659538fSSam Leffler 	ifq_init(&ifp->if_snd, ifp);
570d6f157eaSRobert Watson 
57127d37320SRobert Watson 	refcount_init(&ifp->if_refcount, 1);	/* Index reference. */
572112f50ffSGleb Smirnoff 	for (int i = 0; i < IFCOUNTERS; i++)
573112f50ffSGleb Smirnoff 		ifp->if_counters[i] = counter_u64_alloc(M_WAITOK);
57461dc4344SAndrey V. Elsukov 	ifp->if_get_counter = if_get_counter_default;
575f1379734SKonstantin Belousov 	ifp->if_pcp = IFNET_PCP_NONE;
57661dc4344SAndrey V. Elsukov 	ifnet_setbyindex(ifp->if_index, ifp);
577fc74a9f9SBrooks Davis 	return (ifp);
578fc74a9f9SBrooks Davis }
579fc74a9f9SBrooks Davis 
580a45cbf12SBrooks Davis /*
5814c506522SGleb Smirnoff  * Do the actual work of freeing a struct ifnet, and layer 2 common
5824c506522SGleb Smirnoff  * structure.  This call is made when the last reference to an
583242a8e72SRobert Watson  * interface is released.
584a45cbf12SBrooks Davis  */
585242a8e72SRobert Watson static void
586242a8e72SRobert Watson if_free_internal(struct ifnet *ifp)
587fc74a9f9SBrooks Davis {
588fc74a9f9SBrooks Davis 
589242a8e72SRobert Watson 	KASSERT((ifp->if_flags & IFF_DYING),
590242a8e72SRobert Watson 	    ("if_free_internal: interface not dying"));
591fc74a9f9SBrooks Davis 
59227d37320SRobert Watson 	if (if_com_free[ifp->if_alloctype] != NULL)
59327d37320SRobert Watson 		if_com_free[ifp->if_alloctype](ifp->if_l2com,
59427d37320SRobert Watson 		    ifp->if_alloctype);
595fc74a9f9SBrooks Davis 
596d6f157eaSRobert Watson #ifdef MAC
597d6f157eaSRobert Watson 	mac_ifnet_destroy(ifp);
598d6f157eaSRobert Watson #endif /* MAC */
599215940b3SXin LI 	if (ifp->if_description != NULL)
600215940b3SXin LI 		free(ifp->if_description, M_IFDESCR);
601d6f157eaSRobert Watson 	IF_AFDATA_DESTROY(ifp);
60202f4879dSRobert Watson 	IF_ADDR_LOCK_DESTROY(ifp);
603d659538fSSam Leffler 	ifq_delete(&ifp->if_snd);
604112f50ffSGleb Smirnoff 
605112f50ffSGleb Smirnoff 	for (int i = 0; i < IFCOUNTERS; i++)
606112f50ffSGleb Smirnoff 		counter_u64_free(ifp->if_counters[i]);
607112f50ffSGleb Smirnoff 
608fc74a9f9SBrooks Davis 	free(ifp, M_IFNET);
609c0c9ea90SSam Leffler }
610fc74a9f9SBrooks Davis 
611242a8e72SRobert Watson /*
612f26fa169SBrooks Davis  * Deregister an interface and free the associated storage.
613242a8e72SRobert Watson  */
614242a8e72SRobert Watson void
615f26fa169SBrooks Davis if_free(struct ifnet *ifp)
616242a8e72SRobert Watson {
617242a8e72SRobert Watson 
618242a8e72SRobert Watson 	ifp->if_flags |= IFF_DYING;			/* XXX: Locking */
6194c506522SGleb Smirnoff 
620719fb725SCraig Rodrigues 	CURVNET_SET_QUIET(ifp->if_vnet);
6214c506522SGleb Smirnoff 	IFNET_WLOCK();
6224c506522SGleb Smirnoff 	KASSERT(ifp == ifnet_byindex_locked(ifp->if_index),
6234c506522SGleb Smirnoff 	    ("%s: freeing unallocated ifnet", ifp->if_xname));
6244c506522SGleb Smirnoff 
6254c506522SGleb Smirnoff 	ifindex_free_locked(ifp->if_index);
6264c506522SGleb Smirnoff 	IFNET_WUNLOCK();
6274c506522SGleb Smirnoff 
628719fb725SCraig Rodrigues 	if (refcount_release(&ifp->if_refcount))
629242a8e72SRobert Watson 		if_free_internal(ifp);
630719fb725SCraig Rodrigues 	CURVNET_RESTORE();
631242a8e72SRobert Watson }
632242a8e72SRobert Watson 
633242a8e72SRobert Watson /*
634242a8e72SRobert Watson  * Interfaces to keep an ifnet type-stable despite the possibility of the
635242a8e72SRobert Watson  * driver calling if_free().  If there are additional references, we defer
636242a8e72SRobert Watson  * freeing the underlying data structure.
637242a8e72SRobert Watson  */
638db7f0b97SKip Macy void
63927d37320SRobert Watson if_ref(struct ifnet *ifp)
64027d37320SRobert Watson {
64127d37320SRobert Watson 
64227d37320SRobert Watson 	/* We don't assert the ifnet list lock here, but arguably should. */
64327d37320SRobert Watson 	refcount_acquire(&ifp->if_refcount);
64427d37320SRobert Watson }
64527d37320SRobert Watson 
64627d37320SRobert Watson void
64727d37320SRobert Watson if_rele(struct ifnet *ifp)
64827d37320SRobert Watson {
64927d37320SRobert Watson 
650242a8e72SRobert Watson 	if (!refcount_release(&ifp->if_refcount))
651242a8e72SRobert Watson 		return;
652242a8e72SRobert Watson 	if_free_internal(ifp);
65327d37320SRobert Watson }
65427d37320SRobert Watson 
65527d37320SRobert Watson void
656d659538fSSam Leffler ifq_init(struct ifaltq *ifq, struct ifnet *ifp)
657db7f0b97SKip Macy {
658db7f0b97SKip Macy 
659db7f0b97SKip Macy 	mtx_init(&ifq->ifq_mtx, ifp->if_xname, "if send queue", MTX_DEF);
660db7f0b97SKip Macy 
661db7f0b97SKip Macy 	if (ifq->ifq_maxlen == 0)
662db7f0b97SKip Macy 		ifq->ifq_maxlen = ifqmaxlen;
663db7f0b97SKip Macy 
664db7f0b97SKip Macy 	ifq->altq_type = 0;
665db7f0b97SKip Macy 	ifq->altq_disc = NULL;
666db7f0b97SKip Macy 	ifq->altq_flags &= ALTQF_CANTCHANGE;
667db7f0b97SKip Macy 	ifq->altq_tbr  = NULL;
668db7f0b97SKip Macy 	ifq->altq_ifp  = ifp;
669db7f0b97SKip Macy }
670db7f0b97SKip Macy 
671db7f0b97SKip Macy void
672d659538fSSam Leffler ifq_delete(struct ifaltq *ifq)
673db7f0b97SKip Macy {
674db7f0b97SKip Macy 	mtx_destroy(&ifq->ifq_mtx);
675db7f0b97SKip Macy }
676db7f0b97SKip Macy 
677fc74a9f9SBrooks Davis /*
678a4641f4eSPedro F. Giffuni  * Perform generic interface initialization tasks and attach the interface
679e0c14af9SMarko Zec  * to the list of "active" interfaces.  If vmove flag is set on entry
680e0c14af9SMarko Zec  * to if_attach_internal(), perform only a limited subset of initialization
681e0c14af9SMarko Zec  * tasks, given that we are moving from one vnet to another an ifnet which
682e0c14af9SMarko Zec  * has already been fully initialized.
683a45cbf12SBrooks Davis  *
684c92a456bSHiroki Sato  * Note that if_detach_internal() removes group membership unconditionally
685c92a456bSHiroki Sato  * even when vmove flag is set, and if_attach_internal() adds only IFG_ALL.
686c92a456bSHiroki Sato  * Thus, when if_vmove() is applied to a cloned interface, group membership
687c92a456bSHiroki Sato  * is lost while a cloned one always joins a group whose name is
688c92a456bSHiroki Sato  * ifc->ifc_name.  To recover this after if_detach_internal() and
689c92a456bSHiroki Sato  * if_attach_internal(), the cloner should be specified to
690c92a456bSHiroki Sato  * if_attach_internal() via ifc.  If it is non-NULL, if_attach_internal()
691c92a456bSHiroki Sato  * attempts to join a group whose name is ifc->ifc_name.
692c92a456bSHiroki Sato  *
693a45cbf12SBrooks Davis  * XXX:
694a45cbf12SBrooks Davis  *  - The decision to return void and thus require this function to
695a45cbf12SBrooks Davis  *    succeed is questionable.
696a45cbf12SBrooks Davis  *  - We should probably do more sanity checking.  For instance we don't
697a45cbf12SBrooks Davis  *    do anything to insure if_xname is unique or non-empty.
698df8bae1dSRodney W. Grimes  */
699df8bae1dSRodney W. Grimes void
70072fd1b6aSDag-Erling Smørgrav if_attach(struct ifnet *ifp)
701df8bae1dSRodney W. Grimes {
702e0c14af9SMarko Zec 
703c92a456bSHiroki Sato 	if_attach_internal(ifp, 0, NULL);
704e0c14af9SMarko Zec }
705e0c14af9SMarko Zec 
7069fd573c3SHans Petter Selasky /*
7079fd573c3SHans Petter Selasky  * Compute the least common TSO limit.
7089fd573c3SHans Petter Selasky  */
7099fd573c3SHans Petter Selasky void
7109fd573c3SHans Petter Selasky if_hw_tsomax_common(if_t ifp, struct ifnet_hw_tsomax *pmax)
7119fd573c3SHans Petter Selasky {
7129fd573c3SHans Petter Selasky 	/*
7139fd573c3SHans Petter Selasky 	 * 1) If there is no limit currently, take the limit from
7149fd573c3SHans Petter Selasky 	 * the network adapter.
7159fd573c3SHans Petter Selasky 	 *
7169fd573c3SHans Petter Selasky 	 * 2) If the network adapter has a limit below the current
7179fd573c3SHans Petter Selasky 	 * limit, apply it.
7189fd573c3SHans Petter Selasky 	 */
7199fd573c3SHans Petter Selasky 	if (pmax->tsomaxbytes == 0 || (ifp->if_hw_tsomax != 0 &&
7209fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomax < pmax->tsomaxbytes)) {
7219fd573c3SHans Petter Selasky 		pmax->tsomaxbytes = ifp->if_hw_tsomax;
7229fd573c3SHans Petter Selasky 	}
7239fd573c3SHans Petter Selasky 	if (pmax->tsomaxsegcount == 0 || (ifp->if_hw_tsomaxsegcount != 0 &&
7249fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomaxsegcount < pmax->tsomaxsegcount)) {
7259fd573c3SHans Petter Selasky 		pmax->tsomaxsegcount = ifp->if_hw_tsomaxsegcount;
7269fd573c3SHans Petter Selasky 	}
7279fd573c3SHans Petter Selasky 	if (pmax->tsomaxsegsize == 0 || (ifp->if_hw_tsomaxsegsize != 0 &&
7289fd573c3SHans Petter Selasky 	    ifp->if_hw_tsomaxsegsize < pmax->tsomaxsegsize)) {
7299fd573c3SHans Petter Selasky 		pmax->tsomaxsegsize = ifp->if_hw_tsomaxsegsize;
7309fd573c3SHans Petter Selasky 	}
7319fd573c3SHans Petter Selasky }
7329fd573c3SHans Petter Selasky 
7339fd573c3SHans Petter Selasky /*
7349fd573c3SHans Petter Selasky  * Update TSO limit of a network adapter.
7359fd573c3SHans Petter Selasky  *
7369fd573c3SHans Petter Selasky  * Returns zero if no change. Else non-zero.
7379fd573c3SHans Petter Selasky  */
7389fd573c3SHans Petter Selasky int
7399fd573c3SHans Petter Selasky if_hw_tsomax_update(if_t ifp, struct ifnet_hw_tsomax *pmax)
7409fd573c3SHans Petter Selasky {
7419fd573c3SHans Petter Selasky 	int retval = 0;
7429fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomax != pmax->tsomaxbytes) {
7439fd573c3SHans Petter Selasky 		ifp->if_hw_tsomax = pmax->tsomaxbytes;
7449fd573c3SHans Petter Selasky 		retval++;
7459fd573c3SHans Petter Selasky 	}
7469fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomaxsegsize != pmax->tsomaxsegsize) {
7479fd573c3SHans Petter Selasky 		ifp->if_hw_tsomaxsegsize = pmax->tsomaxsegsize;
7489fd573c3SHans Petter Selasky 		retval++;
7499fd573c3SHans Petter Selasky 	}
7509fd573c3SHans Petter Selasky 	if (ifp->if_hw_tsomaxsegcount != pmax->tsomaxsegcount) {
7519fd573c3SHans Petter Selasky 		ifp->if_hw_tsomaxsegcount = pmax->tsomaxsegcount;
7529fd573c3SHans Petter Selasky 		retval++;
7539fd573c3SHans Petter Selasky 	}
7549fd573c3SHans Petter Selasky 	return (retval);
7559fd573c3SHans Petter Selasky }
7569fd573c3SHans Petter Selasky 
757e0c14af9SMarko Zec static void
758c92a456bSHiroki Sato if_attach_internal(struct ifnet *ifp, int vmove, struct if_clone *ifc)
759e0c14af9SMarko Zec {
760df8bae1dSRodney W. Grimes 	unsigned socksize, ifasize;
7611ce9bf88SPoul-Henning Kamp 	int namelen, masklen;
76272fd1b6aSDag-Erling Smørgrav 	struct sockaddr_dl *sdl;
76372fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
764df8bae1dSRodney W. Grimes 
765fc74a9f9SBrooks Davis 	if (ifp->if_index == 0 || ifp != ifnet_byindex(ifp->if_index))
766fc74a9f9SBrooks Davis 		panic ("%s: BUG: if_attach called without if_alloc'd input()\n",
767fc74a9f9SBrooks Davis 		    ifp->if_xname);
768fc74a9f9SBrooks Davis 
769f6dfe47aSMarko Zec #ifdef VIMAGE
770f6dfe47aSMarko Zec 	ifp->if_vnet = curvnet;
771bc29160dSMarko Zec 	if (ifp->if_home_vnet == NULL)
772bc29160dSMarko Zec 		ifp->if_home_vnet = curvnet;
773f6dfe47aSMarko Zec #endif
774f6dfe47aSMarko Zec 
7750dad3f0eSMax Laier 	if_addgroup(ifp, IFG_ALL);
7760dad3f0eSMax Laier 
777c92a456bSHiroki Sato 	/* Restore group membership for cloned interfaces. */
778c92a456bSHiroki Sato 	if (vmove && ifc != NULL)
779c92a456bSHiroki Sato 		if_clone_addgroup(ifp, ifc);
780c92a456bSHiroki Sato 
78198b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
782e6485f73SGleb Smirnoff 	ifp->if_epoch = time_uptime;
783d6f157eaSRobert Watson 
7847cc5b47fSKip Macy 	KASSERT((ifp->if_transmit == NULL && ifp->if_qflush == NULL) ||
7857cc5b47fSKip Macy 	    (ifp->if_transmit != NULL && ifp->if_qflush != NULL),
7867cc5b47fSKip Macy 	    ("transmit and qflush must both either be set or both be NULL"));
7877cc5b47fSKip Macy 	if (ifp->if_transmit == NULL) {
788db7f0b97SKip Macy 		ifp->if_transmit = if_transmit;
789db7f0b97SKip Macy 		ifp->if_qflush = if_qflush;
7907cc5b47fSKip Macy 	}
791b57d9721SAndrey V. Elsukov 	if (ifp->if_input == NULL)
792b57d9721SAndrey V. Elsukov 		ifp->if_input = if_input_default;
7937cc5b47fSKip Macy 
7944fb3a820SAlexander V. Chernikov 	if (ifp->if_requestencap == NULL)
7954fb3a820SAlexander V. Chernikov 		ifp->if_requestencap = if_requestencap_default;
7964fb3a820SAlexander V. Chernikov 
797e0c14af9SMarko Zec 	if (!vmove) {
798e70cd263SRobert Watson #ifdef MAC
79930d239bcSRobert Watson 		mac_ifnet_create(ifp);
800e70cd263SRobert Watson #endif
801e70cd263SRobert Watson 
802df8bae1dSRodney W. Grimes 		/*
803e0c14af9SMarko Zec 		 * Create a Link Level name for this device.
804df8bae1dSRodney W. Grimes 		 */
8059bf40edeSBrooks Davis 		namelen = strlen(ifp->if_xname);
80636c19a57SBrooks Davis 		/*
807e0c14af9SMarko Zec 		 * Always save enough space for any possiable name so we
808e0c14af9SMarko Zec 		 * can do a rename in place later.
80936c19a57SBrooks Davis 		 */
81036c19a57SBrooks Davis 		masklen = offsetof(struct sockaddr_dl, sdl_data[0]) + IFNAMSIZ;
811df8bae1dSRodney W. Grimes 		socksize = masklen + ifp->if_addrlen;
812df8bae1dSRodney W. Grimes 		if (socksize < sizeof(*sdl))
813df8bae1dSRodney W. Grimes 			socksize = sizeof(*sdl);
814ccb82468SBrooks Davis 		socksize = roundup2(socksize, sizeof(long));
815df8bae1dSRodney W. Grimes 		ifasize = sizeof(*ifa) + 2 * socksize;
81646758960SGleb Smirnoff 		ifa = ifa_alloc(ifasize, M_WAITOK);
817df8bae1dSRodney W. Grimes 		sdl = (struct sockaddr_dl *)(ifa + 1);
818df8bae1dSRodney W. Grimes 		sdl->sdl_len = socksize;
819df8bae1dSRodney W. Grimes 		sdl->sdl_family = AF_LINK;
8209bf40edeSBrooks Davis 		bcopy(ifp->if_xname, sdl->sdl_data, namelen);
8211ce9bf88SPoul-Henning Kamp 		sdl->sdl_nlen = namelen;
822df8bae1dSRodney W. Grimes 		sdl->sdl_index = ifp->if_index;
823df8bae1dSRodney W. Grimes 		sdl->sdl_type = ifp->if_type;
8244a0d6638SRuslan Ermilov 		ifp->if_addr = ifa;
825df8bae1dSRodney W. Grimes 		ifa->ifa_ifp = ifp;
826df8bae1dSRodney W. Grimes 		ifa->ifa_rtrequest = link_rtrequest;
827df8bae1dSRodney W. Grimes 		ifa->ifa_addr = (struct sockaddr *)sdl;
828df8bae1dSRodney W. Grimes 		sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl);
829df8bae1dSRodney W. Grimes 		ifa->ifa_netmask = (struct sockaddr *)sdl;
830df8bae1dSRodney W. Grimes 		sdl->sdl_len = masklen;
831df8bae1dSRodney W. Grimes 		while (namelen != 0)
832df8bae1dSRodney W. Grimes 			sdl->sdl_data[--namelen] = 0xff;
83359562606SGarrett Wollman 		TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
834e0c14af9SMarko Zec 		/* Reliably crash if used uninitialized. */
835e0c14af9SMarko Zec 		ifp->if_broadcastaddr = NULL;
83672f31000SHans Petter Selasky 
837ddae5750SRavi Pokala 		if (ifp->if_type == IFT_ETHER) {
838ddae5750SRavi Pokala 			ifp->if_hw_addr = malloc(ifp->if_addrlen, M_IFADDR,
839ddae5750SRavi Pokala 			    M_WAITOK | M_ZERO);
840ddae5750SRavi Pokala 		}
841ddae5750SRavi Pokala 
84272f31000SHans Petter Selasky #if defined(INET) || defined(INET6)
8439fd573c3SHans Petter Selasky 		/* Use defaults for TSO, if nothing is set */
8449fd573c3SHans Petter Selasky 		if (ifp->if_hw_tsomax == 0 &&
8459fd573c3SHans Petter Selasky 		    ifp->if_hw_tsomaxsegcount == 0 &&
8469fd573c3SHans Petter Selasky 		    ifp->if_hw_tsomaxsegsize == 0) {
8479fd573c3SHans Petter Selasky 			/*
8489fd573c3SHans Petter Selasky 			 * The TSO defaults needs to be such that an
8499fd573c3SHans Petter Selasky 			 * NFS mbuf list of 35 mbufs totalling just
8509fd573c3SHans Petter Selasky 			 * below 64K works and that a chain of mbufs
8519fd573c3SHans Petter Selasky 			 * can be defragged into at most 32 segments:
8529fd573c3SHans Petter Selasky 			 */
8539fd573c3SHans Petter Selasky 			ifp->if_hw_tsomax = min(IP_MAXPACKET, (32 * MCLBYTES) -
85472f31000SHans Petter Selasky 			    (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN));
8559fd573c3SHans Petter Selasky 			ifp->if_hw_tsomaxsegcount = 35;
8569fd573c3SHans Petter Selasky 			ifp->if_hw_tsomaxsegsize = 2048;	/* 2K */
8579fd573c3SHans Petter Selasky 
8589fd573c3SHans Petter Selasky 			/* XXX some drivers set IFCAP_TSO after ethernet attach */
8599fd573c3SHans Petter Selasky 			if (ifp->if_capabilities & IFCAP_TSO) {
8609fd573c3SHans Petter Selasky 				if_printf(ifp, "Using defaults for TSO: %u/%u/%u\n",
8619fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomax,
8629fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomaxsegcount,
8639fd573c3SHans Petter Selasky 				    ifp->if_hw_tsomaxsegsize);
8649fd573c3SHans Petter Selasky 			}
8659fd573c3SHans Petter Selasky 		}
86672f31000SHans Petter Selasky #endif
867e0c14af9SMarko Zec 	}
86852db6805SMarko Zec #ifdef VIMAGE
86952db6805SMarko Zec 	else {
87052db6805SMarko Zec 		/*
87152db6805SMarko Zec 		 * Update the interface index in the link layer address
87252db6805SMarko Zec 		 * of the interface.
87352db6805SMarko Zec 		 */
87452db6805SMarko Zec 		for (ifa = ifp->if_addr; ifa != NULL;
87552db6805SMarko Zec 		    ifa = TAILQ_NEXT(ifa, ifa_link)) {
87652db6805SMarko Zec 			if (ifa->ifa_addr->sa_family == AF_LINK) {
87752db6805SMarko Zec 				sdl = (struct sockaddr_dl *)ifa->ifa_addr;
87852db6805SMarko Zec 				sdl->sdl_index = ifp->if_index;
87952db6805SMarko Zec 			}
88052db6805SMarko Zec 		}
88152db6805SMarko Zec 	}
88252db6805SMarko Zec #endif
883d94ccb09SBrooks Davis 
884457f48e6SGleb Smirnoff 	IFNET_WLOCK();
885603724d3SBjoern A. Zeeb 	TAILQ_INSERT_TAIL(&V_ifnet, ifp, if_link);
88621ca7b57SMarko Zec #ifdef VIMAGE
887006e9db4SRobert Watson 	curvnet->vnet_ifcnt++;
88821ca7b57SMarko Zec #endif
889457f48e6SGleb Smirnoff 	IFNET_WUNLOCK();
890457f48e6SGleb Smirnoff 
89169fb23b7SMax Laier 	if (domain_init_status >= 2)
89231b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
89331b1bfe1SHajimu UMEMOTO 
89425a4adceSMax Laier 	EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
89521ca7b57SMarko Zec 	if (IS_DEFAULT_VNET(curvnet))
896f3b90d48SAndrew Thompson 		devctl_notify("IFNET", ifp->if_xname, "ATTACH", NULL);
89725a4adceSMax Laier 
8987b6edd04SRuslan Ermilov 	/* Announce the interface. */
8997b6edd04SRuslan Ermilov 	rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
900df8bae1dSRodney W. Grimes }
9016182fdbdSPeter Wemm 
90231b1bfe1SHajimu UMEMOTO static void
90372fd1b6aSDag-Erling Smørgrav if_attachdomain(void *dummy)
90431b1bfe1SHajimu UMEMOTO {
90531b1bfe1SHajimu UMEMOTO 	struct ifnet *ifp;
90631b1bfe1SHajimu UMEMOTO 
90770398c2fSMatt Macy 	net_epoch_preempt = epoch_alloc(EPOCH_PREEMPT);
9085e68a3dfSMatt Macy 	net_epoch = epoch_alloc(0);
909603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link)
91031b1bfe1SHajimu UMEMOTO 		if_attachdomain1(ifp);
91131b1bfe1SHajimu UMEMOTO }
91269fb23b7SMax Laier SYSINIT(domainifattach, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_SECOND,
91331b1bfe1SHajimu UMEMOTO     if_attachdomain, NULL);
91431b1bfe1SHajimu UMEMOTO 
91531b1bfe1SHajimu UMEMOTO static void
91672fd1b6aSDag-Erling Smørgrav if_attachdomain1(struct ifnet *ifp)
91731b1bfe1SHajimu UMEMOTO {
91831b1bfe1SHajimu UMEMOTO 	struct domain *dp;
91931b1bfe1SHajimu UMEMOTO 
920234a35c7SHajimu UMEMOTO 	/*
921234a35c7SHajimu UMEMOTO 	 * Since dp->dom_ifattach calls malloc() with M_WAITOK, we
922234a35c7SHajimu UMEMOTO 	 * cannot lock ifp->if_afdata initialization, entirely.
923234a35c7SHajimu UMEMOTO 	 */
924c169d9feSBjoern A. Zeeb 	IF_AFDATA_LOCK(ifp);
92569fb23b7SMax Laier 	if (ifp->if_afdata_initialized >= domain_init_status) {
926234a35c7SHajimu UMEMOTO 		IF_AFDATA_UNLOCK(ifp);
927813ee737SAndre Oppermann 		log(LOG_WARNING, "%s called more than once on %s\n",
928813ee737SAndre Oppermann 		    __func__, ifp->if_xname);
929234a35c7SHajimu UMEMOTO 		return;
930234a35c7SHajimu UMEMOTO 	}
93169fb23b7SMax Laier 	ifp->if_afdata_initialized = domain_init_status;
932234a35c7SHajimu UMEMOTO 	IF_AFDATA_UNLOCK(ifp);
933234a35c7SHajimu UMEMOTO 
93431b1bfe1SHajimu UMEMOTO 	/* address family dependent data region */
93531b1bfe1SHajimu UMEMOTO 	bzero(ifp->if_afdata, sizeof(ifp->if_afdata));
93631b1bfe1SHajimu UMEMOTO 	for (dp = domains; dp; dp = dp->dom_next) {
93731b1bfe1SHajimu UMEMOTO 		if (dp->dom_ifattach)
93831b1bfe1SHajimu UMEMOTO 			ifp->if_afdata[dp->dom_family] =
93931b1bfe1SHajimu UMEMOTO 			    (*dp->dom_ifattach)(ifp);
94031b1bfe1SHajimu UMEMOTO 	}
94131b1bfe1SHajimu UMEMOTO }
94231b1bfe1SHajimu UMEMOTO 
9436182fdbdSPeter Wemm /*
944ec002feeSBruce M Simpson  * Remove any unicast or broadcast network addresses from an interface.
94545778b37SPeter Edwards  */
94645778b37SPeter Edwards void
94745778b37SPeter Edwards if_purgeaddrs(struct ifnet *ifp)
94845778b37SPeter Edwards {
94945778b37SPeter Edwards 	struct ifaddr *ifa, *next;
95045778b37SPeter Edwards 
951f22d78c0SBjoern A. Zeeb 	/* XXX cannot hold IF_ADDR_WLOCK over called functions. */
95245778b37SPeter Edwards 	TAILQ_FOREACH_SAFE(ifa, &ifp->if_addrhead, ifa_link, next) {
9534b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_LINK)
95445778b37SPeter Edwards 			continue;
95545778b37SPeter Edwards #ifdef INET
95645778b37SPeter Edwards 		/* XXX: Ugly!! ad hoc just for INET */
9574b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET) {
95845778b37SPeter Edwards 			struct ifaliasreq ifr;
95945778b37SPeter Edwards 
96045778b37SPeter Edwards 			bzero(&ifr, sizeof(ifr));
96145778b37SPeter Edwards 			ifr.ifra_addr = *ifa->ifa_addr;
96245778b37SPeter Edwards 			if (ifa->ifa_dstaddr)
96345778b37SPeter Edwards 				ifr.ifra_broadaddr = *ifa->ifa_dstaddr;
96445778b37SPeter Edwards 			if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp,
96545778b37SPeter Edwards 			    NULL) == 0)
96645778b37SPeter Edwards 				continue;
96745778b37SPeter Edwards 		}
96845778b37SPeter Edwards #endif /* INET */
96945778b37SPeter Edwards #ifdef INET6
9704b97d7afSYaroslav Tykhiy 		if (ifa->ifa_addr->sa_family == AF_INET6) {
97145778b37SPeter Edwards 			in6_purgeaddr(ifa);
97245778b37SPeter Edwards 			/* ifp_addrhead is already updated */
97345778b37SPeter Edwards 			continue;
97445778b37SPeter Edwards 		}
97545778b37SPeter Edwards #endif /* INET6 */
976f22d78c0SBjoern A. Zeeb 		IF_ADDR_WLOCK(ifp);
97745778b37SPeter Edwards 		TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
978f22d78c0SBjoern A. Zeeb 		IF_ADDR_WUNLOCK(ifp);
9791099f828SRobert Watson 		ifa_free(ifa);
98045778b37SPeter Edwards 	}
98145778b37SPeter Edwards }
98245778b37SPeter Edwards 
98345778b37SPeter Edwards /*
98493ec7edcSShteryana Shopova  * Remove any multicast network addresses from an interface when an ifnet
98593ec7edcSShteryana Shopova  * is going away.
986ec002feeSBruce M Simpson  */
98793ec7edcSShteryana Shopova static void
988ec002feeSBruce M Simpson if_purgemaddrs(struct ifnet *ifp)
989ec002feeSBruce M Simpson {
990ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
991ec002feeSBruce M Simpson 
992137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
993f3e1324bSStephen Hurd 	while (!TAILQ_EMPTY(&ifp->if_multiaddrs)) {
994f3e1324bSStephen Hurd 		ifma = TAILQ_FIRST(&ifp->if_multiaddrs);
995f3e1324bSStephen Hurd 		TAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifma_link);
996ec002feeSBruce M Simpson 		if_delmulti_locked(ifp, ifma, 1);
997f3e1324bSStephen Hurd 	}
998137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
999ec002feeSBruce M Simpson }
1000ec002feeSBruce M Simpson 
1001ec002feeSBruce M Simpson /*
1002e0c14af9SMarko Zec  * Detach an interface, removing it from the list of "active" interfaces.
1003e0c14af9SMarko Zec  * If vmove flag is set on entry to if_detach_internal(), perform only a
1004e0c14af9SMarko Zec  * limited subset of cleanup tasks, given that we are moving an ifnet from
1005e0c14af9SMarko Zec  * one vnet to another, where it must be fully operational.
1006b1c53bc9SRobert Watson  *
1007b1c53bc9SRobert Watson  * XXXRW: There are some significant questions about event ordering, and
1008b1c53bc9SRobert Watson  * how to prevent things from starting to use the interface during detach.
10096182fdbdSPeter Wemm  */
10106182fdbdSPeter Wemm void
101172fd1b6aSDag-Erling Smørgrav if_detach(struct ifnet *ifp)
10126182fdbdSPeter Wemm {
1013e0c14af9SMarko Zec 
1014719fb725SCraig Rodrigues 	CURVNET_SET_QUIET(ifp->if_vnet);
1015c92a456bSHiroki Sato 	if_detach_internal(ifp, 0, NULL);
1016719fb725SCraig Rodrigues 	CURVNET_RESTORE();
1017e0c14af9SMarko Zec }
1018e0c14af9SMarko Zec 
101989856f7eSBjoern A. Zeeb /*
102089856f7eSBjoern A. Zeeb  * The vmove flag, if set, indicates that we are called from a callpath
102189856f7eSBjoern A. Zeeb  * that is moving an interface to a different vnet instance.
102289856f7eSBjoern A. Zeeb  *
102389856f7eSBjoern A. Zeeb  * The shutdown flag, if set, indicates that we are called in the
102489856f7eSBjoern A. Zeeb  * process of shutting down a vnet instance.  Currently only the
102589856f7eSBjoern A. Zeeb  * vnet_if_return SYSUNINIT function sets it.  Note: we can be called
102689856f7eSBjoern A. Zeeb  * on a vnet instance shutdown without this flag being set, e.g., when
102789856f7eSBjoern A. Zeeb  * the cloned interfaces are destoyed as first thing of teardown.
102889856f7eSBjoern A. Zeeb  */
1029f501e6f1SBjoern A. Zeeb static int
1030c92a456bSHiroki Sato if_detach_internal(struct ifnet *ifp, int vmove, struct if_clone **ifcp)
1031e0c14af9SMarko Zec {
103245778b37SPeter Edwards 	struct ifaddr *ifa;
10334bdf0b6aSAlexander V. Chernikov 	int i;
103431b1bfe1SHajimu UMEMOTO 	struct domain *dp;
10353f35d515SPeter Pentchev  	struct ifnet *iter;
1036d3f6f80fSBjoern A. Zeeb  	int found = 0;
1037d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
1038d3f6f80fSBjoern A. Zeeb 	int shutdown;
1039457f48e6SGleb Smirnoff 
104089856f7eSBjoern A. Zeeb 	shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
104189856f7eSBjoern A. Zeeb 		 ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
1042d3f6f80fSBjoern A. Zeeb #endif
1043457f48e6SGleb Smirnoff 	IFNET_WLOCK();
1044603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(iter, &V_ifnet, if_link)
1045457f48e6SGleb Smirnoff 		if (iter == ifp) {
1046603724d3SBjoern A. Zeeb 			TAILQ_REMOVE(&V_ifnet, ifp, if_link);
1047457f48e6SGleb Smirnoff 			found = 1;
1048457f48e6SGleb Smirnoff 			break;
1049457f48e6SGleb Smirnoff 		}
1050457f48e6SGleb Smirnoff 	IFNET_WUNLOCK();
1051e0c14af9SMarko Zec 	if (!found) {
1052f501e6f1SBjoern A. Zeeb 		/*
1053f501e6f1SBjoern A. Zeeb 		 * While we would want to panic here, we cannot
1054f501e6f1SBjoern A. Zeeb 		 * guarantee that the interface is indeed still on
1055f501e6f1SBjoern A. Zeeb 		 * the list given we don't hold locks all the way.
1056f501e6f1SBjoern A. Zeeb 		 */
1057f501e6f1SBjoern A. Zeeb 		return (ENOENT);
1058f501e6f1SBjoern A. Zeeb #if 0
1059e0c14af9SMarko Zec 		if (vmove)
106058606037SBjoern A. Zeeb 			panic("%s: ifp=%p not on the ifnet tailq %p",
106158606037SBjoern A. Zeeb 			    __func__, ifp, &V_ifnet);
1062e0c14af9SMarko Zec 		else
1063e0c14af9SMarko Zec 			return; /* XXX this should panic as well? */
1064f501e6f1SBjoern A. Zeeb #endif
1065e0c14af9SMarko Zec 	}
10666182fdbdSPeter Wemm 
106789856f7eSBjoern A. Zeeb 	/*
106889856f7eSBjoern A. Zeeb 	 * At this point we know the interface still was on the ifnet list
106989856f7eSBjoern A. Zeeb 	 * and we removed it so we are in a stable state.
107089856f7eSBjoern A. Zeeb 	 */
107189856f7eSBjoern A. Zeeb #ifdef VIMAGE
107289856f7eSBjoern A. Zeeb 	curvnet->vnet_ifcnt--;
107389856f7eSBjoern A. Zeeb #endif
107489856f7eSBjoern A. Zeeb 
107589856f7eSBjoern A. Zeeb 	/*
107689856f7eSBjoern A. Zeeb 	 * In any case (destroy or vmove) detach us from the groups
107789856f7eSBjoern A. Zeeb 	 * and remove/wait for pending events on the taskq.
107889856f7eSBjoern A. Zeeb 	 * XXX-BZ in theory an interface could still enqueue a taskq change?
107989856f7eSBjoern A. Zeeb 	 */
108089856f7eSBjoern A. Zeeb 	if_delgroups(ifp);
108189856f7eSBjoern A. Zeeb 
108289856f7eSBjoern A. Zeeb 	taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
108389856f7eSBjoern A. Zeeb 
108489856f7eSBjoern A. Zeeb 	/*
108589856f7eSBjoern A. Zeeb 	 * Check if this is a cloned interface or not. Must do even if
108689856f7eSBjoern A. Zeeb 	 * shutting down as a if_vmove_reclaim() would move the ifp and
108789856f7eSBjoern A. Zeeb 	 * the if_clone_addgroup() will have a corrupted string overwise
108889856f7eSBjoern A. Zeeb 	 * from a gibberish pointer.
108989856f7eSBjoern A. Zeeb 	 */
1090c92a456bSHiroki Sato 	if (vmove && ifcp != NULL)
1091c92a456bSHiroki Sato 		*ifcp = if_clone_findifc(ifp);
1092c92a456bSHiroki Sato 
109389856f7eSBjoern A. Zeeb 	if_down(ifp);
109489856f7eSBjoern A. Zeeb 
1095d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
109668a3482fSGleb Smirnoff 	/*
109789856f7eSBjoern A. Zeeb 	 * On VNET shutdown abort here as the stack teardown will do all
109889856f7eSBjoern A. Zeeb 	 * the work top-down for us.
109968a3482fSGleb Smirnoff 	 */
110089856f7eSBjoern A. Zeeb 	if (shutdown) {
110189856f7eSBjoern A. Zeeb 		/*
110289856f7eSBjoern A. Zeeb 		 * In case of a vmove we are done here without error.
110389856f7eSBjoern A. Zeeb 		 * If we would signal an error it would lead to the same
110489856f7eSBjoern A. Zeeb 		 * abort as if we did not find the ifnet anymore.
110589856f7eSBjoern A. Zeeb 		 * if_detach() calls us in void context and does not care
110689856f7eSBjoern A. Zeeb 		 * about an early abort notification, so life is splendid :)
110789856f7eSBjoern A. Zeeb 		 */
110889856f7eSBjoern A. Zeeb 		goto finish_vnet_shutdown;
110989856f7eSBjoern A. Zeeb 	}
1110d3f6f80fSBjoern A. Zeeb #endif
111189856f7eSBjoern A. Zeeb 
111289856f7eSBjoern A. Zeeb 	/*
111389856f7eSBjoern A. Zeeb 	 * At this point we are not tearing down a VNET and are either
111489856f7eSBjoern A. Zeeb 	 * going to destroy or vmove the interface and have to cleanup
111589856f7eSBjoern A. Zeeb 	 * accordingly.
111689856f7eSBjoern A. Zeeb 	 */
111768a3482fSGleb Smirnoff 
11186182fdbdSPeter Wemm 	/*
11196182fdbdSPeter Wemm 	 * Remove routes and flush queues.
11206182fdbdSPeter Wemm 	 */
112102b199f1SMax Laier #ifdef ALTQ
112202b199f1SMax Laier 	if (ALTQ_IS_ENABLED(&ifp->if_snd))
112302b199f1SMax Laier 		altq_disable(&ifp->if_snd);
112402b199f1SMax Laier 	if (ALTQ_IS_ATTACHED(&ifp->if_snd))
112502b199f1SMax Laier 		altq_detach(&ifp->if_snd);
112602b199f1SMax Laier #endif
11276182fdbdSPeter Wemm 
112845778b37SPeter Edwards 	if_purgeaddrs(ifp);
11296182fdbdSPeter Wemm 
1130b1c53bc9SRobert Watson #ifdef INET
1131b1c53bc9SRobert Watson 	in_ifdetach(ifp);
1132b1c53bc9SRobert Watson #endif
1133b1c53bc9SRobert Watson 
113433841545SHajimu UMEMOTO #ifdef INET6
113533841545SHajimu UMEMOTO 	/*
113633841545SHajimu UMEMOTO 	 * Remove all IPv6 kernel structs related to ifp.  This should be done
113733841545SHajimu UMEMOTO 	 * before removing routing entries below, since IPv6 interface direct
113833841545SHajimu UMEMOTO 	 * routes are expected to be removed by the IPv6-specific kernel API.
113933841545SHajimu UMEMOTO 	 * Otherwise, the kernel will detect some inconsistency and bark it.
114033841545SHajimu UMEMOTO 	 */
114133841545SHajimu UMEMOTO 	in6_ifdetach(ifp);
114233841545SHajimu UMEMOTO #endif
1143ec002feeSBruce M Simpson 	if_purgemaddrs(ifp);
1144ec002feeSBruce M Simpson 
1145af371fc6SRoger Pau Monné 	/* Announce that the interface is gone. */
1146af371fc6SRoger Pau Monné 	rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
1147af371fc6SRoger Pau Monné 	EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
1148af371fc6SRoger Pau Monné 	if (IS_DEFAULT_VNET(curvnet))
1149af371fc6SRoger Pau Monné 		devctl_notify("IFNET", ifp->if_xname, "DETACH", NULL);
1150af371fc6SRoger Pau Monné 
1151e0c14af9SMarko Zec 	if (!vmove) {
1152f4247b59SLuigi Rizzo 		/*
1153111c6b61SRobert Watson 		 * Prevent further calls into the device driver via ifnet.
1154111c6b61SRobert Watson 		 */
1155111c6b61SRobert Watson 		if_dead(ifp);
1156111c6b61SRobert Watson 
1157111c6b61SRobert Watson 		/*
11584a0d6638SRuslan Ermilov 		 * Remove link ifaddr pointer and maybe decrement if_index.
1159f4247b59SLuigi Rizzo 		 * Clean up all addresses.
1160f4247b59SLuigi Rizzo 		 */
1161ddae5750SRavi Pokala 		free(ifp->if_hw_addr, M_IFADDR);
1162ddae5750SRavi Pokala 		ifp->if_hw_addr = NULL;
11634a0d6638SRuslan Ermilov 		ifp->if_addr = NULL;
1164f4247b59SLuigi Rizzo 
1165212bd869SHajimu UMEMOTO 		/* We can now free link ifaddr. */
1166d117fd80SBjoern A. Zeeb 		IF_ADDR_WLOCK(ifp);
11673f35d515SPeter Pentchev 		if (!TAILQ_EMPTY(&ifp->if_addrhead)) {
1168212bd869SHajimu UMEMOTO 			ifa = TAILQ_FIRST(&ifp->if_addrhead);
1169212bd869SHajimu UMEMOTO 			TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link);
1170d117fd80SBjoern A. Zeeb 			IF_ADDR_WUNLOCK(ifp);
11711099f828SRobert Watson 			ifa_free(ifa);
1172d117fd80SBjoern A. Zeeb 		} else
1173d117fd80SBjoern A. Zeeb 			IF_ADDR_WUNLOCK(ifp);
1174e0c14af9SMarko Zec 	}
1175212bd869SHajimu UMEMOTO 
11764bdf0b6aSAlexander V. Chernikov 	rt_flushifroutes(ifp);
11777b6edd04SRuslan Ermilov 
1178d3f6f80fSBjoern A. Zeeb #ifdef VIMAGE
117989856f7eSBjoern A. Zeeb finish_vnet_shutdown:
1180d3f6f80fSBjoern A. Zeeb #endif
1181d8c13659SBjoern A. Zeeb 	/*
1182d8c13659SBjoern A. Zeeb 	 * We cannot hold the lock over dom_ifdetach calls as they might
1183d8c13659SBjoern A. Zeeb 	 * sleep, for example trying to drain a callout, thus open up the
1184d8c13659SBjoern A. Zeeb 	 * theoretical race with re-attaching.
1185d8c13659SBjoern A. Zeeb 	 */
1186234a35c7SHajimu UMEMOTO 	IF_AFDATA_LOCK(ifp);
1187d8c13659SBjoern A. Zeeb 	i = ifp->if_afdata_initialized;
1188d8c13659SBjoern A. Zeeb 	ifp->if_afdata_initialized = 0;
1189d8c13659SBjoern A. Zeeb 	IF_AFDATA_UNLOCK(ifp);
1190d8c13659SBjoern A. Zeeb 	for (dp = domains; i > 0 && dp; dp = dp->dom_next) {
11912d5ad99aSBjoern A. Zeeb 		if (dp->dom_ifdetach && ifp->if_afdata[dp->dom_family]) {
119231b1bfe1SHajimu UMEMOTO 			(*dp->dom_ifdetach)(ifp,
119331b1bfe1SHajimu UMEMOTO 			    ifp->if_afdata[dp->dom_family]);
11942d5ad99aSBjoern A. Zeeb 			ifp->if_afdata[dp->dom_family] = NULL;
11952d5ad99aSBjoern A. Zeeb 		}
119631b1bfe1SHajimu UMEMOTO 	}
1197f501e6f1SBjoern A. Zeeb 
1198f501e6f1SBjoern A. Zeeb 	return (0);
11995500d3beSWarner Losh }
12005500d3beSWarner Losh 
1201e0c14af9SMarko Zec #ifdef VIMAGE
1202e0c14af9SMarko Zec /*
1203e0c14af9SMarko Zec  * if_vmove() performs a limited version of if_detach() in current
1204e0c14af9SMarko Zec  * vnet and if_attach()es the ifnet to the vnet specified as 2nd arg.
1205e0c14af9SMarko Zec  * An attempt is made to shrink if_index in current vnet, find an
1206e0c14af9SMarko Zec  * unused if_index in target vnet and calls if_grow() if necessary,
1207e0c14af9SMarko Zec  * and finally find an unused if_xname for the target vnet.
1208e0c14af9SMarko Zec  */
120989856f7eSBjoern A. Zeeb static void
1210e0c14af9SMarko Zec if_vmove(struct ifnet *ifp, struct vnet *new_vnet)
1211e0c14af9SMarko Zec {
1212c92a456bSHiroki Sato 	struct if_clone *ifc;
121305fc4164SBjoern A. Zeeb 	u_int bif_dlt, bif_hdrlen;
1214f501e6f1SBjoern A. Zeeb 	int rc;
1215e0c14af9SMarko Zec 
1216e0c14af9SMarko Zec  	/*
121705fc4164SBjoern A. Zeeb 	 * if_detach_internal() will call the eventhandler to notify
121805fc4164SBjoern A. Zeeb 	 * interface departure.  That will detach if_bpf.  We need to
121905fc4164SBjoern A. Zeeb 	 * safe the dlt and hdrlen so we can re-attach it later.
122005fc4164SBjoern A. Zeeb 	 */
122105fc4164SBjoern A. Zeeb 	bpf_get_bp_params(ifp->if_bpf, &bif_dlt, &bif_hdrlen);
122205fc4164SBjoern A. Zeeb 
122305fc4164SBjoern A. Zeeb 	/*
1224e0c14af9SMarko Zec 	 * Detach from current vnet, but preserve LLADDR info, do not
1225e0c14af9SMarko Zec 	 * mark as dead etc. so that the ifnet can be reattached later.
1226f501e6f1SBjoern A. Zeeb 	 * If we cannot find it, we lost the race to someone else.
1227e0c14af9SMarko Zec 	 */
1228f501e6f1SBjoern A. Zeeb 	rc = if_detach_internal(ifp, 1, &ifc);
1229f501e6f1SBjoern A. Zeeb 	if (rc != 0)
1230f501e6f1SBjoern A. Zeeb 		return;
1231e0c14af9SMarko Zec 
1232e0c14af9SMarko Zec 	/*
123377dfcdc4SRobert Watson 	 * Unlink the ifnet from ifindex_table[] in current vnet, and shrink
123477dfcdc4SRobert Watson 	 * the if_index for that vnet if possible.
123577dfcdc4SRobert Watson 	 *
123677dfcdc4SRobert Watson 	 * NOTE: IFNET_WLOCK/IFNET_WUNLOCK() are assumed to be unvirtualized,
123777dfcdc4SRobert Watson 	 * or we'd lock on one vnet and unlock on another.
1238e0c14af9SMarko Zec 	 */
1239e0c14af9SMarko Zec 	IFNET_WLOCK();
1240ed2dabfcSRobert Watson 	ifindex_free_locked(ifp->if_index);
1241d3c351c5SMarko Zec 	IFNET_WUNLOCK();
1242d3c351c5SMarko Zec 
1243d3c351c5SMarko Zec 	/*
1244d3c351c5SMarko Zec 	 * Perform interface-specific reassignment tasks, if provided by
1245d3c351c5SMarko Zec 	 * the driver.
1246d3c351c5SMarko Zec 	 */
1247d3c351c5SMarko Zec 	if (ifp->if_reassign != NULL)
1248d3c351c5SMarko Zec 		ifp->if_reassign(ifp, new_vnet, NULL);
1249e0c14af9SMarko Zec 
1250e0c14af9SMarko Zec 	/*
1251e0c14af9SMarko Zec 	 * Switch to the context of the target vnet.
1252e0c14af9SMarko Zec 	 */
1253e0c14af9SMarko Zec 	CURVNET_SET_QUIET(new_vnet);
1254e0c14af9SMarko Zec 
1255d3c351c5SMarko Zec 	IFNET_WLOCK();
1256f4507b71SGleb Smirnoff 	ifp->if_index = ifindex_alloc();
125777dfcdc4SRobert Watson 	ifnet_setbyindex_locked(ifp->if_index, ifp);
1258e0c14af9SMarko Zec 	IFNET_WUNLOCK();
1259e0c14af9SMarko Zec 
1260c92a456bSHiroki Sato 	if_attach_internal(ifp, 1, ifc);
1261e0c14af9SMarko Zec 
126205fc4164SBjoern A. Zeeb 	if (ifp->if_bpf == NULL)
126305fc4164SBjoern A. Zeeb 		bpfattach(ifp, bif_dlt, bif_hdrlen);
126405fc4164SBjoern A. Zeeb 
1265e0c14af9SMarko Zec 	CURVNET_RESTORE();
1266e0c14af9SMarko Zec }
1267be31e5e7SBjoern A. Zeeb 
1268be31e5e7SBjoern A. Zeeb /*
1269be31e5e7SBjoern A. Zeeb  * Move an ifnet to or from another child prison/vnet, specified by the jail id.
1270be31e5e7SBjoern A. Zeeb  */
1271be31e5e7SBjoern A. Zeeb static int
1272be31e5e7SBjoern A. Zeeb if_vmove_loan(struct thread *td, struct ifnet *ifp, char *ifname, int jid)
1273be31e5e7SBjoern A. Zeeb {
1274be31e5e7SBjoern A. Zeeb 	struct prison *pr;
1275be31e5e7SBjoern A. Zeeb 	struct ifnet *difp;
127689856f7eSBjoern A. Zeeb 	int shutdown;
1277be31e5e7SBjoern A. Zeeb 
1278be31e5e7SBjoern A. Zeeb 	/* Try to find the prison within our visibility. */
1279be31e5e7SBjoern A. Zeeb 	sx_slock(&allprison_lock);
1280be31e5e7SBjoern A. Zeeb 	pr = prison_find_child(td->td_ucred->cr_prison, jid);
1281be31e5e7SBjoern A. Zeeb 	sx_sunlock(&allprison_lock);
1282be31e5e7SBjoern A. Zeeb 	if (pr == NULL)
1283be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1284be31e5e7SBjoern A. Zeeb 	prison_hold_locked(pr);
1285be31e5e7SBjoern A. Zeeb 	mtx_unlock(&pr->pr_mtx);
1286be31e5e7SBjoern A. Zeeb 
1287be31e5e7SBjoern A. Zeeb 	/* Do not try to move the iface from and to the same prison. */
1288be31e5e7SBjoern A. Zeeb 	if (pr->pr_vnet == ifp->if_vnet) {
1289be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1290be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1291be31e5e7SBjoern A. Zeeb 	}
1292be31e5e7SBjoern A. Zeeb 
1293be31e5e7SBjoern A. Zeeb 	/* Make sure the named iface does not exists in the dst. prison/vnet. */
1294be31e5e7SBjoern A. Zeeb 	/* XXX Lock interfaces to avoid races. */
12959abb4862SMarko Zec 	CURVNET_SET_QUIET(pr->pr_vnet);
1296be31e5e7SBjoern A. Zeeb 	difp = ifunit(ifname);
1297be31e5e7SBjoern A. Zeeb 	if (difp != NULL) {
129889856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
1299be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1300be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1301be31e5e7SBjoern A. Zeeb 	}
1302be31e5e7SBjoern A. Zeeb 
130389856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
130489856f7eSBjoern A. Zeeb 	shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
130589856f7eSBjoern A. Zeeb 		 ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
130689856f7eSBjoern A. Zeeb 	if (shutdown) {
130789856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
130889856f7eSBjoern A. Zeeb 		prison_free(pr);
130989856f7eSBjoern A. Zeeb 		return (EBUSY);
131089856f7eSBjoern A. Zeeb 	}
131189856f7eSBjoern A. Zeeb 	CURVNET_RESTORE();
131289856f7eSBjoern A. Zeeb 
1313be31e5e7SBjoern A. Zeeb 	/* Move the interface into the child jail/vnet. */
1314be31e5e7SBjoern A. Zeeb 	if_vmove(ifp, pr->pr_vnet);
1315be31e5e7SBjoern A. Zeeb 
1316be31e5e7SBjoern A. Zeeb 	/* Report the new if_xname back to the userland. */
1317be31e5e7SBjoern A. Zeeb 	sprintf(ifname, "%s", ifp->if_xname);
1318be31e5e7SBjoern A. Zeeb 
1319be31e5e7SBjoern A. Zeeb 	prison_free(pr);
1320be31e5e7SBjoern A. Zeeb 	return (0);
1321be31e5e7SBjoern A. Zeeb }
1322be31e5e7SBjoern A. Zeeb 
1323be31e5e7SBjoern A. Zeeb static int
1324be31e5e7SBjoern A. Zeeb if_vmove_reclaim(struct thread *td, char *ifname, int jid)
1325be31e5e7SBjoern A. Zeeb {
1326be31e5e7SBjoern A. Zeeb 	struct prison *pr;
1327be31e5e7SBjoern A. Zeeb 	struct vnet *vnet_dst;
1328be31e5e7SBjoern A. Zeeb 	struct ifnet *ifp;
132989856f7eSBjoern A. Zeeb  	int shutdown;
1330be31e5e7SBjoern A. Zeeb 
1331be31e5e7SBjoern A. Zeeb 	/* Try to find the prison within our visibility. */
1332be31e5e7SBjoern A. Zeeb 	sx_slock(&allprison_lock);
1333be31e5e7SBjoern A. Zeeb 	pr = prison_find_child(td->td_ucred->cr_prison, jid);
1334be31e5e7SBjoern A. Zeeb 	sx_sunlock(&allprison_lock);
1335be31e5e7SBjoern A. Zeeb 	if (pr == NULL)
1336be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1337be31e5e7SBjoern A. Zeeb 	prison_hold_locked(pr);
1338be31e5e7SBjoern A. Zeeb 	mtx_unlock(&pr->pr_mtx);
1339be31e5e7SBjoern A. Zeeb 
1340be31e5e7SBjoern A. Zeeb 	/* Make sure the named iface exists in the source prison/vnet. */
1341be31e5e7SBjoern A. Zeeb 	CURVNET_SET(pr->pr_vnet);
1342be31e5e7SBjoern A. Zeeb 	ifp = ifunit(ifname);		/* XXX Lock to avoid races. */
1343be31e5e7SBjoern A. Zeeb 	if (ifp == NULL) {
1344be31e5e7SBjoern A. Zeeb 		CURVNET_RESTORE();
1345be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1346be31e5e7SBjoern A. Zeeb 		return (ENXIO);
1347be31e5e7SBjoern A. Zeeb 	}
1348be31e5e7SBjoern A. Zeeb 
1349be31e5e7SBjoern A. Zeeb 	/* Do not try to move the iface from and to the same prison. */
1350be31e5e7SBjoern A. Zeeb 	vnet_dst = TD_TO_VNET(td);
1351be31e5e7SBjoern A. Zeeb 	if (vnet_dst == ifp->if_vnet) {
1352be31e5e7SBjoern A. Zeeb 		CURVNET_RESTORE();
1353be31e5e7SBjoern A. Zeeb 		prison_free(pr);
1354be31e5e7SBjoern A. Zeeb 		return (EEXIST);
1355be31e5e7SBjoern A. Zeeb 	}
1356be31e5e7SBjoern A. Zeeb 
135789856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
135889856f7eSBjoern A. Zeeb 	shutdown = (ifp->if_vnet->vnet_state > SI_SUB_VNET &&
135989856f7eSBjoern A. Zeeb 		 ifp->if_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
136089856f7eSBjoern A. Zeeb 	if (shutdown) {
136189856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
136289856f7eSBjoern A. Zeeb 		prison_free(pr);
136389856f7eSBjoern A. Zeeb 		return (EBUSY);
136489856f7eSBjoern A. Zeeb 	}
136589856f7eSBjoern A. Zeeb 
1366be31e5e7SBjoern A. Zeeb 	/* Get interface back from child jail/vnet. */
1367be31e5e7SBjoern A. Zeeb 	if_vmove(ifp, vnet_dst);
1368be31e5e7SBjoern A. Zeeb 	CURVNET_RESTORE();
1369be31e5e7SBjoern A. Zeeb 
1370be31e5e7SBjoern A. Zeeb 	/* Report the new if_xname back to the userland. */
1371be31e5e7SBjoern A. Zeeb 	sprintf(ifname, "%s", ifp->if_xname);
1372be31e5e7SBjoern A. Zeeb 
1373be31e5e7SBjoern A. Zeeb 	prison_free(pr);
1374be31e5e7SBjoern A. Zeeb 	return (0);
1375be31e5e7SBjoern A. Zeeb }
1376e0c14af9SMarko Zec #endif /* VIMAGE */
1377e0c14af9SMarko Zec 
13785500d3beSWarner Losh /*
13790dad3f0eSMax Laier  * Add a group to an interface
13800dad3f0eSMax Laier  */
13810dad3f0eSMax Laier int
13820dad3f0eSMax Laier if_addgroup(struct ifnet *ifp, const char *groupname)
13830dad3f0eSMax Laier {
13840dad3f0eSMax Laier 	struct ifg_list		*ifgl;
13850dad3f0eSMax Laier 	struct ifg_group	*ifg = NULL;
13860dad3f0eSMax Laier 	struct ifg_member	*ifgm;
1387d6d3f01eSGleb Smirnoff 	int 			 new = 0;
13880dad3f0eSMax Laier 
13890dad3f0eSMax Laier 	if (groupname[0] && groupname[strlen(groupname) - 1] >= '0' &&
13900dad3f0eSMax Laier 	    groupname[strlen(groupname) - 1] <= '9')
13910dad3f0eSMax Laier 		return (EINVAL);
13920dad3f0eSMax Laier 
13930dad3f0eSMax Laier 	IFNET_WLOCK();
13940dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
13950dad3f0eSMax Laier 		if (!strcmp(ifgl->ifgl_group->ifg_group, groupname)) {
13960dad3f0eSMax Laier 			IFNET_WUNLOCK();
13970dad3f0eSMax Laier 			return (EEXIST);
13980dad3f0eSMax Laier 		}
13990dad3f0eSMax Laier 
14000dad3f0eSMax Laier 	if ((ifgl = (struct ifg_list *)malloc(sizeof(struct ifg_list), M_TEMP,
14010dad3f0eSMax Laier 	    M_NOWAIT)) == NULL) {
14020dad3f0eSMax Laier 	    	IFNET_WUNLOCK();
14030dad3f0eSMax Laier 		return (ENOMEM);
14040dad3f0eSMax Laier 	}
14050dad3f0eSMax Laier 
14060dad3f0eSMax Laier 	if ((ifgm = (struct ifg_member *)malloc(sizeof(struct ifg_member),
14070dad3f0eSMax Laier 	    M_TEMP, M_NOWAIT)) == NULL) {
14080dad3f0eSMax Laier 		free(ifgl, M_TEMP);
14090dad3f0eSMax Laier 		IFNET_WUNLOCK();
14100dad3f0eSMax Laier 		return (ENOMEM);
14110dad3f0eSMax Laier 	}
14120dad3f0eSMax Laier 
1413603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
14140dad3f0eSMax Laier 		if (!strcmp(ifg->ifg_group, groupname))
14150dad3f0eSMax Laier 			break;
14160dad3f0eSMax Laier 
14170dad3f0eSMax Laier 	if (ifg == NULL) {
14180dad3f0eSMax Laier 		if ((ifg = (struct ifg_group *)malloc(sizeof(struct ifg_group),
14190dad3f0eSMax Laier 		    M_TEMP, M_NOWAIT)) == NULL) {
14200dad3f0eSMax Laier 			free(ifgl, M_TEMP);
14210dad3f0eSMax Laier 			free(ifgm, M_TEMP);
14220dad3f0eSMax Laier 			IFNET_WUNLOCK();
14230dad3f0eSMax Laier 			return (ENOMEM);
14240dad3f0eSMax Laier 		}
14250dad3f0eSMax Laier 		strlcpy(ifg->ifg_group, groupname, sizeof(ifg->ifg_group));
14260dad3f0eSMax Laier 		ifg->ifg_refcnt = 0;
14270dad3f0eSMax Laier 		TAILQ_INIT(&ifg->ifg_members);
1428603724d3SBjoern A. Zeeb 		TAILQ_INSERT_TAIL(&V_ifg_head, ifg, ifg_next);
1429d6d3f01eSGleb Smirnoff 		new = 1;
14300dad3f0eSMax Laier 	}
14310dad3f0eSMax Laier 
14320dad3f0eSMax Laier 	ifg->ifg_refcnt++;
14330dad3f0eSMax Laier 	ifgl->ifgl_group = ifg;
14340dad3f0eSMax Laier 	ifgm->ifgm_ifp = ifp;
14350dad3f0eSMax Laier 
1436137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
14370dad3f0eSMax Laier 	TAILQ_INSERT_TAIL(&ifg->ifg_members, ifgm, ifgm_next);
14380dad3f0eSMax Laier 	TAILQ_INSERT_TAIL(&ifp->if_groups, ifgl, ifgl_next);
1439137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
14400dad3f0eSMax Laier 
14410dad3f0eSMax Laier 	IFNET_WUNLOCK();
14420dad3f0eSMax Laier 
1443d6d3f01eSGleb Smirnoff 	if (new)
1444d6d3f01eSGleb Smirnoff 		EVENTHANDLER_INVOKE(group_attach_event, ifg);
14450dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
14460dad3f0eSMax Laier 
14470dad3f0eSMax Laier 	return (0);
14480dad3f0eSMax Laier }
14490dad3f0eSMax Laier 
14500dad3f0eSMax Laier /*
14510dad3f0eSMax Laier  * Remove a group from an interface
14520dad3f0eSMax Laier  */
14530dad3f0eSMax Laier int
14540dad3f0eSMax Laier if_delgroup(struct ifnet *ifp, const char *groupname)
14550dad3f0eSMax Laier {
14560dad3f0eSMax Laier 	struct ifg_list		*ifgl;
14570dad3f0eSMax Laier 	struct ifg_member	*ifgm;
14580dad3f0eSMax Laier 
14590dad3f0eSMax Laier 	IFNET_WLOCK();
14600dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
14610dad3f0eSMax Laier 		if (!strcmp(ifgl->ifgl_group->ifg_group, groupname))
14620dad3f0eSMax Laier 			break;
14630dad3f0eSMax Laier 	if (ifgl == NULL) {
14640dad3f0eSMax Laier 		IFNET_WUNLOCK();
14650dad3f0eSMax Laier 		return (ENOENT);
14660dad3f0eSMax Laier 	}
14670dad3f0eSMax Laier 
1468137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
14690dad3f0eSMax Laier 	TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
1470137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
14710dad3f0eSMax Laier 
14720dad3f0eSMax Laier 	TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
14730dad3f0eSMax Laier 		if (ifgm->ifgm_ifp == ifp)
14740dad3f0eSMax Laier 			break;
14750dad3f0eSMax Laier 
14760dad3f0eSMax Laier 	if (ifgm != NULL) {
14770dad3f0eSMax Laier 		TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm, ifgm_next);
14780dad3f0eSMax Laier 		free(ifgm, M_TEMP);
14790dad3f0eSMax Laier 	}
14800dad3f0eSMax Laier 
14810dad3f0eSMax Laier 	if (--ifgl->ifgl_group->ifg_refcnt == 0) {
1482603724d3SBjoern A. Zeeb 		TAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_next);
1483d6d3f01eSGleb Smirnoff 		IFNET_WUNLOCK();
14840dad3f0eSMax Laier 		EVENTHANDLER_INVOKE(group_detach_event, ifgl->ifgl_group);
14850dad3f0eSMax Laier 		free(ifgl->ifgl_group, M_TEMP);
1486d6d3f01eSGleb Smirnoff 	} else
14870dad3f0eSMax Laier 		IFNET_WUNLOCK();
14880dad3f0eSMax Laier 
14890dad3f0eSMax Laier 	free(ifgl, M_TEMP);
14900dad3f0eSMax Laier 
14910dad3f0eSMax Laier 	EVENTHANDLER_INVOKE(group_change_event, groupname);
14920dad3f0eSMax Laier 
14930dad3f0eSMax Laier 	return (0);
14940dad3f0eSMax Laier }
14950dad3f0eSMax Laier 
14960dad3f0eSMax Laier /*
14978623f9fdSMax Laier  * Remove an interface from all groups
14988623f9fdSMax Laier  */
14998623f9fdSMax Laier static void
15008623f9fdSMax Laier if_delgroups(struct ifnet *ifp)
15018623f9fdSMax Laier {
15028623f9fdSMax Laier 	struct ifg_list		*ifgl;
15038623f9fdSMax Laier 	struct ifg_member	*ifgm;
15048623f9fdSMax Laier 	char groupname[IFNAMSIZ];
15058623f9fdSMax Laier 
15068623f9fdSMax Laier 	IFNET_WLOCK();
15078623f9fdSMax Laier 	while (!TAILQ_EMPTY(&ifp->if_groups)) {
15088623f9fdSMax Laier 		ifgl = TAILQ_FIRST(&ifp->if_groups);
15098623f9fdSMax Laier 
15108623f9fdSMax Laier 		strlcpy(groupname, ifgl->ifgl_group->ifg_group, IFNAMSIZ);
15118623f9fdSMax Laier 
1512137f91e8SJohn Baldwin 		IF_ADDR_WLOCK(ifp);
15138623f9fdSMax Laier 		TAILQ_REMOVE(&ifp->if_groups, ifgl, ifgl_next);
1514137f91e8SJohn Baldwin 		IF_ADDR_WUNLOCK(ifp);
15158623f9fdSMax Laier 
15168623f9fdSMax Laier 		TAILQ_FOREACH(ifgm, &ifgl->ifgl_group->ifg_members, ifgm_next)
15178623f9fdSMax Laier 			if (ifgm->ifgm_ifp == ifp)
15188623f9fdSMax Laier 				break;
15198623f9fdSMax Laier 
15208623f9fdSMax Laier 		if (ifgm != NULL) {
15218623f9fdSMax Laier 			TAILQ_REMOVE(&ifgl->ifgl_group->ifg_members, ifgm,
15228623f9fdSMax Laier 			    ifgm_next);
15238623f9fdSMax Laier 			free(ifgm, M_TEMP);
15248623f9fdSMax Laier 		}
15258623f9fdSMax Laier 
15268623f9fdSMax Laier 		if (--ifgl->ifgl_group->ifg_refcnt == 0) {
15278623f9fdSMax Laier 			TAILQ_REMOVE(&V_ifg_head, ifgl->ifgl_group, ifg_next);
1528d6d3f01eSGleb Smirnoff 			IFNET_WUNLOCK();
15298623f9fdSMax Laier 			EVENTHANDLER_INVOKE(group_detach_event,
15308623f9fdSMax Laier 			    ifgl->ifgl_group);
15318623f9fdSMax Laier 			free(ifgl->ifgl_group, M_TEMP);
1532d6d3f01eSGleb Smirnoff 		} else
15338623f9fdSMax Laier 			IFNET_WUNLOCK();
15348623f9fdSMax Laier 
15358623f9fdSMax Laier 		free(ifgl, M_TEMP);
15368623f9fdSMax Laier 
15378623f9fdSMax Laier 		EVENTHANDLER_INVOKE(group_change_event, groupname);
15388623f9fdSMax Laier 
15398623f9fdSMax Laier 		IFNET_WLOCK();
15408623f9fdSMax Laier 	}
15418623f9fdSMax Laier 	IFNET_WUNLOCK();
15428623f9fdSMax Laier }
15438623f9fdSMax Laier 
1544756181b8SBrooks Davis static char *
1545756181b8SBrooks Davis ifgr_group_get(void *ifgrp)
1546756181b8SBrooks Davis {
1547756181b8SBrooks Davis 	union ifgroupreq_union *ifgrup;
1548756181b8SBrooks Davis 
1549756181b8SBrooks Davis 	ifgrup = ifgrp;
1550756181b8SBrooks Davis #ifdef COMPAT_FREEBSD32
1551756181b8SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
1552756181b8SBrooks Davis 		return (&ifgrup->ifgr32.ifgr_ifgru.ifgru_group[0]);
1553756181b8SBrooks Davis #endif
1554756181b8SBrooks Davis 	return (&ifgrup->ifgr.ifgr_ifgru.ifgru_group[0]);
1555756181b8SBrooks Davis }
1556756181b8SBrooks Davis 
1557756181b8SBrooks Davis static struct ifg_req *
1558756181b8SBrooks Davis ifgr_groups_get(void *ifgrp)
1559756181b8SBrooks Davis {
1560756181b8SBrooks Davis 	union ifgroupreq_union *ifgrup;
1561756181b8SBrooks Davis 
1562756181b8SBrooks Davis 	ifgrup = ifgrp;
1563756181b8SBrooks Davis #ifdef COMPAT_FREEBSD32
1564756181b8SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
1565756181b8SBrooks Davis 		return ((struct ifg_req *)(uintptr_t)
1566756181b8SBrooks Davis 		    ifgrup->ifgr32.ifgr_ifgru.ifgru_groups);
1567756181b8SBrooks Davis #endif
1568756181b8SBrooks Davis 	return (ifgrup->ifgr.ifgr_ifgru.ifgru_groups);
1569756181b8SBrooks Davis }
1570756181b8SBrooks Davis 
15718623f9fdSMax Laier /*
1572756181b8SBrooks Davis  * Stores all groups from an interface in memory pointed to by ifgr.
15730dad3f0eSMax Laier  */
15740dad3f0eSMax Laier static int
1575756181b8SBrooks Davis if_getgroup(struct ifgroupreq *ifgr, struct ifnet *ifp)
15760dad3f0eSMax Laier {
15770dad3f0eSMax Laier 	int			 len, error;
15780dad3f0eSMax Laier 	struct ifg_list		*ifgl;
15790dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
15800dad3f0eSMax Laier 
15810dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
1582137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
15830dad3f0eSMax Laier 		TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next)
15840dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(struct ifg_req);
1585137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
15860dad3f0eSMax Laier 		return (0);
15870dad3f0eSMax Laier 	}
15880dad3f0eSMax Laier 
15890dad3f0eSMax Laier 	len = ifgr->ifgr_len;
1590756181b8SBrooks Davis 	ifgp = ifgr_groups_get(ifgr);
15910dad3f0eSMax Laier 	/* XXX: wire */
1592137f91e8SJohn Baldwin 	IF_ADDR_RLOCK(ifp);
15930dad3f0eSMax Laier 	TAILQ_FOREACH(ifgl, &ifp->if_groups, ifgl_next) {
15940dad3f0eSMax Laier 		if (len < sizeof(ifgrq)) {
1595137f91e8SJohn Baldwin 			IF_ADDR_RUNLOCK(ifp);
15960dad3f0eSMax Laier 			return (EINVAL);
15970dad3f0eSMax Laier 		}
15980dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
15990dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_group, ifgl->ifgl_group->ifg_group,
16000dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_group));
16010dad3f0eSMax Laier 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
1602137f91e8SJohn Baldwin 		    	IF_ADDR_RUNLOCK(ifp);
16030dad3f0eSMax Laier 			return (error);
16040dad3f0eSMax Laier 		}
16050dad3f0eSMax Laier 		len -= sizeof(ifgrq);
16060dad3f0eSMax Laier 		ifgp++;
16070dad3f0eSMax Laier 	}
1608137f91e8SJohn Baldwin 	IF_ADDR_RUNLOCK(ifp);
16090dad3f0eSMax Laier 
16100dad3f0eSMax Laier 	return (0);
16110dad3f0eSMax Laier }
16120dad3f0eSMax Laier 
16130dad3f0eSMax Laier /*
1614756181b8SBrooks Davis  * Stores all members of a group in memory pointed to by igfr
16150dad3f0eSMax Laier  */
16160dad3f0eSMax Laier static int
1617756181b8SBrooks Davis if_getgroupmembers(struct ifgroupreq *ifgr)
16180dad3f0eSMax Laier {
16190dad3f0eSMax Laier 	struct ifg_group	*ifg;
16200dad3f0eSMax Laier 	struct ifg_member	*ifgm;
16210dad3f0eSMax Laier 	struct ifg_req		 ifgrq, *ifgp;
16220dad3f0eSMax Laier 	int			 len, error;
16230dad3f0eSMax Laier 
16240dad3f0eSMax Laier 	IFNET_RLOCK();
1625603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifg, &V_ifg_head, ifg_next)
16260dad3f0eSMax Laier 		if (!strcmp(ifg->ifg_group, ifgr->ifgr_name))
16270dad3f0eSMax Laier 			break;
16280dad3f0eSMax Laier 	if (ifg == NULL) {
16290dad3f0eSMax Laier 		IFNET_RUNLOCK();
16300dad3f0eSMax Laier 		return (ENOENT);
16310dad3f0eSMax Laier 	}
16320dad3f0eSMax Laier 
16330dad3f0eSMax Laier 	if (ifgr->ifgr_len == 0) {
16340dad3f0eSMax Laier 		TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next)
16350dad3f0eSMax Laier 			ifgr->ifgr_len += sizeof(ifgrq);
16360dad3f0eSMax Laier 		IFNET_RUNLOCK();
16370dad3f0eSMax Laier 		return (0);
16380dad3f0eSMax Laier 	}
16390dad3f0eSMax Laier 
16400dad3f0eSMax Laier 	len = ifgr->ifgr_len;
1641756181b8SBrooks Davis 	ifgp = ifgr_groups_get(ifgr);
16420dad3f0eSMax Laier 	TAILQ_FOREACH(ifgm, &ifg->ifg_members, ifgm_next) {
16430dad3f0eSMax Laier 		if (len < sizeof(ifgrq)) {
16440dad3f0eSMax Laier 			IFNET_RUNLOCK();
16450dad3f0eSMax Laier 			return (EINVAL);
16460dad3f0eSMax Laier 		}
16470dad3f0eSMax Laier 		bzero(&ifgrq, sizeof ifgrq);
16480dad3f0eSMax Laier 		strlcpy(ifgrq.ifgrq_member, ifgm->ifgm_ifp->if_xname,
16490dad3f0eSMax Laier 		    sizeof(ifgrq.ifgrq_member));
16500dad3f0eSMax Laier 		if ((error = copyout(&ifgrq, ifgp, sizeof(struct ifg_req)))) {
16510dad3f0eSMax Laier 			IFNET_RUNLOCK();
16520dad3f0eSMax Laier 			return (error);
16530dad3f0eSMax Laier 		}
16540dad3f0eSMax Laier 		len -= sizeof(ifgrq);
16550dad3f0eSMax Laier 		ifgp++;
16560dad3f0eSMax Laier 	}
16570dad3f0eSMax Laier 	IFNET_RUNLOCK();
16580dad3f0eSMax Laier 
16590dad3f0eSMax Laier 	return (0);
16600dad3f0eSMax Laier }
16610dad3f0eSMax Laier 
16620dad3f0eSMax Laier /*
1663112f50ffSGleb Smirnoff  * Return counter values from counter(9)s stored in ifnet.
1664e6485f73SGleb Smirnoff  */
1665e6485f73SGleb Smirnoff uint64_t
16661b7fb1d9SGleb Smirnoff if_get_counter_default(struct ifnet *ifp, ift_counter cnt)
1667e6485f73SGleb Smirnoff {
1668e6485f73SGleb Smirnoff 
1669112f50ffSGleb Smirnoff 	KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1670112f50ffSGleb Smirnoff 
1671112f50ffSGleb Smirnoff 	return (counter_u64_fetch(ifp->if_counters[cnt]));
1672e6485f73SGleb Smirnoff }
1673e6485f73SGleb Smirnoff 
1674e6485f73SGleb Smirnoff /*
16750b7b006cSGleb Smirnoff  * Increase an ifnet counter. Usually used for counters shared
16760b7b006cSGleb Smirnoff  * between the stack and a driver, but function supports them all.
16770b7b006cSGleb Smirnoff  */
16780b7b006cSGleb Smirnoff void
16791b7fb1d9SGleb Smirnoff if_inc_counter(struct ifnet *ifp, ift_counter cnt, int64_t inc)
16800b7b006cSGleb Smirnoff {
16810b7b006cSGleb Smirnoff 
1682112f50ffSGleb Smirnoff 	KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1683112f50ffSGleb Smirnoff 
1684112f50ffSGleb Smirnoff 	counter_u64_add(ifp->if_counters[cnt], inc);
16850b7b006cSGleb Smirnoff }
16860b7b006cSGleb Smirnoff 
16870b7b006cSGleb Smirnoff /*
1688e6485f73SGleb Smirnoff  * Copy data from ifnet to userland API structure if_data.
1689e6485f73SGleb Smirnoff  */
1690e6485f73SGleb Smirnoff void
1691e6485f73SGleb Smirnoff if_data_copy(struct ifnet *ifp, struct if_data *ifd)
1692e6485f73SGleb Smirnoff {
1693e6485f73SGleb Smirnoff 
1694e6485f73SGleb Smirnoff 	ifd->ifi_type = ifp->if_type;
1695e6485f73SGleb Smirnoff 	ifd->ifi_physical = 0;
1696e6485f73SGleb Smirnoff 	ifd->ifi_addrlen = ifp->if_addrlen;
1697e6485f73SGleb Smirnoff 	ifd->ifi_hdrlen = ifp->if_hdrlen;
1698e6485f73SGleb Smirnoff 	ifd->ifi_link_state = ifp->if_link_state;
1699e6485f73SGleb Smirnoff 	ifd->ifi_vhid = 0;
1700e6485f73SGleb Smirnoff 	ifd->ifi_datalen = sizeof(struct if_data);
1701e6485f73SGleb Smirnoff 	ifd->ifi_mtu = ifp->if_mtu;
1702e6485f73SGleb Smirnoff 	ifd->ifi_metric = ifp->if_metric;
1703e6485f73SGleb Smirnoff 	ifd->ifi_baudrate = ifp->if_baudrate;
1704e6485f73SGleb Smirnoff 	ifd->ifi_hwassist = ifp->if_hwassist;
1705e6485f73SGleb Smirnoff 	ifd->ifi_epoch = ifp->if_epoch;
1706e6485f73SGleb Smirnoff 	ifd->ifi_lastchange = ifp->if_lastchange;
1707e6485f73SGleb Smirnoff 
1708e6485f73SGleb Smirnoff 	ifd->ifi_ipackets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS);
1709e6485f73SGleb Smirnoff 	ifd->ifi_ierrors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS);
1710e6485f73SGleb Smirnoff 	ifd->ifi_opackets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS);
1711e6485f73SGleb Smirnoff 	ifd->ifi_oerrors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS);
1712e6485f73SGleb Smirnoff 	ifd->ifi_collisions = ifp->if_get_counter(ifp, IFCOUNTER_COLLISIONS);
1713e6485f73SGleb Smirnoff 	ifd->ifi_ibytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES);
1714e6485f73SGleb Smirnoff 	ifd->ifi_obytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES);
1715e6485f73SGleb Smirnoff 	ifd->ifi_imcasts = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS);
1716e6485f73SGleb Smirnoff 	ifd->ifi_omcasts = ifp->if_get_counter(ifp, IFCOUNTER_OMCASTS);
1717e6485f73SGleb Smirnoff 	ifd->ifi_iqdrops = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS);
1718e6485f73SGleb Smirnoff 	ifd->ifi_oqdrops = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS);
1719e6485f73SGleb Smirnoff 	ifd->ifi_noproto = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO);
1720e6485f73SGleb Smirnoff }
1721e6485f73SGleb Smirnoff 
1722e6485f73SGleb Smirnoff /*
1723f9ef96caSRobert Watson  * Wrapper functions for struct ifnet address list locking macros.  These are
1724f9ef96caSRobert Watson  * used by kernel modules to avoid encoding programming interface or binary
1725f9ef96caSRobert Watson  * interface assumptions that may be violated when kernel-internal locking
1726f9ef96caSRobert Watson  * approaches change.
1727f9ef96caSRobert Watson  */
1728f9ef96caSRobert Watson void
1729f9ef96caSRobert Watson if_addr_rlock(struct ifnet *ifp)
1730f9ef96caSRobert Watson {
1731f9ef96caSRobert Watson 
1732137f91e8SJohn Baldwin 	IF_ADDR_RLOCK(ifp);
1733f9ef96caSRobert Watson }
1734f9ef96caSRobert Watson 
1735f9ef96caSRobert Watson void
1736f9ef96caSRobert Watson if_addr_runlock(struct ifnet *ifp)
1737f9ef96caSRobert Watson {
1738f9ef96caSRobert Watson 
1739137f91e8SJohn Baldwin 	IF_ADDR_RUNLOCK(ifp);
1740f9ef96caSRobert Watson }
1741f9ef96caSRobert Watson 
1742f9ef96caSRobert Watson void
174362d76917SMarcel Moolenaar if_maddr_rlock(if_t ifp)
1744f9ef96caSRobert Watson {
1745f9ef96caSRobert Watson 
174662d76917SMarcel Moolenaar 	IF_ADDR_RLOCK((struct ifnet *)ifp);
1747f9ef96caSRobert Watson }
1748f9ef96caSRobert Watson 
1749f9ef96caSRobert Watson void
175062d76917SMarcel Moolenaar if_maddr_runlock(if_t ifp)
1751f9ef96caSRobert Watson {
1752f9ef96caSRobert Watson 
175362d76917SMarcel Moolenaar 	IF_ADDR_RUNLOCK((struct ifnet *)ifp);
1754f9ef96caSRobert Watson }
1755f9ef96caSRobert Watson 
1756f9ef96caSRobert Watson /*
1757e8aa8bddSGleb Smirnoff  * Initialization, destruction and refcounting functions for ifaddrs.
17581099f828SRobert Watson  */
175946758960SGleb Smirnoff struct ifaddr *
176046758960SGleb Smirnoff ifa_alloc(size_t size, int flags)
17611099f828SRobert Watson {
176246758960SGleb Smirnoff 	struct ifaddr *ifa;
176346758960SGleb Smirnoff 
176446758960SGleb Smirnoff 	KASSERT(size >= sizeof(struct ifaddr),
176546758960SGleb Smirnoff 	    ("%s: invalid size %zu", __func__, size));
176646758960SGleb Smirnoff 
176746758960SGleb Smirnoff 	ifa = malloc(size, M_IFADDR, M_ZERO | flags);
176846758960SGleb Smirnoff 	if (ifa == NULL)
176946758960SGleb Smirnoff 		return (NULL);
17701099f828SRobert Watson 
17717caf4ab7SGleb Smirnoff 	if ((ifa->ifa_opackets = counter_u64_alloc(flags)) == NULL)
17727caf4ab7SGleb Smirnoff 		goto fail;
17737caf4ab7SGleb Smirnoff 	if ((ifa->ifa_ipackets = counter_u64_alloc(flags)) == NULL)
17747caf4ab7SGleb Smirnoff 		goto fail;
17757caf4ab7SGleb Smirnoff 	if ((ifa->ifa_obytes = counter_u64_alloc(flags)) == NULL)
17767caf4ab7SGleb Smirnoff 		goto fail;
17777caf4ab7SGleb Smirnoff 	if ((ifa->ifa_ibytes = counter_u64_alloc(flags)) == NULL)
17787caf4ab7SGleb Smirnoff 		goto fail;
17797caf4ab7SGleb Smirnoff 
17801099f828SRobert Watson 	refcount_init(&ifa->ifa_refcnt, 1);
178146758960SGleb Smirnoff 
178246758960SGleb Smirnoff 	return (ifa);
17837caf4ab7SGleb Smirnoff 
17847caf4ab7SGleb Smirnoff fail:
17857caf4ab7SGleb Smirnoff 	/* free(NULL) is okay */
17867caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_opackets);
17877caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ipackets);
17887caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_obytes);
17897caf4ab7SGleb Smirnoff 	counter_u64_free(ifa->ifa_ibytes);
17907caf4ab7SGleb Smirnoff 	free(ifa, M_IFADDR);
17917caf4ab7SGleb Smirnoff 
17927caf4ab7SGleb Smirnoff 	return (NULL);
17931099f828SRobert Watson }
17941099f828SRobert Watson 
17951099f828SRobert Watson void
17961099f828SRobert Watson ifa_ref(struct ifaddr *ifa)
17971099f828SRobert Watson {
17981099f828SRobert Watson 
17991099f828SRobert Watson 	refcount_acquire(&ifa->ifa_refcnt);
18001099f828SRobert Watson }
18011099f828SRobert Watson 
18021099f828SRobert Watson void
18031099f828SRobert Watson ifa_free(struct ifaddr *ifa)
18041099f828SRobert Watson {
18051099f828SRobert Watson 
18061099f828SRobert Watson 	if (refcount_release(&ifa->ifa_refcnt)) {
18077caf4ab7SGleb Smirnoff 		counter_u64_free(ifa->ifa_opackets);
18087caf4ab7SGleb Smirnoff 		counter_u64_free(ifa->ifa_ipackets);
18097caf4ab7SGleb Smirnoff 		counter_u64_free(ifa->ifa_obytes);
18107caf4ab7SGleb Smirnoff 		counter_u64_free(ifa->ifa_ibytes);
18111099f828SRobert Watson 		free(ifa, M_IFADDR);
18121099f828SRobert Watson 	}
18131099f828SRobert Watson }
18141099f828SRobert Watson 
181559c180c3SAlexander V. Chernikov static int
181659c180c3SAlexander V. Chernikov ifa_maintain_loopback_route(int cmd, const char *otype, struct ifaddr *ifa,
181759c180c3SAlexander V. Chernikov     struct sockaddr *ia)
18189bb7d0f4SQing Li {
181959c180c3SAlexander V. Chernikov 	int error;
18209bb7d0f4SQing Li 	struct rt_addrinfo info;
182159c180c3SAlexander V. Chernikov 	struct sockaddr_dl null_sdl;
182259c180c3SAlexander V. Chernikov 	struct ifnet *ifp;
182359c180c3SAlexander V. Chernikov 
182459c180c3SAlexander V. Chernikov 	ifp = ifa->ifa_ifp;
18259bb7d0f4SQing Li 
18269bb7d0f4SQing Li 	bzero(&info, sizeof(info));
182759c180c3SAlexander V. Chernikov 	if (cmd != RTM_DELETE)
18289bb7d0f4SQing Li 		info.rti_ifp = V_loif;
18299f23a54eSEugene Grosbein 	info.rti_flags = ifa->ifa_flags | RTF_HOST | RTF_STATIC | RTF_PINNED;
18309bb7d0f4SQing Li 	info.rti_info[RTAX_DST] = ia;
18319bb7d0f4SQing Li 	info.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&null_sdl;
183259c180c3SAlexander V. Chernikov 	link_init_sdl(ifp, (struct sockaddr *)&null_sdl, ifp->if_type);
18339bb7d0f4SQing Li 
183459c180c3SAlexander V. Chernikov 	error = rtrequest1_fib(cmd, &info, NULL, ifp->if_fib);
183559c180c3SAlexander V. Chernikov 
183620f8d7bcSDag-Erling Smørgrav 	if (error != 0 &&
183720f8d7bcSDag-Erling Smørgrav 	    !(cmd == RTM_ADD && error == EEXIST) &&
183820f8d7bcSDag-Erling Smørgrav 	    !(cmd == RTM_DELETE && error == ENOENT))
183920f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "%s failed: %d\n", otype, error);
18409bb7d0f4SQing Li 
18419bb7d0f4SQing Li 	return (error);
18429bb7d0f4SQing Li }
18439bb7d0f4SQing Li 
18449bb7d0f4SQing Li int
184559c180c3SAlexander V. Chernikov ifa_add_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
184659c180c3SAlexander V. Chernikov {
184759c180c3SAlexander V. Chernikov 
184859c180c3SAlexander V. Chernikov 	return (ifa_maintain_loopback_route(RTM_ADD, "insertion", ifa, ia));
184959c180c3SAlexander V. Chernikov }
185059c180c3SAlexander V. Chernikov 
185159c180c3SAlexander V. Chernikov int
18529bb7d0f4SQing Li ifa_del_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
18539bb7d0f4SQing Li {
18549bb7d0f4SQing Li 
185559c180c3SAlexander V. Chernikov 	return (ifa_maintain_loopback_route(RTM_DELETE, "deletion", ifa, ia));
18569bb7d0f4SQing Li }
18579bb7d0f4SQing Li 
18589a6356bcSGleb Smirnoff int
185959c180c3SAlexander V. Chernikov ifa_switch_loopback_route(struct ifaddr *ifa, struct sockaddr *ia)
18609a6356bcSGleb Smirnoff {
18619a6356bcSGleb Smirnoff 
186259c180c3SAlexander V. Chernikov 	return (ifa_maintain_loopback_route(RTM_CHANGE, "switch", ifa, ia));
18639a6356bcSGleb Smirnoff }
18649a6356bcSGleb Smirnoff 
18651099f828SRobert Watson /*
186640d8a302SBruce M Simpson  * XXX: Because sockaddr_dl has deeper structure than the sockaddr
186740d8a302SBruce M Simpson  * structs used to represent other address families, it is necessary
186840d8a302SBruce M Simpson  * to perform a different comparison.
186940d8a302SBruce M Simpson  */
187040d8a302SBruce M Simpson 
187140d8a302SBruce M Simpson #define	sa_dl_equal(a1, a2)	\
1872441f9243SAlexander V. Chernikov 	((((const struct sockaddr_dl *)(a1))->sdl_len ==		\
1873441f9243SAlexander V. Chernikov 	 ((const struct sockaddr_dl *)(a2))->sdl_len) &&		\
1874441f9243SAlexander V. Chernikov 	 (bcmp(CLLADDR((const struct sockaddr_dl *)(a1)),		\
1875441f9243SAlexander V. Chernikov 	       CLLADDR((const struct sockaddr_dl *)(a2)),		\
1876441f9243SAlexander V. Chernikov 	       ((const struct sockaddr_dl *)(a1))->sdl_alen) == 0))
187719fc74fbSJeffrey Hsu 
187830aad87dSBrooks Davis /*
1879df8bae1dSRodney W. Grimes  * Locate an interface based on a complete address.
1880df8bae1dSRodney W. Grimes  */
1881df8bae1dSRodney W. Grimes /*ARGSUSED*/
18828896f83aSRobert Watson static struct ifaddr *
1883441f9243SAlexander V. Chernikov ifa_ifwithaddr_internal(const struct sockaddr *addr, int getref)
1884df8bae1dSRodney W. Grimes {
18850b59d917SJonathan Lemon 	struct ifnet *ifp;
18860b59d917SJonathan Lemon 	struct ifaddr *ifa;
1887df8bae1dSRodney W. Grimes 
188877dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
1889ab5ed8a5SRobert Watson 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
1890137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
189137d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1892df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1893df8bae1dSRodney W. Grimes 				continue;
1894ab5ed8a5SRobert Watson 			if (sa_equal(addr, ifa->ifa_addr)) {
18958c0fec80SRobert Watson 				if (getref)
18968c0fec80SRobert Watson 					ifa_ref(ifa);
1897137f91e8SJohn Baldwin 				IF_ADDR_RUNLOCK(ifp);
18980b59d917SJonathan Lemon 				goto done;
1899ab5ed8a5SRobert Watson 			}
190082cd038dSYoshinobu Inoue 			/* IP6 doesn't have broadcast */
19010b59d917SJonathan Lemon 			if ((ifp->if_flags & IFF_BROADCAST) &&
19020b59d917SJonathan Lemon 			    ifa->ifa_broadaddr &&
190382cd038dSYoshinobu Inoue 			    ifa->ifa_broadaddr->sa_len != 0 &&
1904ab5ed8a5SRobert Watson 			    sa_equal(ifa->ifa_broadaddr, addr)) {
19058c0fec80SRobert Watson 				if (getref)
19068c0fec80SRobert Watson 					ifa_ref(ifa);
1907137f91e8SJohn Baldwin 				IF_ADDR_RUNLOCK(ifp);
19080b59d917SJonathan Lemon 				goto done;
19090b59d917SJonathan Lemon 			}
1910ab5ed8a5SRobert Watson 		}
1911137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
1912ab5ed8a5SRobert Watson 	}
19130b59d917SJonathan Lemon 	ifa = NULL;
19140b59d917SJonathan Lemon done:
191577dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
1916df8bae1dSRodney W. Grimes 	return (ifa);
1917df8bae1dSRodney W. Grimes }
19180b59d917SJonathan Lemon 
19198896f83aSRobert Watson struct ifaddr *
1920441f9243SAlexander V. Chernikov ifa_ifwithaddr(const struct sockaddr *addr)
19218896f83aSRobert Watson {
19228896f83aSRobert Watson 
19238c0fec80SRobert Watson 	return (ifa_ifwithaddr_internal(addr, 1));
19248896f83aSRobert Watson }
19258896f83aSRobert Watson 
19268896f83aSRobert Watson int
1927441f9243SAlexander V. Chernikov ifa_ifwithaddr_check(const struct sockaddr *addr)
19288896f83aSRobert Watson {
19298896f83aSRobert Watson 
19308c0fec80SRobert Watson 	return (ifa_ifwithaddr_internal(addr, 0) != NULL);
19318896f83aSRobert Watson }
19328896f83aSRobert Watson 
1933df8bae1dSRodney W. Grimes /*
1934773725a2SAndre Oppermann  * Locate an interface based on the broadcast address.
1935773725a2SAndre Oppermann  */
1936773725a2SAndre Oppermann /* ARGSUSED */
1937773725a2SAndre Oppermann struct ifaddr *
1938441f9243SAlexander V. Chernikov ifa_ifwithbroadaddr(const struct sockaddr *addr, int fibnum)
1939773725a2SAndre Oppermann {
1940773725a2SAndre Oppermann 	struct ifnet *ifp;
1941773725a2SAndre Oppermann 	struct ifaddr *ifa;
1942773725a2SAndre Oppermann 
194377dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
1944ab5ed8a5SRobert Watson 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
19454f8585e0SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
19464f8585e0SAlan Somers 			continue;
1947137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
1948773725a2SAndre Oppermann 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1949773725a2SAndre Oppermann 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1950773725a2SAndre Oppermann 				continue;
1951773725a2SAndre Oppermann 			if ((ifp->if_flags & IFF_BROADCAST) &&
1952773725a2SAndre Oppermann 			    ifa->ifa_broadaddr &&
1953773725a2SAndre Oppermann 			    ifa->ifa_broadaddr->sa_len != 0 &&
1954ab5ed8a5SRobert Watson 			    sa_equal(ifa->ifa_broadaddr, addr)) {
19558c0fec80SRobert Watson 				ifa_ref(ifa);
1956137f91e8SJohn Baldwin 				IF_ADDR_RUNLOCK(ifp);
1957773725a2SAndre Oppermann 				goto done;
1958773725a2SAndre Oppermann 			}
1959ab5ed8a5SRobert Watson 		}
1960137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
1961ab5ed8a5SRobert Watson 	}
1962773725a2SAndre Oppermann 	ifa = NULL;
1963773725a2SAndre Oppermann done:
196477dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
1965773725a2SAndre Oppermann 	return (ifa);
1966773725a2SAndre Oppermann }
1967773725a2SAndre Oppermann 
1968773725a2SAndre Oppermann /*
1969df8bae1dSRodney W. Grimes  * Locate the point to point interface with a given destination address.
1970df8bae1dSRodney W. Grimes  */
1971df8bae1dSRodney W. Grimes /*ARGSUSED*/
1972df8bae1dSRodney W. Grimes struct ifaddr *
1973441f9243SAlexander V. Chernikov ifa_ifwithdstaddr(const struct sockaddr *addr, int fibnum)
1974df8bae1dSRodney W. Grimes {
19750b59d917SJonathan Lemon 	struct ifnet *ifp;
19760b59d917SJonathan Lemon 	struct ifaddr *ifa;
1977df8bae1dSRodney W. Grimes 
197877dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
1979603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
19800b59d917SJonathan Lemon 		if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
19810b59d917SJonathan Lemon 			continue;
19822f308a34SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
19830cfee0c2SAlan Somers 			continue;
1984137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
198537d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1986df8bae1dSRodney W. Grimes 			if (ifa->ifa_addr->sa_family != addr->sa_family)
1987df8bae1dSRodney W. Grimes 				continue;
1988f0c04221SBjoern A. Zeeb 			if (ifa->ifa_dstaddr != NULL &&
1989ab5ed8a5SRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr)) {
19908c0fec80SRobert Watson 				ifa_ref(ifa);
1991137f91e8SJohn Baldwin 				IF_ADDR_RUNLOCK(ifp);
19920b59d917SJonathan Lemon 				goto done;
1993df8bae1dSRodney W. Grimes 			}
19940b59d917SJonathan Lemon 		}
1995137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
1996ab5ed8a5SRobert Watson 	}
19970b59d917SJonathan Lemon 	ifa = NULL;
19980b59d917SJonathan Lemon done:
199977dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
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 
20167e2a6151SJulian Elischer 	/*
20177e2a6151SJulian Elischer 	 * AF_LINK addresses can be looked up directly by their index number,
20187e2a6151SJulian Elischer 	 * so do that if we can.
20197e2a6151SJulian Elischer 	 */
2020df8bae1dSRodney W. Grimes 	if (af == AF_LINK) {
2021441f9243SAlexander V. Chernikov 	    const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)addr;
2022603724d3SBjoern A. Zeeb 	    if (sdl->sdl_index && sdl->sdl_index <= V_if_index)
2023f9132cebSJonathan Lemon 		return (ifaddr_byindex(sdl->sdl_index));
2024df8bae1dSRodney W. Grimes 	}
20257e2a6151SJulian Elischer 
20267e2a6151SJulian Elischer 	/*
20278c0fec80SRobert Watson 	 * Scan though each interface, looking for ones that have addresses
20280cfee0c2SAlan Somers 	 * in this address family and the requested fib.  Maintain a reference
20290cfee0c2SAlan Somers 	 * on ifa_maybe once we find one, as we release the IF_ADDR_RLOCK() that
20300cfee0c2SAlan Somers 	 * kept it stable when we move onto the next interface.
20317e2a6151SJulian Elischer 	 */
203277dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
2033603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
20342f308a34SAlan Somers 		if ((fibnum != RT_ALL_FIBS) && (ifp->if_fib != fibnum))
20350cfee0c2SAlan Somers 			continue;
2036137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
203737d40066SPoul-Henning Kamp 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2038441f9243SAlexander V. Chernikov 			const char *cp, *cp2, *cp3;
2039df8bae1dSRodney W. Grimes 
2040523a02aaSDavid Greenman 			if (ifa->ifa_addr->sa_family != af)
2041df8bae1dSRodney W. Grimes next:				continue;
20420ed6142bSQing Li 			if (af == AF_INET &&
20430ed6142bSQing Li 			    ifp->if_flags & IFF_POINTOPOINT && !ignore_ptp) {
20447e2a6151SJulian Elischer 				/*
20457e2a6151SJulian Elischer 				 * This is a bit broken as it doesn't
20467e2a6151SJulian Elischer 				 * take into account that the remote end may
20477e2a6151SJulian Elischer 				 * be a single node in the network we are
20487e2a6151SJulian Elischer 				 * looking for.
20497e2a6151SJulian Elischer 				 * The trouble is that we don't know the
20507e2a6151SJulian Elischer 				 * netmask for the remote end.
20517e2a6151SJulian Elischer 				 */
2052f0c04221SBjoern A. Zeeb 				if (ifa->ifa_dstaddr != NULL &&
2053ab5ed8a5SRobert Watson 				    sa_equal(addr, ifa->ifa_dstaddr)) {
20548c0fec80SRobert Watson 					ifa_ref(ifa);
2055137f91e8SJohn Baldwin 					IF_ADDR_RUNLOCK(ifp);
20560b59d917SJonathan Lemon 					goto done;
2057ab5ed8a5SRobert Watson 				}
20583740e2adSDavid Greenman 			} else {
20597e2a6151SJulian Elischer 				/*
20607e2a6151SJulian Elischer 				 * Scan all the bits in the ifa's address.
20617e2a6151SJulian Elischer 				 * If a bit dissagrees with what we are
20627e2a6151SJulian Elischer 				 * looking for, mask it with the netmask
20637e2a6151SJulian Elischer 				 * to see if it really matters.
20647e2a6151SJulian Elischer 				 * (A byte at a time)
20657e2a6151SJulian Elischer 				 */
2066523a02aaSDavid Greenman 				if (ifa->ifa_netmask == 0)
2067523a02aaSDavid Greenman 					continue;
2068df8bae1dSRodney W. Grimes 				cp = addr_data;
2069df8bae1dSRodney W. Grimes 				cp2 = ifa->ifa_addr->sa_data;
2070df8bae1dSRodney W. Grimes 				cp3 = ifa->ifa_netmask->sa_data;
20717e2a6151SJulian Elischer 				cplim = ifa->ifa_netmask->sa_len
20727e2a6151SJulian Elischer 					+ (char *)ifa->ifa_netmask;
2073df8bae1dSRodney W. Grimes 				while (cp3 < cplim)
2074df8bae1dSRodney W. Grimes 					if ((*cp++ ^ *cp2++) & *cp3++)
20757e2a6151SJulian Elischer 						goto next; /* next address! */
20767e2a6151SJulian Elischer 				/*
20777e2a6151SJulian Elischer 				 * If the netmask of what we just found
20787e2a6151SJulian Elischer 				 * is more specific than what we had before
207924421c1cSGleb Smirnoff 				 * (if we had one), or if the virtual status
208024421c1cSGleb Smirnoff 				 * of new prefix is better than of the old one,
208124421c1cSGleb Smirnoff 				 * then remember the new one before continuing
208224421c1cSGleb Smirnoff 				 * to search for an even better one.
20837e2a6151SJulian Elischer 				 */
20848c0fec80SRobert Watson 				if (ifa_maybe == NULL ||
208524421c1cSGleb Smirnoff 				    ifa_preferred(ifa_maybe, ifa) ||
2086df8bae1dSRodney W. Grimes 				    rn_refines((caddr_t)ifa->ifa_netmask,
20878c0fec80SRobert Watson 				    (caddr_t)ifa_maybe->ifa_netmask)) {
20888c0fec80SRobert Watson 					if (ifa_maybe != NULL)
20898c0fec80SRobert Watson 						ifa_free(ifa_maybe);
2090df8bae1dSRodney W. Grimes 					ifa_maybe = ifa;
20918c0fec80SRobert Watson 					ifa_ref(ifa_maybe);
20928c0fec80SRobert Watson 				}
2093df8bae1dSRodney W. Grimes 			}
2094b2af64fdSDavid Greenman 		}
2095137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
2096b2af64fdSDavid Greenman 	}
20970b59d917SJonathan Lemon 	ifa = ifa_maybe;
20988c0fec80SRobert Watson 	ifa_maybe = NULL;
20990b59d917SJonathan Lemon done:
210077dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
21018c0fec80SRobert Watson 	if (ifa_maybe != NULL)
21028c0fec80SRobert Watson 		ifa_free(ifa_maybe);
21030b59d917SJonathan Lemon 	return (ifa);
2104df8bae1dSRodney W. Grimes }
2105df8bae1dSRodney W. Grimes 
2106df8bae1dSRodney W. Grimes /*
2107df8bae1dSRodney W. Grimes  * Find an interface address specific to an interface best matching
2108df8bae1dSRodney W. Grimes  * a given address.
2109df8bae1dSRodney W. Grimes  */
2110df8bae1dSRodney W. Grimes struct ifaddr *
2111441f9243SAlexander V. Chernikov ifaof_ifpforaddr(const struct sockaddr *addr, struct ifnet *ifp)
2112df8bae1dSRodney W. Grimes {
211372fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2114441f9243SAlexander V. Chernikov 	const char *cp, *cp2, *cp3;
211572fd1b6aSDag-Erling Smørgrav 	char *cplim;
21168c0fec80SRobert Watson 	struct ifaddr *ifa_maybe = NULL;
2117df8bae1dSRodney W. Grimes 	u_int af = addr->sa_family;
2118df8bae1dSRodney W. Grimes 
2119df8bae1dSRodney W. Grimes 	if (af >= AF_MAX)
2120cd292f12SBjoern A. Zeeb 		return (NULL);
2121137f91e8SJohn Baldwin 	IF_ADDR_RLOCK(ifp);
212237d40066SPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2123df8bae1dSRodney W. Grimes 		if (ifa->ifa_addr->sa_family != af)
2124df8bae1dSRodney W. Grimes 			continue;
21258c0fec80SRobert Watson 		if (ifa_maybe == NULL)
2126df8bae1dSRodney W. Grimes 			ifa_maybe = ifa;
2127df8bae1dSRodney W. Grimes 		if (ifa->ifa_netmask == 0) {
2128d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_addr) ||
2129d8d5b10eSRobert Watson 			    (ifa->ifa_dstaddr &&
2130d8d5b10eSRobert Watson 			    sa_equal(addr, ifa->ifa_dstaddr)))
21312defe5cdSJonathan Lemon 				goto done;
2132df8bae1dSRodney W. Grimes 			continue;
2133df8bae1dSRodney W. Grimes 		}
2134b2af64fdSDavid Greenman 		if (ifp->if_flags & IFF_POINTOPOINT) {
2135d8d5b10eSRobert Watson 			if (sa_equal(addr, ifa->ifa_dstaddr))
2136a8637146SJonathan Lemon 				goto done;
21373740e2adSDavid Greenman 		} else {
2138df8bae1dSRodney W. Grimes 			cp = addr->sa_data;
2139df8bae1dSRodney W. Grimes 			cp2 = ifa->ifa_addr->sa_data;
2140df8bae1dSRodney W. Grimes 			cp3 = ifa->ifa_netmask->sa_data;
2141df8bae1dSRodney W. Grimes 			cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask;
2142df8bae1dSRodney W. Grimes 			for (; cp3 < cplim; cp3++)
2143df8bae1dSRodney W. Grimes 				if ((*cp++ ^ *cp2++) & *cp3)
2144df8bae1dSRodney W. Grimes 					break;
2145df8bae1dSRodney W. Grimes 			if (cp3 == cplim)
21462defe5cdSJonathan Lemon 				goto done;
2147df8bae1dSRodney W. Grimes 		}
2148b2af64fdSDavid Greenman 	}
2149f9132cebSJonathan Lemon 	ifa = ifa_maybe;
2150f9132cebSJonathan Lemon done:
21518c0fec80SRobert Watson 	if (ifa != NULL)
21528c0fec80SRobert Watson 		ifa_ref(ifa);
2153137f91e8SJohn Baldwin 	IF_ADDR_RUNLOCK(ifp);
2154f9132cebSJonathan Lemon 	return (ifa);
2155df8bae1dSRodney W. Grimes }
2156df8bae1dSRodney W. Grimes 
215724421c1cSGleb Smirnoff /*
215824421c1cSGleb Smirnoff  * See whether new ifa is better than current one:
215924421c1cSGleb Smirnoff  * 1) A non-virtual one is preferred over virtual.
216024421c1cSGleb Smirnoff  * 2) A virtual in master state preferred over any other state.
216124421c1cSGleb Smirnoff  *
216224421c1cSGleb Smirnoff  * Used in several address selecting functions.
216324421c1cSGleb Smirnoff  */
216424421c1cSGleb Smirnoff int
216524421c1cSGleb Smirnoff ifa_preferred(struct ifaddr *cur, struct ifaddr *next)
216624421c1cSGleb Smirnoff {
216724421c1cSGleb Smirnoff 
216824421c1cSGleb Smirnoff 	return (cur->ifa_carp && (!next->ifa_carp ||
216924421c1cSGleb Smirnoff 	    ((*carp_master_p)(next) && !(*carp_master_p)(cur))));
217024421c1cSGleb Smirnoff }
217124421c1cSGleb Smirnoff 
21726e6b3f7cSQing Li #include <net/if_llatbl.h>
21736e6b3f7cSQing Li 
2174df8bae1dSRodney W. Grimes /*
2175df8bae1dSRodney W. Grimes  * Default action when installing a route with a Link Level gateway.
2176df8bae1dSRodney W. Grimes  * Lookup an appropriate real ifa to point to.
2177df8bae1dSRodney W. Grimes  * This should be moved to /sys/net/link.c eventually.
2178df8bae1dSRodney W. Grimes  */
21793bda9f9bSPoul-Henning Kamp static void
218072fd1b6aSDag-Erling Smørgrav link_rtrequest(int cmd, struct rtentry *rt, struct rt_addrinfo *info)
2181df8bae1dSRodney W. Grimes {
218272fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa, *oifa;
2183df8bae1dSRodney W. Grimes 	struct sockaddr *dst;
2184df8bae1dSRodney W. Grimes 	struct ifnet *ifp;
2185df8bae1dSRodney W. Grimes 
2186155d72c4SPedro F. Giffuni 	if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == NULL) ||
2187155d72c4SPedro F. Giffuni 	    ((ifp = ifa->ifa_ifp) == NULL) || ((dst = rt_key(rt)) == NULL))
2188df8bae1dSRodney W. Grimes 		return;
21899448326fSPoul-Henning Kamp 	ifa = ifaof_ifpforaddr(dst, ifp);
21909448326fSPoul-Henning Kamp 	if (ifa) {
2191d1dd20beSSam Leffler 		oifa = rt->rt_ifa;
2192df8bae1dSRodney W. Grimes 		rt->rt_ifa = ifa;
21931099f828SRobert Watson 		ifa_free(oifa);
2194df8bae1dSRodney W. Grimes 		if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest)
21958071913dSRuslan Ermilov 			ifa->ifa_rtrequest(cmd, rt, info);
2196df8bae1dSRodney W. Grimes 	}
2197df8bae1dSRodney W. Grimes }
2198df8bae1dSRodney W. Grimes 
219995fbe4d0SAlexander V. Chernikov struct sockaddr_dl *
220095fbe4d0SAlexander V. Chernikov link_alloc_sdl(size_t size, int flags)
220195fbe4d0SAlexander V. Chernikov {
220295fbe4d0SAlexander V. Chernikov 
220395fbe4d0SAlexander V. Chernikov 	return (malloc(size, M_TEMP, flags));
220495fbe4d0SAlexander V. Chernikov }
220595fbe4d0SAlexander V. Chernikov 
220695fbe4d0SAlexander V. Chernikov void
220795fbe4d0SAlexander V. Chernikov link_free_sdl(struct sockaddr *sa)
220895fbe4d0SAlexander V. Chernikov {
220995fbe4d0SAlexander V. Chernikov 	free(sa, M_TEMP);
221095fbe4d0SAlexander V. Chernikov }
221195fbe4d0SAlexander V. Chernikov 
221295fbe4d0SAlexander V. Chernikov /*
221395fbe4d0SAlexander V. Chernikov  * Fills in given sdl with interface basic info.
221495fbe4d0SAlexander V. Chernikov  * Returns pointer to filled sdl.
221595fbe4d0SAlexander V. Chernikov  */
221695fbe4d0SAlexander V. Chernikov struct sockaddr_dl *
221795fbe4d0SAlexander V. Chernikov link_init_sdl(struct ifnet *ifp, struct sockaddr *paddr, u_char iftype)
221895fbe4d0SAlexander V. Chernikov {
221995fbe4d0SAlexander V. Chernikov 	struct sockaddr_dl *sdl;
222095fbe4d0SAlexander V. Chernikov 
222195fbe4d0SAlexander V. Chernikov 	sdl = (struct sockaddr_dl *)paddr;
222295fbe4d0SAlexander V. Chernikov 	memset(sdl, 0, sizeof(struct sockaddr_dl));
222395fbe4d0SAlexander V. Chernikov 	sdl->sdl_len = sizeof(struct sockaddr_dl);
222495fbe4d0SAlexander V. Chernikov 	sdl->sdl_family = AF_LINK;
222595fbe4d0SAlexander V. Chernikov 	sdl->sdl_index = ifp->if_index;
222695fbe4d0SAlexander V. Chernikov 	sdl->sdl_type = iftype;
222795fbe4d0SAlexander V. Chernikov 
222895fbe4d0SAlexander V. Chernikov 	return (sdl);
222995fbe4d0SAlexander V. Chernikov }
223095fbe4d0SAlexander V. Chernikov 
2231df8bae1dSRodney W. Grimes /*
2232df8bae1dSRodney W. Grimes  * Mark an interface down and notify protocols of
2233df8bae1dSRodney W. Grimes  * the transition.
2234df8bae1dSRodney W. Grimes  */
22358614fb12SMax Laier static void
223672fd1b6aSDag-Erling Smørgrav if_unroute(struct ifnet *ifp, int flag, int fam)
2237df8bae1dSRodney W. Grimes {
223872fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2239df8bae1dSRodney W. Grimes 
2240292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_unroute: flag != IFF_UP"));
2241292ee7beSRobert Watson 
2242e8c2601dSPoul-Henning Kamp 	ifp->if_flags &= ~flag;
224398b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
2244e8c2601dSPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2245e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2246df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFDOWN, ifa->ifa_addr);
2247db7f0b97SKip Macy 	ifp->if_qflush(ifp);
2248db7f0b97SKip Macy 
2249a9771948SGleb Smirnoff 	if (ifp->if_carp)
225054bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2251df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
2252df8bae1dSRodney W. Grimes }
2253df8bae1dSRodney W. Grimes 
2254df8bae1dSRodney W. Grimes /*
2255df8bae1dSRodney W. Grimes  * Mark an interface up and notify protocols of
2256df8bae1dSRodney W. Grimes  * the transition.
2257df8bae1dSRodney W. Grimes  */
22588614fb12SMax Laier static void
225972fd1b6aSDag-Erling Smørgrav if_route(struct ifnet *ifp, int flag, int fam)
2260df8bae1dSRodney W. Grimes {
226172fd1b6aSDag-Erling Smørgrav 	struct ifaddr *ifa;
2262df8bae1dSRodney W. Grimes 
2263292ee7beSRobert Watson 	KASSERT(flag == IFF_UP, ("if_route: flag != IFF_UP"));
2264292ee7beSRobert Watson 
2265e8c2601dSPoul-Henning Kamp 	ifp->if_flags |= flag;
226698b9590eSPoul-Henning Kamp 	getmicrotime(&ifp->if_lastchange);
2267e8c2601dSPoul-Henning Kamp 	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
2268e8c2601dSPoul-Henning Kamp 		if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family))
2269df8bae1dSRodney W. Grimes 			pfctlinput(PRC_IFUP, ifa->ifa_addr);
2270a9771948SGleb Smirnoff 	if (ifp->if_carp)
227154bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2272df8bae1dSRodney W. Grimes 	rt_ifmsg(ifp);
227382cd038dSYoshinobu Inoue #ifdef INET6
227482cd038dSYoshinobu Inoue 	in6_if_up(ifp);
227582cd038dSYoshinobu Inoue #endif
2276df8bae1dSRodney W. Grimes }
2277df8bae1dSRodney W. Grimes 
2278a6fffd6cSBrooks Davis void	(*vlan_link_state_p)(struct ifnet *);	/* XXX: private from if_vlan */
227975ee267cSGleb Smirnoff void	(*vlan_trunk_cap_p)(struct ifnet *);		/* XXX: private from if_vlan */
2280e4cd31ddSJeff Roberson struct ifnet *(*vlan_trunkdev_p)(struct ifnet *);
2281e4cd31ddSJeff Roberson struct	ifnet *(*vlan_devat_p)(struct ifnet *, uint16_t);
2282e4cd31ddSJeff Roberson int	(*vlan_tag_p)(struct ifnet *, uint16_t *);
2283e4cd31ddSJeff Roberson int	(*vlan_setcookie_p)(struct ifnet *, void *);
2284e4cd31ddSJeff Roberson void	*(*vlan_cookie_p)(struct ifnet *);
228594f5c9cfSSam Leffler 
228694f5c9cfSSam Leffler /*
228768a3482fSGleb Smirnoff  * Handle a change in the interface link state. To avoid LORs
228868a3482fSGleb Smirnoff  * between driver lock and upper layer locks, as well as possible
228968a3482fSGleb Smirnoff  * recursions, we post event to taskqueue, and all job
229068a3482fSGleb Smirnoff  * is done in static do_link_state_change().
229194f5c9cfSSam Leffler  */
229294f5c9cfSSam Leffler void
2293d6e82913SSteven Hartland if_link_state_change(struct ifnet *ifp, int link_state)
229494f5c9cfSSam Leffler {
2295d6e82913SSteven Hartland 	/* Return if state hasn't changed. */
2296d6e82913SSteven Hartland 	if (ifp->if_link_state == link_state)
22974d96314fSGleb Smirnoff 		return;
22984d96314fSGleb Smirnoff 
229994f5c9cfSSam Leffler 	ifp->if_link_state = link_state;
23004d96314fSGleb Smirnoff 
230168a3482fSGleb Smirnoff 	taskqueue_enqueue(taskqueue_swi, &ifp->if_linktask);
230268a3482fSGleb Smirnoff }
230368a3482fSGleb Smirnoff 
230468a3482fSGleb Smirnoff static void
230568a3482fSGleb Smirnoff do_link_state_change(void *arg, int pending)
230668a3482fSGleb Smirnoff {
230768a3482fSGleb Smirnoff 	struct ifnet *ifp = (struct ifnet *)arg;
230868a3482fSGleb Smirnoff 	int link_state = ifp->if_link_state;
23098b615593SMarko Zec 	CURVNET_SET(ifp->if_vnet);
231068a3482fSGleb Smirnoff 
23114d96314fSGleb Smirnoff 	/* Notify that the link state has changed. */
231294f5c9cfSSam Leffler 	rt_ifmsg(ifp);
231375ee267cSGleb Smirnoff 	if (ifp->if_vlantrunk != NULL)
2314a6fffd6cSBrooks Davis 		(*vlan_link_state_p)(ifp);
23151c7899c7SGleb Smirnoff 
23161c7899c7SGleb Smirnoff 	if ((ifp->if_type == IFT_ETHER || ifp->if_type == IFT_L2VLAN) &&
2317833e8dc5SGleb Smirnoff 	    ifp->if_l2com != NULL)
23181c7899c7SGleb Smirnoff 		(*ng_ether_link_state_p)(ifp, link_state);
23194d96314fSGleb Smirnoff 	if (ifp->if_carp)
232054bfbd51SWill Andrews 		(*carp_linkstate_p)(ifp);
2321ddf32010SAndrew Thompson 	if (ifp->if_bridge)
23225c30b378SMatt Macy 		ifp->if_bridge_linkstate(ifp);
2323ddf32010SAndrew Thompson 	if (ifp->if_lagg)
2324d6e82913SSteven Hartland 		(*lagg_linkstate_p)(ifp, link_state);
23258f867517SAndrew Thompson 
232621ca7b57SMarko Zec 	if (IS_DEFAULT_VNET(curvnet))
23279d80a330SBrooks Davis 		devctl_notify("IFNET", ifp->if_xname,
232821ca7b57SMarko Zec 		    (link_state == LINK_STATE_UP) ? "LINK_UP" : "LINK_DOWN",
232921ca7b57SMarko Zec 		    NULL);
233068a3482fSGleb Smirnoff 	if (pending > 1)
233168a3482fSGleb Smirnoff 		if_printf(ifp, "%d link states coalesced\n", pending);
23325515c2e7SGleb Smirnoff 	if (log_link_state_change)
233320f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "link state changed to %s\n",
23348b02df24SGleb Smirnoff 		    (link_state == LINK_STATE_UP) ? "UP" : "DOWN" );
2335368bf0c2SSepherosa Ziehau 	EVENTHANDLER_INVOKE(ifnet_link_event, ifp, link_state);
23368b615593SMarko Zec 	CURVNET_RESTORE();
233794f5c9cfSSam Leffler }
233894f5c9cfSSam Leffler 
2339df8bae1dSRodney W. Grimes /*
2340e8c2601dSPoul-Henning Kamp  * Mark an interface down and notify protocols of
2341e8c2601dSPoul-Henning Kamp  * the transition.
2342e8c2601dSPoul-Henning Kamp  */
2343e8c2601dSPoul-Henning Kamp void
234472fd1b6aSDag-Erling Smørgrav if_down(struct ifnet *ifp)
2345e8c2601dSPoul-Henning Kamp {
2346e8c2601dSPoul-Henning Kamp 
234792a6859bSDexuan Cui 	EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_DOWN);
2348e8c2601dSPoul-Henning Kamp 	if_unroute(ifp, IFF_UP, AF_UNSPEC);
2349e8c2601dSPoul-Henning Kamp }
2350e8c2601dSPoul-Henning Kamp 
2351e8c2601dSPoul-Henning Kamp /*
2352e8c2601dSPoul-Henning Kamp  * Mark an interface up and notify protocols of
2353e8c2601dSPoul-Henning Kamp  * the transition.
2354e8c2601dSPoul-Henning Kamp  */
2355e8c2601dSPoul-Henning Kamp void
235672fd1b6aSDag-Erling Smørgrav if_up(struct ifnet *ifp)
2357e8c2601dSPoul-Henning Kamp {
2358e8c2601dSPoul-Henning Kamp 
2359e8c2601dSPoul-Henning Kamp 	if_route(ifp, IFF_UP, AF_UNSPEC);
236092a6859bSDexuan Cui 	EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_UP);
2361e8c2601dSPoul-Henning Kamp }
2362e8c2601dSPoul-Henning Kamp 
2363e8c2601dSPoul-Henning Kamp /*
2364df8bae1dSRodney W. Grimes  * Flush an interface queue.
2365df8bae1dSRodney W. Grimes  */
23667cc5b47fSKip Macy void
2367db7f0b97SKip Macy if_qflush(struct ifnet *ifp)
2368df8bae1dSRodney W. Grimes {
236972fd1b6aSDag-Erling Smørgrav 	struct mbuf *m, *n;
2370db7f0b97SKip Macy 	struct ifaltq *ifq;
2371df8bae1dSRodney W. Grimes 
2372db7f0b97SKip Macy 	ifq = &ifp->if_snd;
23737b21048cSMax Laier 	IFQ_LOCK(ifq);
237402b199f1SMax Laier #ifdef ALTQ
237502b199f1SMax Laier 	if (ALTQ_IS_ENABLED(ifq))
237602b199f1SMax Laier 		ALTQ_PURGE(ifq);
237702b199f1SMax Laier #endif
2378df8bae1dSRodney W. Grimes 	n = ifq->ifq_head;
2379155d72c4SPedro F. Giffuni 	while ((m = n) != NULL) {
2380c29a3321SKevin Lo 		n = m->m_nextpkt;
2381df8bae1dSRodney W. Grimes 		m_freem(m);
2382df8bae1dSRodney W. Grimes 	}
2383df8bae1dSRodney W. Grimes 	ifq->ifq_head = 0;
2384df8bae1dSRodney W. Grimes 	ifq->ifq_tail = 0;
2385df8bae1dSRodney W. Grimes 	ifq->ifq_len = 0;
23867b21048cSMax Laier 	IFQ_UNLOCK(ifq);
2387df8bae1dSRodney W. Grimes }
2388df8bae1dSRodney W. Grimes 
2389df8bae1dSRodney W. Grimes /*
23906064c5d3SRobert Watson  * Map interface name to interface structure pointer, with or without
23916064c5d3SRobert Watson  * returning a reference.
2392df8bae1dSRodney W. Grimes  */
2393df8bae1dSRodney W. Grimes struct ifnet *
23946064c5d3SRobert Watson ifunit_ref(const char *name)
23956064c5d3SRobert Watson {
23966064c5d3SRobert Watson 	struct ifnet *ifp;
23976064c5d3SRobert Watson 
239877dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
23996064c5d3SRobert Watson 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
24008bd015a1SRobert Watson 		if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0 &&
24018bd015a1SRobert Watson 		    !(ifp->if_flags & IFF_DYING))
24026064c5d3SRobert Watson 			break;
24036064c5d3SRobert Watson 	}
24046064c5d3SRobert Watson 	if (ifp != NULL)
24056064c5d3SRobert Watson 		if_ref(ifp);
240677dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
24076064c5d3SRobert Watson 	return (ifp);
24086064c5d3SRobert Watson }
24096064c5d3SRobert Watson 
24106064c5d3SRobert Watson struct ifnet *
241130aad87dSBrooks Davis ifunit(const char *name)
2412df8bae1dSRodney W. Grimes {
24138b7805e4SBoris Popov 	struct ifnet *ifp;
2414df8bae1dSRodney W. Grimes 
241577dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
2416603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
241736c19a57SBrooks Davis 		if (strncmp(name, ifp->if_xname, IFNAMSIZ) == 0)
2418df8bae1dSRodney W. Grimes 			break;
2419df8bae1dSRodney W. Grimes 	}
242077dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
2421df8bae1dSRodney W. Grimes 	return (ifp);
2422df8bae1dSRodney W. Grimes }
2423df8bae1dSRodney W. Grimes 
242486d2ef16SBrooks Davis static void *
24258a4a4a43SBrooks Davis ifr_buffer_get_buffer(void *data)
242686d2ef16SBrooks Davis {
242786d2ef16SBrooks Davis 	union ifreq_union *ifrup;
242886d2ef16SBrooks Davis 
242986d2ef16SBrooks Davis 	ifrup = data;
243086d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24318a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
243286d2ef16SBrooks Davis 		return ((void *)(uintptr_t)
243386d2ef16SBrooks Davis 		    ifrup->ifr32.ifr_ifru.ifru_buffer.buffer);
243486d2ef16SBrooks Davis #endif
243586d2ef16SBrooks Davis 	return (ifrup->ifr.ifr_ifru.ifru_buffer.buffer);
243686d2ef16SBrooks Davis }
243786d2ef16SBrooks Davis 
243886d2ef16SBrooks Davis static void
24398a4a4a43SBrooks Davis ifr_buffer_set_buffer_null(void *data)
244086d2ef16SBrooks Davis {
244186d2ef16SBrooks Davis 	union ifreq_union *ifrup;
244286d2ef16SBrooks Davis 
244386d2ef16SBrooks Davis 	ifrup = data;
244486d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24458a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
244686d2ef16SBrooks Davis 		ifrup->ifr32.ifr_ifru.ifru_buffer.buffer = 0;
244786d2ef16SBrooks Davis 	else
244886d2ef16SBrooks Davis #endif
244986d2ef16SBrooks Davis 		ifrup->ifr.ifr_ifru.ifru_buffer.buffer = NULL;
245086d2ef16SBrooks Davis }
245186d2ef16SBrooks Davis 
245286d2ef16SBrooks Davis static size_t
24538a4a4a43SBrooks Davis ifr_buffer_get_length(void *data)
245486d2ef16SBrooks Davis {
245586d2ef16SBrooks Davis 	union ifreq_union *ifrup;
245686d2ef16SBrooks Davis 
245786d2ef16SBrooks Davis 	ifrup = data;
245886d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24598a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
246086d2ef16SBrooks Davis 		return (ifrup->ifr32.ifr_ifru.ifru_buffer.length);
246186d2ef16SBrooks Davis #endif
246286d2ef16SBrooks Davis 	return (ifrup->ifr.ifr_ifru.ifru_buffer.length);
246386d2ef16SBrooks Davis }
246486d2ef16SBrooks Davis 
246586d2ef16SBrooks Davis static void
24668a4a4a43SBrooks Davis ifr_buffer_set_length(void *data, size_t len)
246786d2ef16SBrooks Davis {
246886d2ef16SBrooks Davis 	union ifreq_union *ifrup;
246986d2ef16SBrooks Davis 
247086d2ef16SBrooks Davis 	ifrup = data;
247186d2ef16SBrooks Davis #ifdef COMPAT_FREEBSD32
24728a4a4a43SBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
247386d2ef16SBrooks Davis 		ifrup->ifr32.ifr_ifru.ifru_buffer.length = len;
247486d2ef16SBrooks Davis 	else
247586d2ef16SBrooks Davis #endif
247686d2ef16SBrooks Davis 		ifrup->ifr.ifr_ifru.ifru_buffer.length = len;
247786d2ef16SBrooks Davis }
247886d2ef16SBrooks Davis 
2479541d96aaSBrooks Davis void *
2480541d96aaSBrooks Davis ifr_data_get_ptr(void *ifrp)
2481541d96aaSBrooks Davis {
2482541d96aaSBrooks Davis 	union ifreq_union *ifrup;
2483541d96aaSBrooks Davis 
2484541d96aaSBrooks Davis 	ifrup = ifrp;
2485541d96aaSBrooks Davis #ifdef COMPAT_FREEBSD32
2486541d96aaSBrooks Davis 	if (SV_CURPROC_FLAG(SV_ILP32))
2487541d96aaSBrooks Davis 		return ((void *)(uintptr_t)
2488541d96aaSBrooks Davis 		    ifrup->ifr32.ifr_ifru.ifru_data);
2489541d96aaSBrooks Davis #endif
2490541d96aaSBrooks Davis 		return (ifrup->ifr.ifr_ifru.ifru_data);
2491541d96aaSBrooks Davis }
2492541d96aaSBrooks Davis 
249382cd038dSYoshinobu Inoue /*
2494f13ad206SJonathan Lemon  * Hardware specific interface ioctls.
2495df8bae1dSRodney W. Grimes  */
2496f13ad206SJonathan Lemon static int
2497f13ad206SJonathan Lemon ifhwioctl(u_long cmd, struct ifnet *ifp, caddr_t data, struct thread *td)
2498df8bae1dSRodney W. Grimes {
2499f13ad206SJonathan Lemon 	struct ifreq *ifr;
2500cc5bb78bSSepherosa Ziehau 	int error = 0, do_ifup = 0;
2501292ee7beSRobert Watson 	int new_flags, temp_flags;
250236c19a57SBrooks Davis 	size_t namelen, onamelen;
2503215940b3SXin LI 	size_t descrlen;
2504215940b3SXin LI 	char *descrbuf, *odescrbuf;
250536c19a57SBrooks Davis 	char new_name[IFNAMSIZ];
250636c19a57SBrooks Davis 	struct ifaddr *ifa;
250736c19a57SBrooks Davis 	struct sockaddr_dl *sdl;
2508df8bae1dSRodney W. Grimes 
2509df8bae1dSRodney W. Grimes 	ifr = (struct ifreq *)data;
251030aad87dSBrooks Davis 	switch (cmd) {
2511de593450SJonathan Lemon 	case SIOCGIFINDEX:
2512de593450SJonathan Lemon 		ifr->ifr_index = ifp->if_index;
2513de593450SJonathan Lemon 		break;
2514de593450SJonathan Lemon 
2515df8bae1dSRodney W. Grimes 	case SIOCGIFFLAGS:
2516292ee7beSRobert Watson 		temp_flags = ifp->if_flags | ifp->if_drv_flags;
2517292ee7beSRobert Watson 		ifr->ifr_flags = temp_flags & 0xffff;
2518292ee7beSRobert Watson 		ifr->ifr_flagshigh = temp_flags >> 16;
2519df8bae1dSRodney W. Grimes 		break;
2520df8bae1dSRodney W. Grimes 
2521016da741SJonathan Lemon 	case SIOCGIFCAP:
2522016da741SJonathan Lemon 		ifr->ifr_reqcap = ifp->if_capabilities;
2523016da741SJonathan Lemon 		ifr->ifr_curcap = ifp->if_capenable;
2524016da741SJonathan Lemon 		break;
2525016da741SJonathan Lemon 
25268f293a63SRobert Watson #ifdef MAC
25278f293a63SRobert Watson 	case SIOCGIFMAC:
252830d239bcSRobert Watson 		error = mac_ifnet_ioctl_get(td->td_ucred, ifr, ifp);
25298f293a63SRobert Watson 		break;
25308f293a63SRobert Watson #endif
25318f293a63SRobert Watson 
2532df8bae1dSRodney W. Grimes 	case SIOCGIFMETRIC:
2533df8bae1dSRodney W. Grimes 		ifr->ifr_metric = ifp->if_metric;
2534df8bae1dSRodney W. Grimes 		break;
2535df8bae1dSRodney W. Grimes 
2536a7028af7SDavid Greenman 	case SIOCGIFMTU:
2537a7028af7SDavid Greenman 		ifr->ifr_mtu = ifp->if_mtu;
2538a7028af7SDavid Greenman 		break;
2539a7028af7SDavid Greenman 
2540074c4a4eSGarrett Wollman 	case SIOCGIFPHYS:
2541e6485f73SGleb Smirnoff 		/* XXXGL: did this ever worked? */
2542e6485f73SGleb Smirnoff 		ifr->ifr_phys = 0;
2543074c4a4eSGarrett Wollman 		break;
2544074c4a4eSGarrett Wollman 
2545215940b3SXin LI 	case SIOCGIFDESCR:
2546215940b3SXin LI 		error = 0;
2547215940b3SXin LI 		sx_slock(&ifdescr_sx);
254857d84848SXin LI 		if (ifp->if_description == NULL)
2549215940b3SXin LI 			error = ENOMSG;
255057d84848SXin LI 		else {
2551215940b3SXin LI 			/* space for terminating nul */
2552215940b3SXin LI 			descrlen = strlen(ifp->if_description) + 1;
25538a4a4a43SBrooks Davis 			if (ifr_buffer_get_length(ifr) < descrlen)
25548a4a4a43SBrooks Davis 				ifr_buffer_set_buffer_null(ifr);
2555215940b3SXin LI 			else
2556215940b3SXin LI 				error = copyout(ifp->if_description,
25578a4a4a43SBrooks Davis 				    ifr_buffer_get_buffer(ifr), descrlen);
25588a4a4a43SBrooks Davis 			ifr_buffer_set_length(ifr, descrlen);
2559215940b3SXin LI 		}
2560215940b3SXin LI 		sx_sunlock(&ifdescr_sx);
2561215940b3SXin LI 		break;
2562215940b3SXin LI 
2563215940b3SXin LI 	case SIOCSIFDESCR:
2564215940b3SXin LI 		error = priv_check(td, PRIV_NET_SETIFDESCR);
2565215940b3SXin LI 		if (error)
2566215940b3SXin LI 			return (error);
2567215940b3SXin LI 
2568215940b3SXin LI 		/*
2569215940b3SXin LI 		 * Copy only (length-1) bytes to make sure that
2570215940b3SXin LI 		 * if_description is always nul terminated.  The
2571215940b3SXin LI 		 * length parameter is supposed to count the
2572215940b3SXin LI 		 * terminating nul in.
2573215940b3SXin LI 		 */
25748a4a4a43SBrooks Davis 		if (ifr_buffer_get_length(ifr) > ifdescr_maxlen)
2575215940b3SXin LI 			return (ENAMETOOLONG);
25768a4a4a43SBrooks Davis 		else if (ifr_buffer_get_length(ifr) == 0)
2577215940b3SXin LI 			descrbuf = NULL;
2578215940b3SXin LI 		else {
25798a4a4a43SBrooks Davis 			descrbuf = malloc(ifr_buffer_get_length(ifr),
258086d2ef16SBrooks Davis 			    M_IFDESCR, M_WAITOK | M_ZERO);
25818a4a4a43SBrooks Davis 			error = copyin(ifr_buffer_get_buffer(ifr), descrbuf,
25828a4a4a43SBrooks Davis 			    ifr_buffer_get_length(ifr) - 1);
2583215940b3SXin LI 			if (error) {
2584215940b3SXin LI 				free(descrbuf, M_IFDESCR);
2585215940b3SXin LI 				break;
2586215940b3SXin LI 			}
2587215940b3SXin LI 		}
2588215940b3SXin LI 
2589215940b3SXin LI 		sx_xlock(&ifdescr_sx);
2590215940b3SXin LI 		odescrbuf = ifp->if_description;
2591215940b3SXin LI 		ifp->if_description = descrbuf;
2592215940b3SXin LI 		sx_xunlock(&ifdescr_sx);
2593215940b3SXin LI 
2594215940b3SXin LI 		getmicrotime(&ifp->if_lastchange);
2595215940b3SXin LI 		free(odescrbuf, M_IFDESCR);
2596215940b3SXin LI 		break;
2597215940b3SXin LI 
259835fd7bc0SBjoern A. Zeeb 	case SIOCGIFFIB:
259935fd7bc0SBjoern A. Zeeb 		ifr->ifr_fib = ifp->if_fib;
260035fd7bc0SBjoern A. Zeeb 		break;
260135fd7bc0SBjoern A. Zeeb 
260235fd7bc0SBjoern A. Zeeb 	case SIOCSIFFIB:
260335fd7bc0SBjoern A. Zeeb 		error = priv_check(td, PRIV_NET_SETIFFIB);
260435fd7bc0SBjoern A. Zeeb 		if (error)
260535fd7bc0SBjoern A. Zeeb 			return (error);
260635fd7bc0SBjoern A. Zeeb 		if (ifr->ifr_fib >= rt_numfibs)
260735fd7bc0SBjoern A. Zeeb 			return (EINVAL);
260835fd7bc0SBjoern A. Zeeb 
260935fd7bc0SBjoern A. Zeeb 		ifp->if_fib = ifr->ifr_fib;
261035fd7bc0SBjoern A. Zeeb 		break;
261135fd7bc0SBjoern A. Zeeb 
2612df8bae1dSRodney W. Grimes 	case SIOCSIFFLAGS:
2613acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFFLAGS);
26149448326fSPoul-Henning Kamp 		if (error)
2615df8bae1dSRodney W. Grimes 			return (error);
2616292ee7beSRobert Watson 		/*
2617292ee7beSRobert Watson 		 * Currently, no driver owned flags pass the IFF_CANTCHANGE
2618292ee7beSRobert Watson 		 * check, so we don't need special handling here yet.
2619292ee7beSRobert Watson 		 */
262062f76486SMaxim Sobolev 		new_flags = (ifr->ifr_flags & 0xffff) |
262162f76486SMaxim Sobolev 		    (ifr->ifr_flagshigh << 16);
2622af50ea38SGleb Smirnoff 		if (ifp->if_flags & IFF_UP &&
262362f76486SMaxim Sobolev 		    (new_flags & IFF_UP) == 0) {
2624df8bae1dSRodney W. Grimes 			if_down(ifp);
262562f76486SMaxim Sobolev 		} else if (new_flags & IFF_UP &&
2626cf4b9371SPoul-Henning Kamp 		    (ifp->if_flags & IFF_UP) == 0) {
2627cc5bb78bSSepherosa Ziehau 			do_ifup = 1;
2628df8bae1dSRodney W. Grimes 		}
26297aebc5e8SYaroslav Tykhiy 		/* See if permanently promiscuous mode bit is about to flip */
26307aebc5e8SYaroslav Tykhiy 		if ((ifp->if_flags ^ new_flags) & IFF_PPROMISC) {
26317aebc5e8SYaroslav Tykhiy 			if (new_flags & IFF_PPROMISC)
26327aebc5e8SYaroslav Tykhiy 				ifp->if_flags |= IFF_PROMISC;
26337aebc5e8SYaroslav Tykhiy 			else if (ifp->if_pcount == 0)
26347aebc5e8SYaroslav Tykhiy 				ifp->if_flags &= ~IFF_PROMISC;
26356d07c157SNick Hibma 			if (log_promisc_mode_change)
263620f8d7bcSDag-Erling Smørgrav                                 if_printf(ifp, "permanently promiscuous mode %s\n",
26376d07c157SNick Hibma                                     ((new_flags & IFF_PPROMISC) ?
26386d07c157SNick Hibma                                      "enabled" : "disabled"));
26397aebc5e8SYaroslav Tykhiy 		}
2640df8bae1dSRodney W. Grimes 		ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) |
264162f76486SMaxim Sobolev 			(new_flags &~ IFF_CANTCHANGE);
264231302ebfSRobert Watson 		if (ifp->if_ioctl) {
2643df8bae1dSRodney W. Grimes 			(void) (*ifp->if_ioctl)(ifp, cmd, data);
264431302ebfSRobert Watson 		}
2645cc5bb78bSSepherosa Ziehau 		if (do_ifup)
2646cc5bb78bSSepherosa Ziehau 			if_up(ifp);
264798b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
2648df8bae1dSRodney W. Grimes 		break;
2649df8bae1dSRodney W. Grimes 
2650016da741SJonathan Lemon 	case SIOCSIFCAP:
2651acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFCAP);
2652016da741SJonathan Lemon 		if (error)
2653016da741SJonathan Lemon 			return (error);
2654efb4018bSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2655efb4018bSYaroslav Tykhiy 			return (EOPNOTSUPP);
2656016da741SJonathan Lemon 		if (ifr->ifr_reqcap & ~ifp->if_capabilities)
2657016da741SJonathan Lemon 			return (EINVAL);
2658efb4018bSYaroslav Tykhiy 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2659efb4018bSYaroslav Tykhiy 		if (error == 0)
2660efb4018bSYaroslav Tykhiy 			getmicrotime(&ifp->if_lastchange);
2661016da741SJonathan Lemon 		break;
2662016da741SJonathan Lemon 
26638f293a63SRobert Watson #ifdef MAC
26648f293a63SRobert Watson 	case SIOCSIFMAC:
266530d239bcSRobert Watson 		error = mac_ifnet_ioctl_set(td->td_ucred, ifr, ifp);
26668f293a63SRobert Watson 		break;
26678f293a63SRobert Watson #endif
26688f293a63SRobert Watson 
266936c19a57SBrooks Davis 	case SIOCSIFNAME:
2670acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFNAME);
2671acd3428bSRobert Watson 		if (error)
267236c19a57SBrooks Davis 			return (error);
2673541d96aaSBrooks Davis 		error = copyinstr(ifr_data_get_ptr(ifr), new_name, IFNAMSIZ,
2674541d96aaSBrooks Davis 		    NULL);
2675bc1470f1SBrooks Davis 		if (error != 0)
267636c19a57SBrooks Davis 			return (error);
2677bc1470f1SBrooks Davis 		if (new_name[0] == '\0')
2678bc1470f1SBrooks Davis 			return (EINVAL);
26791ef3d54dSDon Lewis 		if (new_name[IFNAMSIZ-1] != '\0') {
26801ef3d54dSDon Lewis 			new_name[IFNAMSIZ-1] = '\0';
26811ef3d54dSDon Lewis 			if (strlen(new_name) == IFNAMSIZ-1)
26821ef3d54dSDon Lewis 				return (EINVAL);
26831ef3d54dSDon Lewis 		}
268436c19a57SBrooks Davis 		if (ifunit(new_name) != NULL)
268536c19a57SBrooks Davis 			return (EEXIST);
268636c19a57SBrooks Davis 
26875428776eSJohn Baldwin 		/*
26885428776eSJohn Baldwin 		 * XXX: Locking.  Nothing else seems to lock if_flags,
26895428776eSJohn Baldwin 		 * and there are numerous other races with the
26905428776eSJohn Baldwin 		 * ifunit() checks not being atomic with namespace
26915428776eSJohn Baldwin 		 * changes (renames, vmoves, if_attach, etc).
26925428776eSJohn Baldwin 		 */
26935428776eSJohn Baldwin 		ifp->if_flags |= IFF_RENAMING;
26945428776eSJohn Baldwin 
269536c19a57SBrooks Davis 		/* Announce the departure of the interface. */
269636c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_DEPARTURE);
269752023244SMax Laier 		EVENTHANDLER_INVOKE(ifnet_departure_event, ifp);
269836c19a57SBrooks Davis 
269920f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "changing name to '%s'\n", new_name);
270071672bb6SBrooks Davis 
270167420bdaSGleb Smirnoff 		IF_ADDR_WLOCK(ifp);
270236c19a57SBrooks Davis 		strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname));
27034a0d6638SRuslan Ermilov 		ifa = ifp->if_addr;
270436c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_addr;
270536c19a57SBrooks Davis 		namelen = strlen(new_name);
270636c19a57SBrooks Davis 		onamelen = sdl->sdl_nlen;
270736c19a57SBrooks Davis 		/*
270836c19a57SBrooks Davis 		 * Move the address if needed.  This is safe because we
270936c19a57SBrooks Davis 		 * allocate space for a name of length IFNAMSIZ when we
271036c19a57SBrooks Davis 		 * create this in if_attach().
271136c19a57SBrooks Davis 		 */
271236c19a57SBrooks Davis 		if (namelen != onamelen) {
271336c19a57SBrooks Davis 			bcopy(sdl->sdl_data + onamelen,
271436c19a57SBrooks Davis 			    sdl->sdl_data + namelen, sdl->sdl_alen);
271536c19a57SBrooks Davis 		}
271636c19a57SBrooks Davis 		bcopy(new_name, sdl->sdl_data, namelen);
271736c19a57SBrooks Davis 		sdl->sdl_nlen = namelen;
271836c19a57SBrooks Davis 		sdl = (struct sockaddr_dl *)ifa->ifa_netmask;
271936c19a57SBrooks Davis 		bzero(sdl->sdl_data, onamelen);
272036c19a57SBrooks Davis 		while (namelen != 0)
272136c19a57SBrooks Davis 			sdl->sdl_data[--namelen] = 0xff;
272267420bdaSGleb Smirnoff 		IF_ADDR_WUNLOCK(ifp);
272336c19a57SBrooks Davis 
272425a4adceSMax Laier 		EVENTHANDLER_INVOKE(ifnet_arrival_event, ifp);
272536c19a57SBrooks Davis 		/* Announce the return of the interface. */
272636c19a57SBrooks Davis 		rt_ifannouncemsg(ifp, IFAN_ARRIVAL);
27275428776eSJohn Baldwin 
27285428776eSJohn Baldwin 		ifp->if_flags &= ~IFF_RENAMING;
272936c19a57SBrooks Davis 		break;
273036c19a57SBrooks Davis 
2731679e1390SJamie Gritton #ifdef VIMAGE
2732679e1390SJamie Gritton 	case SIOCSIFVNET:
2733679e1390SJamie Gritton 		error = priv_check(td, PRIV_NET_SETIFVNET);
2734679e1390SJamie Gritton 		if (error)
2735679e1390SJamie Gritton 			return (error);
2736be31e5e7SBjoern A. Zeeb 		error = if_vmove_loan(td, ifp, ifr->ifr_name, ifr->ifr_jid);
2737679e1390SJamie Gritton 		break;
2738679e1390SJamie Gritton #endif
2739679e1390SJamie Gritton 
2740df8bae1dSRodney W. Grimes 	case SIOCSIFMETRIC:
2741acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMETRIC);
27429448326fSPoul-Henning Kamp 		if (error)
2743df8bae1dSRodney W. Grimes 			return (error);
2744df8bae1dSRodney W. Grimes 		ifp->if_metric = ifr->ifr_metric;
274598b9590eSPoul-Henning Kamp 		getmicrotime(&ifp->if_lastchange);
2746df8bae1dSRodney W. Grimes 		break;
2747df8bae1dSRodney W. Grimes 
2748074c4a4eSGarrett Wollman 	case SIOCSIFPHYS:
2749acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFPHYS);
2750e39a0280SGary Palmer 		if (error)
2751913e410eSYaroslav Tykhiy 			return (error);
2752913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2753913e410eSYaroslav Tykhiy 			return (EOPNOTSUPP);
2754e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2755e39a0280SGary Palmer 		if (error == 0)
275698b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2757913e410eSYaroslav Tykhiy 		break;
2758074c4a4eSGarrett Wollman 
2759a7028af7SDavid Greenman 	case SIOCSIFMTU:
276082cd038dSYoshinobu Inoue 	{
276182cd038dSYoshinobu Inoue 		u_long oldmtu = ifp->if_mtu;
276282cd038dSYoshinobu Inoue 
2763acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETIFMTU);
27649448326fSPoul-Henning Kamp 		if (error)
2765a7028af7SDavid Greenman 			return (error);
2766aab3beeeSBrian Somers 		if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU)
276775ee03cbSDavid Greenman 			return (EINVAL);
2768f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
2769f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
2770e39a0280SGary Palmer 		error = (*ifp->if_ioctl)(ifp, cmd, data);
277148f71763SRuslan Ermilov 		if (error == 0) {
277298b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
277348f71763SRuslan Ermilov 			rt_ifmsg(ifp);
2774e5054602SMark Johnston #ifdef INET
2775e5054602SMark Johnston 			NETDUMP_REINIT(ifp);
2776e5054602SMark Johnston #endif
277748f71763SRuslan Ermilov 		}
277882cd038dSYoshinobu Inoue 		/*
277982cd038dSYoshinobu Inoue 		 * If the link MTU changed, do network layer specific procedure.
278082cd038dSYoshinobu Inoue 		 */
278182cd038dSYoshinobu Inoue 		if (ifp->if_mtu != oldmtu) {
278282cd038dSYoshinobu Inoue #ifdef INET6
278382cd038dSYoshinobu Inoue 			nd6_setmtu(ifp);
278482cd038dSYoshinobu Inoue #endif
27857f948f12SAlexander V. Chernikov 			rt_updatemtu(ifp);
278682cd038dSYoshinobu Inoue 		}
2787f13ad206SJonathan Lemon 		break;
278882cd038dSYoshinobu Inoue 	}
2789a7028af7SDavid Greenman 
2790df8bae1dSRodney W. Grimes 	case SIOCADDMULTI:
2791df8bae1dSRodney W. Grimes 	case SIOCDELMULTI:
2792acd3428bSRobert Watson 		if (cmd == SIOCADDMULTI)
2793acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_ADDMULTI);
2794acd3428bSRobert Watson 		else
2795acd3428bSRobert Watson 			error = priv_check(td, PRIV_NET_DELMULTI);
27969448326fSPoul-Henning Kamp 		if (error)
2797df8bae1dSRodney W. Grimes 			return (error);
2798477180fbSGarrett Wollman 
2799477180fbSGarrett Wollman 		/* Don't allow group membership on non-multicast interfaces. */
2800477180fbSGarrett Wollman 		if ((ifp->if_flags & IFF_MULTICAST) == 0)
2801f13ad206SJonathan Lemon 			return (EOPNOTSUPP);
2802477180fbSGarrett Wollman 
2803477180fbSGarrett Wollman 		/* Don't let users screw up protocols' entries. */
2804477180fbSGarrett Wollman 		if (ifr->ifr_addr.sa_family != AF_LINK)
2805f13ad206SJonathan Lemon 			return (EINVAL);
2806477180fbSGarrett Wollman 
2807477180fbSGarrett Wollman 		if (cmd == SIOCADDMULTI) {
2808477180fbSGarrett Wollman 			struct ifmultiaddr *ifma;
2809ec002feeSBruce M Simpson 
2810ec002feeSBruce M Simpson 			/*
2811ec002feeSBruce M Simpson 			 * Userland is only permitted to join groups once
2812ec002feeSBruce M Simpson 			 * via the if_addmulti() KPI, because it cannot hold
2813ec002feeSBruce M Simpson 			 * struct ifmultiaddr * between calls. It may also
2814ec002feeSBruce M Simpson 			 * lose a race while we check if the membership
2815ec002feeSBruce M Simpson 			 * already exists.
2816ec002feeSBruce M Simpson 			 */
2817137f91e8SJohn Baldwin 			IF_ADDR_RLOCK(ifp);
2818ec002feeSBruce M Simpson 			ifma = if_findmulti(ifp, &ifr->ifr_addr);
2819137f91e8SJohn Baldwin 			IF_ADDR_RUNLOCK(ifp);
2820ec002feeSBruce M Simpson 			if (ifma != NULL)
2821ec002feeSBruce M Simpson 				error = EADDRINUSE;
2822ec002feeSBruce M Simpson 			else
2823477180fbSGarrett Wollman 				error = if_addmulti(ifp, &ifr->ifr_addr, &ifma);
2824477180fbSGarrett Wollman 		} else {
2825477180fbSGarrett Wollman 			error = if_delmulti(ifp, &ifr->ifr_addr);
2826477180fbSGarrett Wollman 		}
2827e39a0280SGary Palmer 		if (error == 0)
282898b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2829f13ad206SJonathan Lemon 		break;
2830df8bae1dSRodney W. Grimes 
283141b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR:
283241b3e8e5SJun-ichiro itojun Hagino 	case SIOCDIFPHYADDR:
283341b3e8e5SJun-ichiro itojun Hagino #ifdef INET6
283441b3e8e5SJun-ichiro itojun Hagino 	case SIOCSIFPHYADDR_IN6:
283541b3e8e5SJun-ichiro itojun Hagino #endif
2836a912e453SPeter Wemm 	case SIOCSIFMEDIA:
2837d7189ec6SJoerg Wunsch 	case SIOCSIFGENERIC:
2838acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_HWIOCTL);
2839a912e453SPeter Wemm 		if (error)
2840a912e453SPeter Wemm 			return (error);
2841f13ad206SJonathan Lemon 		if (ifp->if_ioctl == NULL)
2842a912e453SPeter Wemm 			return (EOPNOTSUPP);
2843a912e453SPeter Wemm 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2844a912e453SPeter Wemm 		if (error == 0)
284598b9590eSPoul-Henning Kamp 			getmicrotime(&ifp->if_lastchange);
2846f13ad206SJonathan Lemon 		break;
2847a912e453SPeter Wemm 
2848413dd0baSPoul-Henning Kamp 	case SIOCGIFSTATUS:
284933841545SHajimu UMEMOTO 	case SIOCGIFPSRCADDR:
285033841545SHajimu UMEMOTO 	case SIOCGIFPDSTADDR:
2851a912e453SPeter Wemm 	case SIOCGIFMEDIA:
2852eb7e25b2SEric Joyner 	case SIOCGIFXMEDIA:
2853d7189ec6SJoerg Wunsch 	case SIOCGIFGENERIC:
28540f3af041SSepherosa Ziehau 	case SIOCGIFRSSKEY:
28550f3af041SSepherosa Ziehau 	case SIOCGIFRSSHASH:
2856913e410eSYaroslav Tykhiy 		if (ifp->if_ioctl == NULL)
2857a912e453SPeter Wemm 			return (EOPNOTSUPP);
2858f13ad206SJonathan Lemon 		error = (*ifp->if_ioctl)(ifp, cmd, data);
2859f13ad206SJonathan Lemon 		break;
2860a912e453SPeter Wemm 
2861b106252cSBill Paul 	case SIOCSIFLLADDR:
2862acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_SETLLADDR);
2863b106252cSBill Paul 		if (error)
2864b106252cSBill Paul 			return (error);
2865f13ad206SJonathan Lemon 		error = if_setlladdr(ifp,
286666ce51ceSArchie Cobbs 		    ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len);
2867f13ad206SJonathan Lemon 		break;
286866ce51ceSArchie Cobbs 
2869ddae5750SRavi Pokala 	case SIOCGHWADDR:
2870ddae5750SRavi Pokala 		error = if_gethwaddr(ifp, ifr);
2871ddae5750SRavi Pokala 		break;
2872ddae5750SRavi Pokala 
2873756181b8SBrooks Davis 	CASE_IOC_IFGROUPREQ(SIOCAIFGROUP):
2874acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_ADDIFGROUP);
28750dad3f0eSMax Laier 		if (error)
28760dad3f0eSMax Laier 			return (error);
2877756181b8SBrooks Davis 		if ((error = if_addgroup(ifp,
2878756181b8SBrooks Davis 		    ifgr_group_get((struct ifgroupreq *)data))))
28790dad3f0eSMax Laier 			return (error);
28800dad3f0eSMax Laier 		break;
28810dad3f0eSMax Laier 
2882756181b8SBrooks Davis 	CASE_IOC_IFGROUPREQ(SIOCGIFGROUP):
2883756181b8SBrooks Davis 		if ((error = if_getgroup((struct ifgroupreq *)data, ifp)))
2884756181b8SBrooks Davis 			return (error);
2885756181b8SBrooks Davis 		break;
28860dad3f0eSMax Laier 
2887756181b8SBrooks Davis 	CASE_IOC_IFGROUPREQ(SIOCDIFGROUP):
2888acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_DELIFGROUP);
28890dad3f0eSMax Laier 		if (error)
28900dad3f0eSMax Laier 			return (error);
2891756181b8SBrooks Davis 		if ((error = if_delgroup(ifp,
2892756181b8SBrooks Davis 		    ifgr_group_get((struct ifgroupreq *)data))))
28930dad3f0eSMax Laier 			return (error);
28940dad3f0eSMax Laier 		break;
28950dad3f0eSMax Laier 
2896df8bae1dSRodney W. Grimes 	default:
2897f13ad206SJonathan Lemon 		error = ENOIOCTL;
2898f13ad206SJonathan Lemon 		break;
2899f13ad206SJonathan Lemon 	}
2900f13ad206SJonathan Lemon 	return (error);
2901f13ad206SJonathan Lemon }
2902f13ad206SJonathan Lemon 
29039af74f3dSSergey Kandaurov #ifdef COMPAT_FREEBSD32
29049af74f3dSSergey Kandaurov struct ifconf32 {
29059af74f3dSSergey Kandaurov 	int32_t	ifc_len;
29069af74f3dSSergey Kandaurov 	union {
29079af74f3dSSergey Kandaurov 		uint32_t	ifcu_buf;
29089af74f3dSSergey Kandaurov 		uint32_t	ifcu_req;
29099af74f3dSSergey Kandaurov 	} ifc_ifcu;
29109af74f3dSSergey Kandaurov };
29119af74f3dSSergey Kandaurov #define	SIOCGIFCONF32	_IOWR('i', 36, struct ifconf32)
29129af74f3dSSergey Kandaurov #endif
29139af74f3dSSergey Kandaurov 
29143edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
29153edb7f4eSBrooks Davis static void
29163edb7f4eSBrooks Davis ifmr_init(struct ifmediareq *ifmr, caddr_t data)
29173edb7f4eSBrooks Davis {
29183edb7f4eSBrooks Davis 	struct ifmediareq32 *ifmr32;
29193edb7f4eSBrooks Davis 
29203edb7f4eSBrooks Davis 	ifmr32 = (struct ifmediareq32 *)data;
29213edb7f4eSBrooks Davis 	memcpy(ifmr->ifm_name, ifmr32->ifm_name,
29223edb7f4eSBrooks Davis 	    sizeof(ifmr->ifm_name));
29233edb7f4eSBrooks Davis 	ifmr->ifm_current = ifmr32->ifm_current;
29243edb7f4eSBrooks Davis 	ifmr->ifm_mask = ifmr32->ifm_mask;
29253edb7f4eSBrooks Davis 	ifmr->ifm_status = ifmr32->ifm_status;
29263edb7f4eSBrooks Davis 	ifmr->ifm_active = ifmr32->ifm_active;
29273edb7f4eSBrooks Davis 	ifmr->ifm_count = ifmr32->ifm_count;
29283edb7f4eSBrooks Davis 	ifmr->ifm_ulist = (int *)(uintptr_t)ifmr32->ifm_ulist;
29293edb7f4eSBrooks Davis }
29303edb7f4eSBrooks Davis 
29313edb7f4eSBrooks Davis static void
29323edb7f4eSBrooks Davis ifmr_update(const struct ifmediareq *ifmr, caddr_t data)
29333edb7f4eSBrooks Davis {
29343edb7f4eSBrooks Davis 	struct ifmediareq32 *ifmr32;
29353edb7f4eSBrooks Davis 
29363edb7f4eSBrooks Davis 	ifmr32 = (struct ifmediareq32 *)data;
29373edb7f4eSBrooks Davis 	ifmr32->ifm_current = ifmr->ifm_current;
29383edb7f4eSBrooks Davis 	ifmr32->ifm_mask = ifmr->ifm_mask;
29393edb7f4eSBrooks Davis 	ifmr32->ifm_status = ifmr->ifm_status;
29403edb7f4eSBrooks Davis 	ifmr32->ifm_active = ifmr->ifm_active;
29413edb7f4eSBrooks Davis 	ifmr32->ifm_count = ifmr->ifm_count;
29423edb7f4eSBrooks Davis }
29433edb7f4eSBrooks Davis #endif
29443edb7f4eSBrooks Davis 
2945f13ad206SJonathan Lemon /*
2946f13ad206SJonathan Lemon  * Interface ioctls.
2947f13ad206SJonathan Lemon  */
2948f13ad206SJonathan Lemon int
294972fd1b6aSDag-Erling Smørgrav ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td)
2950f13ad206SJonathan Lemon {
29513edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
29523edb7f4eSBrooks Davis 	caddr_t saved_data;
29533edb7f4eSBrooks Davis 	struct ifmediareq ifmr;
29543edb7f4eSBrooks Davis #endif
29553edb7f4eSBrooks Davis 	struct ifmediareq *ifmrp;
2956f13ad206SJonathan Lemon 	struct ifnet *ifp;
2957f13ad206SJonathan Lemon 	struct ifreq *ifr;
2958f13ad206SJonathan Lemon 	int error;
295962f76486SMaxim Sobolev 	int oif_flags;
296089856f7eSBjoern A. Zeeb #ifdef VIMAGE
296189856f7eSBjoern A. Zeeb 	int shutdown;
296289856f7eSBjoern A. Zeeb #endif
2963f13ad206SJonathan Lemon 
29641fb51a12SBjoern A. Zeeb 	CURVNET_SET(so->so_vnet);
296589856f7eSBjoern A. Zeeb #ifdef VIMAGE
296689856f7eSBjoern A. Zeeb 	/* Make sure the VNET is stable. */
296789856f7eSBjoern A. Zeeb 	shutdown = (so->so_vnet->vnet_state > SI_SUB_VNET &&
296889856f7eSBjoern A. Zeeb 		 so->so_vnet->vnet_state < SI_SUB_VNET_DONE) ? 1 : 0;
296989856f7eSBjoern A. Zeeb 	if (shutdown) {
297089856f7eSBjoern A. Zeeb 		CURVNET_RESTORE();
297189856f7eSBjoern A. Zeeb 		return (EBUSY);
297289856f7eSBjoern A. Zeeb 	}
297389856f7eSBjoern A. Zeeb #endif
297489856f7eSBjoern A. Zeeb 
297589856f7eSBjoern A. Zeeb 
2976f13ad206SJonathan Lemon 	switch (cmd) {
2977f13ad206SJonathan Lemon 	case SIOCGIFCONF:
29781fb51a12SBjoern A. Zeeb 		error = ifconf(cmd, data);
29791fb51a12SBjoern A. Zeeb 		CURVNET_RESTORE();
29801fb51a12SBjoern A. Zeeb 		return (error);
29819af74f3dSSergey Kandaurov 
29829af74f3dSSergey Kandaurov #ifdef COMPAT_FREEBSD32
29839af74f3dSSergey Kandaurov 	case SIOCGIFCONF32:
29849af74f3dSSergey Kandaurov 		{
29859af74f3dSSergey Kandaurov 			struct ifconf32 *ifc32;
29869af74f3dSSergey Kandaurov 			struct ifconf ifc;
29879af74f3dSSergey Kandaurov 
29889af74f3dSSergey Kandaurov 			ifc32 = (struct ifconf32 *)data;
29899af74f3dSSergey Kandaurov 			ifc.ifc_len = ifc32->ifc_len;
29909af74f3dSSergey Kandaurov 			ifc.ifc_buf = PTRIN(ifc32->ifc_buf);
29919af74f3dSSergey Kandaurov 
29921fb51a12SBjoern A. Zeeb 			error = ifconf(SIOCGIFCONF, (void *)&ifc);
29931fb51a12SBjoern A. Zeeb 			CURVNET_RESTORE();
299423519598SSergey Kandaurov 			if (error == 0)
299523519598SSergey Kandaurov 				ifc32->ifc_len = ifc.ifc_len;
29961fb51a12SBjoern A. Zeeb 			return (error);
29979af74f3dSSergey Kandaurov 		}
29989af74f3dSSergey Kandaurov #endif
2999f13ad206SJonathan Lemon 	}
3000f13ad206SJonathan Lemon 
30013edb7f4eSBrooks Davis 	ifmrp = NULL;
30023edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
30033edb7f4eSBrooks Davis 	switch (cmd) {
30043edb7f4eSBrooks Davis 	case SIOCGIFMEDIA32:
30053edb7f4eSBrooks Davis 	case SIOCGIFXMEDIA32:
30063edb7f4eSBrooks Davis 		ifmrp = &ifmr;
30073edb7f4eSBrooks Davis 		ifmr_init(ifmrp, data);
30083edb7f4eSBrooks Davis 		cmd = _IOC_NEWTYPE(cmd, struct ifmediareq);
30093edb7f4eSBrooks Davis 		saved_data = data;
30103edb7f4eSBrooks Davis 		data = (caddr_t)ifmrp;
30113edb7f4eSBrooks Davis 	}
30123edb7f4eSBrooks Davis #endif
30133edb7f4eSBrooks Davis 
30143edb7f4eSBrooks Davis 	ifr = (struct ifreq *)data;
3015f13ad206SJonathan Lemon 	switch (cmd) {
3016feb08d06SMarko Zec #ifdef VIMAGE
3017679e1390SJamie Gritton 	case SIOCSIFRVNET:
3018679e1390SJamie Gritton 		error = priv_check(td, PRIV_NET_SETIFVNET);
30191fb51a12SBjoern A. Zeeb 		if (error == 0)
30201fb51a12SBjoern A. Zeeb 			error = if_vmove_reclaim(td, ifr->ifr_name,
30211fb51a12SBjoern A. Zeeb 			    ifr->ifr_jid);
30223edb7f4eSBrooks Davis 		goto out_noref;
3023feb08d06SMarko Zec #endif
3024f13ad206SJonathan Lemon 	case SIOCIFCREATE:
30256b7330e2SSam Leffler 	case SIOCIFCREATE2:
3026acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFCREATE);
30271fb51a12SBjoern A. Zeeb 		if (error == 0)
30281fb51a12SBjoern A. Zeeb 			error = if_clone_create(ifr->ifr_name,
3029541d96aaSBrooks Davis 			    sizeof(ifr->ifr_name), cmd == SIOCIFCREATE2 ?
3030541d96aaSBrooks Davis 			    ifr_data_get_ptr(ifr) : NULL);
30313edb7f4eSBrooks Davis 		goto out_noref;
3032f13ad206SJonathan Lemon 	case SIOCIFDESTROY:
3033acd3428bSRobert Watson 		error = priv_check(td, PRIV_NET_IFDESTROY);
30341fb51a12SBjoern A. Zeeb 		if (error == 0)
30351fb51a12SBjoern A. Zeeb 			error = if_clone_destroy(ifr->ifr_name);
30363edb7f4eSBrooks Davis 		goto out_noref;
3037f13ad206SJonathan Lemon 
3038f13ad206SJonathan Lemon 	case SIOCIFGCLONERS:
30391fb51a12SBjoern A. Zeeb 		error = if_clone_list((struct if_clonereq *)data);
30403edb7f4eSBrooks Davis 		goto out_noref;
30413edb7f4eSBrooks Davis 
3042756181b8SBrooks Davis 	CASE_IOC_IFGROUPREQ(SIOCGIFGMEMB):
30431fb51a12SBjoern A. Zeeb 		error = if_getgroupmembers((struct ifgroupreq *)data);
30443edb7f4eSBrooks Davis 		goto out_noref;
30453edb7f4eSBrooks Davis 
304608b68b0eSGleb Smirnoff #if defined(INET) || defined(INET6)
304708b68b0eSGleb Smirnoff 	case SIOCSVH:
304808b68b0eSGleb Smirnoff 	case SIOCGVH:
304908b68b0eSGleb Smirnoff 		if (carp_ioctl_p == NULL)
305008b68b0eSGleb Smirnoff 			error = EPROTONOSUPPORT;
305108b68b0eSGleb Smirnoff 		else
305208b68b0eSGleb Smirnoff 			error = (*carp_ioctl_p)(ifr, cmd, td);
30533edb7f4eSBrooks Davis 		goto out_noref;
305408b68b0eSGleb Smirnoff #endif
3055f13ad206SJonathan Lemon 	}
3056f13ad206SJonathan Lemon 
30576064c5d3SRobert Watson 	ifp = ifunit_ref(ifr->ifr_name);
30581fb51a12SBjoern A. Zeeb 	if (ifp == NULL) {
30593edb7f4eSBrooks Davis 		error = ENXIO;
30603edb7f4eSBrooks Davis 		goto out_noref;
30611fb51a12SBjoern A. Zeeb 	}
3062f13ad206SJonathan Lemon 
3063f13ad206SJonathan Lemon 	error = ifhwioctl(cmd, ifp, data, td);
30643edb7f4eSBrooks Davis 	if (error != ENOIOCTL)
30653edb7f4eSBrooks Davis 		goto out_ref;
3066f13ad206SJonathan Lemon 
306782cd038dSYoshinobu Inoue 	oif_flags = ifp->if_flags;
30686064c5d3SRobert Watson 	if (so->so_proto == NULL) {
30693edb7f4eSBrooks Davis 		error = EOPNOTSUPP;
30703edb7f4eSBrooks Davis 		goto out_ref;
30716064c5d3SRobert Watson 	}
30721a05c762SDag-Erling Smørgrav 
30731a05c762SDag-Erling Smørgrav 	/*
30741a05c762SDag-Erling Smørgrav 	 * Pass the request on to the socket control method, and if the
30751a05c762SDag-Erling Smørgrav 	 * latter returns EOPNOTSUPP, directly to the interface.
30761a05c762SDag-Erling Smørgrav 	 *
30771a05c762SDag-Erling Smørgrav 	 * Make an exception for the legacy SIOCSIF* requests.  Drivers
30781a05c762SDag-Erling Smørgrav 	 * trust SIOCSIFADDR et al to come from an already privileged
30791a05c762SDag-Erling Smørgrav 	 * layer, and do not perform any credentials checks or input
30801a05c762SDag-Erling Smørgrav 	 * validation.
30811a05c762SDag-Erling Smørgrav 	 */
30825fb009bdSGleb Smirnoff 	error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, data,
3083b40ce416SJulian Elischer 	    ifp, td));
30841a05c762SDag-Erling Smørgrav 	if (error == EOPNOTSUPP && ifp != NULL && ifp->if_ioctl != NULL &&
30851a05c762SDag-Erling Smørgrav 	    cmd != SIOCSIFADDR && cmd != SIOCSIFBRDADDR &&
30861a05c762SDag-Erling Smørgrav 	    cmd != SIOCSIFDSTADDR && cmd != SIOCSIFNETMASK)
3087bc3977f1SJamie Gritton 		error = (*ifp->if_ioctl)(ifp, cmd, data);
308882cd038dSYoshinobu Inoue 
308982cd038dSYoshinobu Inoue 	if ((oif_flags ^ ifp->if_flags) & IFF_UP) {
309082cd038dSYoshinobu Inoue #ifdef INET6
3091c9b652e3SAndre Oppermann 		if (ifp->if_flags & IFF_UP)
309282cd038dSYoshinobu Inoue 			in6_if_up(ifp);
309382cd038dSYoshinobu Inoue #endif
3094df8bae1dSRodney W. Grimes 	}
30953edb7f4eSBrooks Davis 
30963edb7f4eSBrooks Davis out_ref:
30976064c5d3SRobert Watson 	if_rele(ifp);
30983edb7f4eSBrooks Davis out_noref:
30993edb7f4eSBrooks Davis #ifdef COMPAT_FREEBSD32
31003edb7f4eSBrooks Davis 	if (ifmrp != NULL) {
31013edb7f4eSBrooks Davis 		KASSERT((cmd == SIOCGIFMEDIA || cmd == SIOCGIFXMEDIA),
31023edb7f4eSBrooks Davis 		    ("ifmrp non-NULL, but cmd is not an ifmedia req 0x%lx",
31033edb7f4eSBrooks Davis 		     cmd));
31043edb7f4eSBrooks Davis 		data = saved_data;
31053edb7f4eSBrooks Davis 		ifmr_update(ifmrp, data);
31063edb7f4eSBrooks Davis 	}
31073edb7f4eSBrooks Davis #endif
31081fb51a12SBjoern A. Zeeb 	CURVNET_RESTORE();
3109df8bae1dSRodney W. Grimes 	return (error);
3110df8bae1dSRodney W. Grimes }
3111df8bae1dSRodney W. Grimes 
3112df8bae1dSRodney W. Grimes /*
3113292ee7beSRobert Watson  * The code common to handling reference counted flags,
31141a3b6859SYaroslav Tykhiy  * e.g., in ifpromisc() and if_allmulti().
3115b5c8bd59SYaroslav Tykhiy  * The "pflag" argument can specify a permanent mode flag to check,
31161a3b6859SYaroslav Tykhiy  * such as IFF_PPROMISC for promiscuous mode; should be 0 if none.
3117292ee7beSRobert Watson  *
3118292ee7beSRobert Watson  * Only to be used on stack-owned flags, not driver-owned flags.
31191a3b6859SYaroslav Tykhiy  */
31201a3b6859SYaroslav Tykhiy static int
31211a3b6859SYaroslav Tykhiy if_setflag(struct ifnet *ifp, int flag, int pflag, int *refcount, int onswitch)
31221a3b6859SYaroslav Tykhiy {
31231a3b6859SYaroslav Tykhiy 	struct ifreq ifr;
31241a3b6859SYaroslav Tykhiy 	int error;
31251a3b6859SYaroslav Tykhiy 	int oldflags, oldcount;
31261a3b6859SYaroslav Tykhiy 
31271a3b6859SYaroslav Tykhiy 	/* Sanity checks to catch programming errors */
3128b5c8bd59SYaroslav Tykhiy 	KASSERT((flag & (IFF_DRV_OACTIVE|IFF_DRV_RUNNING)) == 0,
3129b5c8bd59SYaroslav Tykhiy 	    ("%s: setting driver-owned flag %d", __func__, flag));
3130b5c8bd59SYaroslav Tykhiy 
3131b5c8bd59SYaroslav Tykhiy 	if (onswitch)
3132b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount >= 0,
3133b5c8bd59SYaroslav Tykhiy 		    ("%s: increment negative refcount %d for flag %d",
3134b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
3135b5c8bd59SYaroslav Tykhiy 	else
3136b5c8bd59SYaroslav Tykhiy 		KASSERT(*refcount > 0,
3137b5c8bd59SYaroslav Tykhiy 		    ("%s: decrement non-positive refcount %d for flag %d",
3138b5c8bd59SYaroslav Tykhiy 		    __func__, *refcount, flag));
31391a3b6859SYaroslav Tykhiy 
31401a3b6859SYaroslav Tykhiy 	/* In case this mode is permanent, just touch refcount */
31411a3b6859SYaroslav Tykhiy 	if (ifp->if_flags & pflag) {
31421a3b6859SYaroslav Tykhiy 		*refcount += onswitch ? 1 : -1;
31431a3b6859SYaroslav Tykhiy 		return (0);
31441a3b6859SYaroslav Tykhiy 	}
31451a3b6859SYaroslav Tykhiy 
31461a3b6859SYaroslav Tykhiy 	/* Save ifnet parameters for if_ioctl() may fail */
31471a3b6859SYaroslav Tykhiy 	oldcount = *refcount;
31481a3b6859SYaroslav Tykhiy 	oldflags = ifp->if_flags;
31491a3b6859SYaroslav Tykhiy 
31501a3b6859SYaroslav Tykhiy 	/*
31511a3b6859SYaroslav Tykhiy 	 * See if we aren't the only and touching refcount is enough.
31521a3b6859SYaroslav Tykhiy 	 * Actually toggle interface flag if we are the first or last.
31531a3b6859SYaroslav Tykhiy 	 */
31541a3b6859SYaroslav Tykhiy 	if (onswitch) {
31551a3b6859SYaroslav Tykhiy 		if ((*refcount)++)
31561a3b6859SYaroslav Tykhiy 			return (0);
31571a3b6859SYaroslav Tykhiy 		ifp->if_flags |= flag;
31581a3b6859SYaroslav Tykhiy 	} else {
31591a3b6859SYaroslav Tykhiy 		if (--(*refcount))
31601a3b6859SYaroslav Tykhiy 			return (0);
31611a3b6859SYaroslav Tykhiy 		ifp->if_flags &= ~flag;
31621a3b6859SYaroslav Tykhiy 	}
31631a3b6859SYaroslav Tykhiy 
31641a3b6859SYaroslav Tykhiy 	/* Call down the driver since we've changed interface flags */
31651a3b6859SYaroslav Tykhiy 	if (ifp->if_ioctl == NULL) {
31661a3b6859SYaroslav Tykhiy 		error = EOPNOTSUPP;
31671a3b6859SYaroslav Tykhiy 		goto recover;
31681a3b6859SYaroslav Tykhiy 	}
31691a3b6859SYaroslav Tykhiy 	ifr.ifr_flags = ifp->if_flags & 0xffff;
31701a3b6859SYaroslav Tykhiy 	ifr.ifr_flagshigh = ifp->if_flags >> 16;
31711a3b6859SYaroslav Tykhiy 	error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
31721a3b6859SYaroslav Tykhiy 	if (error)
31731a3b6859SYaroslav Tykhiy 		goto recover;
31741a3b6859SYaroslav Tykhiy 	/* Notify userland that interface flags have changed */
31751a3b6859SYaroslav Tykhiy 	rt_ifmsg(ifp);
31761a3b6859SYaroslav Tykhiy 	return (0);
31771a3b6859SYaroslav Tykhiy 
31781a3b6859SYaroslav Tykhiy recover:
31791a3b6859SYaroslav Tykhiy 	/* Recover after driver error */
31801a3b6859SYaroslav Tykhiy 	*refcount = oldcount;
31811a3b6859SYaroslav Tykhiy 	ifp->if_flags = oldflags;
31821a3b6859SYaroslav Tykhiy 	return (error);
31831a3b6859SYaroslav Tykhiy }
31841a3b6859SYaroslav Tykhiy 
31851a3b6859SYaroslav Tykhiy /*
3186963e4c2aSGarrett Wollman  * Set/clear promiscuous mode on interface ifp based on the truth value
3187963e4c2aSGarrett Wollman  * of pswitch.  The calls are reference counted so that only the first
3188963e4c2aSGarrett Wollman  * "on" request actually has an effect, as does the final "off" request.
3189963e4c2aSGarrett Wollman  * Results are undefined if the "off" and "on" requests are not matched.
3190963e4c2aSGarrett Wollman  */
3191963e4c2aSGarrett Wollman int
319272fd1b6aSDag-Erling Smørgrav ifpromisc(struct ifnet *ifp, int pswitch)
3193963e4c2aSGarrett Wollman {
31944a26224cSGarrett Wollman 	int error;
31951a3b6859SYaroslav Tykhiy 	int oldflags = ifp->if_flags;
3196963e4c2aSGarrett Wollman 
31971a3b6859SYaroslav Tykhiy 	error = if_setflag(ifp, IFF_PROMISC, IFF_PPROMISC,
31981a3b6859SYaroslav Tykhiy 			   &ifp->if_pcount, pswitch);
31991a3b6859SYaroslav Tykhiy 	/* If promiscuous mode status has changed, log a message */
32006d07c157SNick Hibma 	if (error == 0 && ((ifp->if_flags ^ oldflags) & IFF_PROMISC) &&
32016d07c157SNick Hibma             log_promisc_mode_change)
320220f8d7bcSDag-Erling Smørgrav 		if_printf(ifp, "promiscuous mode %s\n",
32034f3c11a6SBill Fenner 		    (ifp->if_flags & IFF_PROMISC) ? "enabled" : "disabled");
32041a3b6859SYaroslav Tykhiy 	return (error);
3205963e4c2aSGarrett Wollman }
3206963e4c2aSGarrett Wollman 
3207963e4c2aSGarrett Wollman /*
3208df8bae1dSRodney W. Grimes  * Return interface configuration
3209df8bae1dSRodney W. Grimes  * of system.  List may be used
3210df8bae1dSRodney W. Grimes  * in later ioctl's (above) to get
3211df8bae1dSRodney W. Grimes  * other information.
3212df8bae1dSRodney W. Grimes  */
3213df8bae1dSRodney W. Grimes /*ARGSUSED*/
32143bda9f9bSPoul-Henning Kamp static int
321572fd1b6aSDag-Erling Smørgrav ifconf(u_long cmd, caddr_t data)
3216df8bae1dSRodney W. Grimes {
32170b59d917SJonathan Lemon 	struct ifconf *ifc = (struct ifconf *)data;
32180b59d917SJonathan Lemon 	struct ifnet *ifp;
32190b59d917SJonathan Lemon 	struct ifaddr *ifa;
32204dcf2bbbSBrooks Davis 	struct ifreq ifr;
32214dcf2bbbSBrooks Davis 	struct sbuf *sb;
32224dcf2bbbSBrooks Davis 	int error, full = 0, valid_len, max_len;
3223df8bae1dSRodney W. Grimes 
32244dcf2bbbSBrooks Davis 	/* Limit initial buffer size to MAXPHYS to avoid DoS from userspace. */
32254dcf2bbbSBrooks Davis 	max_len = MAXPHYS - 1;
32264dcf2bbbSBrooks Davis 
3227b0b4b28bSXin LI 	/* Prevent hostile input from being able to crash the system */
3228b0b4b28bSXin LI 	if (ifc->ifc_len <= 0)
3229b0b4b28bSXin LI 		return (EINVAL);
3230b0b4b28bSXin LI 
32314dcf2bbbSBrooks Davis again:
32324dcf2bbbSBrooks Davis 	if (ifc->ifc_len <= max_len) {
32334dcf2bbbSBrooks Davis 		max_len = ifc->ifc_len;
32344dcf2bbbSBrooks Davis 		full = 1;
32354dcf2bbbSBrooks Davis 	}
32364dcf2bbbSBrooks Davis 	sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
32374dcf2bbbSBrooks Davis 	max_len = 0;
32384dcf2bbbSBrooks Davis 	valid_len = 0;
32394dcf2bbbSBrooks Davis 
324077dfcdc4SRobert Watson 	IFNET_RLOCK();
3241603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
32429bf40edeSBrooks Davis 		int addrs;
32432624cf89SGarrett Wollman 
3244fbd24c5eSColin Percival 		/*
32452443045fSBrooks Davis 		 * Zero the ifr to make sure we don't disclose the contents
32462443045fSBrooks Davis 		 * of the stack.
3247fbd24c5eSColin Percival 		 */
32482443045fSBrooks Davis 		memset(&ifr, 0, sizeof(ifr));
3249fbd24c5eSColin Percival 
32509bf40edeSBrooks Davis 		if (strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name))
325162313e4cSSam Leffler 		    >= sizeof(ifr.ifr_name)) {
325262313e4cSSam Leffler 			sbuf_delete(sb);
325362313e4cSSam Leffler 			IFNET_RUNLOCK();
32544dcf2bbbSBrooks Davis 			return (ENAMETOOLONG);
325562313e4cSSam Leffler 		}
32562624cf89SGarrett Wollman 
325775c13541SPoul-Henning Kamp 		addrs = 0;
3258137f91e8SJohn Baldwin 		IF_ADDR_RLOCK(ifp);
32592defe5cdSJonathan Lemon 		TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
32602defe5cdSJonathan Lemon 			struct sockaddr *sa = ifa->ifa_addr;
32612defe5cdSJonathan Lemon 
3262b89e82ddSJamie Gritton 			if (prison_if(curthread->td_ucred, sa) != 0)
326375c13541SPoul-Henning Kamp 				continue;
326475c13541SPoul-Henning Kamp 			addrs++;
3265df8bae1dSRodney W. Grimes 			if (sa->sa_len <= sizeof(*sa)) {
3266e7fdc72eSBrooks Davis 				if (sa->sa_len < sizeof(*sa)) {
3267e7fdc72eSBrooks Davis 					memset(&ifr.ifr_ifru.ifru_addr, 0,
3268e7fdc72eSBrooks Davis 					    sizeof(ifr.ifr_ifru.ifru_addr));
3269e7fdc72eSBrooks Davis 					memcpy(&ifr.ifr_ifru.ifru_addr, sa,
3270e7fdc72eSBrooks Davis 					    sa->sa_len);
3271e7fdc72eSBrooks Davis 				} else
3272e7fdc72eSBrooks Davis 					ifr.ifr_ifru.ifru_addr = *sa;
32734dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr, sizeof(ifr));
32744dcf2bbbSBrooks Davis 				max_len += sizeof(ifr);
3275df8bae1dSRodney W. Grimes 			} else {
32764dcf2bbbSBrooks Davis 				sbuf_bcat(sb, &ifr,
32774dcf2bbbSBrooks Davis 				    offsetof(struct ifreq, ifr_addr));
32784dcf2bbbSBrooks Davis 				max_len += offsetof(struct ifreq, ifr_addr);
32794dcf2bbbSBrooks Davis 				sbuf_bcat(sb, sa, sa->sa_len);
32804dcf2bbbSBrooks Davis 				max_len += sa->sa_len;
3281df8bae1dSRodney W. Grimes 			}
32824dcf2bbbSBrooks Davis 
32834d369413SMatthew D Fleming 			if (sbuf_error(sb) == 0)
32844dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
3285df8bae1dSRodney W. Grimes 		}
3286137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
32874dcf2bbbSBrooks Davis 		if (addrs == 0) {
32884dcf2bbbSBrooks Davis 			sbuf_bcat(sb, &ifr, sizeof(ifr));
32894dcf2bbbSBrooks Davis 			max_len += sizeof(ifr);
32904dcf2bbbSBrooks Davis 
32914d369413SMatthew D Fleming 			if (sbuf_error(sb) == 0)
32924dcf2bbbSBrooks Davis 				valid_len = sbuf_len(sb);
329375c13541SPoul-Henning Kamp 		}
3294df8bae1dSRodney W. Grimes 	}
3295b30a244cSJeffrey Hsu 	IFNET_RUNLOCK();
32964dcf2bbbSBrooks Davis 
32974dcf2bbbSBrooks Davis 	/*
32984dcf2bbbSBrooks Davis 	 * If we didn't allocate enough space (uncommon), try again.  If
32994dcf2bbbSBrooks Davis 	 * we have already allocated as much space as we are allowed,
33004dcf2bbbSBrooks Davis 	 * return what we've got.
33014dcf2bbbSBrooks Davis 	 */
33024dcf2bbbSBrooks Davis 	if (valid_len != max_len && !full) {
33034dcf2bbbSBrooks Davis 		sbuf_delete(sb);
33044dcf2bbbSBrooks Davis 		goto again;
33054dcf2bbbSBrooks Davis 	}
33064dcf2bbbSBrooks Davis 
33074dcf2bbbSBrooks Davis 	ifc->ifc_len = valid_len;
33085ed8cedcSBrian Feldman 	sbuf_finish(sb);
33094dcf2bbbSBrooks Davis 	error = copyout(sbuf_data(sb), ifc->ifc_req, ifc->ifc_len);
33104dcf2bbbSBrooks Davis 	sbuf_delete(sb);
3311df8bae1dSRodney W. Grimes 	return (error);
3312df8bae1dSRodney W. Grimes }
3313df8bae1dSRodney W. Grimes 
33141158dfb7SGarrett Wollman /*
33158b25904eSGleb Smirnoff  * Just like ifpromisc(), but for all-multicast-reception mode.
33161158dfb7SGarrett Wollman  */
33171158dfb7SGarrett Wollman int
331872fd1b6aSDag-Erling Smørgrav if_allmulti(struct ifnet *ifp, int onswitch)
33191158dfb7SGarrett Wollman {
33201158dfb7SGarrett Wollman 
33211a3b6859SYaroslav Tykhiy 	return (if_setflag(ifp, IFF_ALLMULTI, 0, &ifp->if_amcount, onswitch));
33221158dfb7SGarrett Wollman }
33231158dfb7SGarrett Wollman 
33245896d124SBruce M Simpson struct ifmultiaddr *
3325441f9243SAlexander V. Chernikov if_findmulti(struct ifnet *ifp, const struct sockaddr *sa)
33261158dfb7SGarrett Wollman {
33271158dfb7SGarrett Wollman 	struct ifmultiaddr *ifma;
33281158dfb7SGarrett Wollman 
3329c3b31afdSRobert Watson 	IF_ADDR_LOCK_ASSERT(ifp);
3330c3b31afdSRobert Watson 
33316817526dSPoul-Henning Kamp 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
333240d8a302SBruce M Simpson 		if (sa->sa_family == AF_LINK) {
333340d8a302SBruce M Simpson 			if (sa_dl_equal(ifma->ifma_addr, sa))
333440d8a302SBruce M Simpson 				break;
333540d8a302SBruce M Simpson 		} else {
3336c3b31afdSRobert Watson 			if (sa_equal(ifma->ifma_addr, sa))
3337c3b31afdSRobert Watson 				break;
33381158dfb7SGarrett Wollman 		}
333940d8a302SBruce M Simpson 	}
3340c3b31afdSRobert Watson 
3341c3b31afdSRobert Watson 	return ifma;
334257af7922SJulian Elischer }
33431158dfb7SGarrett Wollman 
33441158dfb7SGarrett Wollman /*
3345c3b31afdSRobert Watson  * Allocate a new ifmultiaddr and initialize based on passed arguments.  We
3346c3b31afdSRobert Watson  * make copies of passed sockaddrs.  The ifmultiaddr will not be added to
3347c3b31afdSRobert Watson  * the ifnet multicast address list here, so the caller must do that and
3348c3b31afdSRobert Watson  * other setup work (such as notifying the device driver).  The reference
3349c3b31afdSRobert Watson  * count is initialized to 1.
33501158dfb7SGarrett Wollman  */
3351c3b31afdSRobert Watson static struct ifmultiaddr *
3352c3b31afdSRobert Watson if_allocmulti(struct ifnet *ifp, struct sockaddr *sa, struct sockaddr *llsa,
3353c3b31afdSRobert Watson     int mflags)
3354c3b31afdSRobert Watson {
3355c3b31afdSRobert Watson 	struct ifmultiaddr *ifma;
3356c3b31afdSRobert Watson 	struct sockaddr *dupsa;
3357c3b31afdSRobert Watson 
33581ede983cSDag-Erling Smørgrav 	ifma = malloc(sizeof *ifma, M_IFMADDR, mflags |
3359c3b31afdSRobert Watson 	    M_ZERO);
3360c3b31afdSRobert Watson 	if (ifma == NULL)
3361c3b31afdSRobert Watson 		return (NULL);
3362c3b31afdSRobert Watson 
33631ede983cSDag-Erling Smørgrav 	dupsa = malloc(sa->sa_len, M_IFMADDR, mflags);
3364c3b31afdSRobert Watson 	if (dupsa == NULL) {
33651ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
3366c3b31afdSRobert Watson 		return (NULL);
33671158dfb7SGarrett Wollman 	}
33681158dfb7SGarrett Wollman 	bcopy(sa, dupsa, sa->sa_len);
33691158dfb7SGarrett Wollman 	ifma->ifma_addr = dupsa;
3370c3b31afdSRobert Watson 
33711158dfb7SGarrett Wollman 	ifma->ifma_ifp = ifp;
33721158dfb7SGarrett Wollman 	ifma->ifma_refcount = 1;
3373d4d22970SGleb Smirnoff 	ifma->ifma_protospec = NULL;
3374c3b31afdSRobert Watson 
3375c3b31afdSRobert Watson 	if (llsa == NULL) {
3376c3b31afdSRobert Watson 		ifma->ifma_lladdr = NULL;
3377c3b31afdSRobert Watson 		return (ifma);
3378c3b31afdSRobert Watson 	}
3379c3b31afdSRobert Watson 
33801ede983cSDag-Erling Smørgrav 	dupsa = malloc(llsa->sa_len, M_IFMADDR, mflags);
3381c3b31afdSRobert Watson 	if (dupsa == NULL) {
33821ede983cSDag-Erling Smørgrav 		free(ifma->ifma_addr, M_IFMADDR);
33831ede983cSDag-Erling Smørgrav 		free(ifma, M_IFMADDR);
3384c3b31afdSRobert Watson 		return (NULL);
3385c3b31afdSRobert Watson 	}
3386c3b31afdSRobert Watson 	bcopy(llsa, dupsa, llsa->sa_len);
3387c3b31afdSRobert Watson 	ifma->ifma_lladdr = dupsa;
3388c3b31afdSRobert Watson 
3389c3b31afdSRobert Watson 	return (ifma);
3390c3b31afdSRobert Watson }
3391373f88edSGarrett Wollman 
33921158dfb7SGarrett Wollman /*
3393c3b31afdSRobert Watson  * if_freemulti: free ifmultiaddr structure and possibly attached related
3394c3b31afdSRobert Watson  * addresses.  The caller is responsible for implementing reference
3395c3b31afdSRobert Watson  * counting, notifying the driver, handling routing messages, and releasing
3396c3b31afdSRobert Watson  * any dependent link layer state.
33971158dfb7SGarrett Wollman  */
3398b6f6f880SMatt Macy #ifdef MCAST_VERBOSE
3399b6f6f880SMatt Macy extern void kdb_backtrace(void);
3400b6f6f880SMatt Macy #endif
3401b6f6f880SMatt Macy void
3402c3b31afdSRobert Watson if_freemulti(struct ifmultiaddr *ifma)
3403c3b31afdSRobert Watson {
3404c3b31afdSRobert Watson 
3405ec002feeSBruce M Simpson 	KASSERT(ifma->ifma_refcount == 0, ("if_freemulti: refcount %d",
3406c3b31afdSRobert Watson 	    ifma->ifma_refcount));
3407c3b31afdSRobert Watson 
3408c3b31afdSRobert Watson 	if (ifma->ifma_lladdr != NULL)
34091ede983cSDag-Erling Smørgrav 		free(ifma->ifma_lladdr, M_IFMADDR);
3410b6f6f880SMatt Macy #ifdef MCAST_VERBOSE
3411b6f6f880SMatt Macy 	kdb_backtrace();
3412b6f6f880SMatt Macy 	printf("%s freeing ifma: %p\n", __func__, ifma);
3413b6f6f880SMatt Macy #endif
34141ede983cSDag-Erling Smørgrav 	free(ifma->ifma_addr, M_IFMADDR);
34151ede983cSDag-Erling Smørgrav 	free(ifma, M_IFMADDR);
3416c3b31afdSRobert Watson }
3417c3b31afdSRobert Watson 
3418c3b31afdSRobert Watson /*
3419c3b31afdSRobert Watson  * Register an additional multicast address with a network interface.
3420c3b31afdSRobert Watson  *
3421c3b31afdSRobert Watson  * - If the address is already present, bump the reference count on the
3422c3b31afdSRobert Watson  *   address and return.
3423c3b31afdSRobert Watson  * - If the address is not link-layer, look up a link layer address.
3424c3b31afdSRobert Watson  * - Allocate address structures for one or both addresses, and attach to the
3425c3b31afdSRobert Watson  *   multicast address list on the interface.  If automatically adding a link
3426c3b31afdSRobert Watson  *   layer address, the protocol address will own a reference to the link
3427c3b31afdSRobert Watson  *   layer address, to be freed when it is freed.
3428c3b31afdSRobert Watson  * - Notify the network device driver of an addition to the multicast address
3429c3b31afdSRobert Watson  *   list.
3430c3b31afdSRobert Watson  *
3431c3b31afdSRobert Watson  * 'sa' points to caller-owned memory with the desired multicast address.
3432c3b31afdSRobert Watson  *
3433c3b31afdSRobert Watson  * 'retifma' will be used to return a pointer to the resulting multicast
3434c3b31afdSRobert Watson  * address reference, if desired.
3435c3b31afdSRobert Watson  */
3436c3b31afdSRobert Watson int
3437c3b31afdSRobert Watson if_addmulti(struct ifnet *ifp, struct sockaddr *sa,
3438c3b31afdSRobert Watson     struct ifmultiaddr **retifma)
3439c3b31afdSRobert Watson {
3440c3b31afdSRobert Watson 	struct ifmultiaddr *ifma, *ll_ifma;
3441c3b31afdSRobert Watson 	struct sockaddr *llsa;
344295fbe4d0SAlexander V. Chernikov 	struct sockaddr_dl sdl;
3443c3b31afdSRobert Watson 	int error;
3444c3b31afdSRobert Watson 
3445f3e1324bSStephen Hurd #ifdef INET
3446f3e1324bSStephen Hurd 	IN_MULTI_LIST_UNLOCK_ASSERT();
3447f3e1324bSStephen Hurd #endif
3448f3e1324bSStephen Hurd #ifdef INET6
3449f3e1324bSStephen Hurd 	IN6_MULTI_LIST_UNLOCK_ASSERT();
3450f3e1324bSStephen Hurd #endif
3451c3b31afdSRobert Watson 	/*
3452c3b31afdSRobert Watson 	 * If the address is already present, return a new reference to it;
3453c3b31afdSRobert Watson 	 * otherwise, allocate storage and set up a new address.
3454c3b31afdSRobert Watson 	 */
3455137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
3456c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
3457c3b31afdSRobert Watson 	if (ifma != NULL) {
3458c3b31afdSRobert Watson 		ifma->ifma_refcount++;
3459c3b31afdSRobert Watson 		if (retifma != NULL)
3460c3b31afdSRobert Watson 			*retifma = ifma;
3461137f91e8SJohn Baldwin 		IF_ADDR_WUNLOCK(ifp);
3462c3b31afdSRobert Watson 		return (0);
3463c3b31afdSRobert Watson 	}
3464c3b31afdSRobert Watson 
3465c3b31afdSRobert Watson 	/*
3466c3b31afdSRobert Watson 	 * The address isn't already present; resolve the protocol address
3467c3b31afdSRobert Watson 	 * into a link layer address, and then look that up, bump its
346895fbe4d0SAlexander V. Chernikov 	 * refcount or allocate an ifma for that also.
346995fbe4d0SAlexander V. Chernikov 	 * Most link layer resolving functions returns address data which
347095fbe4d0SAlexander V. Chernikov 	 * fits inside default sockaddr_dl structure. However callback
347195fbe4d0SAlexander V. Chernikov 	 * can allocate another sockaddr structure, in that case we need to
347295fbe4d0SAlexander V. Chernikov 	 * free it later.
3473c3b31afdSRobert Watson 	 */
3474c3b31afdSRobert Watson 	llsa = NULL;
3475c3b31afdSRobert Watson 	ll_ifma = NULL;
3476c3b31afdSRobert Watson 	if (ifp->if_resolvemulti != NULL) {
347795fbe4d0SAlexander V. Chernikov 		/* Provide called function with buffer size information */
347895fbe4d0SAlexander V. Chernikov 		sdl.sdl_len = sizeof(sdl);
347995fbe4d0SAlexander V. Chernikov 		llsa = (struct sockaddr *)&sdl;
3480c3b31afdSRobert Watson 		error = ifp->if_resolvemulti(ifp, &llsa, sa);
3481c3b31afdSRobert Watson 		if (error)
3482c3b31afdSRobert Watson 			goto unlock_out;
3483c3b31afdSRobert Watson 	}
3484c3b31afdSRobert Watson 
3485c3b31afdSRobert Watson 	/*
3486c3b31afdSRobert Watson 	 * Allocate the new address.  Don't hook it up yet, as we may also
3487c3b31afdSRobert Watson 	 * need to allocate a link layer multicast address.
3488c3b31afdSRobert Watson 	 */
3489c3b31afdSRobert Watson 	ifma = if_allocmulti(ifp, sa, llsa, M_NOWAIT);
3490c3b31afdSRobert Watson 	if (ifma == NULL) {
3491c3b31afdSRobert Watson 		error = ENOMEM;
3492c3b31afdSRobert Watson 		goto free_llsa_out;
3493c3b31afdSRobert Watson 	}
3494c3b31afdSRobert Watson 
3495c3b31afdSRobert Watson 	/*
3496c3b31afdSRobert Watson 	 * If a link layer address is found, we'll need to see if it's
3497c3b31afdSRobert Watson 	 * already present in the address list, or allocate is as well.
3498c3b31afdSRobert Watson 	 * When this block finishes, the link layer address will be on the
3499c3b31afdSRobert Watson 	 * list.
3500c3b31afdSRobert Watson 	 */
3501c3b31afdSRobert Watson 	if (llsa != NULL) {
3502c3b31afdSRobert Watson 		ll_ifma = if_findmulti(ifp, llsa);
3503c3b31afdSRobert Watson 		if (ll_ifma == NULL) {
3504c3b31afdSRobert Watson 			ll_ifma = if_allocmulti(ifp, llsa, NULL, M_NOWAIT);
3505c3b31afdSRobert Watson 			if (ll_ifma == NULL) {
3506ec002feeSBruce M Simpson 				--ifma->ifma_refcount;
3507c3b31afdSRobert Watson 				if_freemulti(ifma);
3508c3b31afdSRobert Watson 				error = ENOMEM;
3509c3b31afdSRobert Watson 				goto free_llsa_out;
3510c3b31afdSRobert Watson 			}
3511c3b31afdSRobert Watson 			TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ll_ifma,
3512c3b31afdSRobert Watson 			    ifma_link);
3513c3b31afdSRobert Watson 		} else
3514c3b31afdSRobert Watson 			ll_ifma->ifma_refcount++;
3515ec002feeSBruce M Simpson 		ifma->ifma_llifma = ll_ifma;
3516c3b31afdSRobert Watson 	}
3517c3b31afdSRobert Watson 
3518c3b31afdSRobert Watson 	/*
3519c3b31afdSRobert Watson 	 * We now have a new multicast address, ifma, and possibly a new or
3520c3b31afdSRobert Watson 	 * referenced link layer address.  Add the primary address to the
3521c3b31afdSRobert Watson 	 * ifnet address list.
3522c3b31afdSRobert Watson 	 */
35236817526dSPoul-Henning Kamp 	TAILQ_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link);
3524c3b31afdSRobert Watson 
352513990766SJonathan Mini 	if (retifma != NULL)
3526373f88edSGarrett Wollman 		*retifma = ifma;
35271158dfb7SGarrett Wollman 
3528c3b31afdSRobert Watson 	/*
3529c3b31afdSRobert Watson 	 * Must generate the message while holding the lock so that 'ifma'
3530c3b31afdSRobert Watson 	 * pointer is still valid.
3531c3b31afdSRobert Watson 	 */
3532c3b31afdSRobert Watson 	rt_newmaddrmsg(RTM_NEWMADDR, ifma);
3533137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3534c3b31afdSRobert Watson 
35351158dfb7SGarrett Wollman 	/*
35361158dfb7SGarrett Wollman 	 * We are certain we have added something, so call down to the
35371158dfb7SGarrett Wollman 	 * interface to let them know about it.
35381158dfb7SGarrett Wollman 	 */
35392432c31cSRobert Watson 	if (ifp->if_ioctl != NULL) {
35401a3b6859SYaroslav Tykhiy 		(void) (*ifp->if_ioctl)(ifp, SIOCADDMULTI, 0);
35411a3b6859SYaroslav Tykhiy 	}
35421158dfb7SGarrett Wollman 
354395fbe4d0SAlexander V. Chernikov 	if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
354495fbe4d0SAlexander V. Chernikov 		link_free_sdl(llsa);
3545c3b31afdSRobert Watson 
3546c3b31afdSRobert Watson 	return (0);
3547c3b31afdSRobert Watson 
3548c3b31afdSRobert Watson free_llsa_out:
354995fbe4d0SAlexander V. Chernikov 	if ((llsa != NULL) && (llsa != (struct sockaddr *)&sdl))
355095fbe4d0SAlexander V. Chernikov 		link_free_sdl(llsa);
3551c3b31afdSRobert Watson 
3552c3b31afdSRobert Watson unlock_out:
3553137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3554c3b31afdSRobert Watson 	return (error);
35551158dfb7SGarrett Wollman }
35561158dfb7SGarrett Wollman 
35571158dfb7SGarrett Wollman /*
3558ec002feeSBruce M Simpson  * Delete a multicast group membership by network-layer group address.
3559ec002feeSBruce M Simpson  *
3560ec002feeSBruce M Simpson  * Returns ENOENT if the entry could not be found. If ifp no longer
3561ec002feeSBruce M Simpson  * exists, results are undefined. This entry point should only be used
3562ec002feeSBruce M Simpson  * from subsystems which do appropriate locking to hold ifp for the
3563ec002feeSBruce M Simpson  * duration of the call.
3564ec002feeSBruce M Simpson  * Network-layer protocol domains must use if_delmulti_ifma().
35651158dfb7SGarrett Wollman  */
35661158dfb7SGarrett Wollman int
356772fd1b6aSDag-Erling Smørgrav if_delmulti(struct ifnet *ifp, struct sockaddr *sa)
35681158dfb7SGarrett Wollman {
3569ec002feeSBruce M Simpson 	struct ifmultiaddr *ifma;
3570ec002feeSBruce M Simpson 	int lastref;
3571ec002feeSBruce M Simpson #ifdef INVARIANTS
3572ec002feeSBruce M Simpson 	struct ifnet *oifp;
3573ec002feeSBruce M Simpson 
357477dfcdc4SRobert Watson 	IFNET_RLOCK_NOSLEEP();
3575603724d3SBjoern A. Zeeb 	TAILQ_FOREACH(oifp, &V_ifnet, if_link)
3576ec002feeSBruce M Simpson 		if (ifp == oifp)
3577ec002feeSBruce M Simpson 			break;
3578ec002feeSBruce M Simpson 	if (ifp != oifp)
3579ec002feeSBruce M Simpson 		ifp = NULL;
358077dfcdc4SRobert Watson 	IFNET_RUNLOCK_NOSLEEP();
3581ec002feeSBruce M Simpson 
3582ec002feeSBruce M Simpson 	KASSERT(ifp != NULL, ("%s: ifnet went away", __func__));
3583ec002feeSBruce M Simpson #endif
3584ec002feeSBruce M Simpson 	if (ifp == NULL)
3585ec002feeSBruce M Simpson 		return (ENOENT);
35861158dfb7SGarrett Wollman 
3587137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
3588ec002feeSBruce M Simpson 	lastref = 0;
3589c3b31afdSRobert Watson 	ifma = if_findmulti(ifp, sa);
3590ec002feeSBruce M Simpson 	if (ifma != NULL)
3591ec002feeSBruce M Simpson 		lastref = if_delmulti_locked(ifp, ifma, 0);
3592137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
3593c3b31afdSRobert Watson 
3594ec002feeSBruce M Simpson 	if (ifma == NULL)
3595ec002feeSBruce M Simpson 		return (ENOENT);
3596ec002feeSBruce M Simpson 
3597ec002feeSBruce M Simpson 	if (lastref && ifp->if_ioctl != NULL) {
35981a3b6859SYaroslav Tykhiy 		(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
359931302ebfSRobert Watson 	}
36001158dfb7SGarrett Wollman 
3601ec002feeSBruce M Simpson 	return (0);
3602ec002feeSBruce M Simpson }
3603ec002feeSBruce M Simpson 
3604ec002feeSBruce M Simpson /*
360593ec7edcSShteryana Shopova  * Delete all multicast group membership for an interface.
360693ec7edcSShteryana Shopova  * Should be used to quickly flush all multicast filters.
360793ec7edcSShteryana Shopova  */
360893ec7edcSShteryana Shopova void
360993ec7edcSShteryana Shopova if_delallmulti(struct ifnet *ifp)
361093ec7edcSShteryana Shopova {
361193ec7edcSShteryana Shopova 	struct ifmultiaddr *ifma;
361293ec7edcSShteryana Shopova 	struct ifmultiaddr *next;
361393ec7edcSShteryana Shopova 
3614137f91e8SJohn Baldwin 	IF_ADDR_WLOCK(ifp);
361593ec7edcSShteryana Shopova 	TAILQ_FOREACH_SAFE(ifma, &ifp->if_multiaddrs, ifma_link, next)
361693ec7edcSShteryana Shopova 		if_delmulti_locked(ifp, ifma, 0);
3617137f91e8SJohn Baldwin 	IF_ADDR_WUNLOCK(ifp);
361893ec7edcSShteryana Shopova }
361993ec7edcSShteryana Shopova 
3620b6f6f880SMatt Macy void
3621b6f6f880SMatt Macy if_delmulti_ifma(struct ifmultiaddr *ifma)
3622b6f6f880SMatt Macy {
3623b6f6f880SMatt Macy 	if_delmulti_ifma_flags(ifma, 0);
3624b6f6f880SMatt Macy }
3625b6f6f880SMatt Macy 
362693ec7edcSShteryana Shopova /*
3627ec002feeSBruce M Simpson  * Delete a multicast group membership by group membership pointer.
3628ec002feeSBruce M Simpson  * Network-layer protocol domains must use this routine.
3629ec002feeSBruce M Simpson  *
3630e5adda3dSRobert Watson  * It is safe to call this routine if the ifp disappeared.
3631ec002feeSBruce M Simpson  */
3632ec002feeSBruce M Simpson void
3633b6f6f880SMatt Macy if_delmulti_ifma_flags(struct ifmultiaddr *ifma, int flags)
3634ec002feeSBruce M Simpson {
3635ec002feeSBruce M Simpson 	struct ifnet *ifp;
3636ec002feeSBruce M Simpson 	int lastref;
3637b6f6f880SMatt Macy 	MCDPRINTF("%s freeing ifma: %p\n", __func__, ifma);
3638f3e1324bSStephen Hurd #ifdef INET
3639f3e1324bSStephen Hurd 	IN_MULTI_LIST_UNLOCK_ASSERT();
3640f3e1324bSStephen Hurd #endif
3641ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
3642ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
3643ec002feeSBruce M Simpson 	if (ifp == NULL) {
3644ec002feeSBruce M Simpson 		printf("%s: ifma_ifp seems to be detached\n", __func__);
3645ec002feeSBruce M Simpson 	} else {
3646ec002feeSBruce M Simpson 		struct ifnet *oifp;
3647ec002feeSBruce M Simpson 
364877dfcdc4SRobert Watson 		IFNET_RLOCK_NOSLEEP();
3649603724d3SBjoern A. Zeeb 		TAILQ_FOREACH(oifp, &V_ifnet, if_link)
3650ec002feeSBruce M Simpson 			if (ifp == oifp)
3651ec002feeSBruce M Simpson 				break;
3652ec002feeSBruce M Simpson 		if (ifp != oifp) {
3653ec002feeSBruce M Simpson 			printf("%s: ifnet %p disappeared\n", __func__, ifp);
3654ec002feeSBruce M Simpson 			ifp = NULL;
3655ec002feeSBruce M Simpson 		}
365677dfcdc4SRobert Watson 		IFNET_RUNLOCK_NOSLEEP();
3657ec002feeSBruce M Simpson 	}
3658ec002feeSBruce M Simpson #endif
3659ec002feeSBruce M Simpson 	/*
3660ec002feeSBruce M Simpson 	 * If and only if the ifnet instance exists: Acquire the address lock.
3661ec002feeSBruce M Simpson 	 */
3662ec002feeSBruce M Simpson 	if (ifp != NULL)
3663137f91e8SJohn Baldwin 		IF_ADDR_WLOCK(ifp);
3664ec002feeSBruce M Simpson 
3665b6f6f880SMatt Macy 	lastref = if_delmulti_locked(ifp, ifma, flags);
3666ec002feeSBruce M Simpson 
3667ec002feeSBruce M Simpson 	if (ifp != NULL) {
3668ec002feeSBruce M Simpson 		/*
3669ec002feeSBruce M Simpson 		 * If and only if the ifnet instance exists:
3670ec002feeSBruce M Simpson 		 *  Release the address lock.
3671ec002feeSBruce M Simpson 		 *  If the group was left: update the hardware hash filter.
3672ec002feeSBruce M Simpson 		 */
3673137f91e8SJohn Baldwin 		IF_ADDR_WUNLOCK(ifp);
3674ec002feeSBruce M Simpson 		if (lastref && ifp->if_ioctl != NULL) {
3675ec002feeSBruce M Simpson 			(void)(*ifp->if_ioctl)(ifp, SIOCDELMULTI, 0);
3676ec002feeSBruce M Simpson 		}
3677ec002feeSBruce M Simpson 	}
3678ec002feeSBruce M Simpson }
3679ec002feeSBruce M Simpson 
3680ec002feeSBruce M Simpson /*
3681ec002feeSBruce M Simpson  * Perform deletion of network-layer and/or link-layer multicast address.
3682ec002feeSBruce M Simpson  *
3683ec002feeSBruce M Simpson  * Return 0 if the reference count was decremented.
3684ec002feeSBruce M Simpson  * Return 1 if the final reference was released, indicating that the
3685ec002feeSBruce M Simpson  * hardware hash filter should be reprogrammed.
3686ec002feeSBruce M Simpson  */
3687ec002feeSBruce M Simpson static int
3688ec002feeSBruce M Simpson if_delmulti_locked(struct ifnet *ifp, struct ifmultiaddr *ifma, int detaching)
3689ec002feeSBruce M Simpson {
3690ec002feeSBruce M Simpson 	struct ifmultiaddr *ll_ifma;
3691ec002feeSBruce M Simpson 
3692ec002feeSBruce M Simpson 	if (ifp != NULL && ifma->ifma_ifp != NULL) {
3693ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_ifp == ifp,
3694ec002feeSBruce M Simpson 		    ("%s: inconsistent ifp %p", __func__, ifp));
3695137f91e8SJohn Baldwin 		IF_ADDR_WLOCK_ASSERT(ifp);
3696ec002feeSBruce M Simpson 	}
3697ec002feeSBruce M Simpson 
3698ec002feeSBruce M Simpson 	ifp = ifma->ifma_ifp;
3699b6f6f880SMatt Macy 	MCDPRINTF("%s freeing %p from %s \n", __func__, ifma, ifp ? ifp->if_xname : "");
3700ec002feeSBruce M Simpson 
3701ec002feeSBruce M Simpson 	/*
3702ec002feeSBruce M Simpson 	 * If the ifnet is detaching, null out references to ifnet,
3703ec002feeSBruce M Simpson 	 * so that upper protocol layers will notice, and not attempt
370475ae0c01SBruce M Simpson 	 * to obtain locks for an ifnet which no longer exists. The
370575ae0c01SBruce M Simpson 	 * routing socket announcement must happen before the ifnet
370675ae0c01SBruce M Simpson 	 * instance is detached from the system.
3707ec002feeSBruce M Simpson 	 */
3708ec002feeSBruce M Simpson 	if (detaching) {
3709ec002feeSBruce M Simpson #ifdef DIAGNOSTIC
3710ec002feeSBruce M Simpson 		printf("%s: detaching ifnet instance %p\n", __func__, ifp);
3711ec002feeSBruce M Simpson #endif
371275ae0c01SBruce M Simpson 		/*
371375ae0c01SBruce M Simpson 		 * ifp may already be nulled out if we are being reentered
371475ae0c01SBruce M Simpson 		 * to delete the ll_ifma.
371575ae0c01SBruce M Simpson 		 */
371675ae0c01SBruce M Simpson 		if (ifp != NULL) {
371775ae0c01SBruce M Simpson 			rt_newmaddrmsg(RTM_DELMADDR, ifma);
3718ec002feeSBruce M Simpson 			ifma->ifma_ifp = NULL;
3719ec002feeSBruce M Simpson 		}
372075ae0c01SBruce M Simpson 	}
3721ec002feeSBruce M Simpson 
3722ec002feeSBruce M Simpson 	if (--ifma->ifma_refcount > 0)
37231158dfb7SGarrett Wollman 		return 0;
3724ec002feeSBruce M Simpson 
3725b6f6f880SMatt Macy 	if (ifp != NULL && detaching == 0)
3726b6f6f880SMatt Macy 		TAILQ_REMOVE(&ifp->if_multiaddrs, ifma, ifma_link);
3727b6f6f880SMatt Macy 
3728ec002feeSBruce M Simpson 	/*
3729ec002feeSBruce M Simpson 	 * If this ifma is a network-layer ifma, a link-layer ifma may
3730ec002feeSBruce M Simpson 	 * have been associated with it. Release it first if so.
3731ec002feeSBruce M Simpson 	 */
3732ec002feeSBruce M Simpson 	ll_ifma = ifma->ifma_llifma;
3733ec002feeSBruce M Simpson 	if (ll_ifma != NULL) {
3734ec002feeSBruce M Simpson 		KASSERT(ifma->ifma_lladdr != NULL,
3735ec002feeSBruce M Simpson 		    ("%s: llifma w/o lladdr", __func__));
3736ec002feeSBruce M Simpson 		if (detaching)
3737ec002feeSBruce M Simpson 			ll_ifma->ifma_ifp = NULL;	/* XXX */
3738ec002feeSBruce M Simpson 		if (--ll_ifma->ifma_refcount == 0) {
3739ec002feeSBruce M Simpson 			if (ifp != NULL) {
3740ec002feeSBruce M Simpson 				TAILQ_REMOVE(&ifp->if_multiaddrs, ll_ifma,
3741ec002feeSBruce M Simpson 				    ifma_link);
3742ec002feeSBruce M Simpson 			}
3743ec002feeSBruce M Simpson 			if_freemulti(ll_ifma);
3744ec002feeSBruce M Simpson 		}
3745ec002feeSBruce M Simpson 	}
3746b6f6f880SMatt Macy #ifdef INVARIANTS
3747b6f6f880SMatt Macy 	if (ifp) {
3748b6f6f880SMatt Macy 		struct ifmultiaddr *ifmatmp;
3749ec002feeSBruce M Simpson 
3750b6f6f880SMatt Macy 		TAILQ_FOREACH(ifmatmp, &ifp->if_multiaddrs, ifma_link)
3751b6f6f880SMatt Macy 			MPASS(ifma != ifmatmp);
3752b6f6f880SMatt Macy 	}
3753b6f6f880SMatt Macy #endif
3754ec002feeSBruce M Simpson 	if_freemulti(ifma);
3755ec002feeSBruce M Simpson 	/*
3756ec002feeSBruce M Simpson 	 * The last reference to this instance of struct ifmultiaddr
3757ec002feeSBruce M Simpson 	 * was released; the hardware should be notified of this change.
3758ec002feeSBruce M Simpson 	 */
3759ec002feeSBruce M Simpson 	return 1;
37601158dfb7SGarrett Wollman }
37611158dfb7SGarrett Wollman 
376266ce51ceSArchie Cobbs /*
376366ce51ceSArchie Cobbs  * Set the link layer address on an interface.
376466ce51ceSArchie Cobbs  *
376566ce51ceSArchie Cobbs  * At this time we only support certain types of interfaces,
376666ce51ceSArchie Cobbs  * and we don't allow the length of the address to change.
3767bb3d23fdSAlexander V. Chernikov  *
3768bb3d23fdSAlexander V. Chernikov  * Set noinline to be dtrace-friendly
376966ce51ceSArchie Cobbs  */
3770bb3d23fdSAlexander V. Chernikov __noinline int
377166ce51ceSArchie Cobbs if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len)
377266ce51ceSArchie Cobbs {
377366ce51ceSArchie Cobbs 	struct sockaddr_dl *sdl;
377466ce51ceSArchie Cobbs 	struct ifaddr *ifa;
3775d637e989SPeter Wemm 	struct ifreq ifr;
377666ce51ceSArchie Cobbs 
3777137f91e8SJohn Baldwin 	IF_ADDR_RLOCK(ifp);
37784a0d6638SRuslan Ermilov 	ifa = ifp->if_addr;
37793baaf297SRobert Watson 	if (ifa == NULL) {
3780137f91e8SJohn Baldwin 		IF_ADDR_RUNLOCK(ifp);
378166ce51ceSArchie Cobbs 		return (EINVAL);
37823baaf297SRobert Watson 	}
37833baaf297SRobert Watson 	ifa_ref(ifa);
3784137f91e8SJohn Baldwin 	IF_ADDR_RUNLOCK(ifp);
378566ce51ceSArchie Cobbs 	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
37863baaf297SRobert Watson 	if (sdl == NULL) {
37873baaf297SRobert Watson 		ifa_free(ifa);
378866ce51ceSArchie Cobbs 		return (EINVAL);
37893baaf297SRobert Watson 	}
37903baaf297SRobert Watson 	if (len != sdl->sdl_alen) {	/* don't allow length to change */
37913baaf297SRobert Watson 		ifa_free(ifa);
379266ce51ceSArchie Cobbs 		return (EINVAL);
37933baaf297SRobert Watson 	}
379466ce51ceSArchie Cobbs 	switch (ifp->if_type) {
3795d09ed26fSRuslan Ermilov 	case IFT_ETHER:
379666ce51ceSArchie Cobbs 	case IFT_XETHER:
3797b7bffa71SYaroslav Tykhiy 	case IFT_L2VLAN:
37988f867517SAndrew Thompson 	case IFT_BRIDGE:
3799b47888ceSAndrew Thompson 	case IFT_IEEE8023ADLAG:
380066ce51ceSArchie Cobbs 		bcopy(lladdr, LLADDR(sdl), len);
38013baaf297SRobert Watson 		ifa_free(ifa);
380266ce51ceSArchie Cobbs 		break;
380366ce51ceSArchie Cobbs 	default:
38043baaf297SRobert Watson 		ifa_free(ifa);
380566ce51ceSArchie Cobbs 		return (ENODEV);
380666ce51ceSArchie Cobbs 	}
38073baaf297SRobert Watson 
380866ce51ceSArchie Cobbs 	/*
380966ce51ceSArchie Cobbs 	 * If the interface is already up, we need
381066ce51ceSArchie Cobbs 	 * to re-init it in order to reprogram its
381166ce51ceSArchie Cobbs 	 * address filter.
381266ce51ceSArchie Cobbs 	 */
381366ce51ceSArchie Cobbs 	if ((ifp->if_flags & IFF_UP) != 0) {
38141a3b6859SYaroslav Tykhiy 		if (ifp->if_ioctl) {
381566ce51ceSArchie Cobbs 			ifp->if_flags &= ~IFF_UP;
381662f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
381762f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
3818ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
381966ce51ceSArchie Cobbs 			ifp->if_flags |= IFF_UP;
382062f76486SMaxim Sobolev 			ifr.ifr_flags = ifp->if_flags & 0xffff;
382162f76486SMaxim Sobolev 			ifr.ifr_flagshigh = ifp->if_flags >> 16;
3822ee0a4f7eSSUZUKI Shinsuke 			(*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
38231a3b6859SYaroslav Tykhiy 		}
382466ce51ceSArchie Cobbs 	}
38258ad43f2dSAlexander V. Chernikov 	EVENTHANDLER_INVOKE(iflladdr_event, ifp);
382666ce51ceSArchie Cobbs 	return (0);
382766ce51ceSArchie Cobbs }
382866ce51ceSArchie Cobbs 
38299bf40edeSBrooks Davis /*
38304fb3a820SAlexander V. Chernikov  * Compat function for handling basic encapsulation requests.
38314fb3a820SAlexander V. Chernikov  * Not converted stacks (FDDI, IB, ..) supports traditional
38324fb3a820SAlexander V. Chernikov  * output model: ARP (and other similar L2 protocols) are handled
38334fb3a820SAlexander V. Chernikov  * inside output routine, arpresolve/nd6_resolve() returns MAC
38344fb3a820SAlexander V. Chernikov  * address instead of full prepend.
38354fb3a820SAlexander V. Chernikov  *
38364fb3a820SAlexander V. Chernikov  * This function creates calculated header==MAC for IPv4/IPv6 and
38374fb3a820SAlexander V. Chernikov  * returns EAFNOSUPPORT (which is then handled in ARP code) for other
38384fb3a820SAlexander V. Chernikov  * address families.
38394fb3a820SAlexander V. Chernikov  */
38404fb3a820SAlexander V. Chernikov static int
38414fb3a820SAlexander V. Chernikov if_requestencap_default(struct ifnet *ifp, struct if_encap_req *req)
38424fb3a820SAlexander V. Chernikov {
38434fb3a820SAlexander V. Chernikov 
38444fb3a820SAlexander V. Chernikov 	if (req->rtype != IFENCAP_LL)
38454fb3a820SAlexander V. Chernikov 		return (EOPNOTSUPP);
38464fb3a820SAlexander V. Chernikov 
38474fb3a820SAlexander V. Chernikov 	if (req->bufsize < req->lladdr_len)
38484fb3a820SAlexander V. Chernikov 		return (ENOMEM);
38494fb3a820SAlexander V. Chernikov 
38504fb3a820SAlexander V. Chernikov 	switch (req->family) {
38514fb3a820SAlexander V. Chernikov 	case AF_INET:
38524fb3a820SAlexander V. Chernikov 	case AF_INET6:
38534fb3a820SAlexander V. Chernikov 		break;
38544fb3a820SAlexander V. Chernikov 	default:
38554fb3a820SAlexander V. Chernikov 		return (EAFNOSUPPORT);
38564fb3a820SAlexander V. Chernikov 	}
38574fb3a820SAlexander V. Chernikov 
38584fb3a820SAlexander V. Chernikov 	/* Copy lladdr to storage as is */
38594fb3a820SAlexander V. Chernikov 	memmove(req->buf, req->lladdr, req->lladdr_len);
38604fb3a820SAlexander V. Chernikov 	req->bufsize = req->lladdr_len;
38614fb3a820SAlexander V. Chernikov 	req->lladdr_off = 0;
38624fb3a820SAlexander V. Chernikov 
38634fb3a820SAlexander V. Chernikov 	return (0);
38644fb3a820SAlexander V. Chernikov }
38654fb3a820SAlexander V. Chernikov 
38664fb3a820SAlexander V. Chernikov /*
3867ddae5750SRavi Pokala  * Get the link layer address that was read from the hardware at attach.
3868ddae5750SRavi Pokala  *
3869ddae5750SRavi Pokala  * This is only set by Ethernet NICs (IFT_ETHER), but laggX interfaces re-type
3870ddae5750SRavi Pokala  * their component interfaces as IFT_IEEE8023ADLAG.
3871ddae5750SRavi Pokala  */
3872ddae5750SRavi Pokala int
3873ddae5750SRavi Pokala if_gethwaddr(struct ifnet *ifp, struct ifreq *ifr)
3874ddae5750SRavi Pokala {
3875ddae5750SRavi Pokala 
3876ddae5750SRavi Pokala 	if (ifp->if_hw_addr == NULL)
3877ddae5750SRavi Pokala 		return (ENODEV);
3878ddae5750SRavi Pokala 
3879ddae5750SRavi Pokala 	switch (ifp->if_type) {
3880ddae5750SRavi Pokala 	case IFT_ETHER:
3881ddae5750SRavi Pokala 	case IFT_IEEE8023ADLAG:
3882ddae5750SRavi Pokala 		bcopy(ifp->if_hw_addr, ifr->ifr_addr.sa_data, ifp->if_addrlen);
3883ddae5750SRavi Pokala 		return (0);
3884ddae5750SRavi Pokala 	default:
3885ddae5750SRavi Pokala 		return (ENODEV);
3886ddae5750SRavi Pokala 	}
3887ddae5750SRavi Pokala }
3888ddae5750SRavi Pokala 
3889ddae5750SRavi Pokala /*
38909bf40edeSBrooks Davis  * The name argument must be a pointer to storage which will last as
38919bf40edeSBrooks Davis  * long as the interface does.  For physical devices, the result of
38929bf40edeSBrooks Davis  * device_get_name(dev) is a good choice and for pseudo-devices a
38939bf40edeSBrooks Davis  * static string works well.
38949bf40edeSBrooks Davis  */
38959bf40edeSBrooks Davis void
38969bf40edeSBrooks Davis if_initname(struct ifnet *ifp, const char *name, int unit)
38979bf40edeSBrooks Davis {
38989bf40edeSBrooks Davis 	ifp->if_dname = name;
38999bf40edeSBrooks Davis 	ifp->if_dunit = unit;
39009bf40edeSBrooks Davis 	if (unit != IF_DUNIT_NONE)
39019bf40edeSBrooks Davis 		snprintf(ifp->if_xname, IFNAMSIZ, "%s%d", name, unit);
39029bf40edeSBrooks Davis 	else
39039bf40edeSBrooks Davis 		strlcpy(ifp->if_xname, name, IFNAMSIZ);
39049bf40edeSBrooks Davis }
39059bf40edeSBrooks Davis 
3906fa882e87SBrooks Davis int
3907fa882e87SBrooks Davis if_printf(struct ifnet *ifp, const char *fmt, ...)
3908fa882e87SBrooks Davis {
390920f8d7bcSDag-Erling Smørgrav 	char if_fmt[256];
3910fa882e87SBrooks Davis 	va_list ap;
3911fa882e87SBrooks Davis 
391220f8d7bcSDag-Erling Smørgrav 	snprintf(if_fmt, sizeof(if_fmt), "%s: %s", ifp->if_xname, fmt);
3913fa882e87SBrooks Davis 	va_start(ap, fmt);
391420f8d7bcSDag-Erling Smørgrav 	vlog(LOG_INFO, if_fmt, ap);
3915fa882e87SBrooks Davis 	va_end(ap);
391620f8d7bcSDag-Erling Smørgrav 	return (0);
3917fa882e87SBrooks Davis }
3918fa882e87SBrooks Davis 
3919af5e59bfSRobert Watson void
3920af5e59bfSRobert Watson if_start(struct ifnet *ifp)
3921af5e59bfSRobert Watson {
3922af5e59bfSRobert Watson 
3923af5e59bfSRobert Watson 	(*(ifp)->if_start)(ifp);
3924af5e59bfSRobert Watson }
3925af5e59bfSRobert Watson 
3926db7f0b97SKip Macy /*
3927db7f0b97SKip Macy  * Backwards compatibility interface for drivers
3928db7f0b97SKip Macy  * that have not implemented it
3929db7f0b97SKip Macy  */
3930db7f0b97SKip Macy static int
3931db7f0b97SKip Macy if_transmit(struct ifnet *ifp, struct mbuf *m)
3932db7f0b97SKip Macy {
3933db7f0b97SKip Macy 	int error;
3934db7f0b97SKip Macy 
3935db7f0b97SKip Macy 	IFQ_HANDOFF(ifp, m, error);
3936db7f0b97SKip Macy 	return (error);
3937db7f0b97SKip Macy }
3938db7f0b97SKip Macy 
3939b57d9721SAndrey V. Elsukov static void
3940b57d9721SAndrey V. Elsukov if_input_default(struct ifnet *ifp __unused, struct mbuf *m)
3941b57d9721SAndrey V. Elsukov {
3942b57d9721SAndrey V. Elsukov 
3943b57d9721SAndrey V. Elsukov 	m_freem(m);
3944b57d9721SAndrey V. Elsukov }
3945b57d9721SAndrey V. Elsukov 
39460b762445SRobert Watson int
39470b762445SRobert Watson if_handoff(struct ifqueue *ifq, struct mbuf *m, struct ifnet *ifp, int adjust)
39480b762445SRobert Watson {
39490b762445SRobert Watson 	int active = 0;
39500b762445SRobert Watson 
39510b762445SRobert Watson 	IF_LOCK(ifq);
39520b762445SRobert Watson 	if (_IF_QFULL(ifq)) {
39530b762445SRobert Watson 		IF_UNLOCK(ifq);
3954112f50ffSGleb Smirnoff 		if_inc_counter(ifp, IFCOUNTER_OQDROPS, 1);
39550b762445SRobert Watson 		m_freem(m);
39560b762445SRobert Watson 		return (0);
39570b762445SRobert Watson 	}
39580b762445SRobert Watson 	if (ifp != NULL) {
3959112f50ffSGleb Smirnoff 		if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len + adjust);
39600b762445SRobert Watson 		if (m->m_flags & (M_BCAST|M_MCAST))
3961112f50ffSGleb Smirnoff 			if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
3962292ee7beSRobert Watson 		active = ifp->if_drv_flags & IFF_DRV_OACTIVE;
39630b762445SRobert Watson 	}
39640b762445SRobert Watson 	_IF_ENQUEUE(ifq, m);
39650b762445SRobert Watson 	IF_UNLOCK(ifq);
39660b762445SRobert Watson 	if (ifp != NULL && !active)
3967e5adda3dSRobert Watson 		(*(ifp)->if_start)(ifp);
39680b762445SRobert Watson 	return (1);
39690b762445SRobert Watson }
3970fc74a9f9SBrooks Davis 
3971fc74a9f9SBrooks Davis void
3972fc74a9f9SBrooks Davis if_register_com_alloc(u_char type,
3973fc74a9f9SBrooks Davis     if_com_alloc_t *a, if_com_free_t *f)
3974fc74a9f9SBrooks Davis {
3975fc74a9f9SBrooks Davis 
3976fc74a9f9SBrooks Davis 	KASSERT(if_com_alloc[type] == NULL,
3977fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d already registered", type));
3978fc74a9f9SBrooks Davis 	KASSERT(if_com_free[type] == NULL,
3979fc74a9f9SBrooks Davis 	    ("if_register_com_alloc: %d free already registered", type));
3980fc74a9f9SBrooks Davis 
3981fc74a9f9SBrooks Davis 	if_com_alloc[type] = a;
3982fc74a9f9SBrooks Davis 	if_com_free[type] = f;
3983fc74a9f9SBrooks Davis }
3984fc74a9f9SBrooks Davis 
3985fc74a9f9SBrooks Davis void
3986fc74a9f9SBrooks Davis if_deregister_com_alloc(u_char type)
3987fc74a9f9SBrooks Davis {
3988fc74a9f9SBrooks Davis 
3989affcaf78SMax Khon 	KASSERT(if_com_alloc[type] != NULL,
3990fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d not registered", type));
3991affcaf78SMax Khon 	KASSERT(if_com_free[type] != NULL,
3992fc74a9f9SBrooks Davis 	    ("if_deregister_com_alloc: %d free not registered", type));
3993fc74a9f9SBrooks Davis 	if_com_alloc[type] = NULL;
3994fc74a9f9SBrooks Davis 	if_com_free[type] = NULL;
3995fc74a9f9SBrooks Davis }
399662d76917SMarcel Moolenaar 
399762d76917SMarcel Moolenaar /* API for driver access to network stack owned ifnet.*/
399862d76917SMarcel Moolenaar uint64_t
399909a8241fSGleb Smirnoff if_setbaudrate(struct ifnet *ifp, uint64_t baudrate)
400062d76917SMarcel Moolenaar {
400162d76917SMarcel Moolenaar 	uint64_t oldbrate;
400262d76917SMarcel Moolenaar 
400362d76917SMarcel Moolenaar 	oldbrate = ifp->if_baudrate;
400462d76917SMarcel Moolenaar 	ifp->if_baudrate = baudrate;
400562d76917SMarcel Moolenaar 	return (oldbrate);
400662d76917SMarcel Moolenaar }
400762d76917SMarcel Moolenaar 
400862d76917SMarcel Moolenaar uint64_t
400962d76917SMarcel Moolenaar if_getbaudrate(if_t ifp)
401062d76917SMarcel Moolenaar {
401162d76917SMarcel Moolenaar 
401262d76917SMarcel Moolenaar 	return (((struct ifnet *)ifp)->if_baudrate);
401362d76917SMarcel Moolenaar }
401462d76917SMarcel Moolenaar 
401562d76917SMarcel Moolenaar int
401662d76917SMarcel Moolenaar if_setcapabilities(if_t ifp, int capabilities)
401762d76917SMarcel Moolenaar {
401862d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities = capabilities;
401962d76917SMarcel Moolenaar 	return (0);
402062d76917SMarcel Moolenaar }
402162d76917SMarcel Moolenaar 
402262d76917SMarcel Moolenaar int
402362d76917SMarcel Moolenaar if_setcapabilitiesbit(if_t ifp, int setbit, int clearbit)
402462d76917SMarcel Moolenaar {
402562d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities |= setbit;
402662d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capabilities &= ~clearbit;
402762d76917SMarcel Moolenaar 
402862d76917SMarcel Moolenaar 	return (0);
402962d76917SMarcel Moolenaar }
403062d76917SMarcel Moolenaar 
403162d76917SMarcel Moolenaar int
403262d76917SMarcel Moolenaar if_getcapabilities(if_t ifp)
403362d76917SMarcel Moolenaar {
403462d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_capabilities;
403562d76917SMarcel Moolenaar }
403662d76917SMarcel Moolenaar 
403762d76917SMarcel Moolenaar int
403862d76917SMarcel Moolenaar if_setcapenable(if_t ifp, int capabilities)
403962d76917SMarcel Moolenaar {
404062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capenable = capabilities;
404162d76917SMarcel Moolenaar 	return (0);
404262d76917SMarcel Moolenaar }
404362d76917SMarcel Moolenaar 
404462d76917SMarcel Moolenaar int
404562d76917SMarcel Moolenaar if_setcapenablebit(if_t ifp, int setcap, int clearcap)
404662d76917SMarcel Moolenaar {
404762d76917SMarcel Moolenaar 	if(setcap)
404862d76917SMarcel Moolenaar 		((struct ifnet *)ifp)->if_capenable |= setcap;
404962d76917SMarcel Moolenaar 	if(clearcap)
405062d76917SMarcel Moolenaar 		((struct ifnet *)ifp)->if_capenable &= ~clearcap;
405162d76917SMarcel Moolenaar 
405262d76917SMarcel Moolenaar 	return (0);
405362d76917SMarcel Moolenaar }
405462d76917SMarcel Moolenaar 
405562d76917SMarcel Moolenaar const char *
405662d76917SMarcel Moolenaar if_getdname(if_t ifp)
405762d76917SMarcel Moolenaar {
405862d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_dname;
405962d76917SMarcel Moolenaar }
406062d76917SMarcel Moolenaar 
406162d76917SMarcel Moolenaar int
406262d76917SMarcel Moolenaar if_togglecapenable(if_t ifp, int togglecap)
406362d76917SMarcel Moolenaar {
406462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_capenable ^= togglecap;
406562d76917SMarcel Moolenaar 	return (0);
406662d76917SMarcel Moolenaar }
406762d76917SMarcel Moolenaar 
406862d76917SMarcel Moolenaar int
406962d76917SMarcel Moolenaar if_getcapenable(if_t ifp)
407062d76917SMarcel Moolenaar {
407162d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_capenable;
407262d76917SMarcel Moolenaar }
407362d76917SMarcel Moolenaar 
407462d76917SMarcel Moolenaar /*
407562d76917SMarcel Moolenaar  * This is largely undesirable because it ties ifnet to a device, but does
407662d76917SMarcel Moolenaar  * provide flexiblity for an embedded product vendor. Should be used with
407762d76917SMarcel Moolenaar  * the understanding that it violates the interface boundaries, and should be
407862d76917SMarcel Moolenaar  * a last resort only.
407962d76917SMarcel Moolenaar  */
408062d76917SMarcel Moolenaar int
408162d76917SMarcel Moolenaar if_setdev(if_t ifp, void *dev)
408262d76917SMarcel Moolenaar {
408362d76917SMarcel Moolenaar 	return (0);
408462d76917SMarcel Moolenaar }
408562d76917SMarcel Moolenaar 
408662d76917SMarcel Moolenaar int
408762d76917SMarcel Moolenaar if_setdrvflagbits(if_t ifp, int set_flags, int clear_flags)
408862d76917SMarcel Moolenaar {
408962d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags |= set_flags;
409062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags &= ~clear_flags;
409162d76917SMarcel Moolenaar 
409262d76917SMarcel Moolenaar 	return (0);
409362d76917SMarcel Moolenaar }
409462d76917SMarcel Moolenaar 
409562d76917SMarcel Moolenaar int
409662d76917SMarcel Moolenaar if_getdrvflags(if_t ifp)
409762d76917SMarcel Moolenaar {
409862d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_drv_flags;
409962d76917SMarcel Moolenaar }
410062d76917SMarcel Moolenaar 
410162d76917SMarcel Moolenaar int
410262d76917SMarcel Moolenaar if_setdrvflags(if_t ifp, int flags)
410362d76917SMarcel Moolenaar {
410462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_drv_flags = flags;
410562d76917SMarcel Moolenaar 	return (0);
410662d76917SMarcel Moolenaar }
410762d76917SMarcel Moolenaar 
410862d76917SMarcel Moolenaar 
410962d76917SMarcel Moolenaar int
411062d76917SMarcel Moolenaar if_setflags(if_t ifp, int flags)
411162d76917SMarcel Moolenaar {
411262d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_flags = flags;
411362d76917SMarcel Moolenaar 	return (0);
411462d76917SMarcel Moolenaar }
411562d76917SMarcel Moolenaar 
411662d76917SMarcel Moolenaar int
411762d76917SMarcel Moolenaar if_setflagbits(if_t ifp, int set, int clear)
411862d76917SMarcel Moolenaar {
411962d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_flags |= set;
412062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_flags &= ~clear;
412162d76917SMarcel Moolenaar 
412262d76917SMarcel Moolenaar 	return (0);
412362d76917SMarcel Moolenaar }
412462d76917SMarcel Moolenaar 
412562d76917SMarcel Moolenaar int
412662d76917SMarcel Moolenaar if_getflags(if_t ifp)
412762d76917SMarcel Moolenaar {
412862d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_flags;
412962d76917SMarcel Moolenaar }
413062d76917SMarcel Moolenaar 
413162d76917SMarcel Moolenaar int
413262d76917SMarcel Moolenaar if_clearhwassist(if_t ifp)
413362d76917SMarcel Moolenaar {
413462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist = 0;
413562d76917SMarcel Moolenaar 	return (0);
413662d76917SMarcel Moolenaar }
413762d76917SMarcel Moolenaar 
413862d76917SMarcel Moolenaar int
413962d76917SMarcel Moolenaar if_sethwassistbits(if_t ifp, int toset, int toclear)
414062d76917SMarcel Moolenaar {
414162d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist |= toset;
414262d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist &= ~toclear;
414362d76917SMarcel Moolenaar 
414462d76917SMarcel Moolenaar 	return (0);
414562d76917SMarcel Moolenaar }
414662d76917SMarcel Moolenaar 
414762d76917SMarcel Moolenaar int
414862d76917SMarcel Moolenaar if_sethwassist(if_t ifp, int hwassist_bit)
414962d76917SMarcel Moolenaar {
415062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_hwassist = hwassist_bit;
415162d76917SMarcel Moolenaar 	return (0);
415262d76917SMarcel Moolenaar }
415362d76917SMarcel Moolenaar 
415462d76917SMarcel Moolenaar int
415562d76917SMarcel Moolenaar if_gethwassist(if_t ifp)
415662d76917SMarcel Moolenaar {
415762d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_hwassist;
415862d76917SMarcel Moolenaar }
415962d76917SMarcel Moolenaar 
416062d76917SMarcel Moolenaar int
416162d76917SMarcel Moolenaar if_setmtu(if_t ifp, int mtu)
416262d76917SMarcel Moolenaar {
416362d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_mtu = mtu;
416462d76917SMarcel Moolenaar 	return (0);
416562d76917SMarcel Moolenaar }
416662d76917SMarcel Moolenaar 
416762d76917SMarcel Moolenaar int
416862d76917SMarcel Moolenaar if_getmtu(if_t ifp)
416962d76917SMarcel Moolenaar {
417062d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_mtu;
417162d76917SMarcel Moolenaar }
417262d76917SMarcel Moolenaar 
417362d76917SMarcel Moolenaar int
41741a75e3b2SAlexander V. Chernikov if_getmtu_family(if_t ifp, int family)
41751a75e3b2SAlexander V. Chernikov {
41761a75e3b2SAlexander V. Chernikov 	struct domain *dp;
41771a75e3b2SAlexander V. Chernikov 
41781a75e3b2SAlexander V. Chernikov 	for (dp = domains; dp; dp = dp->dom_next) {
41791a75e3b2SAlexander V. Chernikov 		if (dp->dom_family == family && dp->dom_ifmtu != NULL)
41801a75e3b2SAlexander V. Chernikov 			return (dp->dom_ifmtu((struct ifnet *)ifp));
41811a75e3b2SAlexander V. Chernikov 	}
41821a75e3b2SAlexander V. Chernikov 
41831a75e3b2SAlexander V. Chernikov 	return (((struct ifnet *)ifp)->if_mtu);
41841a75e3b2SAlexander V. Chernikov }
41851a75e3b2SAlexander V. Chernikov 
41861a75e3b2SAlexander V. Chernikov int
418762d76917SMarcel Moolenaar if_setsoftc(if_t ifp, void *softc)
418862d76917SMarcel Moolenaar {
418962d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_softc = softc;
419062d76917SMarcel Moolenaar 	return (0);
419162d76917SMarcel Moolenaar }
419262d76917SMarcel Moolenaar 
419362d76917SMarcel Moolenaar void *
419462d76917SMarcel Moolenaar if_getsoftc(if_t ifp)
419562d76917SMarcel Moolenaar {
419662d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_softc;
419762d76917SMarcel Moolenaar }
419862d76917SMarcel Moolenaar 
419962d76917SMarcel Moolenaar void
420062d76917SMarcel Moolenaar if_setrcvif(struct mbuf *m, if_t ifp)
420162d76917SMarcel Moolenaar {
420262d76917SMarcel Moolenaar 	m->m_pkthdr.rcvif = (struct ifnet *)ifp;
420362d76917SMarcel Moolenaar }
420462d76917SMarcel Moolenaar 
420562d76917SMarcel Moolenaar void
420662d76917SMarcel Moolenaar if_setvtag(struct mbuf *m, uint16_t tag)
420762d76917SMarcel Moolenaar {
420862d76917SMarcel Moolenaar 	m->m_pkthdr.ether_vtag = tag;
420962d76917SMarcel Moolenaar }
421062d76917SMarcel Moolenaar 
421162d76917SMarcel Moolenaar uint16_t
421262d76917SMarcel Moolenaar if_getvtag(struct mbuf *m)
421362d76917SMarcel Moolenaar {
421462d76917SMarcel Moolenaar 
421562d76917SMarcel Moolenaar 	return (m->m_pkthdr.ether_vtag);
421662d76917SMarcel Moolenaar }
421762d76917SMarcel Moolenaar 
421862d76917SMarcel Moolenaar int
421962d76917SMarcel Moolenaar if_sendq_empty(if_t ifp)
422062d76917SMarcel Moolenaar {
422162d76917SMarcel Moolenaar 	return IFQ_DRV_IS_EMPTY(&((struct ifnet *)ifp)->if_snd);
422262d76917SMarcel Moolenaar }
422362d76917SMarcel Moolenaar 
422462d76917SMarcel Moolenaar struct ifaddr *
422562d76917SMarcel Moolenaar if_getifaddr(if_t ifp)
422662d76917SMarcel Moolenaar {
422762d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_addr;
422862d76917SMarcel Moolenaar }
422962d76917SMarcel Moolenaar 
423062d76917SMarcel Moolenaar int
423162d76917SMarcel Moolenaar if_getamcount(if_t ifp)
423262d76917SMarcel Moolenaar {
423362d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_amcount;
423462d76917SMarcel Moolenaar }
423562d76917SMarcel Moolenaar 
423662d76917SMarcel Moolenaar 
423762d76917SMarcel Moolenaar int
423862d76917SMarcel Moolenaar if_setsendqready(if_t ifp)
423962d76917SMarcel Moolenaar {
424062d76917SMarcel Moolenaar 	IFQ_SET_READY(&((struct ifnet *)ifp)->if_snd);
424162d76917SMarcel Moolenaar 	return (0);
424262d76917SMarcel Moolenaar }
424362d76917SMarcel Moolenaar 
424462d76917SMarcel Moolenaar int
424562d76917SMarcel Moolenaar if_setsendqlen(if_t ifp, int tx_desc_count)
424662d76917SMarcel Moolenaar {
424762d76917SMarcel Moolenaar 	IFQ_SET_MAXLEN(&((struct ifnet *)ifp)->if_snd, tx_desc_count);
424862d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_snd.ifq_drv_maxlen = tx_desc_count;
424962d76917SMarcel Moolenaar 
425062d76917SMarcel Moolenaar 	return (0);
425162d76917SMarcel Moolenaar }
425262d76917SMarcel Moolenaar 
425362d76917SMarcel Moolenaar int
425462d76917SMarcel Moolenaar if_vlantrunkinuse(if_t ifp)
425562d76917SMarcel Moolenaar {
425662d76917SMarcel Moolenaar 	return ((struct ifnet *)ifp)->if_vlantrunk != NULL?1:0;
425762d76917SMarcel Moolenaar }
425862d76917SMarcel Moolenaar 
425962d76917SMarcel Moolenaar int
426062d76917SMarcel Moolenaar if_input(if_t ifp, struct mbuf* sendmp)
426162d76917SMarcel Moolenaar {
426262d76917SMarcel Moolenaar 	(*((struct ifnet *)ifp)->if_input)((struct ifnet *)ifp, sendmp);
426362d76917SMarcel Moolenaar 	return (0);
426462d76917SMarcel Moolenaar 
426562d76917SMarcel Moolenaar }
426662d76917SMarcel Moolenaar 
426762d76917SMarcel Moolenaar /* XXX */
426862d76917SMarcel Moolenaar #ifndef ETH_ADDR_LEN
426962d76917SMarcel Moolenaar #define ETH_ADDR_LEN 6
427062d76917SMarcel Moolenaar #endif
427162d76917SMarcel Moolenaar 
427262d76917SMarcel Moolenaar int
427362d76917SMarcel Moolenaar if_setupmultiaddr(if_t ifp, void *mta, int *cnt, int max)
427462d76917SMarcel Moolenaar {
427562d76917SMarcel Moolenaar 	struct ifmultiaddr *ifma;
427662d76917SMarcel Moolenaar 	uint8_t *lmta = (uint8_t *)mta;
427762d76917SMarcel Moolenaar 	int mcnt = 0;
427862d76917SMarcel Moolenaar 
427962d76917SMarcel Moolenaar 	TAILQ_FOREACH(ifma, &((struct ifnet *)ifp)->if_multiaddrs, ifma_link) {
428062d76917SMarcel Moolenaar 		if (ifma->ifma_addr->sa_family != AF_LINK)
428162d76917SMarcel Moolenaar 			continue;
428262d76917SMarcel Moolenaar 
428362d76917SMarcel Moolenaar 		if (mcnt == max)
428462d76917SMarcel Moolenaar 			break;
428562d76917SMarcel Moolenaar 
428662d76917SMarcel Moolenaar 		bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
428762d76917SMarcel Moolenaar 		    &lmta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
428862d76917SMarcel Moolenaar 		mcnt++;
428962d76917SMarcel Moolenaar 	}
429062d76917SMarcel Moolenaar 	*cnt = mcnt;
429162d76917SMarcel Moolenaar 
429262d76917SMarcel Moolenaar 	return (0);
429362d76917SMarcel Moolenaar }
429462d76917SMarcel Moolenaar 
429562d76917SMarcel Moolenaar int
429662d76917SMarcel Moolenaar if_multiaddr_array(if_t ifp, void *mta, int *cnt, int max)
429762d76917SMarcel Moolenaar {
429862d76917SMarcel Moolenaar 	int error;
429962d76917SMarcel Moolenaar 
430062d76917SMarcel Moolenaar 	if_maddr_rlock(ifp);
430162d76917SMarcel Moolenaar 	error = if_setupmultiaddr(ifp, mta, cnt, max);
430262d76917SMarcel Moolenaar 	if_maddr_runlock(ifp);
430362d76917SMarcel Moolenaar 	return (error);
430462d76917SMarcel Moolenaar }
430562d76917SMarcel Moolenaar 
430662d76917SMarcel Moolenaar int
430762d76917SMarcel Moolenaar if_multiaddr_count(if_t ifp, int max)
430862d76917SMarcel Moolenaar {
430962d76917SMarcel Moolenaar 	struct ifmultiaddr *ifma;
431062d76917SMarcel Moolenaar 	int count;
431162d76917SMarcel Moolenaar 
431262d76917SMarcel Moolenaar 	count = 0;
431362d76917SMarcel Moolenaar 	if_maddr_rlock(ifp);
431462d76917SMarcel Moolenaar 	TAILQ_FOREACH(ifma, &((struct ifnet *)ifp)->if_multiaddrs, ifma_link) {
431562d76917SMarcel Moolenaar 		if (ifma->ifma_addr->sa_family != AF_LINK)
431662d76917SMarcel Moolenaar 			continue;
431762d76917SMarcel Moolenaar 		count++;
431862d76917SMarcel Moolenaar 		if (count == max)
431962d76917SMarcel Moolenaar 			break;
432062d76917SMarcel Moolenaar 	}
432162d76917SMarcel Moolenaar 	if_maddr_runlock(ifp);
432262d76917SMarcel Moolenaar 	return (count);
432362d76917SMarcel Moolenaar }
432462d76917SMarcel Moolenaar 
43254c7070dbSScott Long int
43264c7070dbSScott Long if_multi_apply(struct ifnet *ifp, int (*filter)(void *, struct ifmultiaddr *, int), void *arg)
43274c7070dbSScott Long {
43284c7070dbSScott Long 	struct ifmultiaddr *ifma;
43294c7070dbSScott Long 	int cnt = 0;
43304c7070dbSScott Long 
43314c7070dbSScott Long 	if_maddr_rlock(ifp);
43324c7070dbSScott Long 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
43334c7070dbSScott Long 		cnt += filter(arg, ifma, cnt);
43344c7070dbSScott Long 	if_maddr_runlock(ifp);
43354c7070dbSScott Long 	return (cnt);
43364c7070dbSScott Long }
43374c7070dbSScott Long 
433862d76917SMarcel Moolenaar struct mbuf *
433962d76917SMarcel Moolenaar if_dequeue(if_t ifp)
434062d76917SMarcel Moolenaar {
434162d76917SMarcel Moolenaar 	struct mbuf *m;
434262d76917SMarcel Moolenaar 	IFQ_DRV_DEQUEUE(&((struct ifnet *)ifp)->if_snd, m);
434362d76917SMarcel Moolenaar 
434462d76917SMarcel Moolenaar 	return (m);
434562d76917SMarcel Moolenaar }
434662d76917SMarcel Moolenaar 
434762d76917SMarcel Moolenaar int
434862d76917SMarcel Moolenaar if_sendq_prepend(if_t ifp, struct mbuf *m)
434962d76917SMarcel Moolenaar {
435062d76917SMarcel Moolenaar 	IFQ_DRV_PREPEND(&((struct ifnet *)ifp)->if_snd, m);
435162d76917SMarcel Moolenaar 	return (0);
435262d76917SMarcel Moolenaar }
435362d76917SMarcel Moolenaar 
435462d76917SMarcel Moolenaar int
435562d76917SMarcel Moolenaar if_setifheaderlen(if_t ifp, int len)
435662d76917SMarcel Moolenaar {
4357e6485f73SGleb Smirnoff 	((struct ifnet *)ifp)->if_hdrlen = len;
435862d76917SMarcel Moolenaar 	return (0);
435962d76917SMarcel Moolenaar }
436062d76917SMarcel Moolenaar 
436162d76917SMarcel Moolenaar caddr_t
436262d76917SMarcel Moolenaar if_getlladdr(if_t ifp)
436362d76917SMarcel Moolenaar {
436462d76917SMarcel Moolenaar 	return (IF_LLADDR((struct ifnet *)ifp));
436562d76917SMarcel Moolenaar }
436662d76917SMarcel Moolenaar 
436762d76917SMarcel Moolenaar void *
436862d76917SMarcel Moolenaar if_gethandle(u_char type)
436962d76917SMarcel Moolenaar {
437062d76917SMarcel Moolenaar 	return (if_alloc(type));
437162d76917SMarcel Moolenaar }
437262d76917SMarcel Moolenaar 
437362d76917SMarcel Moolenaar void
437462d76917SMarcel Moolenaar if_bpfmtap(if_t ifh, struct mbuf *m)
437562d76917SMarcel Moolenaar {
437662d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
437762d76917SMarcel Moolenaar 
437862d76917SMarcel Moolenaar 	BPF_MTAP(ifp, m);
437962d76917SMarcel Moolenaar }
438062d76917SMarcel Moolenaar 
438162d76917SMarcel Moolenaar void
438262d76917SMarcel Moolenaar if_etherbpfmtap(if_t ifh, struct mbuf *m)
438362d76917SMarcel Moolenaar {
438462d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
438562d76917SMarcel Moolenaar 
438662d76917SMarcel Moolenaar 	ETHER_BPF_MTAP(ifp, m);
438762d76917SMarcel Moolenaar }
438862d76917SMarcel Moolenaar 
438962d76917SMarcel Moolenaar void
439062d76917SMarcel Moolenaar if_vlancap(if_t ifh)
439162d76917SMarcel Moolenaar {
439262d76917SMarcel Moolenaar 	struct ifnet *ifp = (struct ifnet *)ifh;
439362d76917SMarcel Moolenaar 	VLAN_CAPABILITIES(ifp);
439462d76917SMarcel Moolenaar }
439562d76917SMarcel Moolenaar 
4396d0b2cad1SStephen J. Kiernan int
4397d0b2cad1SStephen J. Kiernan if_sethwtsomax(if_t ifp, u_int if_hw_tsomax)
4398d0b2cad1SStephen J. Kiernan {
4399d0b2cad1SStephen J. Kiernan 
4400d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomax = if_hw_tsomax;
4401d0b2cad1SStephen J. Kiernan         return (0);
4402d0b2cad1SStephen J. Kiernan }
4403d0b2cad1SStephen J. Kiernan 
4404d0b2cad1SStephen J. Kiernan int
4405d0b2cad1SStephen J. Kiernan if_sethwtsomaxsegcount(if_t ifp, u_int if_hw_tsomaxsegcount)
4406d0b2cad1SStephen J. Kiernan {
4407d0b2cad1SStephen J. Kiernan 
4408d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomaxsegcount = if_hw_tsomaxsegcount;
4409d0b2cad1SStephen J. Kiernan         return (0);
4410d0b2cad1SStephen J. Kiernan }
4411d0b2cad1SStephen J. Kiernan 
4412d0b2cad1SStephen J. Kiernan int
4413d0b2cad1SStephen J. Kiernan if_sethwtsomaxsegsize(if_t ifp, u_int if_hw_tsomaxsegsize)
4414d0b2cad1SStephen J. Kiernan {
4415d0b2cad1SStephen J. Kiernan 
4416d0b2cad1SStephen J. Kiernan 	((struct ifnet *)ifp)->if_hw_tsomaxsegsize = if_hw_tsomaxsegsize;
4417d0b2cad1SStephen J. Kiernan         return (0);
4418d0b2cad1SStephen J. Kiernan }
4419d0b2cad1SStephen J. Kiernan 
4420d0b2cad1SStephen J. Kiernan u_int
4421d0b2cad1SStephen J. Kiernan if_gethwtsomax(if_t ifp)
4422d0b2cad1SStephen J. Kiernan {
4423d0b2cad1SStephen J. Kiernan 
4424d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomax);
4425d0b2cad1SStephen J. Kiernan }
4426d0b2cad1SStephen J. Kiernan 
4427d0b2cad1SStephen J. Kiernan u_int
4428d0b2cad1SStephen J. Kiernan if_gethwtsomaxsegcount(if_t ifp)
4429d0b2cad1SStephen J. Kiernan {
4430d0b2cad1SStephen J. Kiernan 
4431d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomaxsegcount);
4432d0b2cad1SStephen J. Kiernan }
4433d0b2cad1SStephen J. Kiernan 
4434d0b2cad1SStephen J. Kiernan u_int
4435d0b2cad1SStephen J. Kiernan if_gethwtsomaxsegsize(if_t ifp)
4436d0b2cad1SStephen J. Kiernan {
4437d0b2cad1SStephen J. Kiernan 
4438d0b2cad1SStephen J. Kiernan 	return (((struct ifnet *)ifp)->if_hw_tsomaxsegsize);
4439d0b2cad1SStephen J. Kiernan }
4440d0b2cad1SStephen J. Kiernan 
444162d76917SMarcel Moolenaar void
444262d76917SMarcel Moolenaar if_setinitfn(if_t ifp, void (*init_fn)(void *))
444362d76917SMarcel Moolenaar {
444462d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_init = init_fn;
444562d76917SMarcel Moolenaar }
444662d76917SMarcel Moolenaar 
444762d76917SMarcel Moolenaar void
444809a8241fSGleb Smirnoff if_setioctlfn(if_t ifp, int (*ioctl_fn)(if_t, u_long, caddr_t))
444962d76917SMarcel Moolenaar {
445062d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_ioctl = (void *)ioctl_fn;
445162d76917SMarcel Moolenaar }
445262d76917SMarcel Moolenaar 
445362d76917SMarcel Moolenaar void
445409a8241fSGleb Smirnoff if_setstartfn(if_t ifp, void (*start_fn)(if_t))
445562d76917SMarcel Moolenaar {
445662d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_start = (void *)start_fn;
445762d76917SMarcel Moolenaar }
445862d76917SMarcel Moolenaar 
445962d76917SMarcel Moolenaar void
446062d76917SMarcel Moolenaar if_settransmitfn(if_t ifp, if_transmit_fn_t start_fn)
446162d76917SMarcel Moolenaar {
446262d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_transmit = start_fn;
446362d76917SMarcel Moolenaar }
446462d76917SMarcel Moolenaar 
446562d76917SMarcel Moolenaar void if_setqflushfn(if_t ifp, if_qflush_fn_t flush_fn)
446662d76917SMarcel Moolenaar {
446762d76917SMarcel Moolenaar 	((struct ifnet *)ifp)->if_qflush = flush_fn;
446862d76917SMarcel Moolenaar 
446962d76917SMarcel Moolenaar }
447062d76917SMarcel Moolenaar 
447135853c2cSGleb Smirnoff void
447235853c2cSGleb Smirnoff if_setgetcounterfn(if_t ifp, if_get_counter_t fn)
447335853c2cSGleb Smirnoff {
447435853c2cSGleb Smirnoff 
447535853c2cSGleb Smirnoff 	ifp->if_get_counter = fn;
447635853c2cSGleb Smirnoff }
447735853c2cSGleb Smirnoff 
447862d76917SMarcel Moolenaar /* Revisit these - These are inline functions originally. */
447962d76917SMarcel Moolenaar int
448062d76917SMarcel Moolenaar drbr_inuse_drv(if_t ifh, struct buf_ring *br)
448162d76917SMarcel Moolenaar {
4482966ab68dSDimitry Andric 	return drbr_inuse(ifh, br);
448362d76917SMarcel Moolenaar }
448462d76917SMarcel Moolenaar 
448562d76917SMarcel Moolenaar struct mbuf*
448662d76917SMarcel Moolenaar drbr_dequeue_drv(if_t ifh, struct buf_ring *br)
448762d76917SMarcel Moolenaar {
448862d76917SMarcel Moolenaar 	return drbr_dequeue(ifh, br);
448962d76917SMarcel Moolenaar }
449062d76917SMarcel Moolenaar 
449162d76917SMarcel Moolenaar int
449262d76917SMarcel Moolenaar drbr_needs_enqueue_drv(if_t ifh, struct buf_ring *br)
449362d76917SMarcel Moolenaar {
449462d76917SMarcel Moolenaar 	return drbr_needs_enqueue(ifh, br);
449562d76917SMarcel Moolenaar }
449662d76917SMarcel Moolenaar 
449762d76917SMarcel Moolenaar int
449862d76917SMarcel Moolenaar drbr_enqueue_drv(if_t ifh, struct buf_ring *br, struct mbuf *m)
449962d76917SMarcel Moolenaar {
450062d76917SMarcel Moolenaar 	return drbr_enqueue(ifh, br, m);
450162d76917SMarcel Moolenaar 
450262d76917SMarcel Moolenaar }
4503