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
55static const char edscname[] = "edsc";
56
57/*
58 * Software configuration of an interface specific to this device type.
59 */
60struct 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 */
72VNET_DEFINE_STATIC(struct if_clone *, edsc_cloner);
73#define	V_edsc_cloner	VNET(edsc_cloner)
74static int	edsc_clone_create(struct if_clone *, int, caddr_t);
75static void	edsc_clone_destroy(struct ifnet *);
76
77/*
78 * Interface driver methods.
79 */
80static void	edsc_init(void *dummy);
81/* static void edsc_input(struct ifnet *ifp, struct mbuf *m); would be here */
82static int	edsc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
83static void	edsc_start(struct ifnet *ifp);
84
85/*
86 * We'll allocate softc instances from this.
87 */
88static		MALLOC_DEFINE(M_EDSC, edscname, "Ethernet discard interface");
89
90/*
91 * Create an interface instance.
92 */
93static int
94edsc_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 */
171static void
172edsc_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 */
192static void
193edsc_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 */
206static int
207edsc_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 */
251static void
252edsc_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
315static void
316vnet_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}
329VNET_SYSINIT(vnet_edsc_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
330    vnet_edsc_init, NULL);
331
332static void
333vnet_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}
342VNET_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 */
348static int
349edsc_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
366static moduledata_t edsc_mod = {
367	"if_edsc",			/* name */
368	edsc_modevent,			/* event handler */
369	NULL				/* additional data */
370};
371
372DECLARE_MODULE(if_edsc, edsc_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
373