if_tap.c revision 1.10
1 1.10 atatat /* $NetBSD: if_tap.c,v 1.10 2005/06/20 02:49:19 atatat Exp $ */ 2 1.1 cube 3 1.1 cube /* 4 1.1 cube * Copyright (c) 2003, 2004 The NetBSD Foundation. 5 1.1 cube * All rights reserved. 6 1.1 cube * 7 1.1 cube * This code is derived from software contributed to the NetBSD Foundation 8 1.1 cube * by Quentin Garnier. 9 1.6 perry * 10 1.1 cube * Redistribution and use in source and binary forms, with or without 11 1.1 cube * modification, are permitted provided that the following conditions 12 1.1 cube * are met: 13 1.1 cube * 1. Redistributions of source code must retain the above copyright 14 1.1 cube * notice, this list of conditions and the following disclaimer. 15 1.1 cube * 2. Redistributions in binary form must reproduce the above copyright 16 1.1 cube * notice, this list of conditions and the following disclaimer in the 17 1.1 cube * documentation and/or other materials provided with the distribution. 18 1.1 cube * 3. All advertising materials mentioning features or use of this software 19 1.1 cube * must display the following acknowledgement: 20 1.1 cube * This product includes software developed by the NetBSD 21 1.1 cube * Foundation, Inc. and its contributors. 22 1.1 cube * 4. Neither the name of The NetBSD Foundation nor the names of its 23 1.1 cube * contributors may be used to endorse or promote products derived 24 1.1 cube * from this software without specific prior written permission. 25 1.6 perry * 26 1.1 cube * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 1.1 cube * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 1.1 cube * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 1.1 cube * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 1.1 cube * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 1.1 cube * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 1.1 cube * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 1.1 cube * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 1.1 cube * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 1.1 cube * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 1.1 cube * POSSIBILITY OF SUCH DAMAGE. 37 1.1 cube */ 38 1.1 cube 39 1.1 cube /* 40 1.1 cube * tap(4) is a virtual Ethernet interface. It appears as a real Ethernet 41 1.1 cube * device to the system, but can also be accessed by userland through a 42 1.1 cube * character device interface, which allows reading and injecting frames. 43 1.1 cube */ 44 1.1 cube 45 1.1 cube #include <sys/cdefs.h> 46 1.10 atatat __KERNEL_RCSID(0, "$NetBSD: if_tap.c,v 1.10 2005/06/20 02:49:19 atatat Exp $"); 47 1.1 cube 48 1.2 cube #if defined(_KERNEL_OPT) 49 1.1 cube #include "bpfilter.h" 50 1.2 cube #endif 51 1.1 cube 52 1.1 cube #include <sys/param.h> 53 1.1 cube #include <sys/systm.h> 54 1.1 cube #include <sys/kernel.h> 55 1.1 cube #include <sys/malloc.h> 56 1.1 cube #include <sys/conf.h> 57 1.1 cube #include <sys/device.h> 58 1.1 cube #include <sys/file.h> 59 1.1 cube #include <sys/filedesc.h> 60 1.1 cube #include <sys/ksyms.h> 61 1.1 cube #include <sys/poll.h> 62 1.1 cube #include <sys/select.h> 63 1.1 cube #include <sys/sockio.h> 64 1.1 cube #include <sys/sysctl.h> 65 1.1 cube 66 1.1 cube #include <net/if.h> 67 1.1 cube #include <net/if_dl.h> 68 1.1 cube #include <net/if_ether.h> 69 1.1 cube #include <net/if_media.h> 70 1.1 cube #include <net/if_tap.h> 71 1.1 cube #if NBPFILTER > 0 72 1.1 cube #include <net/bpf.h> 73 1.1 cube #endif 74 1.1 cube 75 1.1 cube /* 76 1.1 cube * sysctl node management 77 1.1 cube * 78 1.1 cube * It's not really possible to use a SYSCTL_SETUP block with 79 1.1 cube * current LKM implementation, so it is easier to just define 80 1.1 cube * our own function. 81 1.1 cube * 82 1.1 cube * The handler function is a "helper" in Andrew Brown's sysctl 83 1.1 cube * framework terminology. It is used as a gateway for sysctl 84 1.1 cube * requests over the nodes. 85 1.1 cube * 86 1.1 cube * tap_log allows the module to log creations of nodes and 87 1.1 cube * destroy them all at once using sysctl_teardown. 88 1.1 cube */ 89 1.1 cube static int tap_node; 90 1.1 cube static int tap_sysctl_handler(SYSCTLFN_PROTO); 91 1.2 cube SYSCTL_SETUP_PROTO(sysctl_tap_setup); 92 1.1 cube 93 1.1 cube /* 94 1.1 cube * Since we're an Ethernet device, we need the 3 following 95 1.1 cube * components: a leading struct device, a struct ethercom, 96 1.1 cube * and also a struct ifmedia since we don't attach a PHY to 97 1.1 cube * ourselves. We could emulate one, but there's no real 98 1.1 cube * point. 99 1.1 cube */ 100 1.1 cube 101 1.1 cube struct tap_softc { 102 1.1 cube struct device sc_dev; 103 1.1 cube struct ifmedia sc_im; 104 1.1 cube struct ethercom sc_ec; 105 1.1 cube int sc_flags; 106 1.1 cube #define TAP_INUSE 0x00000001 /* tap device can only be opened once */ 107 1.1 cube #define TAP_ASYNCIO 0x00000002 /* user is using async I/O (SIGIO) on the device */ 108 1.1 cube #define TAP_NBIO 0x00000004 /* user wants calls to avoid blocking */ 109 1.1 cube #define TAP_GOING 0x00000008 /* interface is being destroyed */ 110 1.1 cube struct selinfo sc_rsel; 111 1.1 cube pid_t sc_pgid; /* For async. IO */ 112 1.1 cube struct lock sc_rdlock; 113 1.1 cube struct simplelock sc_kqlock; 114 1.1 cube }; 115 1.1 cube 116 1.1 cube /* autoconf(9) glue */ 117 1.1 cube 118 1.1 cube void tapattach(int); 119 1.1 cube 120 1.1 cube static int tap_match(struct device *, struct cfdata *, void *); 121 1.1 cube static void tap_attach(struct device *, struct device *, void *); 122 1.1 cube static int tap_detach(struct device*, int); 123 1.1 cube 124 1.1 cube /* Ethernet address helper functions */ 125 1.1 cube 126 1.1 cube static char *tap_ether_sprintf(char *, const u_char *); 127 1.1 cube static int tap_ether_aton(u_char *, char *); 128 1.1 cube 129 1.1 cube CFATTACH_DECL(tap, sizeof(struct tap_softc), 130 1.1 cube tap_match, tap_attach, tap_detach, NULL); 131 1.1 cube extern struct cfdriver tap_cd; 132 1.1 cube 133 1.1 cube /* Real device access routines */ 134 1.1 cube static int tap_dev_close(struct tap_softc *); 135 1.1 cube static int tap_dev_read(int, struct uio *, int); 136 1.1 cube static int tap_dev_write(int, struct uio *, int); 137 1.1 cube static int tap_dev_ioctl(int, u_long, caddr_t, struct proc *); 138 1.1 cube static int tap_dev_poll(int, int, struct proc *); 139 1.1 cube static int tap_dev_kqfilter(int, struct knote *); 140 1.1 cube 141 1.1 cube /* Fileops access routines */ 142 1.1 cube static int tap_fops_close(struct file *, struct proc *); 143 1.1 cube static int tap_fops_read(struct file *, off_t *, struct uio *, 144 1.1 cube struct ucred *, int); 145 1.1 cube static int tap_fops_write(struct file *, off_t *, struct uio *, 146 1.1 cube struct ucred *, int); 147 1.1 cube static int tap_fops_ioctl(struct file *, u_long, void *, 148 1.1 cube struct proc *); 149 1.1 cube static int tap_fops_poll(struct file *, int, struct proc *); 150 1.1 cube static int tap_fops_kqfilter(struct file *, struct knote *); 151 1.1 cube 152 1.1 cube static const struct fileops tap_fileops = { 153 1.1 cube tap_fops_read, 154 1.1 cube tap_fops_write, 155 1.1 cube tap_fops_ioctl, 156 1.1 cube fnullop_fcntl, 157 1.1 cube tap_fops_poll, 158 1.1 cube fbadop_stat, 159 1.1 cube tap_fops_close, 160 1.1 cube tap_fops_kqfilter, 161 1.1 cube }; 162 1.1 cube 163 1.1 cube /* Helper for cloning open() */ 164 1.1 cube static int tap_dev_cloner(struct proc *); 165 1.1 cube 166 1.1 cube /* Character device routines */ 167 1.1 cube static int tap_cdev_open(dev_t, int, int, struct proc *); 168 1.1 cube static int tap_cdev_close(dev_t, int, int, struct proc *); 169 1.1 cube static int tap_cdev_read(dev_t, struct uio *, int); 170 1.1 cube static int tap_cdev_write(dev_t, struct uio *, int); 171 1.1 cube static int tap_cdev_ioctl(dev_t, u_long, caddr_t, int, struct proc *); 172 1.1 cube static int tap_cdev_poll(dev_t, int, struct proc *); 173 1.1 cube static int tap_cdev_kqfilter(dev_t, struct knote *); 174 1.1 cube 175 1.1 cube const struct cdevsw tap_cdevsw = { 176 1.1 cube tap_cdev_open, tap_cdev_close, 177 1.1 cube tap_cdev_read, tap_cdev_write, 178 1.1 cube tap_cdev_ioctl, nostop, notty, 179 1.1 cube tap_cdev_poll, nommap, 180 1.1 cube tap_cdev_kqfilter, 181 1.1 cube }; 182 1.1 cube 183 1.1 cube #define TAP_CLONER 0xfffff /* Maximal minor value */ 184 1.1 cube 185 1.1 cube /* kqueue-related routines */ 186 1.1 cube static void tap_kqdetach(struct knote *); 187 1.1 cube static int tap_kqread(struct knote *, long); 188 1.1 cube 189 1.1 cube /* 190 1.1 cube * Those are needed by the if_media interface. 191 1.1 cube */ 192 1.1 cube 193 1.1 cube static int tap_mediachange(struct ifnet *); 194 1.1 cube static void tap_mediastatus(struct ifnet *, struct ifmediareq *); 195 1.1 cube 196 1.1 cube /* 197 1.1 cube * Those are needed by the ifnet interface, and would typically be 198 1.1 cube * there for any network interface driver. 199 1.1 cube * Some other routines are optional: watchdog and drain. 200 1.1 cube */ 201 1.1 cube 202 1.1 cube static void tap_start(struct ifnet *); 203 1.1 cube static void tap_stop(struct ifnet *, int); 204 1.1 cube static int tap_init(struct ifnet *); 205 1.1 cube static int tap_ioctl(struct ifnet *, u_long, caddr_t); 206 1.1 cube 207 1.1 cube /* This is an internal function to keep tap_ioctl readable */ 208 1.1 cube static int tap_lifaddr(struct ifnet *, u_long, struct ifaliasreq *); 209 1.1 cube 210 1.1 cube /* 211 1.1 cube * tap is a clonable interface, although it is highly unrealistic for 212 1.1 cube * an Ethernet device. 213 1.1 cube * 214 1.1 cube * Here are the bits needed for a clonable interface. 215 1.1 cube */ 216 1.1 cube static int tap_clone_create(struct if_clone *, int); 217 1.1 cube static int tap_clone_destroy(struct ifnet *); 218 1.1 cube 219 1.1 cube struct if_clone tap_cloners = IF_CLONE_INITIALIZER("tap", 220 1.1 cube tap_clone_create, 221 1.1 cube tap_clone_destroy); 222 1.1 cube 223 1.1 cube /* Helper functionis shared by the two cloning code paths */ 224 1.1 cube static struct tap_softc * tap_clone_creator(int); 225 1.1 cube static int tap_clone_destroyer(struct device *); 226 1.1 cube 227 1.1 cube void 228 1.1 cube tapattach(int n) 229 1.1 cube { 230 1.1 cube int error; 231 1.1 cube 232 1.1 cube error = config_cfattach_attach(tap_cd.cd_name, &tap_ca); 233 1.1 cube if (error) { 234 1.1 cube aprint_error("%s: unable to register cfattach\n", 235 1.1 cube tap_cd.cd_name); 236 1.1 cube (void)config_cfdriver_detach(&tap_cd); 237 1.1 cube return; 238 1.1 cube } 239 1.1 cube 240 1.1 cube if_clone_attach(&tap_cloners); 241 1.1 cube } 242 1.1 cube 243 1.1 cube /* Pretty much useless for a pseudo-device */ 244 1.1 cube static int 245 1.1 cube tap_match(struct device *self, struct cfdata *cfdata, void *arg) 246 1.1 cube { 247 1.1 cube return (1); 248 1.1 cube } 249 1.1 cube 250 1.1 cube void 251 1.1 cube tap_attach(struct device *parent, struct device *self, void *aux) 252 1.1 cube { 253 1.1 cube struct tap_softc *sc = (struct tap_softc *)self; 254 1.1 cube struct ifnet *ifp; 255 1.1 cube u_int8_t enaddr[ETHER_ADDR_LEN] = 256 1.7 cube { 0xf2, 0x0b, 0xa4, 0xff, 0xff, 0xff }; 257 1.1 cube char enaddrstr[18]; 258 1.1 cube uint32_t ui; 259 1.1 cube int error; 260 1.10 atatat const struct sysctlnode *node; 261 1.1 cube 262 1.1 cube aprint_normal("%s: faking Ethernet device\n", 263 1.1 cube self->dv_xname); 264 1.1 cube 265 1.1 cube /* 266 1.1 cube * In order to obtain unique initial Ethernet address on a host, 267 1.1 cube * do some randomisation using mono_time. It's not meant for anything 268 1.1 cube * but avoiding hard-coding an address. 269 1.1 cube */ 270 1.1 cube ui = (mono_time.tv_sec ^ mono_time.tv_usec) & 0xffffff; 271 1.1 cube memcpy(enaddr+3, (u_int8_t *)&ui, 3); 272 1.1 cube 273 1.1 cube aprint_normal("%s: Ethernet address %s\n", sc->sc_dev.dv_xname, 274 1.1 cube tap_ether_sprintf(enaddrstr, enaddr)); 275 1.1 cube 276 1.1 cube /* 277 1.1 cube * Why 1000baseT? Why not? You can add more. 278 1.1 cube * 279 1.1 cube * Note that there are 3 steps: init, one or several additions to 280 1.1 cube * list of supported media, and in the end, the selection of one 281 1.1 cube * of them. 282 1.1 cube */ 283 1.1 cube ifmedia_init(&sc->sc_im, 0, tap_mediachange, tap_mediastatus); 284 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_1000_T, 0, NULL); 285 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_1000_T|IFM_FDX, 0, NULL); 286 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_100_TX, 0, NULL); 287 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL); 288 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_10_T, 0, NULL); 289 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL); 290 1.1 cube ifmedia_add(&sc->sc_im, IFM_ETHER|IFM_AUTO, 0, NULL); 291 1.1 cube ifmedia_set(&sc->sc_im, IFM_ETHER|IFM_AUTO); 292 1.1 cube 293 1.1 cube /* 294 1.1 cube * One should note that an interface must do multicast in order 295 1.1 cube * to support IPv6. 296 1.1 cube */ 297 1.1 cube ifp = &sc->sc_ec.ec_if; 298 1.1 cube strcpy(ifp->if_xname, sc->sc_dev.dv_xname); 299 1.1 cube ifp->if_softc = sc; 300 1.1 cube ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 301 1.1 cube ifp->if_ioctl = tap_ioctl; 302 1.1 cube ifp->if_start = tap_start; 303 1.1 cube ifp->if_stop = tap_stop; 304 1.1 cube ifp->if_init = tap_init; 305 1.1 cube IFQ_SET_READY(&ifp->if_snd); 306 1.1 cube 307 1.1 cube sc->sc_ec.ec_capabilities = ETHERCAP_VLAN_MTU | ETHERCAP_JUMBO_MTU; 308 1.1 cube 309 1.1 cube /* Those steps are mandatory for an Ethernet driver, the fisrt call 310 1.1 cube * being common to all network interface drivers. */ 311 1.1 cube if_attach(ifp); 312 1.1 cube ether_ifattach(ifp, enaddr); 313 1.1 cube 314 1.1 cube sc->sc_flags = 0; 315 1.1 cube 316 1.1 cube /* 317 1.1 cube * Add a sysctl node for that interface. 318 1.1 cube * 319 1.1 cube * The pointer transmitted is not a string, but instead a pointer to 320 1.1 cube * the softc structure, which we can use to build the string value on 321 1.1 cube * the fly in the helper function of the node. See the comments for 322 1.1 cube * tap_sysctl_handler for details. 323 1.1 cube */ 324 1.1 cube if ((error = sysctl_createv(NULL, 0, NULL, 325 1.1 cube &node, CTLFLAG_READWRITE, 326 1.1 cube CTLTYPE_STRING, sc->sc_dev.dv_xname, NULL, 327 1.1 cube tap_sysctl_handler, 0, sc, 18, 328 1.3 cube CTL_NET, AF_LINK, tap_node, sc->sc_dev.dv_unit, CTL_EOL)) != 0) 329 1.1 cube aprint_error("%s: sysctl_createv returned %d, ignoring\n", 330 1.1 cube sc->sc_dev.dv_xname, error); 331 1.1 cube 332 1.1 cube /* 333 1.1 cube * Initialize the two locks for the device. 334 1.1 cube * 335 1.1 cube * We need a lock here because even though the tap device can be 336 1.1 cube * opened only once, the file descriptor might be passed to another 337 1.1 cube * process, say a fork(2)ed child. 338 1.1 cube * 339 1.1 cube * The Giant saves us from most of the hassle, but since the read 340 1.1 cube * operation can sleep, we don't want two processes to wake up at 341 1.1 cube * the same moment and both try and dequeue a single packet. 342 1.1 cube * 343 1.1 cube * The queue for event listeners (used by kqueue(9), see below) has 344 1.1 cube * to be protected, too, but we don't need the same level of 345 1.1 cube * complexity for that lock, so a simple spinning lock is fine. 346 1.1 cube */ 347 1.1 cube lockinit(&sc->sc_rdlock, PSOCK|PCATCH, "tapl", 0, LK_SLEEPFAIL); 348 1.1 cube simple_lock_init(&sc->sc_kqlock); 349 1.1 cube } 350 1.1 cube 351 1.1 cube /* 352 1.1 cube * When detaching, we do the inverse of what is done in the attach 353 1.1 cube * routine, in reversed order. 354 1.1 cube */ 355 1.1 cube static int 356 1.1 cube tap_detach(struct device* self, int flags) 357 1.1 cube { 358 1.1 cube struct tap_softc *sc = (struct tap_softc *)self; 359 1.1 cube struct ifnet *ifp = &sc->sc_ec.ec_if; 360 1.1 cube int error, s; 361 1.1 cube 362 1.1 cube /* 363 1.1 cube * Some processes might be sleeping on "tap", so we have to make 364 1.1 cube * them release their hold on the device. 365 1.1 cube * 366 1.1 cube * The LK_DRAIN operation will wait for every locked process to 367 1.1 cube * release their hold. 368 1.1 cube */ 369 1.1 cube sc->sc_flags |= TAP_GOING; 370 1.1 cube s = splnet(); 371 1.1 cube tap_stop(ifp, 1); 372 1.1 cube if_down(ifp); 373 1.1 cube splx(s); 374 1.1 cube lockmgr(&sc->sc_rdlock, LK_DRAIN, NULL); 375 1.1 cube 376 1.1 cube /* 377 1.1 cube * Destroying a single leaf is a very straightforward operation using 378 1.1 cube * sysctl_destroyv. One should be sure to always end the path with 379 1.1 cube * CTL_EOL. 380 1.1 cube */ 381 1.3 cube if ((error = sysctl_destroyv(NULL, CTL_NET, AF_LINK, tap_node, 382 1.1 cube sc->sc_dev.dv_unit, CTL_EOL)) != 0) 383 1.1 cube aprint_error("%s: sysctl_destroyv returned %d, ignoring\n", 384 1.1 cube sc->sc_dev.dv_xname, error); 385 1.1 cube ether_ifdetach(ifp); 386 1.1 cube if_detach(ifp); 387 1.1 cube ifmedia_delete_instance(&sc->sc_im, IFM_INST_ANY); 388 1.1 cube 389 1.1 cube return (0); 390 1.1 cube } 391 1.1 cube 392 1.1 cube /* 393 1.1 cube * This function is called by the ifmedia layer to notify the driver 394 1.1 cube * that the user requested a media change. A real driver would 395 1.1 cube * reconfigure the hardware. 396 1.1 cube */ 397 1.1 cube static int 398 1.1 cube tap_mediachange(struct ifnet *ifp) 399 1.1 cube { 400 1.1 cube return (0); 401 1.1 cube } 402 1.1 cube 403 1.1 cube /* 404 1.1 cube * Here the user asks for the currently used media. 405 1.1 cube */ 406 1.1 cube static void 407 1.1 cube tap_mediastatus(struct ifnet *ifp, struct ifmediareq *imr) 408 1.1 cube { 409 1.1 cube struct tap_softc *sc = (struct tap_softc *)ifp->if_softc; 410 1.1 cube imr->ifm_active = sc->sc_im.ifm_cur->ifm_media; 411 1.1 cube } 412 1.1 cube 413 1.1 cube /* 414 1.1 cube * This is the function where we SEND packets. 415 1.1 cube * 416 1.1 cube * There is no 'receive' equivalent. A typical driver will get 417 1.1 cube * interrupts from the hardware, and from there will inject new packets 418 1.1 cube * into the network stack. 419 1.1 cube * 420 1.1 cube * Once handled, a packet must be freed. A real driver might not be able 421 1.1 cube * to fit all the pending packets into the hardware, and is allowed to 422 1.1 cube * return before having sent all the packets. It should then use the 423 1.1 cube * if_flags flag IFF_OACTIVE to notify the upper layer. 424 1.1 cube * 425 1.1 cube * There are also other flags one should check, such as IFF_PAUSE. 426 1.1 cube * 427 1.1 cube * It is our duty to make packets available to BPF listeners. 428 1.1 cube * 429 1.1 cube * You should be aware that this function is called by the Ethernet layer 430 1.1 cube * at splnet(). 431 1.1 cube * 432 1.1 cube * When the device is opened, we have to pass the packet(s) to the 433 1.1 cube * userland. For that we stay in OACTIVE mode while the userland gets 434 1.1 cube * the packets, and we send a signal to the processes waiting to read. 435 1.1 cube * 436 1.1 cube * wakeup(sc) is the counterpart to the tsleep call in 437 1.1 cube * tap_dev_read, while selnotify() is used for kevent(2) and 438 1.1 cube * poll(2) (which includes select(2)) listeners. 439 1.1 cube */ 440 1.1 cube static void 441 1.1 cube tap_start(struct ifnet *ifp) 442 1.1 cube { 443 1.1 cube struct tap_softc *sc = (struct tap_softc *)ifp->if_softc; 444 1.1 cube struct mbuf *m0; 445 1.1 cube 446 1.1 cube if ((sc->sc_flags & TAP_INUSE) == 0) { 447 1.1 cube /* Simply drop packets */ 448 1.1 cube for(;;) { 449 1.1 cube IFQ_DEQUEUE(&ifp->if_snd, m0); 450 1.1 cube if (m0 == NULL) 451 1.1 cube return; 452 1.1 cube 453 1.1 cube ifp->if_opackets++; 454 1.1 cube #if NBPFILTER > 0 455 1.1 cube if (ifp->if_bpf) 456 1.1 cube bpf_mtap(ifp->if_bpf, m0); 457 1.1 cube #endif 458 1.1 cube 459 1.1 cube m_freem(m0); 460 1.1 cube } 461 1.1 cube } else if (!IFQ_IS_EMPTY(&ifp->if_snd)) { 462 1.1 cube ifp->if_flags |= IFF_OACTIVE; 463 1.1 cube wakeup(sc); 464 1.1 cube selnotify(&sc->sc_rsel, 1); 465 1.1 cube if (sc->sc_flags & TAP_ASYNCIO) 466 1.1 cube fownsignal(sc->sc_pgid, SIGIO, POLL_IN, 467 1.1 cube POLLIN|POLLRDNORM, NULL); 468 1.1 cube } 469 1.1 cube } 470 1.1 cube 471 1.1 cube /* 472 1.1 cube * A typical driver will only contain the following handlers for 473 1.1 cube * ioctl calls, except SIOCSIFPHYADDR. 474 1.1 cube * The latter is a hack I used to set the Ethernet address of the 475 1.1 cube * faked device. 476 1.1 cube * 477 1.1 cube * Note that both ifmedia_ioctl() and ether_ioctl() have to be 478 1.1 cube * called under splnet(). 479 1.1 cube */ 480 1.1 cube static int 481 1.1 cube tap_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 482 1.1 cube { 483 1.1 cube struct tap_softc *sc = (struct tap_softc *)ifp->if_softc; 484 1.1 cube struct ifreq *ifr = (struct ifreq *)data; 485 1.1 cube int s, error; 486 1.1 cube 487 1.1 cube s = splnet(); 488 1.1 cube 489 1.1 cube switch (cmd) { 490 1.1 cube case SIOCSIFMEDIA: 491 1.1 cube case SIOCGIFMEDIA: 492 1.1 cube error = ifmedia_ioctl(ifp, ifr, &sc->sc_im, cmd); 493 1.1 cube break; 494 1.1 cube case SIOCSIFPHYADDR: 495 1.1 cube error = tap_lifaddr(ifp, cmd, (struct ifaliasreq *)data); 496 1.1 cube break; 497 1.1 cube default: 498 1.1 cube error = ether_ioctl(ifp, cmd, data); 499 1.1 cube if (error == ENETRESET) 500 1.1 cube error = 0; 501 1.1 cube break; 502 1.1 cube } 503 1.1 cube 504 1.1 cube splx(s); 505 1.1 cube 506 1.1 cube return (error); 507 1.1 cube } 508 1.1 cube 509 1.1 cube /* 510 1.1 cube * Helper function to set Ethernet address. This shouldn't be done there, 511 1.1 cube * and should actually be available to all Ethernet drivers, real or not. 512 1.1 cube */ 513 1.1 cube static int 514 1.1 cube tap_lifaddr(struct ifnet *ifp, u_long cmd, struct ifaliasreq *ifra) 515 1.1 cube { 516 1.1 cube struct sockaddr *sa = (struct sockaddr *)&ifra->ifra_addr; 517 1.1 cube 518 1.1 cube if (sa->sa_family != AF_LINK) 519 1.1 cube return (EINVAL); 520 1.1 cube 521 1.1 cube memcpy(LLADDR(ifp->if_sadl), sa->sa_data, ETHER_ADDR_LEN); 522 1.1 cube 523 1.1 cube return (0); 524 1.1 cube } 525 1.1 cube 526 1.1 cube /* 527 1.1 cube * _init() would typically be called when an interface goes up, 528 1.1 cube * meaning it should configure itself into the state in which it 529 1.1 cube * can send packets. 530 1.1 cube */ 531 1.1 cube static int 532 1.1 cube tap_init(struct ifnet *ifp) 533 1.1 cube { 534 1.1 cube ifp->if_flags |= IFF_RUNNING; 535 1.1 cube 536 1.1 cube tap_start(ifp); 537 1.1 cube 538 1.1 cube return (0); 539 1.1 cube } 540 1.1 cube 541 1.1 cube /* 542 1.1 cube * _stop() is called when an interface goes down. It is our 543 1.1 cube * responsability to validate that state by clearing the 544 1.1 cube * IFF_RUNNING flag. 545 1.1 cube * 546 1.1 cube * We have to wake up all the sleeping processes to have the pending 547 1.1 cube * read requests cancelled. 548 1.1 cube */ 549 1.1 cube static void 550 1.1 cube tap_stop(struct ifnet *ifp, int disable) 551 1.1 cube { 552 1.1 cube struct tap_softc *sc = (struct tap_softc *)ifp->if_softc; 553 1.1 cube 554 1.1 cube ifp->if_flags &= ~IFF_RUNNING; 555 1.1 cube wakeup(sc); 556 1.1 cube selnotify(&sc->sc_rsel, 1); 557 1.1 cube if (sc->sc_flags & TAP_ASYNCIO) 558 1.1 cube fownsignal(sc->sc_pgid, SIGIO, POLL_HUP, 0, NULL); 559 1.1 cube } 560 1.1 cube 561 1.1 cube /* 562 1.1 cube * The 'create' command of ifconfig can be used to create 563 1.1 cube * any numbered instance of a given device. Thus we have to 564 1.1 cube * make sure we have enough room in cd_devs to create the 565 1.1 cube * user-specified instance. config_attach_pseudo will do this 566 1.1 cube * for us. 567 1.1 cube */ 568 1.1 cube static int 569 1.1 cube tap_clone_create(struct if_clone *ifc, int unit) 570 1.1 cube { 571 1.1 cube if (tap_clone_creator(unit) == NULL) { 572 1.1 cube aprint_error("%s%d: unable to attach an instance\n", 573 1.1 cube tap_cd.cd_name, unit); 574 1.1 cube return (ENXIO); 575 1.1 cube } 576 1.1 cube 577 1.1 cube return (0); 578 1.1 cube } 579 1.1 cube 580 1.1 cube /* 581 1.1 cube * tap(4) can be cloned by two ways: 582 1.1 cube * using 'ifconfig tap0 create', which will use the network 583 1.1 cube * interface cloning API, and call tap_clone_create above. 584 1.1 cube * opening the cloning device node, whose minor number is TAP_CLONER. 585 1.1 cube * See below for an explanation on how this part work. 586 1.1 cube * 587 1.1 cube * config_attach_pseudo can be called with unit = DVUNIT_ANY to have 588 1.1 cube * autoconf(9) choose a unit number for us. This is what happens when 589 1.1 cube * the cloner is openend, while the ifcloner interface creates a device 590 1.1 cube * with a specific unit number. 591 1.1 cube */ 592 1.1 cube static struct tap_softc * 593 1.1 cube tap_clone_creator(int unit) 594 1.1 cube { 595 1.1 cube struct cfdata *cf; 596 1.1 cube 597 1.1 cube cf = malloc(sizeof(*cf), M_DEVBUF, M_WAITOK); 598 1.1 cube cf->cf_name = tap_cd.cd_name; 599 1.1 cube cf->cf_atname = tap_ca.ca_name; 600 1.1 cube cf->cf_unit = unit; 601 1.1 cube cf->cf_fstate = FSTATE_STAR; 602 1.1 cube 603 1.1 cube return (struct tap_softc *)config_attach_pseudo(cf); 604 1.1 cube } 605 1.1 cube 606 1.1 cube /* 607 1.1 cube * The clean design of if_clone and autoconf(9) makes that part 608 1.1 cube * really straightforward. The second argument of config_detach 609 1.1 cube * means neither QUIET nor FORCED. 610 1.1 cube */ 611 1.1 cube static int 612 1.1 cube tap_clone_destroy(struct ifnet *ifp) 613 1.1 cube { 614 1.1 cube return tap_clone_destroyer((struct device *)ifp->if_softc); 615 1.1 cube } 616 1.1 cube 617 1.1 cube static int 618 1.1 cube tap_clone_destroyer(struct device *dev) 619 1.1 cube { 620 1.1 cube struct cfdata *cf = dev->dv_cfdata; 621 1.1 cube int error; 622 1.1 cube 623 1.1 cube if ((error = config_detach(dev, 0)) != 0) 624 1.1 cube aprint_error("%s: unable to detach instance\n", 625 1.1 cube dev->dv_xname); 626 1.1 cube free(cf, M_DEVBUF); 627 1.1 cube 628 1.1 cube return (error); 629 1.1 cube } 630 1.1 cube 631 1.1 cube /* 632 1.1 cube * tap(4) is a bit of an hybrid device. It can be used in two different 633 1.1 cube * ways: 634 1.1 cube * 1. ifconfig tapN create, then use /dev/tapN to read/write off it. 635 1.1 cube * 2. open /dev/tap, get a new interface created and read/write off it. 636 1.1 cube * That interface is destroyed when the process that had it created exits. 637 1.1 cube * 638 1.1 cube * The first way is managed by the cdevsw structure, and you access interfaces 639 1.1 cube * through a (major, minor) mapping: tap4 is obtained by the minor number 640 1.1 cube * 4. The entry points for the cdevsw interface are prefixed by tap_cdev_. 641 1.1 cube * 642 1.1 cube * The second way is the so-called "cloning" device. It's a special minor 643 1.1 cube * number (chosen as the maximal number, to allow as much tap devices as 644 1.1 cube * possible). The user first opens the cloner (e.g., /dev/tap), and that 645 1.1 cube * call ends in tap_cdev_open. The actual place where it is handled is 646 1.1 cube * tap_dev_cloner. 647 1.1 cube * 648 1.1 cube * An tap device cannot be opened more than once at a time, so the cdevsw 649 1.1 cube * part of open() does nothing but noting that the interface is being used and 650 1.1 cube * hence ready to actually handle packets. 651 1.1 cube */ 652 1.1 cube 653 1.1 cube static int 654 1.1 cube tap_cdev_open(dev_t dev, int flags, int fmt, struct proc *p) 655 1.1 cube { 656 1.1 cube struct tap_softc *sc; 657 1.1 cube 658 1.1 cube if (minor(dev) == TAP_CLONER) 659 1.1 cube return tap_dev_cloner(p); 660 1.1 cube 661 1.1 cube sc = (struct tap_softc *)device_lookup(&tap_cd, minor(dev)); 662 1.1 cube if (sc == NULL) 663 1.1 cube return (ENXIO); 664 1.1 cube 665 1.1 cube /* The device can only be opened once */ 666 1.1 cube if (sc->sc_flags & TAP_INUSE) 667 1.1 cube return (EBUSY); 668 1.1 cube sc->sc_flags |= TAP_INUSE; 669 1.1 cube return (0); 670 1.1 cube } 671 1.1 cube 672 1.1 cube /* 673 1.1 cube * There are several kinds of cloning devices, and the most simple is the one 674 1.1 cube * tap(4) uses. What it does is change the file descriptor with a new one, 675 1.1 cube * with its own fileops structure (which maps to the various read, write, 676 1.1 cube * ioctl functions). It starts allocating a new file descriptor with falloc, 677 1.1 cube * then actually creates the new tap devices. 678 1.1 cube * 679 1.1 cube * Once those two steps are successful, we can re-wire the existing file 680 1.1 cube * descriptor to its new self. This is done with fdclone(): it fills the fp 681 1.1 cube * structure as needed (notably f_data gets filled with the fifth parameter 682 1.1 cube * passed, the unit of the tap device which will allows us identifying the 683 1.1 cube * device later), and returns EMOVEFD. 684 1.1 cube * 685 1.1 cube * That magic value is interpreted by sys_open() which then replaces the 686 1.1 cube * current file descriptor by the new one (through a magic member of struct 687 1.1 cube * proc, p_dupfd). 688 1.1 cube * 689 1.1 cube * The tap device is flagged as being busy since it otherwise could be 690 1.1 cube * externally accessed through the corresponding device node with the cdevsw 691 1.1 cube * interface. 692 1.1 cube */ 693 1.1 cube 694 1.1 cube static int 695 1.1 cube tap_dev_cloner(struct proc *p) 696 1.1 cube { 697 1.1 cube struct tap_softc *sc; 698 1.1 cube struct file *fp; 699 1.1 cube int error, fd; 700 1.1 cube 701 1.1 cube if ((error = falloc(p, &fp, &fd)) != 0) 702 1.1 cube return (error); 703 1.1 cube 704 1.1 cube if ((sc = tap_clone_creator(DVUNIT_ANY)) == NULL) { 705 1.1 cube FILE_UNUSE(fp, p); 706 1.1 cube ffree(fp); 707 1.1 cube return (ENXIO); 708 1.1 cube } 709 1.1 cube 710 1.1 cube sc->sc_flags |= TAP_INUSE; 711 1.1 cube 712 1.5 christos return fdclone(p, fp, fd, FREAD|FWRITE, &tap_fileops, 713 1.5 christos (void *)(intptr_t)sc->sc_dev.dv_unit); 714 1.1 cube } 715 1.1 cube 716 1.1 cube /* 717 1.1 cube * While all other operations (read, write, ioctl, poll and kqfilter) are 718 1.1 cube * really the same whether we are in cdevsw or fileops mode, the close() 719 1.1 cube * function is slightly different in the two cases. 720 1.1 cube * 721 1.1 cube * As for the other, the core of it is shared in tap_dev_close. What 722 1.1 cube * it does is sufficient for the cdevsw interface, but the cloning interface 723 1.1 cube * needs another thing: the interface is destroyed when the processes that 724 1.1 cube * created it closes it. 725 1.1 cube */ 726 1.1 cube static int 727 1.1 cube tap_cdev_close(dev_t dev, int flags, int fmt, struct proc *p) 728 1.1 cube { 729 1.1 cube struct tap_softc *sc = 730 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, minor(dev)); 731 1.1 cube 732 1.1 cube if (sc == NULL) 733 1.1 cube return (ENXIO); 734 1.1 cube 735 1.1 cube return tap_dev_close(sc); 736 1.1 cube } 737 1.1 cube 738 1.1 cube /* 739 1.1 cube * It might happen that the administrator used ifconfig to externally destroy 740 1.1 cube * the interface. In that case, tap_fops_close will be called while 741 1.1 cube * tap_detach is already happening. If we called it again from here, we 742 1.1 cube * would dead lock. TAP_GOING ensures that this situation doesn't happen. 743 1.1 cube */ 744 1.1 cube static int 745 1.1 cube tap_fops_close(struct file *fp, struct proc *p) 746 1.1 cube { 747 1.1 cube int unit = (intptr_t)fp->f_data; 748 1.1 cube struct tap_softc *sc; 749 1.1 cube int error; 750 1.1 cube 751 1.1 cube sc = (struct tap_softc *)device_lookup(&tap_cd, unit); 752 1.1 cube if (sc == NULL) 753 1.1 cube return (ENXIO); 754 1.1 cube 755 1.1 cube /* tap_dev_close currently always succeeds, but it might not 756 1.1 cube * always be the case. */ 757 1.1 cube if ((error = tap_dev_close(sc)) != 0) 758 1.1 cube return (error); 759 1.1 cube 760 1.1 cube /* Destroy the device now that it is no longer useful, 761 1.1 cube * unless it's already being destroyed. */ 762 1.1 cube if ((sc->sc_flags & TAP_GOING) != 0) 763 1.1 cube return (0); 764 1.1 cube 765 1.1 cube return tap_clone_destroyer((struct device *)sc); 766 1.1 cube } 767 1.1 cube 768 1.1 cube static int 769 1.1 cube tap_dev_close(struct tap_softc *sc) 770 1.1 cube { 771 1.1 cube struct ifnet *ifp; 772 1.1 cube int s; 773 1.1 cube 774 1.1 cube s = splnet(); 775 1.1 cube /* Let tap_start handle packets again */ 776 1.1 cube ifp = &sc->sc_ec.ec_if; 777 1.1 cube ifp->if_flags &= ~IFF_OACTIVE; 778 1.1 cube 779 1.1 cube /* Purge output queue */ 780 1.1 cube if (!(IFQ_IS_EMPTY(&ifp->if_snd))) { 781 1.1 cube struct mbuf *m; 782 1.1 cube 783 1.1 cube for (;;) { 784 1.1 cube IFQ_DEQUEUE(&ifp->if_snd, m); 785 1.1 cube if (m == NULL) 786 1.1 cube break; 787 1.1 cube 788 1.1 cube ifp->if_opackets++; 789 1.1 cube #if NBPFILTER > 0 790 1.1 cube if (ifp->if_bpf) 791 1.1 cube bpf_mtap(ifp->if_bpf, m); 792 1.1 cube #endif 793 1.1 cube } 794 1.1 cube } 795 1.1 cube splx(s); 796 1.1 cube 797 1.1 cube sc->sc_flags &= ~(TAP_INUSE | TAP_ASYNCIO); 798 1.1 cube 799 1.1 cube return (0); 800 1.1 cube } 801 1.1 cube 802 1.1 cube static int 803 1.1 cube tap_cdev_read(dev_t dev, struct uio *uio, int flags) 804 1.1 cube { 805 1.1 cube return tap_dev_read(minor(dev), uio, flags); 806 1.1 cube } 807 1.1 cube 808 1.1 cube static int 809 1.1 cube tap_fops_read(struct file *fp, off_t *offp, struct uio *uio, 810 1.1 cube struct ucred *cred, int flags) 811 1.1 cube { 812 1.1 cube return tap_dev_read((intptr_t)fp->f_data, uio, flags); 813 1.1 cube } 814 1.1 cube 815 1.1 cube static int 816 1.1 cube tap_dev_read(int unit, struct uio *uio, int flags) 817 1.1 cube { 818 1.1 cube struct tap_softc *sc = 819 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, unit); 820 1.1 cube struct ifnet *ifp; 821 1.1 cube struct mbuf *m, *n; 822 1.1 cube int error = 0, s; 823 1.1 cube 824 1.1 cube if (sc == NULL) 825 1.1 cube return (ENXIO); 826 1.1 cube 827 1.1 cube ifp = &sc->sc_ec.ec_if; 828 1.1 cube if ((ifp->if_flags & IFF_UP) == 0) 829 1.1 cube return (EHOSTDOWN); 830 1.1 cube 831 1.1 cube /* 832 1.1 cube * In the TAP_NBIO case, we have to make sure we won't be sleeping 833 1.1 cube */ 834 1.1 cube if ((sc->sc_flags & TAP_NBIO) && 835 1.1 cube lockstatus(&sc->sc_rdlock) == LK_EXCLUSIVE) 836 1.1 cube return (EWOULDBLOCK); 837 1.1 cube error = lockmgr(&sc->sc_rdlock, LK_EXCLUSIVE, NULL); 838 1.1 cube if (error != 0) 839 1.1 cube return (error); 840 1.1 cube 841 1.1 cube s = splnet(); 842 1.1 cube if (IFQ_IS_EMPTY(&ifp->if_snd)) { 843 1.1 cube ifp->if_flags &= ~IFF_OACTIVE; 844 1.1 cube splx(s); 845 1.1 cube /* 846 1.1 cube * We must release the lock before sleeping, and re-acquire it 847 1.1 cube * after. 848 1.1 cube */ 849 1.1 cube (void)lockmgr(&sc->sc_rdlock, LK_RELEASE, NULL); 850 1.1 cube if (sc->sc_flags & TAP_NBIO) 851 1.1 cube error = EWOULDBLOCK; 852 1.1 cube else 853 1.1 cube error = tsleep(sc, PSOCK|PCATCH, "tap", 0); 854 1.1 cube 855 1.1 cube if (error != 0) 856 1.1 cube return (error); 857 1.1 cube /* The device might have been downed */ 858 1.1 cube if ((ifp->if_flags & IFF_UP) == 0) 859 1.1 cube return (EHOSTDOWN); 860 1.1 cube if ((sc->sc_flags & TAP_NBIO) && 861 1.1 cube lockstatus(&sc->sc_rdlock) == LK_EXCLUSIVE) 862 1.1 cube return (EWOULDBLOCK); 863 1.1 cube error = lockmgr(&sc->sc_rdlock, LK_EXCLUSIVE, NULL); 864 1.1 cube if (error != 0) 865 1.1 cube return (error); 866 1.1 cube s = splnet(); 867 1.1 cube } 868 1.1 cube 869 1.1 cube IFQ_DEQUEUE(&ifp->if_snd, m); 870 1.1 cube ifp->if_flags &= ~IFF_OACTIVE; 871 1.1 cube splx(s); 872 1.1 cube if (m == NULL) { 873 1.1 cube error = 0; 874 1.1 cube goto out; 875 1.1 cube } 876 1.1 cube 877 1.1 cube ifp->if_opackets++; 878 1.1 cube #if NBPFILTER > 0 879 1.1 cube if (ifp->if_bpf) 880 1.1 cube bpf_mtap(ifp->if_bpf, m); 881 1.1 cube #endif 882 1.1 cube 883 1.1 cube /* 884 1.1 cube * One read is one packet. 885 1.1 cube */ 886 1.1 cube do { 887 1.1 cube error = uiomove(mtod(m, caddr_t), 888 1.1 cube min(m->m_len, uio->uio_resid), uio); 889 1.1 cube MFREE(m, n); 890 1.1 cube m = n; 891 1.1 cube } while (m != NULL && uio->uio_resid > 0 && error == 0); 892 1.1 cube 893 1.1 cube if (m != NULL) 894 1.1 cube m_freem(m); 895 1.1 cube 896 1.1 cube out: 897 1.1 cube (void)lockmgr(&sc->sc_rdlock, LK_RELEASE, NULL); 898 1.1 cube return (error); 899 1.1 cube } 900 1.1 cube 901 1.1 cube static int 902 1.1 cube tap_cdev_write(dev_t dev, struct uio *uio, int flags) 903 1.1 cube { 904 1.1 cube return tap_dev_write(minor(dev), uio, flags); 905 1.1 cube } 906 1.1 cube 907 1.1 cube static int 908 1.1 cube tap_fops_write(struct file *fp, off_t *offp, struct uio *uio, 909 1.1 cube struct ucred *cred, int flags) 910 1.1 cube { 911 1.1 cube return tap_dev_write((intptr_t)fp->f_data, uio, flags); 912 1.1 cube } 913 1.1 cube 914 1.1 cube static int 915 1.1 cube tap_dev_write(int unit, struct uio *uio, int flags) 916 1.1 cube { 917 1.1 cube struct tap_softc *sc = 918 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, unit); 919 1.1 cube struct ifnet *ifp; 920 1.1 cube struct mbuf *m, **mp; 921 1.1 cube int error = 0; 922 1.9 bouyer int s; 923 1.1 cube 924 1.1 cube if (sc == NULL) 925 1.1 cube return (ENXIO); 926 1.1 cube 927 1.1 cube ifp = &sc->sc_ec.ec_if; 928 1.1 cube 929 1.1 cube /* One write, one packet, that's the rule */ 930 1.1 cube MGETHDR(m, M_DONTWAIT, MT_DATA); 931 1.1 cube if (m == NULL) { 932 1.1 cube ifp->if_ierrors++; 933 1.1 cube return (ENOBUFS); 934 1.1 cube } 935 1.1 cube m->m_pkthdr.len = uio->uio_resid; 936 1.1 cube 937 1.1 cube mp = &m; 938 1.1 cube while (error == 0 && uio->uio_resid > 0) { 939 1.1 cube if (*mp != m) { 940 1.1 cube MGET(*mp, M_DONTWAIT, MT_DATA); 941 1.1 cube if (*mp == NULL) { 942 1.1 cube error = ENOBUFS; 943 1.1 cube break; 944 1.1 cube } 945 1.1 cube } 946 1.1 cube (*mp)->m_len = min(MHLEN, uio->uio_resid); 947 1.1 cube error = uiomove(mtod(*mp, caddr_t), (*mp)->m_len, uio); 948 1.1 cube mp = &(*mp)->m_next; 949 1.1 cube } 950 1.1 cube if (error) { 951 1.1 cube ifp->if_ierrors++; 952 1.1 cube m_freem(m); 953 1.1 cube return (error); 954 1.1 cube } 955 1.1 cube 956 1.1 cube ifp->if_ipackets++; 957 1.1 cube m->m_pkthdr.rcvif = ifp; 958 1.1 cube 959 1.1 cube #if NBPFILTER > 0 960 1.1 cube if (ifp->if_bpf) 961 1.1 cube bpf_mtap(ifp->if_bpf, m); 962 1.1 cube #endif 963 1.9 bouyer s =splnet(); 964 1.1 cube (*ifp->if_input)(ifp, m); 965 1.9 bouyer splx(s); 966 1.1 cube 967 1.1 cube return (0); 968 1.1 cube } 969 1.1 cube 970 1.1 cube static int 971 1.1 cube tap_cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int flags, 972 1.1 cube struct proc *p) 973 1.1 cube { 974 1.1 cube return tap_dev_ioctl(minor(dev), cmd, data, p); 975 1.1 cube } 976 1.1 cube 977 1.1 cube static int 978 1.1 cube tap_fops_ioctl(struct file *fp, u_long cmd, void *data, struct proc *p) 979 1.1 cube { 980 1.1 cube return tap_dev_ioctl((intptr_t)fp->f_data, cmd, (caddr_t)data, p); 981 1.1 cube } 982 1.1 cube 983 1.1 cube static int 984 1.1 cube tap_dev_ioctl(int unit, u_long cmd, caddr_t data, struct proc *p) 985 1.1 cube { 986 1.1 cube struct tap_softc *sc = 987 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, unit); 988 1.1 cube int error = 0; 989 1.1 cube 990 1.1 cube if (sc == NULL) 991 1.1 cube return (ENXIO); 992 1.1 cube 993 1.1 cube switch (cmd) { 994 1.1 cube case FIONREAD: 995 1.1 cube { 996 1.1 cube struct ifnet *ifp = &sc->sc_ec.ec_if; 997 1.1 cube struct mbuf *m; 998 1.1 cube int s; 999 1.1 cube 1000 1.1 cube s = splnet(); 1001 1.1 cube IFQ_POLL(&ifp->if_snd, m); 1002 1.1 cube 1003 1.1 cube if (m == NULL) 1004 1.1 cube *(int *)data = 0; 1005 1.1 cube else 1006 1.1 cube *(int *)data = m->m_pkthdr.len; 1007 1.1 cube splx(s); 1008 1.1 cube } break; 1009 1.1 cube case TIOCSPGRP: 1010 1.1 cube case FIOSETOWN: 1011 1.1 cube error = fsetown(p, &sc->sc_pgid, cmd, data); 1012 1.1 cube break; 1013 1.1 cube case TIOCGPGRP: 1014 1.1 cube case FIOGETOWN: 1015 1.1 cube error = fgetown(p, sc->sc_pgid, cmd, data); 1016 1.1 cube break; 1017 1.1 cube case FIOASYNC: 1018 1.1 cube if (*(int *)data) 1019 1.1 cube sc->sc_flags |= TAP_ASYNCIO; 1020 1.1 cube else 1021 1.1 cube sc->sc_flags &= ~TAP_ASYNCIO; 1022 1.1 cube break; 1023 1.1 cube case FIONBIO: 1024 1.1 cube if (*(int *)data) 1025 1.1 cube sc->sc_flags |= TAP_NBIO; 1026 1.1 cube else 1027 1.1 cube sc->sc_flags &= ~TAP_NBIO; 1028 1.1 cube break; 1029 1.1 cube case TAPGIFNAME: 1030 1.1 cube { 1031 1.1 cube struct ifreq *ifr = (struct ifreq *)data; 1032 1.1 cube struct ifnet *ifp = &sc->sc_ec.ec_if; 1033 1.1 cube 1034 1.1 cube strlcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ); 1035 1.1 cube } break; 1036 1.1 cube default: 1037 1.1 cube error = ENOTTY; 1038 1.1 cube break; 1039 1.1 cube } 1040 1.1 cube 1041 1.1 cube return (0); 1042 1.1 cube } 1043 1.1 cube 1044 1.1 cube static int 1045 1.1 cube tap_cdev_poll(dev_t dev, int events, struct proc *p) 1046 1.1 cube { 1047 1.1 cube return tap_dev_poll(minor(dev), events, p); 1048 1.1 cube } 1049 1.1 cube 1050 1.1 cube static int 1051 1.1 cube tap_fops_poll(struct file *fp, int events, struct proc *p) 1052 1.1 cube { 1053 1.1 cube return tap_dev_poll((intptr_t)fp->f_data, events, p); 1054 1.1 cube } 1055 1.1 cube 1056 1.1 cube static int 1057 1.1 cube tap_dev_poll(int unit, int events, struct proc *p) 1058 1.1 cube { 1059 1.1 cube struct tap_softc *sc = 1060 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, unit); 1061 1.1 cube int revents = 0; 1062 1.1 cube 1063 1.1 cube if (sc == NULL) 1064 1.1 cube return (ENXIO); 1065 1.1 cube 1066 1.1 cube if (events & (POLLIN|POLLRDNORM)) { 1067 1.1 cube struct ifnet *ifp = &sc->sc_ec.ec_if; 1068 1.1 cube struct mbuf *m; 1069 1.1 cube int s; 1070 1.1 cube 1071 1.1 cube s = splnet(); 1072 1.1 cube IFQ_POLL(&ifp->if_snd, m); 1073 1.1 cube splx(s); 1074 1.1 cube 1075 1.1 cube if (m != NULL) 1076 1.1 cube revents |= events & (POLLIN|POLLRDNORM); 1077 1.1 cube else { 1078 1.4 ragge simple_lock(&sc->sc_kqlock); 1079 1.1 cube selrecord(p, &sc->sc_rsel); 1080 1.1 cube simple_unlock(&sc->sc_kqlock); 1081 1.1 cube } 1082 1.1 cube } 1083 1.1 cube revents |= events & (POLLOUT|POLLWRNORM); 1084 1.1 cube 1085 1.1 cube return (revents); 1086 1.1 cube } 1087 1.1 cube 1088 1.1 cube static struct filterops tap_read_filterops = { 1, NULL, tap_kqdetach, 1089 1.1 cube tap_kqread }; 1090 1.1 cube static struct filterops tap_seltrue_filterops = { 1, NULL, tap_kqdetach, 1091 1.1 cube filt_seltrue }; 1092 1.1 cube 1093 1.1 cube static int 1094 1.1 cube tap_cdev_kqfilter(dev_t dev, struct knote *kn) 1095 1.1 cube { 1096 1.1 cube return tap_dev_kqfilter(minor(dev), kn); 1097 1.1 cube } 1098 1.1 cube 1099 1.1 cube static int 1100 1.1 cube tap_fops_kqfilter(struct file *fp, struct knote *kn) 1101 1.1 cube { 1102 1.1 cube return tap_dev_kqfilter((intptr_t)fp->f_data, kn); 1103 1.1 cube } 1104 1.1 cube 1105 1.1 cube static int 1106 1.1 cube tap_dev_kqfilter(int unit, struct knote *kn) 1107 1.1 cube { 1108 1.1 cube struct tap_softc *sc = 1109 1.1 cube (struct tap_softc *)device_lookup(&tap_cd, unit); 1110 1.1 cube 1111 1.1 cube if (sc == NULL) 1112 1.1 cube return (ENXIO); 1113 1.1 cube 1114 1.1 cube switch(kn->kn_filter) { 1115 1.1 cube case EVFILT_READ: 1116 1.1 cube kn->kn_fop = &tap_read_filterops; 1117 1.1 cube break; 1118 1.1 cube case EVFILT_WRITE: 1119 1.1 cube kn->kn_fop = &tap_seltrue_filterops; 1120 1.1 cube break; 1121 1.1 cube default: 1122 1.1 cube return (1); 1123 1.1 cube } 1124 1.1 cube 1125 1.1 cube kn->kn_hook = sc; 1126 1.4 ragge simple_lock(&sc->sc_kqlock); 1127 1.1 cube SLIST_INSERT_HEAD(&sc->sc_rsel.sel_klist, kn, kn_selnext); 1128 1.1 cube simple_unlock(&sc->sc_kqlock); 1129 1.1 cube return (0); 1130 1.1 cube } 1131 1.1 cube 1132 1.1 cube static void 1133 1.1 cube tap_kqdetach(struct knote *kn) 1134 1.1 cube { 1135 1.1 cube struct tap_softc *sc = (struct tap_softc *)kn->kn_hook; 1136 1.1 cube 1137 1.4 ragge simple_lock(&sc->sc_kqlock); 1138 1.1 cube SLIST_REMOVE(&sc->sc_rsel.sel_klist, kn, knote, kn_selnext); 1139 1.1 cube simple_unlock(&sc->sc_kqlock); 1140 1.1 cube } 1141 1.1 cube 1142 1.1 cube static int 1143 1.1 cube tap_kqread(struct knote *kn, long hint) 1144 1.1 cube { 1145 1.1 cube struct tap_softc *sc = (struct tap_softc *)kn->kn_hook; 1146 1.1 cube struct ifnet *ifp = &sc->sc_ec.ec_if; 1147 1.1 cube struct mbuf *m; 1148 1.1 cube int s; 1149 1.1 cube 1150 1.1 cube s = splnet(); 1151 1.1 cube IFQ_POLL(&ifp->if_snd, m); 1152 1.1 cube 1153 1.1 cube if (m == NULL) 1154 1.1 cube kn->kn_data = 0; 1155 1.1 cube else 1156 1.1 cube kn->kn_data = m->m_pkthdr.len; 1157 1.1 cube splx(s); 1158 1.1 cube return (kn->kn_data != 0 ? 1 : 0); 1159 1.1 cube } 1160 1.1 cube 1161 1.1 cube /* 1162 1.1 cube * sysctl management routines 1163 1.1 cube * You can set the address of an interface through: 1164 1.1 cube * net.link.tap.tap<number> 1165 1.1 cube * 1166 1.1 cube * Note the consistent use of tap_log in order to use 1167 1.1 cube * sysctl_teardown at unload time. 1168 1.1 cube * 1169 1.1 cube * In the kernel you will find a lot of SYSCTL_SETUP blocks. Those 1170 1.1 cube * blocks register a function in a special section of the kernel 1171 1.1 cube * (called a link set) which is used at init_sysctl() time to cycle 1172 1.1 cube * through all those functions to create the kernel's sysctl tree. 1173 1.1 cube * 1174 1.1 cube * It is not (currently) possible to use link sets in a LKM, so the 1175 1.1 cube * easiest is to simply call our own setup routine at load time. 1176 1.1 cube * 1177 1.1 cube * In the SYSCTL_SETUP blocks you find in the kernel, nodes have the 1178 1.1 cube * CTLFLAG_PERMANENT flag, meaning they cannot be removed. Once the 1179 1.1 cube * whole kernel sysctl tree is built, it is not possible to add any 1180 1.1 cube * permanent node. 1181 1.1 cube * 1182 1.1 cube * It should be noted that we're not saving the sysctlnode pointer 1183 1.1 cube * we are returned when creating the "tap" node. That structure 1184 1.1 cube * cannot be trusted once out of the calling function, as it might 1185 1.1 cube * get reused. So we just save the MIB number, and always give the 1186 1.1 cube * full path starting from the root for later calls to sysctl_createv 1187 1.1 cube * and sysctl_destroyv. 1188 1.1 cube */ 1189 1.1 cube SYSCTL_SETUP(sysctl_tap_setup, "sysctl net.link.tap subtree setup") 1190 1.1 cube { 1191 1.10 atatat const struct sysctlnode *node; 1192 1.1 cube int error = 0; 1193 1.1 cube 1194 1.1 cube if ((error = sysctl_createv(clog, 0, NULL, NULL, 1195 1.1 cube CTLFLAG_PERMANENT, 1196 1.1 cube CTLTYPE_NODE, "net", NULL, 1197 1.1 cube NULL, 0, NULL, 0, 1198 1.1 cube CTL_NET, CTL_EOL)) != 0) 1199 1.1 cube return; 1200 1.1 cube 1201 1.1 cube if ((error = sysctl_createv(clog, 0, NULL, NULL, 1202 1.1 cube CTLFLAG_PERMANENT, 1203 1.1 cube CTLTYPE_NODE, "link", NULL, 1204 1.1 cube NULL, 0, NULL, 0, 1205 1.3 cube CTL_NET, AF_LINK, CTL_EOL)) != 0) 1206 1.1 cube return; 1207 1.1 cube 1208 1.1 cube /* 1209 1.1 cube * The first four parameters of sysctl_createv are for management. 1210 1.1 cube * 1211 1.1 cube * The four that follows, here starting with a '0' for the flags, 1212 1.1 cube * describe the node. 1213 1.1 cube * 1214 1.1 cube * The next series of four set its value, through various possible 1215 1.1 cube * means. 1216 1.1 cube * 1217 1.1 cube * Last but not least, the path to the node is described. That path 1218 1.1 cube * is relative to the given root (third argument). Here we're 1219 1.1 cube * starting from the root. 1220 1.1 cube */ 1221 1.1 cube if ((error = sysctl_createv(clog, 0, NULL, &node, 1222 1.1 cube CTLFLAG_PERMANENT, 1223 1.1 cube CTLTYPE_NODE, "tap", NULL, 1224 1.1 cube NULL, 0, NULL, 0, 1225 1.3 cube CTL_NET, AF_LINK, CTL_CREATE, CTL_EOL)) != 0) 1226 1.1 cube return; 1227 1.1 cube tap_node = node->sysctl_num; 1228 1.1 cube } 1229 1.1 cube 1230 1.1 cube /* 1231 1.1 cube * The helper functions make Andrew Brown's interface really 1232 1.1 cube * shine. It makes possible to create value on the fly whether 1233 1.1 cube * the sysctl value is read or written. 1234 1.1 cube * 1235 1.1 cube * As shown as an example in the man page, the first step is to 1236 1.1 cube * create a copy of the node to have sysctl_lookup work on it. 1237 1.1 cube * 1238 1.1 cube * Here, we have more work to do than just a copy, since we have 1239 1.1 cube * to create the string. The first step is to collect the actual 1240 1.1 cube * value of the node, which is a convenient pointer to the softc 1241 1.1 cube * of the interface. From there we create the string and use it 1242 1.1 cube * as the value, but only for the *copy* of the node. 1243 1.1 cube * 1244 1.1 cube * Then we let sysctl_lookup do the magic, which consists in 1245 1.1 cube * setting oldp and newp as required by the operation. When the 1246 1.1 cube * value is read, that means that the string will be copied to 1247 1.1 cube * the user, and when it is written, the new value will be copied 1248 1.1 cube * over in the addr array. 1249 1.1 cube * 1250 1.1 cube * If newp is NULL, the user was reading the value, so we don't 1251 1.1 cube * have anything else to do. If a new value was written, we 1252 1.1 cube * have to check it. 1253 1.1 cube * 1254 1.1 cube * If it is incorrect, we can return an error and leave 'node' as 1255 1.1 cube * it is: since it is a copy of the actual node, the change will 1256 1.1 cube * be forgotten. 1257 1.1 cube * 1258 1.1 cube * Upon a correct input, we commit the change to the ifnet 1259 1.1 cube * structure of our interface. 1260 1.1 cube */ 1261 1.1 cube static int 1262 1.1 cube tap_sysctl_handler(SYSCTLFN_ARGS) 1263 1.1 cube { 1264 1.1 cube struct sysctlnode node; 1265 1.1 cube struct tap_softc *sc; 1266 1.1 cube struct ifnet *ifp; 1267 1.1 cube int error; 1268 1.1 cube size_t len; 1269 1.1 cube char addr[18]; 1270 1.1 cube 1271 1.1 cube node = *rnode; 1272 1.1 cube sc = node.sysctl_data; 1273 1.1 cube ifp = &sc->sc_ec.ec_if; 1274 1.1 cube (void)tap_ether_sprintf(addr, LLADDR(ifp->if_sadl)); 1275 1.1 cube node.sysctl_data = addr; 1276 1.1 cube error = sysctl_lookup(SYSCTLFN_CALL(&node)); 1277 1.1 cube if (error || newp == NULL) 1278 1.1 cube return (error); 1279 1.1 cube 1280 1.1 cube len = strlen(addr); 1281 1.1 cube if (len < 11 || len > 17) 1282 1.1 cube return (EINVAL); 1283 1.1 cube 1284 1.1 cube /* Commit change */ 1285 1.1 cube if (tap_ether_aton(LLADDR(ifp->if_sadl), addr) != 0) 1286 1.1 cube return (EINVAL); 1287 1.1 cube return (error); 1288 1.1 cube } 1289 1.1 cube 1290 1.1 cube /* 1291 1.1 cube * ether_aton implementation, not using a static buffer. 1292 1.1 cube */ 1293 1.1 cube static int 1294 1.1 cube tap_ether_aton(u_char *dest, char *str) 1295 1.1 cube { 1296 1.1 cube int i; 1297 1.1 cube char *cp = str; 1298 1.1 cube u_char val[6]; 1299 1.1 cube 1300 1.1 cube #define set_value \ 1301 1.1 cube if (*cp > '9' && *cp < 'a') \ 1302 1.1 cube *cp -= 'A' - 10; \ 1303 1.1 cube else if (*cp > '9') \ 1304 1.1 cube *cp -= 'a' - 10; \ 1305 1.1 cube else \ 1306 1.1 cube *cp -= '0' 1307 1.1 cube 1308 1.1 cube for (i = 0; i < 6; i++, cp++) { 1309 1.1 cube if (!isxdigit(*cp)) 1310 1.1 cube return (1); 1311 1.1 cube set_value; 1312 1.1 cube val[i] = *cp++; 1313 1.1 cube if (isxdigit(*cp)) { 1314 1.1 cube set_value; 1315 1.1 cube val[i] *= 16; 1316 1.1 cube val[i] += *cp++; 1317 1.1 cube } 1318 1.1 cube if (*cp == ':' || i == 5) 1319 1.1 cube continue; 1320 1.1 cube else 1321 1.1 cube return (1); 1322 1.1 cube } 1323 1.1 cube memcpy(dest, val, 6); 1324 1.1 cube return (0); 1325 1.1 cube } 1326 1.1 cube 1327 1.1 cube /* 1328 1.1 cube * ether_sprintf made thread-safer. 1329 1.1 cube * 1330 1.1 cube * Copied over from sys/net/if_ethersubr.c, with a change to avoid the use 1331 1.1 cube * of a static buffer. 1332 1.1 cube */ 1333 1.1 cube 1334 1.1 cube /* 1335 1.1 cube * Copyright (c) 1982, 1989, 1993 1336 1.1 cube * The Regents of the University of California. All rights reserved. 1337 1.1 cube * 1338 1.1 cube * Redistribution and use in source and binary forms, with or without 1339 1.1 cube * modification, are permitted provided that the following conditions 1340 1.1 cube * are met: 1341 1.1 cube * 1. Redistributions of source code must retain the above copyright 1342 1.1 cube * notice, this list of conditions and the following disclaimer. 1343 1.1 cube * 2. Redistributions in binary form must reproduce the above copyright 1344 1.1 cube * notice, this list of conditions and the following disclaimer in the 1345 1.1 cube * documentation and/or other materials provided with the distribution. 1346 1.1 cube * 3. Neither the name of the University nor the names of its contributors 1347 1.1 cube * may be used to endorse or promote products derived from this software 1348 1.1 cube * without specific prior written permission. 1349 1.1 cube * 1350 1.1 cube * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 1351 1.1 cube * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1352 1.1 cube * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1353 1.1 cube * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 1354 1.1 cube * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1355 1.1 cube * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 1356 1.1 cube * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 1357 1.1 cube * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 1358 1.1 cube * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 1359 1.1 cube * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 1360 1.1 cube * SUCH DAMAGE. 1361 1.1 cube * 1362 1.1 cube * @(#)if_ethersubr.c 8.2 (Berkeley) 4/4/96 1363 1.1 cube */ 1364 1.1 cube 1365 1.1 cube static char * 1366 1.1 cube tap_ether_sprintf(char *dest, const u_char *ap) 1367 1.1 cube { 1368 1.1 cube char *cp = dest; 1369 1.1 cube int i; 1370 1.1 cube 1371 1.1 cube for (i = 0; i < 6; i++) { 1372 1.8 christos *cp++ = hexdigits[*ap >> 4]; 1373 1.8 christos *cp++ = hexdigits[*ap++ & 0xf]; 1374 1.1 cube *cp++ = ':'; 1375 1.1 cube } 1376 1.1 cube *--cp = 0; 1377 1.1 cube return (dest); 1378 1.1 cube } 1379
Indexes created Mon Sep 22 05:09:51 GMT 2025