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