1 files changed, 172 insertions, 496 deletions

diff --git a/freebsd/sys/net/if_gre.c b/freebsd/sys/net/if_gre.c
index 0bff9bc9..5ff41259 100644
--- a/freebsd/sys/net/if_gre.c
+++ b/freebsd/sys/net/if_gre.c
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
- * Copyright (c) 2014 Andrey V. Elsukov <ae@FreeBSD.org>
+ * Copyright (c) 2014, 2018 Andrey V. Elsukov <ae@FreeBSD.org>
  * All rights reserved.
  *
  * This code is derived from software contributed to The NetBSD Foundation
@@ -43,17 +43,13 @@ __FBSDID("$FreeBSD$");
 #include <rtems/bsd/local/opt_inet6.h>
 
 #include <sys/param.h>
-#include <sys/jail.h>
 #include <sys/kernel.h>
 #include <sys/lock.h>
-#include <sys/libkern.h>
 #include <sys/malloc.h>
 #include <sys/module.h>
 #include <sys/mbuf.h>
 #include <sys/priv.h>
 #include <sys/proc.h>
-#include <sys/protosw.h>
-#include <sys/rmlock.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sx.h>
@@ -72,7 +68,6 @@ __FBSDID("$FreeBSD$");
 
 #include <netinet/in.h>
 #ifdef INET
-#include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #include <netinet/ip.h>
 #include <netinet/ip_var.h>
@@ -82,7 +77,6 @@ __FBSDID("$FreeBSD$");
 #include <netinet/ip6.h>
 #include <netinet6/in6_var.h>
 #include <netinet6/ip6_var.h>
-#include <netinet6/scope6_var.h>
 #endif
 
 #include <netinet/ip_encap.h>
@@ -93,24 +87,16 @@ __FBSDID("$FreeBSD$");
 #include <security/mac/mac_framework.h>
 
 #define	GREMTU			1476
+
 static const char grename[] = "gre";
-static MALLOC_DEFINE(M_GRE, grename, "Generic Routing Encapsulation");
-static VNET_DEFINE(struct mtx, gre_mtx);
-#define	V_gre_mtx	VNET(gre_mtx)
-#define	GRE_LIST_LOCK_INIT(x)		mtx_init(&V_gre_mtx, "gre_mtx", NULL, \
-					    MTX_DEF)
-#define	GRE_LIST_LOCK_DESTROY(x)	mtx_destroy(&V_gre_mtx)
-#define	GRE_LIST_LOCK(x)		mtx_lock(&V_gre_mtx)
-#define	GRE_LIST_UNLOCK(x)		mtx_unlock(&V_gre_mtx)
-
-static VNET_DEFINE(LIST_HEAD(, gre_softc), gre_softc_list);
-#define	V_gre_softc_list	VNET(gre_softc_list)
+MALLOC_DEFINE(M_GRE, grename, "Generic Routing Encapsulation");
+
 static struct sx gre_ioctl_sx;
 SX_SYSINIT(gre_ioctl_sx, &gre_ioctl_sx, "gre_ioctl");
 
 static int	gre_clone_create(struct if_clone *, int, caddr_t);
 static void	gre_clone_destroy(struct ifnet *);
-static VNET_DEFINE(struct if_clone *, gre_cloner);
+VNET_DEFINE_STATIC(struct if_clone *, gre_cloner);
 #define	V_gre_cloner	VNET(gre_cloner)
 
 static void	gre_qflush(struct ifnet *);
@@ -118,11 +104,7 @@ static int	gre_transmit(struct ifnet *, struct mbuf *);
 static int	gre_ioctl(struct ifnet *, u_long, caddr_t);
 static int	gre_output(struct ifnet *, struct mbuf *,
 		    const struct sockaddr *, struct route *);
-
-static void	gre_updatehdr(struct gre_softc *);
-static int	gre_set_tunnel(struct ifnet *, struct sockaddr *,
-    struct sockaddr *);
-static void	gre_delete_tunnel(struct ifnet *);
+static void	gre_delete_tunnel(struct gre_softc *);
 
 SYSCTL_DECL(_net_link);
 static SYSCTL_NODE(_net_link, IFT_TUNNEL, gre, CTLFLAG_RW, 0,
@@ -139,7 +121,7 @@ static SYSCTL_NODE(_net_link, IFT_TUNNEL, gre, CTLFLAG_RW, 0,
 #define MAX_GRE_NEST 1
 #endif
 
-static VNET_DEFINE(int, max_gre_nesting) = MAX_GRE_NEST;
+VNET_DEFINE_STATIC(int, max_gre_nesting) = MAX_GRE_NEST;
 #define	V_max_gre_nesting	VNET(max_gre_nesting)
 SYSCTL_INT(_net_link_gre, OID_AUTO, max_nesting, CTLFLAG_RW | CTLFLAG_VNET,
     &VNET_NAME(max_gre_nesting), 0, "Max nested tunnels");
@@ -147,10 +129,15 @@ SYSCTL_INT(_net_link_gre, OID_AUTO, max_nesting, CTLFLAG_RW | CTLFLAG_VNET,
 static void
 vnet_gre_init(const void *unused __unused)
 {
-	LIST_INIT(&V_gre_softc_list);
-	GRE_LIST_LOCK_INIT();
+
 	V_gre_cloner = if_clone_simple(grename, gre_clone_create,
 	    gre_clone_destroy, 0);
+#ifdef INET
+	in_gre_init();
+#endif
+#ifdef INET6
+	in6_gre_init();
+#endif
 }
 VNET_SYSINIT(vnet_gre_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
     vnet_gre_init, NULL);
@@ -160,7 +147,12 @@ vnet_gre_uninit(const void *unused __unused)
 {
 
 	if_clone_detach(V_gre_cloner);
-	GRE_LIST_LOCK_DESTROY();
+#ifdef INET
+	in_gre_uninit();
+#endif
+#ifdef INET6
+	in6_gre_uninit();
+#endif
 }
 VNET_SYSUNINIT(vnet_gre_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
     vnet_gre_uninit, NULL);
@@ -177,7 +169,6 @@ gre_clone_create(struct if_clone *ifc, int unit, caddr_t params)
 	sc->gre_fibnum = BSD_DEFAULT_FIB;
 #endif /* __rtems__ */
 	GRE2IFP(sc) = if_alloc(IFT_TUNNEL);
-	GRE_LOCK_INIT(sc);
 	GRE2IFP(sc)->if_softc = sc;
 	if_initname(GRE2IFP(sc), grename, unit);
 
@@ -191,9 +182,6 @@ gre_clone_create(struct if_clone *ifc, int unit, caddr_t params)
 	GRE2IFP(sc)->if_capenable |= IFCAP_LINKSTATE;
 	if_attach(GRE2IFP(sc));
 	bpfattach(GRE2IFP(sc), DLT_NULL, sizeof(u_int32_t));
-	GRE_LIST_LOCK();
-	LIST_INSERT_HEAD(&V_gre_softc_list, sc, gre_list);
-	GRE_LIST_UNLOCK();
 	return (0);
 }
 
@@ -204,33 +192,22 @@ gre_clone_destroy(struct ifnet *ifp)
 
 	sx_xlock(&gre_ioctl_sx);
 	sc = ifp->if_softc;
-	gre_delete_tunnel(ifp);
-	GRE_LIST_LOCK();
-	LIST_REMOVE(sc, gre_list);
-	GRE_LIST_UNLOCK();
+	gre_delete_tunnel(sc);
 	bpfdetach(ifp);
 	if_detach(ifp);
 	ifp->if_softc = NULL;
 	sx_xunlock(&gre_ioctl_sx);
 
+	GRE_WAIT();
 	if_free(ifp);
-	GRE_LOCK_DESTROY(sc);
 	free(sc, M_GRE);
 }
 
 static int
 gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 {
-	GRE_RLOCK_TRACKER;
 	struct ifreq *ifr = (struct ifreq *)data;
-	struct sockaddr *src, *dst;
 	struct gre_softc *sc;
-#ifdef INET
-	struct sockaddr_in *sin = NULL;
-#endif
-#ifdef INET6
-	struct sockaddr_in6 *sin6 = NULL;
-#endif
 	uint32_t opt;
 	int error;
 
@@ -255,7 +232,6 @@ gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 	case GREGPROTO:
 		return (EOPNOTSUPP);
 	}
-	src = dst = NULL;
 	sx_xlock(&gre_ioctl_sx);
 	sc = ifp->if_softc;
 	if (sc == NULL) {
@@ -264,189 +240,25 @@ gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 	}
 	error = 0;
 	switch (cmd) {
-	case SIOCSIFPHYADDR:
-#ifdef INET6
-	case SIOCSIFPHYADDR_IN6:
-#endif
-		error = EINVAL;
-		switch (cmd) {
-#ifdef INET
-		case SIOCSIFPHYADDR:
-			src = (struct sockaddr *)
-				&(((struct in_aliasreq *)data)->ifra_addr);
-			dst = (struct sockaddr *)
-				&(((struct in_aliasreq *)data)->ifra_dstaddr);
-			break;
-#endif
-#ifdef INET6
-		case SIOCSIFPHYADDR_IN6:
-			src = (struct sockaddr *)
-				&(((struct in6_aliasreq *)data)->ifra_addr);
-			dst = (struct sockaddr *)
-				&(((struct in6_aliasreq *)data)->ifra_dstaddr);
-			break;
-#endif
-		default:
-			error = EAFNOSUPPORT;
-			goto end;
-		}
-		/* sa_family must be equal */
-		if (src->sa_family != dst->sa_family ||
-		    src->sa_len != dst->sa_len)
-			goto end;
-
-		/* validate sa_len */
-		switch (src->sa_family) {
-#ifdef INET
-		case AF_INET:
-			if (src->sa_len != sizeof(struct sockaddr_in))
-				goto end;
-			break;
-#endif
-#ifdef INET6
-		case AF_INET6:
-			if (src->sa_len != sizeof(struct sockaddr_in6))
-				goto end;
-			break;
-#endif
-		default:
-			error = EAFNOSUPPORT;
-			goto end;
-		}
-		/* check sa_family looks sane for the cmd */
-		error = EAFNOSUPPORT;
-		switch (cmd) {
-#ifdef INET
-		case SIOCSIFPHYADDR:
-			if (src->sa_family == AF_INET)
-				break;
-			goto end;
-#endif
-#ifdef INET6
-		case SIOCSIFPHYADDR_IN6:
-			if (src->sa_family == AF_INET6)
-				break;
-			goto end;
-#endif
-		}
-		error = EADDRNOTAVAIL;
-		switch (src->sa_family) {
-#ifdef INET
-		case AF_INET:
-			if (satosin(src)->sin_addr.s_addr == INADDR_ANY ||
-			    satosin(dst)->sin_addr.s_addr == INADDR_ANY)
-				goto end;
-			break;
-#endif
-#ifdef INET6
-		case AF_INET6:
-			if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(src)->sin6_addr)
-			    ||
-			    IN6_IS_ADDR_UNSPECIFIED(&satosin6(dst)->sin6_addr))
-				goto end;
-			/*
-			 * Check validity of the scope zone ID of the
-			 * addresses, and convert it into the kernel
-			 * internal form if necessary.
-			 */
-			error = sa6_embedscope(satosin6(src), 0);
-			if (error != 0)
-				goto end;
-			error = sa6_embedscope(satosin6(dst), 0);
-			if (error != 0)
-				goto end;
-#endif
-		}
-		error = gre_set_tunnel(ifp, src, dst);
-		break;
 	case SIOCDIFPHYADDR:
-		gre_delete_tunnel(ifp);
+		if (sc->gre_family == 0)
+			break;
+		gre_delete_tunnel(sc);
 		break;
+#ifdef INET
+	case SIOCSIFPHYADDR:
 	case SIOCGIFPSRCADDR:
 	case SIOCGIFPDSTADDR:
+		error = in_gre_ioctl(sc, cmd, data);
+		break;
+#endif
 #ifdef INET6
+	case SIOCSIFPHYADDR_IN6:
 	case SIOCGIFPSRCADDR_IN6:
 	case SIOCGIFPDSTADDR_IN6:
-#endif
-		if (sc->gre_family == 0) {
-			error = EADDRNOTAVAIL;
-			break;
-		}
-		GRE_RLOCK(sc);
-		switch (cmd) {
-#ifdef INET
-		case SIOCGIFPSRCADDR:
-		case SIOCGIFPDSTADDR:
-			if (sc->gre_family != AF_INET) {
-				error = EADDRNOTAVAIL;
-				break;
-			}
-			sin = (struct sockaddr_in *)&ifr->ifr_addr;
-			memset(sin, 0, sizeof(*sin));
-			sin->sin_family = AF_INET;
-			sin->sin_len = sizeof(*sin);
-			break;
-#endif
-#ifdef INET6
-		case SIOCGIFPSRCADDR_IN6:
-		case SIOCGIFPDSTADDR_IN6:
-			if (sc->gre_family != AF_INET6) {
-				error = EADDRNOTAVAIL;
-				break;
-			}
-			sin6 = (struct sockaddr_in6 *)
-				&(((struct in6_ifreq *)data)->ifr_addr);
-			memset(sin6, 0, sizeof(*sin6));
-			sin6->sin6_family = AF_INET6;
-			sin6->sin6_len = sizeof(*sin6);
-			break;
-#endif
-		}
-		if (error == 0) {
-			switch (cmd) {
-#ifdef INET
-			case SIOCGIFPSRCADDR:
-				sin->sin_addr = sc->gre_oip.ip_src;
-				break;
-			case SIOCGIFPDSTADDR:
-				sin->sin_addr = sc->gre_oip.ip_dst;
-				break;
-#endif
-#ifdef INET6
-			case SIOCGIFPSRCADDR_IN6:
-				sin6->sin6_addr = sc->gre_oip6.ip6_src;
-				break;
-			case SIOCGIFPDSTADDR_IN6:
-				sin6->sin6_addr = sc->gre_oip6.ip6_dst;
-				break;
-#endif
-			}
-		}
-		GRE_RUNLOCK(sc);
-		if (error != 0)
-			break;
-		switch (cmd) {
-#ifdef INET
-		case SIOCGIFPSRCADDR:
-		case SIOCGIFPDSTADDR:
-			error = prison_if(curthread->td_ucred,
-			    (struct sockaddr *)sin);
-			if (error != 0)
-				memset(sin, 0, sizeof(*sin));
-			break;
-#endif
-#ifdef INET6
-		case SIOCGIFPSRCADDR_IN6:
-		case SIOCGIFPDSTADDR_IN6:
-			error = prison_if(curthread->td_ucred,
-			    (struct sockaddr *)sin6);
-			if (error == 0)
-				error = sa6_recoverscope(sin6);
-			if (error != 0)
-				memset(sin6, 0, sizeof(*sin6));
-#endif
-		}
+		error = in6_gre_ioctl(sc, cmd, data);
 		break;
+#endif
 	case SIOCGTUNFIB:
 		ifr->ifr_fib = sc->gre_fibnum;
 		break;
@@ -459,40 +271,50 @@ gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 			sc->gre_fibnum = ifr->ifr_fib;
 		break;
 	case GRESKEY:
+	case GRESOPTS:
 		if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0)
 			break;
 		if ((error = copyin(ifr_data_get_ptr(ifr), &opt,
 		    sizeof(opt))) != 0)
 			break;
-		if (sc->gre_key != opt) {
-			GRE_WLOCK(sc);
-			sc->gre_key = opt;
-			gre_updatehdr(sc);
-			GRE_WUNLOCK(sc);
+		if (cmd == GRESKEY) {
+			if (sc->gre_key == opt)
+				break;
+		} else if (cmd == GRESOPTS) {
+			if (opt & ~GRE_OPTMASK) {
+				error = EINVAL;
+				break;
+			}
+			if (sc->gre_options == opt)
+				break;
 		}
-		break;
-	case GREGKEY:
-		error = copyout(&sc->gre_key, ifr_data_get_ptr(ifr),
-		    sizeof(sc->gre_key));
-		break;
-	case GRESOPTS:
-		if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0)
+		switch (sc->gre_family) {
+#ifdef INET
+		case AF_INET:
+			in_gre_setopts(sc, cmd, opt);
 			break;
-		if ((error = copyin(ifr_data_get_ptr(ifr), &opt,
-		    sizeof(opt))) != 0)
+#endif
+#ifdef INET6
+		case AF_INET6:
+			in6_gre_setopts(sc, cmd, opt);
 			break;
-		if (opt & ~GRE_OPTMASK)
-			error = EINVAL;
-		else {
-			if (sc->gre_options != opt) {
-				GRE_WLOCK(sc);
+#endif
+		default:
+			if (cmd == GRESKEY)
+				sc->gre_key = opt;
+			else
 				sc->gre_options = opt;
-				gre_updatehdr(sc);
-				GRE_WUNLOCK(sc);
-			}
+			break;
 		}
+		/*
+		 * XXX: Do we need to initiate change of interface
+		 * state here?
+		 */
+		break;
+	case GREGKEY:
+		error = copyout(&sc->gre_key, ifr_data_get_ptr(ifr),
+		    sizeof(sc->gre_key));
 		break;
-
 	case GREGOPTS:
 		error = copyout(&sc->gre_options, ifr_data_get_ptr(ifr),
 		    sizeof(sc->gre_options));
@@ -501,40 +323,68 @@ gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 		error = EINVAL;
 		break;
 	}
+	if (error == 0 && sc->gre_family != 0) {
+		if (
+#ifdef INET
+		    cmd == SIOCSIFPHYADDR ||
+#endif
+#ifdef INET6
+		    cmd == SIOCSIFPHYADDR_IN6 ||
+#endif
+		    0) {
+			ifp->if_drv_flags |= IFF_DRV_RUNNING;
+			if_link_state_change(ifp, LINK_STATE_UP);
+		}
+	}
 end:
 	sx_xunlock(&gre_ioctl_sx);
 	return (error);
 }
 
 static void
-gre_updatehdr(struct gre_softc *sc)
+gre_delete_tunnel(struct gre_softc *sc)
+{
+
+	sx_assert(&gre_ioctl_sx, SA_XLOCKED);
+	if (sc->gre_family != 0) {
+		CK_LIST_REMOVE(sc, chain);
+		GRE_WAIT();
+		free(sc->gre_hdr, M_GRE);
+		sc->gre_family = 0;
+	}
+	GRE2IFP(sc)->if_drv_flags &= ~IFF_DRV_RUNNING;
+	if_link_state_change(GRE2IFP(sc), LINK_STATE_DOWN);
+}
+
+struct gre_list *
+gre_hashinit(void)
+{
+	struct gre_list *hash;
+	int i;
+
+	hash = malloc(sizeof(struct gre_list) * GRE_HASH_SIZE,
+	    M_GRE, M_WAITOK);
+	for (i = 0; i < GRE_HASH_SIZE; i++)
+		CK_LIST_INIT(&hash[i]);
+
+	return (hash);
+}
+
+void
+gre_hashdestroy(struct gre_list *hash)
+{
+
+	free(hash, M_GRE);
+}
+
+void
+gre_updatehdr(struct gre_softc *sc, struct grehdr *gh)
 {
-	struct grehdr *gh = NULL;
 	uint32_t *opts;
 	uint16_t flags;
 
-	GRE_WLOCK_ASSERT(sc);
-	switch (sc->gre_family) {
-#ifdef INET
-	case AF_INET:
-		sc->gre_hlen = sizeof(struct greip);
-		sc->gre_oip.ip_v = IPPROTO_IPV4;
-		sc->gre_oip.ip_hl = sizeof(struct ip) >> 2;
-		sc->gre_oip.ip_p = IPPROTO_GRE;
-		gh = &sc->gre_gihdr->gi_gre;
-		break;
-#endif
-#ifdef INET6
-	case AF_INET6:
-		sc->gre_hlen = sizeof(struct greip6);
-		sc->gre_oip6.ip6_vfc = IPV6_VERSION;
-		sc->gre_oip6.ip6_nxt = IPPROTO_GRE;
-		gh = &sc->gre_gi6hdr->gi6_gre;
-		break;
-#endif
-	default:
-		return;
-	}
+	sx_assert(&gre_ioctl_sx, SA_XLOCKED);
+
 	flags = 0;
 	opts = gh->gre_opts;
 	if (sc->gre_options & GRE_ENABLE_CSUM) {
@@ -556,136 +406,12 @@ gre_updatehdr(struct gre_softc *sc)
 	gh->gre_flags = htons(flags);
 }
 
-static void
-gre_detach(struct gre_softc *sc)
-{
-
-	sx_assert(&gre_ioctl_sx, SA_XLOCKED);
-	if (sc->gre_ecookie != NULL)
-		encap_detach(sc->gre_ecookie);
-	sc->gre_ecookie = NULL;
-}
-
-static int
-gre_set_tunnel(struct ifnet *ifp, struct sockaddr *src,
-    struct sockaddr *dst)
-{
-	struct gre_softc *sc, *tsc;
-#ifdef INET6
-	struct ip6_hdr *ip6;
-#endif
-#ifdef INET
-	struct ip *ip;
-#endif
-	void *hdr;
-	int error;
-
-	sx_assert(&gre_ioctl_sx, SA_XLOCKED);
-	GRE_LIST_LOCK();
-	sc = ifp->if_softc;
-	LIST_FOREACH(tsc, &V_gre_softc_list, gre_list) {
-		if (tsc == sc || tsc->gre_family != src->sa_family)
-			continue;
-#ifdef INET
-		if (tsc->gre_family == AF_INET &&
-		    tsc->gre_oip.ip_src.s_addr ==
-		    satosin(src)->sin_addr.s_addr &&
-		    tsc->gre_oip.ip_dst.s_addr ==
-		    satosin(dst)->sin_addr.s_addr) {
-			GRE_LIST_UNLOCK();
-			return (EADDRNOTAVAIL);
-		}
-#endif
-#ifdef INET6
-		if (tsc->gre_family == AF_INET6 &&
-		    IN6_ARE_ADDR_EQUAL(&tsc->gre_oip6.ip6_src,
-		    &satosin6(src)->sin6_addr) &&
-		    IN6_ARE_ADDR_EQUAL(&tsc->gre_oip6.ip6_dst,
-			&satosin6(dst)->sin6_addr)) {
-			GRE_LIST_UNLOCK();
-			return (EADDRNOTAVAIL);
-		}
-#endif
-	}
-	GRE_LIST_UNLOCK();
-
-	switch (src->sa_family) {
-#ifdef INET
-	case AF_INET:
-		hdr = ip = malloc(sizeof(struct greip) +
-		    3 * sizeof(uint32_t), M_GRE, M_WAITOK | M_ZERO);
-		ip->ip_src = satosin(src)->sin_addr;
-		ip->ip_dst = satosin(dst)->sin_addr;
-		break;
-#endif
-#ifdef INET6
-	case AF_INET6:
-		hdr = ip6 = malloc(sizeof(struct greip6) +
-		    3 * sizeof(uint32_t), M_GRE, M_WAITOK | M_ZERO);
-		ip6->ip6_src = satosin6(src)->sin6_addr;
-		ip6->ip6_dst = satosin6(dst)->sin6_addr;
-		break;
-#endif
-	default:
-		return (EAFNOSUPPORT);
-	}
-	if (sc->gre_family != 0)
-		gre_detach(sc);
-	GRE_WLOCK(sc);
-	if (sc->gre_family != 0)
-		free(sc->gre_hdr, M_GRE);
-	sc->gre_family = src->sa_family;
-	sc->gre_hdr = hdr;
-	sc->gre_oseq = 0;
-	sc->gre_iseq = UINT32_MAX;
-	gre_updatehdr(sc);
-	GRE_WUNLOCK(sc);
-
-	error = 0;
-	switch (src->sa_family) {
-#ifdef INET
-	case AF_INET:
-		error = in_gre_attach(sc);
-		break;
-#endif
-#ifdef INET6
-	case AF_INET6:
-		error = in6_gre_attach(sc);
-		break;
-#endif
-	}
-	if (error == 0) {
-		ifp->if_drv_flags |= IFF_DRV_RUNNING;
-		if_link_state_change(ifp, LINK_STATE_UP);
-	}
-	return (error);
-}
-
-static void
-gre_delete_tunnel(struct ifnet *ifp)
-{
-	struct gre_softc *sc = ifp->if_softc;
-	int family;
-
-	GRE_WLOCK(sc);
-	family = sc->gre_family;
-	sc->gre_family = 0;
-	GRE_WUNLOCK(sc);
-	if (family != 0) {
-		gre_detach(sc);
-		free(sc->gre_hdr, M_GRE);
-	}
-	ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
-	if_link_state_change(ifp, LINK_STATE_DOWN);
-}
-
 int
-gre_input(struct mbuf **mp, int *offp, int proto)
+gre_input(struct mbuf *m, int off, int proto, void *arg)
 {
-	struct gre_softc *sc;
+	struct gre_softc *sc = arg;
 	struct grehdr *gh;
 	struct ifnet *ifp;
-	struct mbuf *m;
 	uint32_t *opts;
 #ifdef notyet
 	uint32_t key;
@@ -693,12 +419,8 @@ gre_input(struct mbuf **mp, int *offp, int proto)
 	uint16_t flags;
 	int hlen, isr, af;
 
-	m = *mp;
-	sc = encap_getarg(m);
-	KASSERT(sc != NULL, ("encap_getarg returned NULL"));
-
 	ifp = GRE2IFP(sc);
-	hlen = *offp + sizeof(struct grehdr) + 4 * sizeof(uint32_t);
+	hlen = off + sizeof(struct grehdr) + 4 * sizeof(uint32_t);
 	if (m->m_pkthdr.len < hlen)
 		goto drop;
 	if (m->m_len < hlen) {
@@ -706,7 +428,7 @@ gre_input(struct mbuf **mp, int *offp, int proto)
 		if (m == NULL)
 			goto drop;
 	}
-	gh = (struct grehdr *)mtodo(m, *offp);
+	gh = (struct grehdr *)mtodo(m, off);
 	flags = ntohs(gh->gre_flags);
 	if (flags & ~GRE_FLAGS_MASK)
 		goto drop;
@@ -716,7 +438,7 @@ gre_input(struct mbuf **mp, int *offp, int proto)
 		/* reserved1 field must be zero */
 		if (((uint16_t *)opts)[1] != 0)
 			goto drop;
-		if (in_cksum_skip(m, m->m_pkthdr.len, *offp) != 0)
+		if (in_cksum_skip(m, m->m_pkthdr.len, off) != 0)
 			goto drop;
 		hlen += 2 * sizeof(uint16_t);
 		opts++;
@@ -766,7 +488,7 @@ gre_input(struct mbuf **mp, int *offp, int proto)
 	default:
 		goto drop;
 	}
-	m_adj(m, *offp + hlen);
+	m_adj(m, off + hlen);
 	m_clrprotoflags(m);
 	m->m_pkthdr.rcvif = ifp;
 	M_SETFIB(m, ifp->if_fib);
@@ -787,70 +509,23 @@ drop:
 	return (IPPROTO_DONE);
 }
 
-#define	MTAG_GRE	1307983903
-static int
-gre_check_nesting(struct ifnet *ifp, struct mbuf *m)
-{
-	struct m_tag *mtag;
-	int count;
-
-	count = 1;
-	mtag = NULL;
-	while ((mtag = m_tag_locate(m, MTAG_GRE, 0, mtag)) != NULL) {
-		if (*(struct ifnet **)(mtag + 1) == ifp) {
-			log(LOG_NOTICE, "%s: loop detected\n", ifp->if_xname);
-			return (EIO);
-		}
-		count++;
-	}
-	if (count > V_max_gre_nesting) {
-		log(LOG_NOTICE,
-		    "%s: if_output recursively called too many times(%d)\n",
-		    ifp->if_xname, count);
-		return (EIO);
-	}
-	mtag = m_tag_alloc(MTAG_GRE, 0, sizeof(struct ifnet *), M_NOWAIT);
-	if (mtag == NULL)
-		return (ENOMEM);
-	*(struct ifnet **)(mtag + 1) = ifp;
-	m_tag_prepend(m, mtag);
-	return (0);
-}
-
 static int
 gre_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
    struct route *ro)
 {
 	uint32_t af;
-	int error;
 
-#ifdef MAC
-	error = mac_ifnet_check_transmit(ifp, m);
-	if (error != 0)
-		goto drop;
-#endif
-	if ((ifp->if_flags & IFF_MONITOR) != 0 ||
-	    (ifp->if_flags & IFF_UP) == 0) {
-		error = ENETDOWN;
-		goto drop;
-	}
-
-	error = gre_check_nesting(ifp, m);
-	if (error != 0)
-		goto drop;
-
-	m->m_flags &= ~(M_BCAST|M_MCAST);
 	if (dst->sa_family == AF_UNSPEC)
 		bcopy(dst->sa_data, &af, sizeof(af));
 	else
 		af = dst->sa_family;
-	BPF_MTAP2(ifp, &af, sizeof(af), m);
-	m->m_pkthdr.csum_data = af;	/* save af for if_transmit */
+	/*
+	 * Now save the af in the inbound pkt csum data, this is a cheat since
+	 * we are using the inbound csum_data field to carry the af over to
+	 * the gre_transmit() routine, avoiding using yet another mtag.
+	 */
+	m->m_pkthdr.csum_data = af;
 	return (ifp->if_transmit(ifp, m));
-drop:
-	m_freem(m);
-	if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
-	return (error);
 }
 
 static void
@@ -870,95 +545,95 @@ gre_setseqn(struct grehdr *gh, uint32_t seq)
 	*opts = htonl(seq);
 }
 
+#define	MTAG_GRE	1307983903
 static int
 gre_transmit(struct ifnet *ifp, struct mbuf *m)
 {
-	GRE_RLOCK_TRACKER;
 	struct gre_softc *sc;
 	struct grehdr *gh;
-	uint32_t iaf, oaf, oseq;
-	int error, hlen, olen, plen;
-	int want_seq, want_csum;
+	uint32_t af;
+	int error, len;
+	uint16_t proto;
 
-	plen = 0;
-	sc = ifp->if_softc;
-	if (sc == NULL) {
-		error = ENETDOWN;
+	len = 0;
+#ifdef MAC
+	error = mac_ifnet_check_transmit(ifp, m);
+	if (error) {
 		m_freem(m);
 		goto drop;
 	}
-	GRE_RLOCK(sc);
-	if (sc->gre_family == 0) {
-		GRE_RUNLOCK(sc);
-		error = ENETDOWN;
+#endif
+	error = ENETDOWN;
+	GRE_RLOCK();
+	sc = ifp->if_softc;
+	if ((ifp->if_flags & IFF_MONITOR) != 0 ||
+	    (ifp->if_flags & IFF_UP) == 0 ||
+	    sc->gre_family == 0 ||
+	    (error = if_tunnel_check_nesting(ifp, m, MTAG_GRE,
+		V_max_gre_nesting)) != 0) {
 		m_freem(m);
 		goto drop;
 	}
-	iaf = m->m_pkthdr.csum_data;
-	oaf = sc->gre_family;
-	hlen = sc->gre_hlen;
-	want_seq = (sc->gre_options & GRE_ENABLE_SEQ) != 0;
-	if (want_seq)
-		oseq = sc->gre_oseq++; /* XXX */
-	else
-		oseq = 0;		/* Make compiler happy. */
-	want_csum = (sc->gre_options & GRE_ENABLE_CSUM) != 0;
+	af = m->m_pkthdr.csum_data;
 	M_SETFIB(m, sc->gre_fibnum);
-	M_PREPEND(m, hlen, M_NOWAIT);
+	M_PREPEND(m, sc->gre_hlen, M_NOWAIT);
 	if (m == NULL) {
-		GRE_RUNLOCK(sc);
 		error = ENOBUFS;
 		goto drop;
 	}
-	bcopy(sc->gre_hdr, mtod(m, void *), hlen);
-	GRE_RUNLOCK(sc);
-	switch (oaf) {
+	bcopy(sc->gre_hdr, mtod(m, void *), sc->gre_hlen);
+	/* Determine GRE proto */
+	switch (af) {
 #ifdef INET
 	case AF_INET:
-		olen = sizeof(struct ip);
+		proto = htons(ETHERTYPE_IP);
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:
-		olen = sizeof(struct ip6_hdr);
+		proto = htons(ETHERTYPE_IPV6);
 		break;
 #endif
 	default:
+		m_freem(m);
 		error = ENETDOWN;
 		goto drop;
 	}
-	gh = (struct grehdr *)mtodo(m, olen);
-	switch (iaf) {
+	/* Determine offset of GRE header */
+	switch (sc->gre_family) {
 #ifdef INET
 	case AF_INET:
-		gh->gre_proto = htons(ETHERTYPE_IP);
+		len = sizeof(struct ip);
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:
-		gh->gre_proto = htons(ETHERTYPE_IPV6);
+		len = sizeof(struct ip6_hdr);
 		break;
 #endif
 	default:
+		m_freem(m);
 		error = ENETDOWN;
 		goto drop;
 	}
-	if (want_seq)
-		gre_setseqn(gh, oseq);
-	if (want_csum) {
+	gh = (struct grehdr *)mtodo(m, len);
+	gh->gre_proto = proto;
+	if (sc->gre_options & GRE_ENABLE_SEQ)
+		gre_setseqn(gh, sc->gre_oseq++);
+	if (sc->gre_options & GRE_ENABLE_CSUM) {
 		*(uint16_t *)gh->gre_opts = in_cksum_skip(m,
-		    m->m_pkthdr.len, olen);
+		    m->m_pkthdr.len, len);
 	}
-	plen = m->m_pkthdr.len - hlen;
-	switch (oaf) {
+	len = m->m_pkthdr.len - len;
+	switch (sc->gre_family) {
 #ifdef INET
 	case AF_INET:
-		error = in_gre_output(m, iaf, hlen);
+		error = in_gre_output(m, af, sc->gre_hlen);
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:
-		error = in6_gre_output(m, iaf, hlen);
+		error = in6_gre_output(m, af, sc->gre_hlen);
 		break;
 #endif
 	default:
@@ -970,8 +645,9 @@ drop:
 		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 	else {
 		if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
-		if_inc_counter(ifp, IFCOUNTER_OBYTES, plen);
+		if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
 	}
+	GRE_RUNLOCK();
 	return (error);
 }