FreeBSD/Linux Kernel Cross Reference
sys/net/if_edsc.c
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 * 4. 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: releng/11.1/sys/net/if_edsc.c 302054 2016-06-21 13:48:49Z bz $
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);
Cache object: bdd70182b0261b5ba230c45b5898d811
|