xref: /netbsd-src/sys/net/if_gif.c (revision ae50415a0d4ae64507de19cdae67ca5e888136ff)
1 /*	$NetBSD: if_gif.c,v 1.159 2024/09/15 09:46:45 skrll Exp $	*/
2 /*	$KAME: if_gif.c,v 1.76 2001/08/20 02:01:02 kjc Exp $	*/
3 
4 /*
5  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the project nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: if_gif.c,v 1.159 2024/09/15 09:46:45 skrll Exp $");
35 
36 #ifdef _KERNEL_OPT
37 #include "opt_inet.h"
38 #include "opt_net_mpsafe.h"
39 #endif
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/atomic.h>
44 #include <sys/kernel.h>
45 #include <sys/mbuf.h>
46 #include <sys/socket.h>
47 #include <sys/sockio.h>
48 #include <sys/errno.h>
49 #include <sys/ioctl.h>
50 #include <sys/time.h>
51 #include <sys/socketvar.h>
52 #include <sys/syslog.h>
53 #include <sys/proc.h>
54 #include <sys/cpu.h>
55 #include <sys/intr.h>
56 #include <sys/kmem.h>
57 #include <sys/sysctl.h>
58 #include <sys/xcall.h>
59 #include <sys/device.h>
60 #include <sys/module.h>
61 #include <sys/mutex.h>
62 #include <sys/pserialize.h>
63 #include <sys/psref.h>
64 
65 #include <net/if.h>
66 #include <net/if_types.h>
67 #include <net/route.h>
68 #include <net/bpf.h>
69 
70 #include <netinet/in.h>
71 #include <netinet/in_systm.h>
72 #include <netinet/ip.h>
73 #ifdef	INET
74 #include <netinet/in_var.h>
75 #endif	/* INET */
76 #include <netinet/in_gif.h>
77 
78 #ifdef INET6
79 #ifndef INET
80 #include <netinet/in.h>
81 #endif
82 #include <netinet6/in6_var.h>
83 #include <netinet/ip6.h>
84 #include <netinet6/ip6_var.h>
85 #include <netinet6/in6_gif.h>
86 #endif /* INET6 */
87 
88 #include <netinet/ip_encap.h>
89 #include <net/if_gif.h>
90 
91 #include "ioconf.h"
92 
93 #ifdef NET_MPSAFE
94 #define GIF_MPSAFE	1
95 #endif
96 
97 /*
98  * gif global variable definitions
99  */
100 static struct {
101 	LIST_HEAD(gif_sclist, gif_softc) list;
102 	kmutex_t lock;
103 } gif_softcs __cacheline_aligned;
104 
105 struct psref_class *gv_psref_class __read_mostly;
106 
107 static pktq_rps_hash_func_t gif_pktq_rps_hash_p;
108 
109 static int	gifattach0(struct gif_softc *);
110 static int	gif_output(struct ifnet *, struct mbuf *,
111 			   const struct sockaddr *, const struct rtentry *);
112 static void	gif_start(struct ifnet *);
113 static int	gif_transmit(struct ifnet *, struct mbuf *);
114 static int	gif_transmit_direct(struct gif_variant *, struct mbuf *);
115 static int	gif_ioctl(struct ifnet *, u_long, void *);
116 static int	gif_set_tunnel(struct ifnet *, struct sockaddr *,
117 			       struct sockaddr *);
118 static void	gif_delete_tunnel(struct ifnet *);
119 
120 static int	gif_clone_create(struct if_clone *, int);
121 static int	gif_clone_destroy(struct ifnet *);
122 static int	gif_check_nesting(struct ifnet *, struct mbuf *);
123 
124 static int	gif_encap_attach(struct gif_variant *);
125 static int	gif_encap_detach(struct gif_variant *);
126 
127 static void	gif_update_variant(struct gif_softc *, struct gif_variant *);
128 
129 static struct if_clone gif_cloner =
130     IF_CLONE_INITIALIZER("gif", gif_clone_create, gif_clone_destroy);
131 
132 #ifndef MAX_GIF_NEST
133 /*
134  * This macro controls the upper limitation on nesting of gif tunnels.
135  * Since, setting a large value to this macro with a careless configuration
136  * may introduce system crash, we don't allow any nestings by default.
137  * If you need to configure nested gif tunnels, you can define this macro
138  * in your kernel configuration file.  However, if you do so, please be
139  * careful to configure the tunnels so that it won't make a loop.
140  */
141 #define MAX_GIF_NEST 1
142 #endif
143 static int max_gif_nesting = MAX_GIF_NEST;
144 
145 static struct sysctllog *gif_sysctl;
146 
147 #ifdef INET6
148 static int
149 sysctl_gif_pmtu_global(SYSCTLFN_ARGS)
150 {
151 	int error, pmtu;
152 	struct sysctlnode node = *rnode;
153 
154 	pmtu = ip6_gif_pmtu;
155 	node.sysctl_data = &pmtu;
156 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
157 	if (error || newp == NULL)
158 		return error;
159 
160 	switch (pmtu) {
161 	case GIF_PMTU_MINMTU:
162 	case GIF_PMTU_OUTERMTU:
163 		ip6_gif_pmtu = pmtu;
164 		break;
165 	default:
166 		return EINVAL;
167 	}
168 
169 	return 0;
170 }
171 
172 static int
173 sysctl_gif_pmtu_perif(SYSCTLFN_ARGS)
174 {
175 	int error, pmtu;
176 	struct sysctlnode node = *rnode;
177 	struct gif_softc *sc = (struct gif_softc *)node.sysctl_data;
178 
179 	pmtu = sc->gif_pmtu;
180 	node.sysctl_data = &pmtu;
181 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
182 	if (error || newp == NULL)
183 		return error;
184 
185 	switch (pmtu) {
186 	case GIF_PMTU_SYSDEFAULT:
187 	case GIF_PMTU_MINMTU:
188 	case GIF_PMTU_OUTERMTU:
189 		sc->gif_pmtu = pmtu;
190 		break;
191 	default:
192 		return EINVAL;
193 	}
194 
195 	return 0;
196 }
197 #endif
198 
199 static void
200 gif_sysctl_setup(void)
201 {
202 	const struct sysctlnode *node = NULL;
203 
204 	gif_sysctl = NULL;
205 
206 #ifdef INET
207 	/*
208 	 * Previously create "net.inet.ip" entry to avoid sysctl_createv error.
209 	 */
210 	sysctl_createv(NULL, 0, NULL, NULL,
211 		       CTLFLAG_PERMANENT,
212 		       CTLTYPE_NODE, "inet",
213 		       SYSCTL_DESCR("PF_INET related settings"),
214 		       NULL, 0, NULL, 0,
215 		       CTL_NET, PF_INET, CTL_EOL);
216 	sysctl_createv(NULL, 0, NULL, NULL,
217 		       CTLFLAG_PERMANENT,
218 		       CTLTYPE_NODE, "ip",
219 		       SYSCTL_DESCR("IPv4 related settings"),
220 		       NULL, 0, NULL, 0,
221 		       CTL_NET, PF_INET, IPPROTO_IP, CTL_EOL);
222 
223 	sysctl_createv(&gif_sysctl, 0, NULL, NULL,
224 		       CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
225 		       CTLTYPE_INT, "gifttl",
226 		       SYSCTL_DESCR("Default TTL for a gif tunnel datagram"),
227 		       NULL, 0, &ip_gif_ttl, 0,
228 		       CTL_NET, PF_INET, IPPROTO_IP,
229 		       IPCTL_GIF_TTL, CTL_EOL);
230 #endif
231 #ifdef INET6
232 	/*
233 	 * Previously create "net.inet6.ip6" entry to avoid sysctl_createv error.
234 	 */
235 	sysctl_createv(NULL, 0, NULL, NULL,
236 		       CTLFLAG_PERMANENT,
237 		       CTLTYPE_NODE, "inet6",
238 		       SYSCTL_DESCR("PF_INET6 related settings"),
239 		       NULL, 0, NULL, 0,
240 		       CTL_NET, PF_INET6, CTL_EOL);
241 	sysctl_createv(NULL, 0, NULL, NULL,
242 		       CTLFLAG_PERMANENT,
243 		       CTLTYPE_NODE, "ip6",
244 		       SYSCTL_DESCR("IPv6 related settings"),
245 		       NULL, 0, NULL, 0,
246 		       CTL_NET, PF_INET6, IPPROTO_IPV6, CTL_EOL);
247 
248 	sysctl_createv(&gif_sysctl, 0, NULL, NULL,
249 		       CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
250 		       CTLTYPE_INT, "gifhlim",
251 		       SYSCTL_DESCR("Default hop limit for a gif tunnel datagram"),
252 		       NULL, 0, &ip6_gif_hlim, 0,
253 		       CTL_NET, PF_INET6, IPPROTO_IPV6,
254 		       IPV6CTL_GIF_HLIM, CTL_EOL);
255 
256 	sysctl_createv(&gif_sysctl, 0, NULL, NULL,
257 		       CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
258 		       CTLTYPE_INT, "gifpmtu",
259 		       SYSCTL_DESCR("Default Path MTU setting for gif tunnels"),
260 		       sysctl_gif_pmtu_global, 0, NULL, 0,
261 		       CTL_NET, PF_INET6, IPPROTO_IPV6,
262 		       IPV6CTL_GIF_PMTU, CTL_EOL);
263 #endif
264 
265 	sysctl_createv(&gif_sysctl, 0, NULL, &node,
266 		       CTLFLAG_PERMANENT,
267 		       CTLTYPE_NODE, "gif",
268 		       SYSCTL_DESCR("gif global control"),
269 		       NULL, 0, NULL, 0,
270 		       CTL_NET, CTL_CREATE, CTL_EOL);
271 
272 	sysctl_createv(&gif_sysctl, 0, &node, NULL,
273 		       CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
274 		       CTLTYPE_STRING, "rps_hash",
275 		       SYSCTL_DESCR("Interface rps hash function control"),
276 		       sysctl_pktq_rps_hash_handler, 0, (void *)&gif_pktq_rps_hash_p,
277 		       PKTQ_RPS_HASH_NAME_LEN,
278 		       CTL_CREATE, CTL_EOL);
279 }
280 
281 static void
282 gif_perif_sysctl_setup(struct sysctllog **clog, struct gif_softc *sc)
283 {
284 #ifdef INET6
285 	const struct sysctlnode *cnode, *rnode;
286 	struct ifnet *ifp = &sc->gif_if;
287 	const char *ifname = ifp->if_xname;
288 	int rv;
289 
290 	/*
291 	 * Already created in sysctl_sndq_setup().
292 	 */
293 	sysctl_createv(clog, 0, NULL, &rnode,
294 		       CTLFLAG_PERMANENT,
295 		       CTLTYPE_NODE, "interfaces",
296 		       SYSCTL_DESCR("Per-interface controls"),
297 		       NULL, 0, NULL, 0,
298 		       CTL_NET, CTL_CREATE, CTL_EOL);
299 	sysctl_createv(clog, 0, &rnode, &rnode,
300 		       CTLFLAG_PERMANENT,
301 		       CTLTYPE_NODE, ifname,
302 		       SYSCTL_DESCR("Interface controls"),
303 		       NULL, 0, NULL, 0,
304 		       CTL_CREATE, CTL_EOL);
305 
306 	rv = sysctl_createv(clog, 0, &rnode, &cnode,
307 			    CTLFLAG_PERMANENT,
308 			    CTLTYPE_INT, "pmtu",
309 			    SYSCTL_DESCR("Path MTU setting for this gif tunnel"),
310 			    sysctl_gif_pmtu_perif, 0, (void *)sc, 0,
311 			    CTL_CREATE, CTL_EOL);
312 	if (rv != 0)
313 		log(LOG_WARNING, "%s: could not attach sysctl node pmtu\n", ifname);
314 
315 	sc->gif_pmtu = GIF_PMTU_SYSDEFAULT;
316 #endif
317 }
318 
319 /* ARGSUSED */
320 void
321 gifattach(int count)
322 {
323 	/*
324 	 * Nothing to do here, initialization is handled by the
325 	 * module initialization code in gifinit() below).
326 	 */
327 }
328 
329 static void
330 gifinit(void)
331 {
332 
333 	mutex_init(&gif_softcs.lock, MUTEX_DEFAULT, IPL_NONE);
334 	LIST_INIT(&gif_softcs.list);
335 	if_clone_attach(&gif_cloner);
336 
337 	gv_psref_class = psref_class_create("gifvar", IPL_SOFTNET);
338 
339 	gif_pktq_rps_hash_p = pktq_rps_hash_default;
340 	gif_sysctl_setup();
341 }
342 
343 static int
344 gifdetach(void)
345 {
346 
347 	mutex_enter(&gif_softcs.lock);
348 	if (!LIST_EMPTY(&gif_softcs.list)) {
349 		mutex_exit(&gif_softcs.lock);
350 		return EBUSY;
351 	}
352 
353 	psref_class_destroy(gv_psref_class);
354 
355 	if_clone_detach(&gif_cloner);
356 	sysctl_teardown(&gif_sysctl);
357 	mutex_exit(&gif_softcs.lock);
358 	mutex_destroy(&gif_softcs.lock);
359 	return 0;
360 }
361 
362 static int
363 gif_clone_create(struct if_clone *ifc, int unit)
364 {
365 	struct gif_softc *sc;
366 	struct gif_variant *var;
367 	struct ifnet *ifp;
368 	int rv;
369 
370 	sc = kmem_zalloc(sizeof(struct gif_softc), KM_SLEEP);
371 
372 	if_initname(&sc->gif_if, ifc->ifc_name, unit);
373 
374 	rv = gifattach0(sc);
375 	if (rv != 0) {
376 		kmem_free(sc, sizeof(struct gif_softc));
377 		return rv;
378 	}
379 
380 	ifp = &sc->gif_if;
381 	gif_perif_sysctl_setup(&ifp->if_sysctl_log, sc);
382 
383 	var = kmem_zalloc(sizeof(*var), KM_SLEEP);
384 	var->gv_softc = sc;
385 	psref_target_init(&var->gv_psref, gv_psref_class);
386 
387 	sc->gif_var = var;
388 	mutex_init(&sc->gif_lock, MUTEX_DEFAULT, IPL_NONE);
389 	sc->gif_psz = pserialize_create();
390 
391 	sc->gif_ro_percpu = if_tunnel_alloc_ro_percpu();
392 	mutex_enter(&gif_softcs.lock);
393 	LIST_INSERT_HEAD(&gif_softcs.list, sc, gif_list);
394 	mutex_exit(&gif_softcs.lock);
395 	return 0;
396 }
397 
398 static int
399 gifattach0(struct gif_softc *sc)
400 {
401 
402 	sc->gif_if.if_addrlen = 0;
403 	sc->gif_if.if_mtu    = GIF_MTU;
404 	sc->gif_if.if_flags  = IFF_POINTOPOINT | IFF_MULTICAST;
405 #ifdef GIF_MPSAFE
406 	sc->gif_if.if_extflags  |= IFEF_MPSAFE;
407 #endif
408 	sc->gif_if.if_ioctl  = gif_ioctl;
409 	sc->gif_if.if_output = gif_output;
410 	sc->gif_if.if_start = gif_start;
411 	sc->gif_if.if_transmit = gif_transmit;
412 	sc->gif_if.if_type   = IFT_GIF;
413 	sc->gif_if.if_dlt    = DLT_NULL;
414 	sc->gif_if.if_softc  = sc;
415 	IFQ_SET_READY(&sc->gif_if.if_snd);
416 	if_initialize(&sc->gif_if);
417 
418 	sc->gif_if.if_link_state = LINK_STATE_DOWN;
419 	if_alloc_sadl(&sc->gif_if);
420 	bpf_attach(&sc->gif_if, DLT_NULL, sizeof(u_int));
421 	if_register(&sc->gif_if);
422 	return 0;
423 }
424 
425 static int
426 gif_clone_destroy(struct ifnet *ifp)
427 {
428 	struct gif_softc *sc = (void *) ifp;
429 	struct gif_variant *var;
430 
431 	LIST_REMOVE(sc, gif_list);
432 
433 	gif_delete_tunnel(&sc->gif_if);
434 	bpf_detach(ifp);
435 	if_detach(ifp);
436 
437 	if_tunnel_free_ro_percpu(sc->gif_ro_percpu);
438 
439 	pserialize_destroy(sc->gif_psz);
440 	mutex_destroy(&sc->gif_lock);
441 
442 	var = sc->gif_var;
443 	kmem_free(var, sizeof(*var));
444 	kmem_free(sc, sizeof(struct gif_softc));
445 
446 	return 0;
447 }
448 
449 #ifdef GIF_ENCAPCHECK
450 int
451 gif_encapcheck(struct mbuf *m, int off, int proto, void *arg)
452 {
453 	struct ip ip;
454 	struct gif_softc *sc;
455 	struct gif_variant *var;
456 	struct psref psref;
457 	int ret = 0;
458 
459 	sc = arg;
460 	if (sc == NULL)
461 		return 0;
462 
463 	if ((sc->gif_if.if_flags & IFF_UP) == 0)
464 		return 0;
465 
466 	var = gif_getref_variant(sc, &psref);
467 	/* no physical address */
468 	if (var->gv_psrc == NULL || var->gv_pdst == NULL)
469 		goto out;
470 
471 	switch (proto) {
472 #ifdef INET
473 	case IPPROTO_IPV4:
474 		break;
475 #endif
476 #ifdef INET6
477 	case IPPROTO_IPV6:
478 		break;
479 #endif
480 	default:
481 		goto out;
482 	}
483 
484 	/* Bail on short packets */
485 	KASSERT(m->m_flags & M_PKTHDR);
486 	if (m->m_pkthdr.len < sizeof(ip))
487 		goto  out;
488 
489 	m_copydata(m, 0, sizeof(ip), &ip);
490 
491 	switch (ip.ip_v) {
492 #ifdef INET
493 	case 4:
494 		if (var->gv_psrc->sa_family != AF_INET ||
495 		    var->gv_pdst->sa_family != AF_INET)
496 			goto out;
497 		ret = gif_encapcheck4(m, off, proto, var);
498 		break;
499 #endif
500 #ifdef INET6
501 	case 6:
502 		if (m->m_pkthdr.len < sizeof(struct ip6_hdr))
503 			goto out;
504 		if (var->gv_psrc->sa_family != AF_INET6 ||
505 		    var->gv_pdst->sa_family != AF_INET6)
506 			goto out;
507 		ret = gif_encapcheck6(m, off, proto, var);
508 		break;
509 #endif
510 	default:
511 		goto out;
512 	}
513 
514 out:
515 	gif_putref_variant(var, &psref);
516 	return ret;
517 }
518 #endif
519 
520 /*
521  * gif may cause infinite recursion calls when misconfigured.
522  * We'll prevent this by introducing upper limit.
523  */
524 static int
525 gif_check_nesting(struct ifnet *ifp, struct mbuf *m)
526 {
527 
528 	return if_tunnel_check_nesting(ifp, m, max_gif_nesting);
529 }
530 
531 static int
532 gif_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
533     const struct rtentry *rt)
534 {
535 	struct gif_softc *sc = ifp->if_softc;
536 	struct gif_variant *var = NULL;
537 	struct psref psref;
538 	int error = 0;
539 
540 	IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
541 
542 	if ((error = gif_check_nesting(ifp, m)) != 0) {
543 		m_freem(m);
544 		goto end;
545 	}
546 
547 	if ((ifp->if_flags & IFF_UP) == 0) {
548 		m_freem(m);
549 		error = ENETDOWN;
550 		goto end;
551 	}
552 
553 	var = gif_getref_variant(sc, &psref);
554 	if (var->gv_psrc == NULL || var->gv_pdst == NULL) {
555 		m_freem(m);
556 		error = ENETDOWN;
557 		goto end;
558 	}
559 	/* XXX should we check if our outer source is legal? */
560 
561 	m->m_flags &= ~(M_BCAST | M_MCAST);
562 
563 	/* use DLT_NULL encapsulation here to pass inner af type */
564 	M_PREPEND(m, sizeof(int), M_DONTWAIT);
565 	if (!m) {
566 		error = ENOBUFS;
567 		goto end;
568 	}
569 	*mtod(m, int *) = dst->sa_family;
570 
571 	/* Clear checksum-offload flags. */
572 	m->m_pkthdr.csum_flags = 0;
573 	m->m_pkthdr.csum_data = 0;
574 
575 	error = if_transmit_lock(ifp, m);
576 
577 end:
578 	if (var != NULL)
579 		gif_putref_variant(var, &psref);
580 	if (error)
581 		if_statinc(ifp, if_oerrors);
582 	return error;
583 }
584 
585 static void
586 gif_start(struct ifnet *ifp)
587 {
588 	struct gif_softc *sc;
589 	struct gif_variant *var;
590 	struct mbuf *m;
591 	struct psref psref;
592 	int family;
593 	int len;
594 	int error;
595 
596 	sc = ifp->if_softc;
597 	var = gif_getref_variant(sc, &psref);
598 
599 	KASSERT(var->gv_output != NULL);
600 
601 	/* output processing */
602 	while (1) {
603 		IFQ_DEQUEUE(&sc->gif_if.if_snd, m);
604 		if (m == NULL)
605 			break;
606 
607 		/* grab and chop off inner af type */
608 		if (sizeof(int) > m->m_len) {
609 			m = m_pullup(m, sizeof(int));
610 			if (!m) {
611 				if_statinc(ifp, if_oerrors);
612 				continue;
613 			}
614 		}
615 		family = *mtod(m, int *);
616 		bpf_mtap(ifp, m, BPF_D_OUT);
617 		m_adj(m, sizeof(int));
618 
619 		len = m->m_pkthdr.len;
620 
621 		error = var->gv_output(var, family, m);
622 		if (error)
623 			if_statinc(ifp, if_oerrors);
624 		else
625 			if_statadd2(ifp, if_opackets, 1, if_obytes, len);
626 	}
627 
628 	gif_putref_variant(var, &psref);
629 }
630 
631 static int
632 gif_transmit(struct ifnet *ifp, struct mbuf *m)
633 {
634 	struct gif_softc *sc;
635 	struct gif_variant *var;
636 	struct psref psref;
637 	int error;
638 
639 	sc = ifp->if_softc;
640 
641 	/* output processing */
642 	if (m == NULL)
643 		return EINVAL;
644 
645 	var = gif_getref_variant(sc, &psref);
646 	error = gif_transmit_direct(var, m);
647 	gif_putref_variant(var, &psref);
648 
649 	return error;
650 }
651 
652 static int
653 gif_transmit_direct(struct gif_variant *var, struct mbuf *m)
654 {
655 	struct ifnet *ifp = &var->gv_softc->gif_if;
656 	int error;
657 	int family;
658 	int len;
659 
660 	KASSERT(gif_heldref_variant(var));
661 	KASSERT(var->gv_output != NULL);
662 
663 	/* grab and chop off inner af type */
664 	if (sizeof(int) > m->m_len) {
665 		m = m_pullup(m, sizeof(int));
666 		if (!m) {
667 			if_statinc(ifp, if_oerrors);
668 			return ENOBUFS;
669 		}
670 	}
671 	family = *mtod(m, int *);
672 	bpf_mtap(ifp, m, BPF_D_OUT);
673 	m_adj(m, sizeof(int));
674 
675 	len = m->m_pkthdr.len;
676 
677 	error = var->gv_output(var, family, m);
678 	if (error)
679 		if_statinc(ifp, if_oerrors);
680 	else
681 		if_statadd2(ifp, if_opackets, 1, if_obytes, len);
682 
683 	return error;
684 }
685 
686 void
687 gif_input(struct mbuf *m, int af, struct ifnet *ifp)
688 {
689 	pktqueue_t *pktq;
690 	size_t pktlen;
691 
692 	if (ifp == NULL) {
693 		/* just in case */
694 		m_freem(m);
695 		return;
696 	}
697 
698 	m_set_rcvif(m, ifp);
699 	pktlen = m->m_pkthdr.len;
700 
701 	bpf_mtap_af(ifp, af, m, BPF_D_IN);
702 
703 	/*
704 	 * Put the packet to the network layer input queue according to the
705 	 * specified address family.  Note: we avoid direct call to the
706 	 * input function of the network layer in order to avoid recursion.
707 	 * This may be revisited in the future.
708 	 */
709 	switch (af) {
710 #ifdef INET
711 	case AF_INET:
712 		pktq = ip_pktq;
713 		break;
714 #endif
715 #ifdef INET6
716 	case AF_INET6:
717 		pktq = ip6_pktq;
718 		break;
719 #endif
720 	default:
721 		m_freem(m);
722 		return;
723 	}
724 
725 	const uint32_t h = pktq_rps_hash(&gif_pktq_rps_hash_p, m);
726 	if (__predict_true(pktq_enqueue(pktq, m, h))) {
727 		if_statadd2(ifp, if_ibytes, pktlen, if_ipackets, 1);
728 	} else {
729 		m_freem(m);
730 	}
731 }
732 
733 /* XXX how should we handle IPv6 scope on SIOC[GS]IFPHYADDR? */
734 static int
735 gif_ioctl(struct ifnet *ifp, u_long cmd, void *data)
736 {
737 	struct gif_softc *sc  = ifp->if_softc;
738 	struct ifreq     *ifr = (struct ifreq*)data;
739 	struct ifaddr    *ifa = (struct ifaddr*)data;
740 	int error = 0, size, bound;
741 	struct sockaddr *dst, *src;
742 	struct gif_variant *var;
743 	struct psref psref;
744 
745 	switch (cmd) {
746 	case SIOCINITIFADDR:
747 		ifp->if_flags |= IFF_UP;
748 		ifa->ifa_rtrequest = p2p_rtrequest;
749 		break;
750 
751 	case SIOCADDMULTI:
752 	case SIOCDELMULTI:
753 		switch (ifr->ifr_addr.sa_family) {
754 #ifdef INET
755 		case AF_INET:	/* IP supports Multicast */
756 			break;
757 #endif /* INET */
758 #ifdef INET6
759 		case AF_INET6:	/* IP6 supports Multicast */
760 			break;
761 #endif /* INET6 */
762 		default:  /* Other protocols doesn't support Multicast */
763 			error = EAFNOSUPPORT;
764 			break;
765 		}
766 		break;
767 
768 	case SIOCSIFMTU:
769 		if (ifr->ifr_mtu < GIF_MTU_MIN || ifr->ifr_mtu > GIF_MTU_MAX)
770 			return EINVAL;
771 		else if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
772 			error = 0;
773 		break;
774 
775 #ifdef INET
776 	case SIOCSIFPHYADDR:
777 #endif
778 #ifdef INET6
779 	case SIOCSIFPHYADDR_IN6:
780 #endif /* INET6 */
781 	case SIOCSLIFPHYADDR:
782 		switch (cmd) {
783 #ifdef INET
784 		case SIOCSIFPHYADDR:
785 			src = (struct sockaddr *)
786 				&(((struct in_aliasreq *)data)->ifra_addr);
787 			dst = (struct sockaddr *)
788 				&(((struct in_aliasreq *)data)->ifra_dstaddr);
789 			break;
790 #endif
791 #ifdef INET6
792 		case SIOCSIFPHYADDR_IN6:
793 			src = (struct sockaddr *)
794 				&(((struct in6_aliasreq *)data)->ifra_addr);
795 			dst = (struct sockaddr *)
796 				&(((struct in6_aliasreq *)data)->ifra_dstaddr);
797 			break;
798 #endif
799 		case SIOCSLIFPHYADDR:
800 			src = (struct sockaddr *)
801 				&(((struct if_laddrreq *)data)->addr);
802 			dst = (struct sockaddr *)
803 				&(((struct if_laddrreq *)data)->dstaddr);
804 			break;
805 		default:
806 			return EINVAL;
807 		}
808 
809 		/* sa_family must be equal */
810 		if (src->sa_family != dst->sa_family)
811 			return EINVAL;
812 
813 		/* validate sa_len */
814 		switch (src->sa_family) {
815 #ifdef INET
816 		case AF_INET:
817 			if (src->sa_len != sizeof(struct sockaddr_in))
818 				return EINVAL;
819 			break;
820 #endif
821 #ifdef INET6
822 		case AF_INET6:
823 			if (src->sa_len != sizeof(struct sockaddr_in6))
824 				return EINVAL;
825 			break;
826 #endif
827 		default:
828 			return EAFNOSUPPORT;
829 		}
830 		switch (dst->sa_family) {
831 #ifdef INET
832 		case AF_INET:
833 			if (dst->sa_len != sizeof(struct sockaddr_in))
834 				return EINVAL;
835 			break;
836 #endif
837 #ifdef INET6
838 		case AF_INET6:
839 			if (dst->sa_len != sizeof(struct sockaddr_in6))
840 				return EINVAL;
841 			break;
842 #endif
843 		default:
844 			return EAFNOSUPPORT;
845 		}
846 
847 		/* check sa_family looks sane for the cmd */
848 		switch (cmd) {
849 		case SIOCSIFPHYADDR:
850 			if (src->sa_family == AF_INET)
851 				break;
852 			return EAFNOSUPPORT;
853 #ifdef INET6
854 		case SIOCSIFPHYADDR_IN6:
855 			if (src->sa_family == AF_INET6)
856 				break;
857 			return EAFNOSUPPORT;
858 #endif /* INET6 */
859 		case SIOCSLIFPHYADDR:
860 			/* checks done in the above */
861 			break;
862 		}
863 
864 		/*
865 		 * calls gif_getref_variant() for other softcs to check
866 		 * address pair duplication
867 		 */
868 		bound = curlwp_bind();
869 		error = gif_set_tunnel(&sc->gif_if, src, dst);
870 		if (error == 0)
871 			if_link_state_change(&sc->gif_if, LINK_STATE_UP);
872 		curlwp_bindx(bound);
873 
874 		break;
875 
876 #ifdef SIOCDIFPHYADDR
877 	case SIOCDIFPHYADDR:
878 		bound = curlwp_bind();
879 		gif_delete_tunnel(&sc->gif_if);
880 		if_link_state_change(&sc->gif_if, LINK_STATE_DOWN);
881 		curlwp_bindx(bound);
882 		break;
883 #endif
884 
885 	case SIOCGIFPSRCADDR:
886 #ifdef INET6
887 	case SIOCGIFPSRCADDR_IN6:
888 #endif /* INET6 */
889 		bound = curlwp_bind();
890 		var = gif_getref_variant(sc, &psref);
891 		if (var->gv_psrc == NULL) {
892 			gif_putref_variant(var, &psref);
893 			curlwp_bindx(bound);
894 			error = EADDRNOTAVAIL;
895 			goto bad;
896 		}
897 		src = var->gv_psrc;
898 		switch (cmd) {
899 #ifdef INET
900 		case SIOCGIFPSRCADDR:
901 			dst = &ifr->ifr_addr;
902 			size = sizeof(ifr->ifr_addr);
903 			break;
904 #endif /* INET */
905 #ifdef INET6
906 		case SIOCGIFPSRCADDR_IN6:
907 			dst = (struct sockaddr *)
908 				&(((struct in6_ifreq *)data)->ifr_addr);
909 			size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
910 			break;
911 #endif /* INET6 */
912 		default:
913 			gif_putref_variant(var, &psref);
914 			curlwp_bindx(bound);
915 			error = EADDRNOTAVAIL;
916 			goto bad;
917 		}
918 		if (src->sa_len > size) {
919 			gif_putref_variant(var, &psref);
920 			curlwp_bindx(bound);
921 			return EINVAL;
922 		}
923 		memcpy(dst, src, src->sa_len);
924 		gif_putref_variant(var, &psref);
925 		curlwp_bindx(bound);
926 		break;
927 
928 	case SIOCGIFPDSTADDR:
929 #ifdef INET6
930 	case SIOCGIFPDSTADDR_IN6:
931 #endif /* INET6 */
932 		bound = curlwp_bind();
933 		var = gif_getref_variant(sc, &psref);
934 		if (var->gv_pdst == NULL) {
935 			gif_putref_variant(var, &psref);
936 			curlwp_bindx(bound);
937 			error = EADDRNOTAVAIL;
938 			goto bad;
939 		}
940 		src = var->gv_pdst;
941 		switch (cmd) {
942 #ifdef INET
943 		case SIOCGIFPDSTADDR:
944 			dst = &ifr->ifr_addr;
945 			size = sizeof(ifr->ifr_addr);
946 			break;
947 #endif /* INET */
948 #ifdef INET6
949 		case SIOCGIFPDSTADDR_IN6:
950 			dst = (struct sockaddr *)
951 				&(((struct in6_ifreq *)data)->ifr_addr);
952 			size = sizeof(((struct in6_ifreq *)data)->ifr_addr);
953 			break;
954 #endif /* INET6 */
955 		default:
956 			gif_putref_variant(var, &psref);
957 			curlwp_bindx(bound);
958 			error = EADDRNOTAVAIL;
959 			goto bad;
960 		}
961 		if (src->sa_len > size) {
962 			gif_putref_variant(var, &psref);
963 			curlwp_bindx(bound);
964 			return EINVAL;
965 		}
966 		memcpy(dst, src, src->sa_len);
967 		gif_putref_variant(var, &psref);
968 		curlwp_bindx(bound);
969 		break;
970 
971 	case SIOCGLIFPHYADDR:
972 		bound = curlwp_bind();
973 		var = gif_getref_variant(sc, &psref);
974 		if (var->gv_psrc == NULL || var->gv_pdst == NULL) {
975 			gif_putref_variant(var, &psref);
976 			curlwp_bindx(bound);
977 			error = EADDRNOTAVAIL;
978 			goto bad;
979 		}
980 
981 		/* copy src */
982 		src = var->gv_psrc;
983 		dst = (struct sockaddr *)
984 			&(((struct if_laddrreq *)data)->addr);
985 		size = sizeof(((struct if_laddrreq *)data)->addr);
986 		if (src->sa_len > size) {
987 			gif_putref_variant(var, &psref);
988 			curlwp_bindx(bound);
989 			return EINVAL;
990 		}
991 		memcpy(dst, src, src->sa_len);
992 
993 		/* copy dst */
994 		src = var->gv_pdst;
995 		dst = (struct sockaddr *)
996 			&(((struct if_laddrreq *)data)->dstaddr);
997 		size = sizeof(((struct if_laddrreq *)data)->dstaddr);
998 		if (src->sa_len > size) {
999 			gif_putref_variant(var, &psref);
1000 			curlwp_bindx(bound);
1001 			return EINVAL;
1002 		}
1003 		memcpy(dst, src, src->sa_len);
1004 		gif_putref_variant(var, &psref);
1005 		curlwp_bindx(bound);
1006 		break;
1007 
1008 	default:
1009 		return ifioctl_common(ifp, cmd, data);
1010 	}
1011  bad:
1012 	return error;
1013 }
1014 
1015 static int
1016 gif_encap_attach(struct gif_variant *var)
1017 {
1018 	int error;
1019 
1020 	if (var == NULL || var->gv_psrc == NULL)
1021 		return EINVAL;
1022 
1023 	switch (var->gv_psrc->sa_family) {
1024 #ifdef INET
1025 	case AF_INET:
1026 		error = in_gif_attach(var);
1027 		break;
1028 #endif
1029 #ifdef INET6
1030 	case AF_INET6:
1031 		error = in6_gif_attach(var);
1032 		break;
1033 #endif
1034 	default:
1035 		error = EINVAL;
1036 		break;
1037 	}
1038 
1039 	return error;
1040 }
1041 
1042 static int
1043 gif_encap_detach(struct gif_variant *var)
1044 {
1045 	int error;
1046 
1047 	if (var == NULL || var->gv_psrc == NULL)
1048 		return EINVAL;
1049 
1050 	switch (var->gv_psrc->sa_family) {
1051 #ifdef INET
1052 	case AF_INET:
1053 		error = in_gif_detach(var);
1054 		break;
1055 #endif
1056 #ifdef INET6
1057 	case AF_INET6:
1058 		error = in6_gif_detach(var);
1059 		break;
1060 #endif
1061 	default:
1062 		error = EINVAL;
1063 		break;
1064 	}
1065 
1066 	return error;
1067 }
1068 
1069 static int
1070 gif_set_tunnel(struct ifnet *ifp, struct sockaddr *src, struct sockaddr *dst)
1071 {
1072 	struct gif_softc *sc = ifp->if_softc;
1073 	struct gif_softc *sc2;
1074 	struct gif_variant *ovar, *nvar;
1075 	struct sockaddr *osrc, *odst;
1076 	struct sockaddr *nsrc, *ndst;
1077 	int error;
1078 #ifndef GIF_MPSAFE
1079 	int s;
1080 
1081 	s = splsoftnet();
1082 #endif
1083 	error = encap_lock_enter();
1084 	if (error) {
1085 #ifndef GIF_MPSAFE
1086 		splx(s);
1087 #endif
1088 		return error;
1089 	}
1090 
1091 	nsrc = sockaddr_dup(src, M_WAITOK);
1092 	ndst = sockaddr_dup(dst, M_WAITOK);
1093 	nvar = kmem_alloc(sizeof(*nvar), KM_SLEEP);
1094 
1095 	mutex_enter(&sc->gif_lock);
1096 
1097 	ovar = sc->gif_var;
1098 
1099 	if ((ovar->gv_pdst && sockaddr_cmp(ovar->gv_pdst, dst) == 0) &&
1100 	    (ovar->gv_psrc && sockaddr_cmp(ovar->gv_psrc, src) == 0)) {
1101 		/* address and port pair not changed. */
1102 		error = 0;
1103 		goto out;
1104 	}
1105 
1106 	mutex_enter(&gif_softcs.lock);
1107 	LIST_FOREACH(sc2, &gif_softcs.list, gif_list) {
1108 		struct gif_variant *var2;
1109 		struct psref psref;
1110 
1111 		if (sc2 == sc)
1112 			continue;
1113 		var2 = gif_getref_variant(sc2, &psref);
1114 		if (!var2->gv_pdst || !var2->gv_psrc) {
1115 			gif_putref_variant(var2, &psref);
1116 			continue;
1117 		}
1118 		/* can't configure same pair of address onto two gifs */
1119 		if (sockaddr_cmp(var2->gv_pdst, dst) == 0 &&
1120 		    sockaddr_cmp(var2->gv_psrc, src) == 0) {
1121 			/* continue to use the old configuration. */
1122 			gif_putref_variant(var2, &psref);
1123 			mutex_exit(&gif_softcs.lock);
1124 			error =  EADDRNOTAVAIL;
1125 			goto out;
1126 		}
1127 		gif_putref_variant(var2, &psref);
1128 		/* XXX both end must be valid? (I mean, not 0.0.0.0) */
1129 	}
1130 	mutex_exit(&gif_softcs.lock);
1131 
1132 	osrc = ovar->gv_psrc;
1133 	odst = ovar->gv_pdst;
1134 
1135 	*nvar = *ovar;
1136 	nvar->gv_psrc = nsrc;
1137 	nvar->gv_pdst = ndst;
1138 	nvar->gv_encap_cookie4 = NULL;
1139 	nvar->gv_encap_cookie6 = NULL;
1140 	error = gif_encap_attach(nvar);
1141 	if (error)
1142 		goto out;
1143 	psref_target_init(&nvar->gv_psref, gv_psref_class);
1144 	gif_update_variant(sc, nvar);
1145 
1146 	mutex_exit(&sc->gif_lock);
1147 
1148 	(void)gif_encap_detach(ovar);
1149 	encap_lock_exit();
1150 
1151 	if (osrc)
1152 		sockaddr_free(osrc);
1153 	if (odst)
1154 		sockaddr_free(odst);
1155 	kmem_free(ovar, sizeof(*ovar));
1156 
1157 #ifndef GIF_MPSAFE
1158 	splx(s);
1159 #endif
1160 	return 0;
1161 
1162  out:
1163 	mutex_exit(&sc->gif_lock);
1164 	encap_lock_exit();
1165 
1166 	sockaddr_free(nsrc);
1167 	sockaddr_free(ndst);
1168 	kmem_free(nvar, sizeof(*nvar));
1169 
1170 #ifndef GIF_MPSAFE
1171 	splx(s);
1172 #endif
1173 	return error;
1174 }
1175 
1176 static void
1177 gif_delete_tunnel(struct ifnet *ifp)
1178 {
1179 	struct gif_softc *sc = ifp->if_softc;
1180 	struct gif_variant *ovar, *nvar;
1181 	struct sockaddr *osrc, *odst;
1182 	int error;
1183 #ifndef GIF_MPSAFE
1184 	int s;
1185 
1186 	s = splsoftnet();
1187 #endif
1188 	error = encap_lock_enter();
1189 	if (error) {
1190 #ifndef GIF_MPSAFE
1191 		splx(s);
1192 #endif
1193 		return;
1194 	}
1195 
1196 	nvar = kmem_alloc(sizeof(*nvar), KM_SLEEP);
1197 
1198 	mutex_enter(&sc->gif_lock);
1199 
1200 	ovar = sc->gif_var;
1201 	osrc = ovar->gv_psrc;
1202 	odst = ovar->gv_pdst;
1203 	if (osrc == NULL || odst == NULL) {
1204 		/* address pair not changed. */
1205 		mutex_exit(&sc->gif_lock);
1206 		encap_lock_exit();
1207 		kmem_free(nvar, sizeof(*nvar));
1208 #ifndef GIF_MPSAFE
1209 		splx(s);
1210 #endif
1211 		return;
1212 	}
1213 
1214 	*nvar = *ovar;
1215 	nvar->gv_psrc = NULL;
1216 	nvar->gv_pdst = NULL;
1217 	nvar->gv_encap_cookie4 = NULL;
1218 	nvar->gv_encap_cookie6 = NULL;
1219 	nvar->gv_output = NULL;
1220 	psref_target_init(&nvar->gv_psref, gv_psref_class);
1221 	gif_update_variant(sc, nvar);
1222 
1223 	mutex_exit(&sc->gif_lock);
1224 
1225 	gif_encap_detach(ovar);
1226 	encap_lock_exit();
1227 
1228 	sockaddr_free(osrc);
1229 	sockaddr_free(odst);
1230 	kmem_free(ovar, sizeof(*ovar));
1231 
1232 #ifndef GIF_MPSAFE
1233 	splx(s);
1234 #endif
1235 }
1236 
1237 /*
1238  * gif_variant update API.
1239  *
1240  * Assumption:
1241  * reader side dereferences sc->gif_var in reader critical section only,
1242  * that is, all of reader sides do not reader the sc->gif_var after
1243  * pserialize_perform().
1244  */
1245 static void
1246 gif_update_variant(struct gif_softc *sc, struct gif_variant *nvar)
1247 {
1248 	struct ifnet *ifp = &sc->gif_if;
1249 	struct gif_variant *ovar = sc->gif_var;
1250 
1251 	KASSERT(mutex_owned(&sc->gif_lock));
1252 
1253 	atomic_store_release(&sc->gif_var, nvar);
1254 	pserialize_perform(sc->gif_psz);
1255 	psref_target_destroy(&ovar->gv_psref, gv_psref_class);
1256 
1257 	if (nvar->gv_psrc != NULL && nvar->gv_pdst != NULL)
1258 		ifp->if_flags |= IFF_RUNNING;
1259 	else
1260 		ifp->if_flags &= ~IFF_RUNNING;
1261 }
1262 
1263 /*
1264  * Module infrastructure
1265  */
1266 #include "if_module.h"
1267 
1268 IF_MODULE(MODULE_CLASS_DRIVER, gif, "ip_ecn")
1269