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