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