 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_tap.c,v 1.47.4.4 2009/03/18 05:19:59 snj Exp $	*/
+/*	$NetBSD: if_tap.c,v 1.47.4.5 2009/03/18 05:23:44 snj Exp $	*/
 /*
  *  Copyright (c) 2003, 2004, 2008 The NetBSD Foundation.
  *  All rights reserved.
+ *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions
  *  are met:
  *  1. Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
 @@ -23,78 +23,85 @@
  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  *  POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * tap(4) is a virtual Ethernet interface.  It appears as a real Ethernet
  * device to the system, but can also be accessed by userland through a
  * character device interface, which allows reading and injecting frames.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_tap.c,v 1.47.4.4 2009/03/18 05:19:59 snj Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_tap.c,v 1.47.4.5 2009/03/18 05:23:44 snj Exp $");
 #if defined(_KERNEL_OPT)
 #include "bpfilter.h"
 #include "opt_modular.h"
 #include "opt_compat_netbsd.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/ksyms.h>
 #include <sys/poll.h>
 #include <sys/proc.h>
 #include <sys/select.h>
 #include <sys/sockio.h>
 #if defined(COMPAT_40) || defined(MODULAR)
 #include <sys/sysctl.h>
 #endif
 #include <sys/kauth.h>
 #include <sys/mutex.h>
 #include <sys/simplelock.h>
 #include <sys/intr.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_ether.h>
 #include <net/if_media.h>
 #include <net/if_tap.h>
 #if NBPFILTER > 0
 #include <net/bpf.h>
 #endif
 #include <compat/sys/sockio.h>
 #if defined(COMPAT_40) || defined(MODULAR)
 /*
  * sysctl node management
+ *
  * It's not really possible to use a SYSCTL_SETUP block with
  * current LKM implementation, so it is easier to just define
  * our own function.
+ *
  * The handler function is a "helper" in Andrew Brown's sysctl
  * framework terminology.  It is used as a gateway for sysctl
  * requests over the nodes.
+ *
  * tap_log allows the module to log creations of nodes and
  * destroy them all at once using sysctl_teardown.
  */
 static int tap_node;
 static int	tap_sysctl_handler(SYSCTLFN_PROTO);
 SYSCTL_SETUP_PROTO(sysctl_tap_setup);
 #endif
 /*
  * Since we're an Ethernet device, we need the 3 following
  * components: a leading struct device, a struct ethercom,
  * and also a struct ifmedia since we don't attach a PHY to
  * ourselves. We could emulate one, but there's no real
  * point.
  */
 struct tap_softc {
 	device_t	sc_dev;
 	struct ifmedia	sc_im;
 	struct ethercom	sc_ec;
 @@ -187,27 +194,29 @@ static void	tap_mediastatus(struct ifnet
 /*
  * Those are needed by the ifnet interface, and would typically be
  * there for any network interface driver.
  * Some other routines are optional: watchdog and drain.
  */
 static void	tap_start(struct ifnet *);
 static void	tap_stop(struct ifnet *, int);
 static int	tap_init(struct ifnet *);
 static int	tap_ioctl(struct ifnet *, u_long, void *);
 /* Internal functions */
 #if defined(COMPAT_40) || defined(MODULAR)
 static int	tap_lifaddr(struct ifnet *, u_long, struct ifaliasreq *);
 #endif
 static void	tap_softintr(void *);
 /*
  * tap is a clonable interface, although it is highly unrealistic for
  * an Ethernet device.
+ *
  * Here are the bits needed for a clonable interface.
  */
 static int	tap_clone_create(struct if_clone *, int);
 static int	tap_clone_destroy(struct ifnet *);
 struct if_clone tap_cloners = IF_CLONE_INITIALIZER("tap",
 					tap_clone_create,
 @@ -236,33 +245,35 @@ tapattach(int n)
 /* Pretty much useless for a pseudo-device */
 static int
 tap_match(device_t parent, cfdata_t cfdata, void *arg)
+{
 	return (1);
+}
 void
 tap_attach(device_t parent, device_t self, void *aux)
+{
 	struct tap_softc *sc = device_private(self);
 	struct ifnet *ifp;
 #if defined(COMPAT_40) || defined(MODULAR)
 	const struct sysctlnode *node;
 	int error;
 #endif
 	uint8_t enaddr[ETHER_ADDR_LEN] =
 	    { 0xf2, 0x0b, 0xa4, 0xff, 0xff, 0xff };
 	char enaddrstr[3 * ETHER_ADDR_LEN];
 	struct timeval tv;
 	uint32_t ui;
 	int error;
 	sc->sc_dev = self;
 	sc->sc_sih = softint_establish(SOFTINT_CLOCK, tap_softintr, sc);
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	/*
 	 * In order to obtain unique initial Ethernet address on a host,
 	 * do some randomisation using the current uptime.  It's not meant
 	 * for anything but avoiding hard-coding an address.
 	 */
 	getmicrouptime(&tv);
 @@ -302,48 +313,50 @@ tap_attach(device_t parent, device_t sel
 	ifp->if_stop	= tap_stop;
 	ifp->if_init	= tap_init;
 	IFQ_SET_READY(&ifp->if_snd);
 	sc->sc_ec.ec_capabilities = ETHERCAP_VLAN_MTU | ETHERCAP_JUMBO_MTU;
 	/* Those steps are mandatory for an Ethernet driver, the fisrt call
 	 * being common to all network interface drivers. */
 	if_attach(ifp);
 	ether_ifattach(ifp, enaddr);
 	sc->sc_flags = 0;
 #if defined(COMPAT_40) || defined(MODULAR)
 	/*
 	 * Add a sysctl node for that interface.
+	 *
 	 * The pointer transmitted is not a string, but instead a pointer to
 	 * the softc structure, which we can use to build the string value on
 	 * the fly in the helper function of the node.  See the comments for
 	 * tap_sysctl_handler for details.
+	 *
 	 * Usually sysctl_createv is called with CTL_CREATE as the before-last
 	 * component.  However, we can allocate a number ourselves, as we are
 	 * the only consumer of the net.link.<iface> node.  In this case, the
 	 * unit number is conveniently used to number the node.  CTL_CREATE
 	 * would just work, too.
 	 */
 	if ((error = sysctl_createv(NULL, 0, NULL,
 	    &node, CTLFLAG_READWRITE,
 	    CTLTYPE_STRING, device_xname(self), NULL,
 	    tap_sysctl_handler, 0, sc, 18,
 	    CTL_NET, AF_LINK, tap_node, device_unit(sc->sc_dev),
 	    CTL_EOL)) != 0)
 		aprint_error_dev(self, "sysctl_createv returned %d, ignoring\n",
 		    error);
 #endif
 	/*
 	 * Initialize the two locks for the device.
+	 *
 	 * We need a lock here because even though the tap device can be
 	 * opened only once, the file descriptor might be passed to another
 	 * process, say a fork(2)ed child.
+	 *
 	 * The Giant saves us from most of the hassle, but since the read
 	 * operation can sleep, we don't want two processes to wake up at
 	 * the same moment and both try and dequeue a single packet.
+	 *
 	 * The queue for event listeners (used by kqueue(9), see below) has
 @@ -355,45 +368,50 @@ tap_attach(device_t parent, device_t sel
 	selinit(&sc->sc_rsel);
+}
 /*
  * When detaching, we do the inverse of what is done in the attach
  * routine, in reversed order.
  */
 static int
 tap_detach(device_t self, int flags)
+{
 	struct tap_softc *sc = device_private(self);
 	struct ifnet *ifp = &sc->sc_ec.ec_if;
-	int error, s;
+#if defined(COMPAT_40) || defined(MODULAR)
 	int error;
 #endif
 	int s;
 	sc->sc_flags |= TAP_GOING;
 	s = splnet();
 	tap_stop(ifp, 1);
 	if_down(ifp);
 	splx(s);
 	softint_disestablish(sc->sc_sih);
 #if defined(COMPAT_40) || defined(MODULAR)
 	/*
 	 * Destroying a single leaf is a very straightforward operation using
 	 * sysctl_destroyv.  One should be sure to always end the path with
 	 * CTL_EOL.
 	 */
 	if ((error = sysctl_destroyv(NULL, CTL_NET, AF_LINK, tap_node,
 	    device_unit(sc->sc_dev), CTL_EOL)) != 0)
 		aprint_error_dev(self,
 		    "sysctl_destroyv returned %d, ignoring\n", error);
 #endif
 	ether_ifdetach(ifp);
 	if_detach(ifp);
 	ifmedia_delete_instance(&sc->sc_im, IFM_INST_ANY);
 	seldestroy(&sc->sc_rsel);
 	mutex_destroy(&sc->sc_rdlock);
 	pmf_device_deregister(self);
 	return (0);
+}
 /*
  * This function is called by the ifmedia layer to notify the driver
 @@ -511,57 +529,61 @@ tap_ioctl(struct ifnet *ifp, u_long cmd,
 	struct ifreq *ifr = (struct ifreq *)data;
 	int s, error;
 	s = splnet();
 	switch (cmd) {
 #ifdef OSIOCSIFMEDIA
 	case OSIOCSIFMEDIA:
 #endif
 	case SIOCSIFMEDIA:
 	case SIOCGIFMEDIA:
 		error = ifmedia_ioctl(ifp, ifr, &sc->sc_im, cmd);
 		break;
 #if defined(COMPAT_40) || defined(MODULAR)
 	case SIOCSIFPHYADDR:
 		error = tap_lifaddr(ifp, cmd, (struct ifaliasreq *)data);
 		break;
 #endif
 	default:
 		error = ether_ioctl(ifp, cmd, data);
 		if (error == ENETRESET)
 			error = 0;
 		break;
+	}
 	splx(s);
 	return (error);
+}
 #if defined(COMPAT_40) || defined(MODULAR)
 /*
- * Helper function to set Ethernet address.  This shouldn't be done there,
+ * Helper function to set Ethernet address.  This has been replaced by
- * and should actually be available to all Ethernet drivers, real or not.
+ * the generic SIOCALIFADDR ioctl on a PF_LINK socket.
  */
 static int
 tap_lifaddr(struct ifnet *ifp, u_long cmd, struct ifaliasreq *ifra)
+{
 	const struct sockaddr *sa = &ifra->ifra_addr;
 	if (sa->sa_family != AF_LINK)
 		return (EINVAL);
 	if_set_sadl(ifp, sa->sa_data, ETHER_ADDR_LEN);
 	return (0);
+}
 #endif
 /*
  * _init() would typically be called when an interface goes up,
  * meaning it should configure itself into the state in which it
  * can send packets.
  */
 static int
 tap_init(struct ifnet *ifp)
+{
 	ifp->if_flags |= IFF_RUNNING;
 	tap_start(ifp);
 @@ -1208,26 +1230,27 @@ tap_kqread(struct knote *kn, long hint)
 	s = splnet();
 	IFQ_POLL(&ifp->if_snd, m);
 	if (m == NULL)
 		kn->kn_data = 0;
 	else
 		kn->kn_data = m->m_pkthdr.len;
 	splx(s);
 	rv = (kn->kn_data != 0 ? 1 : 0);
 	KERNEL_UNLOCK_ONE(NULL);
 	return rv;
+}
 #if defined(COMPAT_40) || defined(MODULAR)
 /*
  * sysctl management routines
  * You can set the address of an interface through:
  * net.link.tap.tap<number>
+ *
  * Note the consistent use of tap_log in order to use
  * sysctl_teardown at unload time.
+ *
  * In the kernel you will find a lot of SYSCTL_SETUP blocks.  Those
  * blocks register a function in a special section of the kernel
  * (called a link set) which is used at init_sysctl() time to cycle
  * through all those functions to create the kernel's sysctl tree.
+ *
 @@ -1338,13 +1361,14 @@ tap_sysctl_handler(SYSCTLFN_ARGS)
 	if (error || newp == NULL)
 		return (error);
 	len = strlen(addr);
 	if (len < 11 || len > 17)
 		return (EINVAL);
 	/* Commit change */
 	if (ether_nonstatic_aton(enaddr, addr) != 0)
 		return (EINVAL);
 	if_set_sadl(ifp, enaddr, ETHER_ADDR_LEN);
 	return (error);
+}
 #endif