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