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