1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1982, 1986, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following edsclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following edsclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE EDSCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /* 33 * Discard interface driver for protocol testing and timing. 34 * Mimics an Ethernet device so that VLANs can be attached to it etc. 35 */ 36 37 #include <sys/param.h> /* types, important constants */ 38 #include <sys/kernel.h> /* SYSINIT for load-time initializations */ 39 #include <sys/malloc.h> /* malloc(9) */ 40 #include <sys/module.h> /* module(9) */ 41 #include <sys/mbuf.h> /* mbuf(9) */ 42 #include <sys/socket.h> /* struct ifreq */ 43 #include <sys/sockio.h> /* socket ioctl's */ 44 /* #include <sys/systm.h> if you need printf(9) or other all-purpose globals */ 45 46 #include <net/bpf.h> /* bpf(9) */ 47 #include <net/ethernet.h> /* Ethernet related constants and types */ 48 #include <net/if.h> 49 #include <net/if_var.h> /* basic part of ifnet(9) */ 50 #include <net/if_private.h> 51 #include <net/if_clone.h> /* network interface cloning */ 52 #include <net/if_types.h> /* IFT_ETHER and friends */ 53 #include <net/vnet.h> 54 55 static const char edscname[] = "edsc"; 56 57 /* 58 * Software configuration of an interface specific to this device type. 59 */ 60 struct edsc_softc { 61 struct ifnet *sc_ifp; /* ptr to generic interface configuration */ 62 63 /* 64 * A non-null driver can keep various things here, for instance, 65 * the hardware revision, cached values of write-only registers, etc. 66 */ 67 }; 68 69 /* 70 * Attach to the interface cloning framework. 71 */ 72 VNET_DEFINE_STATIC(struct if_clone *, edsc_cloner); 73 #define V_edsc_cloner VNET(edsc_cloner) 74 static int edsc_clone_create(struct if_clone *, int, caddr_t); 75 static void edsc_clone_destroy(struct ifnet *); 76 77 /* 78 * Interface driver methods. 79 */ 80 static void edsc_init(void *dummy); 81 /* static void edsc_input(struct ifnet *ifp, struct mbuf *m); would be here */ 82 static int edsc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data); 83 static void edsc_start(struct ifnet *ifp); 84 85 /* 86 * We'll allocate softc instances from this. 87 */ 88 static MALLOC_DEFINE(M_EDSC, edscname, "Ethernet discard interface"); 89 90 /* 91 * Create an interface instance. 92 */ 93 static int 94 edsc_clone_create(struct if_clone *ifc, int unit, caddr_t params) 95 { 96 struct edsc_softc *sc; 97 struct ifnet *ifp; 98 struct ether_addr eaddr; 99 100 /* 101 * Allocate soft and ifnet structures. Link each to the other. 102 */ 103 sc = malloc(sizeof(struct edsc_softc), M_EDSC, M_WAITOK | M_ZERO); 104 ifp = sc->sc_ifp = if_alloc(IFT_ETHER); 105 if (ifp == NULL) { 106 free(sc, M_EDSC); 107 return (ENOSPC); 108 } 109 110 ifp->if_softc = sc; 111 112 /* 113 * Get a name for this particular interface in its ifnet structure. 114 */ 115 if_initname(ifp, edscname, unit); 116 117 /* 118 * Typical Ethernet interface flags: we can do broadcast and 119 * multicast but can't hear our own broadcasts or multicasts. 120 */ 121 ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX; 122 123 /* 124 * We can pretent we have the whole set of hardware features 125 * because we just discard all packets we get from the upper layer. 126 * However, the features are disabled initially. They can be 127 * enabled via edsc_ioctl() when needed. 128 */ 129 ifp->if_capabilities = 130 IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM | 131 IFCAP_HWCSUM | IFCAP_TSO | 132 IFCAP_JUMBO_MTU; 133 ifp->if_capenable = 0; 134 135 /* 136 * Set the interface driver methods. 137 */ 138 ifp->if_init = edsc_init; 139 /* ifp->if_input = edsc_input; */ 140 ifp->if_ioctl = edsc_ioctl; 141 ifp->if_start = edsc_start; 142 143 /* 144 * Set the maximum output queue length from the global parameter. 145 */ 146 ifp->if_snd.ifq_maxlen = ifqmaxlen; 147 148 /* 149 * Generate an arbitrary MAC address for the cloned interface. 150 */ 151 ether_gen_addr(ifp, &eaddr); 152 153 /* 154 * Do ifnet initializations common to all Ethernet drivers 155 * and attach to the network interface framework. 156 */ 157 ether_ifattach(ifp, eaddr.octet); 158 159 /* 160 * Now we can mark the interface as running, i.e., ready 161 * for operation. 162 */ 163 ifp->if_drv_flags |= IFF_DRV_RUNNING; 164 165 return (0); 166 } 167 168 /* 169 * Destroy an interface instance. 170 */ 171 static void 172 edsc_clone_destroy(struct ifnet *ifp) 173 { 174 struct edsc_softc *sc = ifp->if_softc; 175 176 /* 177 * Detach from the network interface framework. 178 */ 179 ether_ifdetach(ifp); 180 181 /* 182 * Free memory occupied by ifnet and softc. 183 */ 184 if_free(ifp); 185 free(sc, M_EDSC); 186 } 187 188 /* 189 * This method is invoked from ether_ioctl() when it's time 190 * to bring up the hardware. 191 */ 192 static void 193 edsc_init(void *dummy) 194 { 195 #if 0 /* what a hardware driver would do here... */ 196 struct edsc_soft *sc = (struct edsc_softc *)dummy; 197 struct ifnet *ifp = sc->sc_ifp; 198 199 /* blah-blah-blah */ 200 #endif 201 } 202 203 /* 204 * Network interfaces are controlled via the ioctl(2) syscall. 205 */ 206 static int 207 edsc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 208 { 209 struct ifreq *ifr = (struct ifreq *)data; 210 211 switch (cmd) { 212 case SIOCSIFCAP: 213 #if 1 214 /* 215 * Just turn on any capabilities requested. 216 * The generic ifioctl() function has already made sure 217 * that they are supported, i.e., set in if_capabilities. 218 */ 219 ifp->if_capenable = ifr->ifr_reqcap; 220 #else 221 /* 222 * A h/w driver would need to analyze the requested 223 * bits and program the hardware, e.g.: 224 */ 225 mask = ifp->if_capenable ^ ifr->ifr_reqcap; 226 227 if (mask & IFCAP_VLAN_HWTAGGING) { 228 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING; 229 230 if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) 231 /* blah-blah-blah */ 232 else 233 /* etc-etc-etc */ 234 } 235 #endif 236 break; 237 238 default: 239 /* 240 * Offload the rest onto the common Ethernet handler. 241 */ 242 return (ether_ioctl(ifp, cmd, data)); 243 } 244 245 return (0); 246 } 247 248 /* 249 * Process the output queue. 250 */ 251 static void 252 edsc_start(struct ifnet *ifp) 253 { 254 struct mbuf *m; 255 256 /* 257 * A hardware interface driver can set IFF_DRV_OACTIVE 258 * in ifp->if_drv_flags: 259 * 260 * ifp->if_drv_flags |= IFF_DRV_OACTIVE; 261 * 262 * to prevent if_start from being invoked again while the 263 * transmission is under way. The flag is to protect the 264 * device's transmitter, not the method itself. The output 265 * queue is locked and several threads can process it in 266 * parallel safely, so the driver can use other means to 267 * serialize access to the transmitter. 268 * 269 * If using IFF_DRV_OACTIVE, the driver should clear the flag 270 * not earlier than the current transmission is complete, e.g., 271 * upon an interrupt from the device, not just before returning 272 * from if_start. This method merely starts the transmission, 273 * which may proceed asynchronously. 274 */ 275 276 /* 277 * We loop getting packets from the queue until it's empty. 278 * A h/w driver would loop until the device can accept more 279 * data into its buffer, or while there are free transmit 280 * descriptors, or whatever. 281 */ 282 for (;;) { 283 /* 284 * Try to dequeue one packet. Stop if the queue is empty. 285 * Use IF_DEQUEUE() here if ALTQ(9) support is unneeded. 286 */ 287 IFQ_DEQUEUE(&ifp->if_snd, m); 288 if (m == NULL) 289 break; 290 291 /* 292 * Let bpf(9) at the packet. 293 */ 294 BPF_MTAP(ifp, m); 295 296 /* 297 * Update the interface counters. 298 */ 299 if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len); 300 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 301 302 /* 303 * Finally, just drop the packet. 304 * TODO: Reply to ARP requests unless IFF_NOARP is set. 305 */ 306 m_freem(m); 307 } 308 309 /* 310 * ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 311 * would be here only if the transmission were synchronous. 312 */ 313 } 314 315 static void 316 vnet_edsc_init(const void *unused __unused) 317 { 318 319 /* 320 * Connect to the network interface cloning framework. 321 * The last argument is the number of units to be created 322 * from the outset. It's also the minimum number of units 323 * allowed. We don't want any units created as soon as the 324 * driver is loaded. 325 */ 326 V_edsc_cloner = if_clone_simple(edscname, edsc_clone_create, 327 edsc_clone_destroy, 0); 328 } 329 VNET_SYSINIT(vnet_edsc_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 330 vnet_edsc_init, NULL); 331 332 static void 333 vnet_edsc_uninit(const void *unused __unused) 334 { 335 336 /* 337 * Disconnect from the cloning framework. 338 * Existing interfaces will be disposed of properly. 339 */ 340 if_clone_detach(V_edsc_cloner); 341 } 342 VNET_SYSUNINIT(vnet_edsc_uninit, SI_SUB_INIT_IF, SI_ORDER_ANY, 343 vnet_edsc_uninit, NULL); 344 345 /* 346 * This function provides handlers for module events, namely load and unload. 347 */ 348 static int 349 edsc_modevent(module_t mod, int type, void *data) 350 { 351 352 switch (type) { 353 case MOD_LOAD: 354 case MOD_UNLOAD: 355 break; 356 default: 357 /* 358 * There are other event types, but we don't handle them. 359 * See module(9). 360 */ 361 return (EOPNOTSUPP); 362 } 363 return (0); 364 } 365 366 static moduledata_t edsc_mod = { 367 "if_edsc", /* name */ 368 edsc_modevent, /* event handler */ 369 NULL /* additional data */ 370 }; 371 372 DECLARE_MODULE(if_edsc, edsc_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 373