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