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