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