1/*
2 * Copyright (c) 2000-2020 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/*
29 * Copyright (c) 1982, 1986, 1993
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)if_loop.c 8.1 (Berkeley) 6/10/93
61 * $FreeBSD: src/sys/net/if_loop.c,v 1.47.2.5 2001/07/03 11:01:41 ume Exp $
62 */
63/*
64 * NOTICE: This file was modified by SPARTA, Inc. in 2006 to introduce
65 * support for mandatory and extensible security protections. This notice
66 * is included in support of clause 2.2 (b) of the Apple Public License,
67 * Version 2.0.
68 */
69
70/*
71 * Loopback interface driver for protocol testing and timing.
72 */
73#include "loop.h"
74#if NLOOP > 0
75
76#if NLOOP != 1
77#error "More than one loopback interface is not supported."
78#endif
79
80#include <sys/param.h>
81#include <sys/systm.h>
82#include <sys/kernel.h>
83#include <sys/mbuf.h>
84#include <sys/socket.h>
85#include <sys/sockio.h>
86#include <sys/mcache.h>
87#include <sys/sysctl.h>
88
89#include <net/if.h>
90#include <net/if_types.h>
91#include <net/route.h>
92#include <net/bpf.h>
93#include <sys/malloc.h>
94
95#if INET
96#include <netinet/in.h>
97#include <netinet/in_var.h>
98#endif
99
100#if !INET
101#include <netinet/in.h>
102#endif
103#include <netinet6/in6_var.h>
104#include <netinet/ip6.h>
105
106#include <net/dlil.h>
107#include <net/kpi_protocol.h>
108
109#include <pexpert/pexpert.h>
110
111#define LOMTU 16384
112#define LOSNDQ_MAXLEN 256
113
114#define LO_BPF_TAP_OUT(_m) { \
115 if (lo_statics[0].bpf_callback != NULL) { \
116 bpf_tap_out(lo_ifp, DLT_NULL, _m, \
117 &((struct loopback_header *)_m->m_pkthdr.pkt_hdr)-> \
118 protocol, sizeof (u_int32_t)); \
119 } \
120}
121
122#define LO_BPF_TAP_OUT_MULTI(_m) { \
123 if (lo_statics[0].bpf_callback != NULL) { \
124 struct mbuf *_n; \
125 for (_n = _m; _n != NULL; _n = _n->m_nextpkt) \
126 LO_BPF_TAP_OUT(_n); \
127 } \
128}
129
130struct lo_statics_str {
131 int bpf_mode;
132 bpf_packet_func bpf_callback;
133};
134
135static struct lo_statics_str lo_statics[NLOOP];
136static int lo_txstart = 0;
137
138struct ifnet *lo_ifp = NULL;
139
140struct loopback_header {
141 protocol_family_t protocol;
142};
143
144/* Local forward declerations */
145void loopattach(void);
146static errno_t lo_demux(struct ifnet *, struct mbuf *, char *,
147 protocol_family_t *);
148static errno_t
149lo_framer(struct ifnet *, struct mbuf **, const struct sockaddr *,
150 const char *, const char *, u_int32_t *, u_int32_t *);
151static errno_t lo_add_proto(struct ifnet *, protocol_family_t,
152 const struct ifnet_demux_desc *, u_int32_t);
153static errno_t lo_del_proto(struct ifnet *, protocol_family_t);
154static int lo_output(struct ifnet *, struct mbuf *);
155static errno_t lo_pre_enqueue(struct ifnet *, struct mbuf *);
156static void lo_start(struct ifnet *);
157static errno_t lo_pre_output(struct ifnet *, protocol_family_t, struct mbuf **,
158 const struct sockaddr *, void *, char *, char *);
159static errno_t lo_input(struct ifnet *, protocol_family_t, struct mbuf *);
160static void lo_rtrequest(int, struct rtentry *, struct sockaddr *);
161static errno_t lo_ioctl(struct ifnet *, u_long, void *);
162static errno_t lo_attach_proto(struct ifnet *, protocol_family_t);
163static void lo_reg_if_mods(void);
164static errno_t lo_set_bpf_tap(struct ifnet *, bpf_tap_mode, bpf_packet_func);
165static int sysctl_dequeue_max SYSCTL_HANDLER_ARGS;
166static int sysctl_sched_model SYSCTL_HANDLER_ARGS;
167static int sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS;
168
169SYSCTL_DECL(_net_link);
170
171SYSCTL_NODE(_net_link, OID_AUTO, loopback, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
172 "loopback interface");
173
174static u_int32_t lo_dequeue_max = LOSNDQ_MAXLEN;
175SYSCTL_PROC(_net_link_loopback, OID_AUTO, max_dequeue,
176 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_dequeue_max, LOSNDQ_MAXLEN,
177 sysctl_dequeue_max, "I", "Maximum number of packets dequeued at a time");
178
179static u_int32_t lo_sched_model = IFNET_SCHED_MODEL_NORMAL;
180SYSCTL_PROC(_net_link_loopback, OID_AUTO, sched_model,
181 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_sched_model,
182 IFNET_SCHED_MODEL_NORMAL, sysctl_sched_model, "I", "Scheduling model");
183
184static u_int32_t lo_dequeue_sc = MBUF_SC_BE;
185static int lo_dequeue_scidx = MBUF_SCIDX(MBUF_SC_BE);
186SYSCTL_PROC(_net_link_loopback, OID_AUTO, dequeue_sc,
187 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &lo_dequeue_scidx,
188 MBUF_SC_BE, sysctl_dequeue_scidx, "I", "Dequeue a specific SC index");
189
190static errno_t
191lo_demux(struct ifnet *ifp, struct mbuf *m, char *frame_header,
192 protocol_family_t *protocol_family)
193{
194#pragma unused(ifp, m)
195 struct loopback_header *header =
196 (struct loopback_header *)(void *)frame_header;
197
198 *protocol_family = header->protocol;
199
200 return 0;
201}
202
203static errno_t
204lo_framer(struct ifnet *ifp, struct mbuf **m, const struct sockaddr *dest,
205 const char *dest_linkaddr, const char *frame_type,
206 u_int32_t *prepend_len, u_int32_t *postpend_len)
207{
208#pragma unused(ifp, dest, dest_linkaddr)
209 struct loopback_header *header;
210
211 M_PREPEND(*m, sizeof(struct loopback_header), M_WAITOK, 1);
212 if (*m == NULL) {
213 /* Tell caller not to try to free passed-in mbuf */
214 return EJUSTRETURN;
215 }
216
217 if (prepend_len != NULL) {
218 *prepend_len = sizeof(struct loopback_header);
219 }
220 if (postpend_len != NULL) {
221 *postpend_len = 0;
222 }
223
224 header = mtod(*m, struct loopback_header *);
225 bcopy(src: frame_type, dst: &header->protocol, n: sizeof(u_int32_t));
226 return 0;
227}
228
229static errno_t
230lo_add_proto(struct ifnet *interface, protocol_family_t protocol_family,
231 const struct ifnet_demux_desc *demux_array, u_int32_t demux_count)
232{
233#pragma unused(interface, protocol_family, demux_array, demux_count)
234 return 0;
235}
236
237static errno_t
238lo_del_proto(struct ifnet *ifp, protocol_family_t protocol)
239{
240#pragma unused(ifp, protocol)
241 return 0;
242}
243
244static void
245lo_tx_compl(struct ifnet *ifp, struct mbuf *m)
246{
247 errno_t error;
248
249 if ((ifp->if_xflags & IFXF_TIMESTAMP_ENABLED) != 0) {
250 boolean_t requested;
251
252 error = mbuf_get_timestamp_requested(mbuf: m, requested: &requested);
253 if (requested) {
254 struct timespec now;
255 u_int64_t ts;
256
257 nanouptime(ts: &now);
258 net_timernsec(&now, &ts);
259
260 error = mbuf_set_timestamp(mbuf: m, ts, TRUE);
261 if (error != 0) {
262 printf("%s: mbuf_set_timestamp() failed %d\n",
263 __func__, error);
264 }
265 }
266 }
267 error = mbuf_set_status(mbuf: m, KERN_SUCCESS);
268 if (error != 0) {
269 printf("%s: mbuf_set_status() failed %d\n",
270 __func__, error);
271 }
272
273 ifnet_tx_compl(ifp, m);
274}
275
276/*
277 * Output callback.
278 *
279 * This routine is called only when lo_txstart is disabled.
280 */
281static int
282lo_output(struct ifnet *ifp, struct mbuf *m_list)
283{
284 struct mbuf *m, *m_tail = NULL;
285 struct ifnet_stat_increment_param s;
286 u_int32_t cnt = 0, len = 0;
287
288 bzero(s: &s, n: sizeof(s));
289
290 for (m = m_list; m; m = m->m_nextpkt) {
291 VERIFY(m->m_flags & M_PKTHDR);
292 cnt++;
293
294 /*
295 * Don't overwrite the rcvif field if it is in use.
296 * This is used to match multicast packets, sent looping
297 * back, with the appropriate group record on input.
298 */
299 if (m->m_pkthdr.rcvif == NULL) {
300 m->m_pkthdr.rcvif = ifp;
301 }
302
303 m->m_pkthdr.pkt_flags |= PKTF_LOOP;
304 m->m_pkthdr.pkt_hdr = mtod(m, char *);
305
306 /* loopback checksums are always OK */
307 m->m_pkthdr.csum_data = 0xffff;
308 m->m_pkthdr.csum_flags =
309 CSUM_DATA_VALID | CSUM_PSEUDO_HDR |
310 CSUM_IP_CHECKED | CSUM_IP_VALID;
311
312 m_adj(m, sizeof(struct loopback_header));
313 len += m->m_pkthdr.len;
314
315 LO_BPF_TAP_OUT(m);
316 if (m->m_nextpkt == NULL) {
317 m_tail = m;
318 }
319 lo_tx_compl(ifp, m);
320 }
321
322 s.packets_in = cnt;
323 s.packets_out = cnt;
324 s.bytes_in = len;
325 s.bytes_out = len;
326
327 return ifnet_input_extended(interface: ifp, first_packet: m_list, last_packet: m_tail, stats: &s);
328}
329
330/*
331 * Pre-enqueue callback.
332 *
333 * This routine is called only when lo_txstart is enabled.
334 */
335static errno_t
336lo_pre_enqueue(struct ifnet *ifp, struct mbuf *m0)
337{
338 struct mbuf *m = m0, *n;
339 int error = 0;
340
341 while (m != NULL) {
342 VERIFY(m->m_flags & M_PKTHDR);
343
344 n = m->m_nextpkt;
345 m->m_nextpkt = NULL;
346
347 /*
348 * Don't overwrite the rcvif field if it is in use.
349 * This is used to match multicast packets, sent looping
350 * back, with the appropriate group record on input.
351 */
352 if (m->m_pkthdr.rcvif == NULL) {
353 m->m_pkthdr.rcvif = ifp;
354 }
355
356 m->m_pkthdr.pkt_flags |= PKTF_LOOP;
357 m->m_pkthdr.pkt_hdr = mtod(m, char *);
358
359 /* loopback checksums are always OK */
360 m->m_pkthdr.csum_data = 0xffff;
361 m->m_pkthdr.csum_flags =
362 CSUM_DATA_VALID | CSUM_PSEUDO_HDR |
363 CSUM_IP_CHECKED | CSUM_IP_VALID;
364
365 m_adj(m, sizeof(struct loopback_header));
366
367 /*
368 * Let the callee free it in case of error,
369 * and perform any necessary accounting.
370 */
371 (void) ifnet_enqueue(interface: ifp, packet: m);
372
373 m = n;
374 }
375
376 return error;
377}
378
379/*
380 * Start output callback.
381 *
382 * This routine is invoked by the start worker thread; because we never call
383 * it directly, there is no need do deploy any serialization mechanism other
384 * than what's already used by the worker thread, i.e. this is already single
385 * threaded.
386 *
387 * This routine is called only when lo_txstart is enabled.
388 */
389static void
390lo_start(struct ifnet *ifp)
391{
392 struct ifnet_stat_increment_param s;
393
394 bzero(s: &s, n: sizeof(s));
395
396 for (;;) {
397 struct mbuf *m = NULL, *m_tail = NULL;
398 u_int32_t cnt, len = 0;
399
400 if (lo_sched_model == IFNET_SCHED_MODEL_NORMAL) {
401 if (ifnet_dequeue_multi(interface: ifp, max: lo_dequeue_max, first_packet: &m,
402 last_packet: &m_tail, cnt: &cnt, len: &len) != 0) {
403 break;
404 }
405 } else {
406 if (ifnet_dequeue_service_class_multi(interface: ifp,
407 sc: lo_dequeue_sc, max: lo_dequeue_max, first_packet: &m,
408 last_packet: &m_tail, cnt: &cnt, len: &len) != 0) {
409 break;
410 }
411 }
412
413 LO_BPF_TAP_OUT_MULTI(m);
414 lo_tx_compl(ifp, m);
415
416 /* stats are required for extended variant */
417 s.packets_in = cnt;
418 s.packets_out = cnt;
419 s.bytes_in = len;
420 s.bytes_out = len;
421
422 (void) ifnet_input_extended(interface: ifp, first_packet: m, last_packet: m_tail, stats: &s);
423 }
424}
425
426/*
427 * This is a common pre-output route used by INET and INET6. This could
428 * (should?) be split into separate pre-output routines for each protocol.
429 */
430static errno_t
431lo_pre_output(struct ifnet *ifp, protocol_family_t protocol_family,
432 struct mbuf **m, const struct sockaddr *dst, void *route, char *frame_type,
433 char *dst_addr)
434{
435#pragma unused(ifp, dst, dst_addr)
436 struct rtentry *rt = route;
437
438 VERIFY((*m)->m_flags & M_PKTHDR);
439
440 (*m)->m_flags |= M_LOOP;
441
442 if (rt != NULL) {
443 u_int32_t rt_flags = rt->rt_flags;
444 if (rt_flags & (RTF_REJECT | RTF_BLACKHOLE)) {
445 if (rt_flags & RTF_BLACKHOLE) {
446 m_freem(*m);
447 return EJUSTRETURN;
448 } else {
449 return (rt_flags & RTF_HOST) ?
450 EHOSTUNREACH : ENETUNREACH;
451 }
452 }
453 }
454
455 bcopy(src: &protocol_family, dst: frame_type, n: sizeof(protocol_family));
456
457 return 0;
458}
459
460/*
461 * lo_input - This should work for all attached protocols that use the
462 * ifq/schednetisr input mechanism.
463 */
464static errno_t
465lo_input(struct ifnet *ifp, protocol_family_t protocol_family, struct mbuf *m)
466{
467#pragma unused(ifp, protocol_family)
468
469 if ((ifp->if_xflags & IFXF_TIMESTAMP_ENABLED) != 0) {
470 errno_t error;
471 struct timespec now;
472 u_int64_t ts;
473
474 nanouptime(ts: &now);
475 net_timernsec(&now, &ts);
476
477 error = mbuf_set_timestamp(mbuf: m, ts, TRUE);
478 if (error != 0) {
479 printf("%s: mbuf_set_timestamp() failed %d\n",
480 __func__, error);
481 }
482 }
483
484 if (proto_input(protocol: protocol_family, packet: m) != 0) {
485 m_freem(m);
486 }
487 return 0;
488}
489
490/* ARGSUSED */
491static void
492lo_rtrequest(int cmd, struct rtentry *rt, struct sockaddr *sa)
493{
494#pragma unused(cmd, sa)
495 if (rt != NULL) {
496 RT_LOCK_ASSERT_HELD(rt);
497 rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; /* for ISO */
498 /*
499 * For optimal performance, the send and receive buffers
500 * should be at least twice the MTU plus a little more for
501 * overhead.
502 */
503 rt->rt_rmx.rmx_recvpipe = rt->rt_rmx.rmx_sendpipe = 3 * LOMTU;
504 }
505}
506
507/*
508 * Process an ioctl request.
509 */
510static errno_t
511lo_ioctl(struct ifnet *ifp, u_long cmd, void *data)
512{
513 int error = 0;
514
515 switch (cmd) {
516 case SIOCSIFADDR: { /* struct ifaddr pointer */
517 struct ifaddr *ifa = data;
518
519 ifnet_set_flags(interface: ifp, IFF_UP | IFF_RUNNING, IFF_UP | IFF_RUNNING);
520 IFA_LOCK_SPIN(ifa);
521 ifa->ifa_rtrequest = lo_rtrequest;
522 IFA_UNLOCK(ifa);
523 /*
524 * Everything else is done at a higher level.
525 */
526 break;
527 }
528
529 case SIOCADDMULTI: /* struct ifreq */
530 case SIOCDELMULTI: { /* struct ifreq */
531 struct ifreq *ifr = data;
532
533 if (ifr == NULL) {
534 error = EAFNOSUPPORT; /* XXX */
535 break;
536 }
537 switch (ifr->ifr_addr.sa_family) {
538#if INET
539 case AF_INET:
540 break;
541#endif
542 case AF_INET6:
543 break;
544
545 default:
546 error = EAFNOSUPPORT;
547 break;
548 }
549 break;
550 }
551
552 case SIOCSIFMTU: { /* struct ifreq */
553 struct ifreq *ifr = data;
554
555 bcopy(src: &ifr->ifr_mtu, dst: &ifp->if_mtu, n: sizeof(int));
556 break;
557 }
558
559 case SIOCSIFFLAGS: /* struct ifreq */
560 case SIOCSIFTIMESTAMPENABLE:
561 case SIOCSIFTIMESTAMPDISABLE:
562 break;
563
564 default:
565 error = EOPNOTSUPP;
566 break;
567 }
568 return error;
569}
570#endif /* NLOOP > 0 */
571
572
573static errno_t
574lo_attach_proto(struct ifnet *ifp, protocol_family_t protocol_family)
575{
576 struct ifnet_attach_proto_param_v2 proto;
577 errno_t result = 0;
578
579 bzero(s: &proto, n: sizeof(proto));
580 proto.input = lo_input;
581 proto.pre_output = lo_pre_output;
582
583 result = ifnet_attach_protocol_v2(interface: ifp, protocol_family, proto_details: &proto);
584
585 if (result && result != EEXIST) {
586 printf("lo_attach_proto: ifnet_attach_protocol for %u "
587 "returned=%d\n", protocol_family, result);
588 }
589
590 return result;
591}
592
593static void
594lo_reg_if_mods(void)
595{
596 int error;
597
598 /* Register protocol registration functions */
599 if ((error = proto_register_plumber(PF_INET,
600 APPLE_IF_FAM_LOOPBACK, plumb: lo_attach_proto, NULL)) != 0) {
601 printf("proto_register_plumber failed for AF_INET "
602 "error=%d\n", error);
603 }
604
605 if ((error = proto_register_plumber(PF_INET6,
606 APPLE_IF_FAM_LOOPBACK, plumb: lo_attach_proto, NULL)) != 0) {
607 printf("proto_register_plumber failed for AF_INET6 "
608 "error=%d\n", error);
609 }
610}
611
612static errno_t
613lo_set_bpf_tap(struct ifnet *ifp, bpf_tap_mode mode,
614 bpf_packet_func bpf_callback)
615{
616 VERIFY(ifp == lo_ifp);
617
618 lo_statics[0].bpf_mode = mode;
619
620 switch (mode) {
621 case BPF_TAP_DISABLE:
622 case BPF_TAP_INPUT:
623 lo_statics[0].bpf_callback = NULL;
624 break;
625
626 case BPF_TAP_OUTPUT:
627 case BPF_TAP_INPUT_OUTPUT:
628 lo_statics[0].bpf_callback = bpf_callback;
629 break;
630 }
631
632 return 0;
633}
634
635/* ARGSUSED */
636void
637loopattach(void)
638{
639 struct ifnet_init_eparams lo_init;
640 errno_t result = 0;
641
642 PE_parse_boot_argn(arg_string: "lo_txstart", arg_ptr: &lo_txstart, max_arg: sizeof(lo_txstart));
643
644 lo_reg_if_mods();
645
646 lo_statics[0].bpf_callback = NULL;
647 lo_statics[0].bpf_mode = BPF_TAP_DISABLE;
648
649 bzero(s: &lo_init, n: sizeof(lo_init));
650 lo_init.ver = IFNET_INIT_CURRENT_VERSION;
651 lo_init.len = sizeof(lo_init);
652 lo_init.sndq_maxlen = LOSNDQ_MAXLEN;
653 if (lo_txstart) {
654 lo_init.flags = 0;
655 lo_init.pre_enqueue = lo_pre_enqueue;
656 lo_init.start = lo_start;
657 lo_init.output_sched_model = lo_sched_model;
658 } else {
659 lo_init.flags = IFNET_INIT_LEGACY;
660 lo_init.output = lo_output;
661 }
662 lo_init.flags |= IFNET_INIT_NX_NOAUTO;
663 lo_init.name = "lo";
664 lo_init.unit = 0;
665 lo_init.family = IFNET_FAMILY_LOOPBACK;
666 lo_init.type = IFT_LOOP;
667 lo_init.demux = lo_demux;
668 lo_init.add_proto = lo_add_proto;
669 lo_init.del_proto = lo_del_proto;
670 lo_init.framer_extended = lo_framer;
671 lo_init.softc = &lo_statics[0];
672 lo_init.ioctl = lo_ioctl;
673 lo_init.set_bpf_tap = lo_set_bpf_tap;
674
675 result = ifnet_allocate_extended(init: &lo_init, interface: &lo_ifp);
676 if (result != 0) {
677 panic("%s: couldn't allocate loopback ifnet (%d)",
678 __func__, result);
679 /* NOTREACHED */
680 }
681
682 ifnet_set_mtu(interface: lo_ifp, LOMTU);
683 ifnet_set_flags(interface: lo_ifp, IFF_LOOPBACK | IFF_MULTICAST,
684 IFF_LOOPBACK | IFF_MULTICAST);
685 ifnet_set_offload(interface: lo_ifp,
686 offload: IFNET_CSUM_IP | IFNET_CSUM_TCP | IFNET_CSUM_UDP |
687 IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6 | IFNET_IPV6_FRAGMENT |
688 IFNET_CSUM_FRAGMENT | IFNET_IP_FRAGMENT | IFNET_MULTIPAGES |
689 IFNET_TX_STATUS | IFNET_SW_TIMESTAMP);
690 ifnet_set_hdrlen(interface: lo_ifp, hdrlen: sizeof(struct loopback_header));
691 ifnet_set_eflags(interface: lo_ifp, IFEF_SENDLIST, IFEF_SENDLIST);
692
693 result = ifnet_attach(interface: lo_ifp, NULL);
694 if (result != 0) {
695 panic("%s: couldn't attach loopback ifnet (%d)",
696 __func__, result);
697 /* NOTREACHED */
698 }
699 /*
700 * Disable ECN on loopback as ECN serves no purpose and otherwise
701 * TCP connections are subject to heuristics like SYN retransmits on RST
702 */
703 if_clear_eflags(lo_ifp, IFEF_ECN_ENABLE);
704 if_set_eflags(lo_ifp, IFEF_ECN_DISABLE);
705
706 bpfattach(interface: lo_ifp, DLT_NULL, header_length: sizeof(u_int32_t));
707}
708
709static int
710sysctl_dequeue_max SYSCTL_HANDLER_ARGS
711{
712#pragma unused(arg1, arg2)
713 u_int32_t i;
714 int err;
715
716 i = lo_dequeue_max;
717
718 err = sysctl_handle_int(oidp, arg1: &i, arg2: 0, req);
719 if (err != 0 || req->newptr == USER_ADDR_NULL) {
720 return err;
721 }
722
723 if (i < 1) {
724 i = 1;
725 } else if (i > LOSNDQ_MAXLEN) {
726 i = LOSNDQ_MAXLEN;
727 }
728
729 lo_dequeue_max = i;
730
731 return err;
732}
733
734static int
735sysctl_sched_model SYSCTL_HANDLER_ARGS
736{
737#pragma unused(arg1, arg2)
738 u_int32_t i;
739 int err;
740
741 i = lo_sched_model;
742
743 err = sysctl_handle_int(oidp, arg1: &i, arg2: 0, req);
744 if (err != 0 || req->newptr == USER_ADDR_NULL) {
745 return err;
746 }
747
748 switch (i) {
749 case IFNET_SCHED_MODEL_NORMAL:
750 case IFNET_SCHED_MODEL_DRIVER_MANAGED:
751 case IFNET_SCHED_MODEL_FQ_CODEL:
752 break;
753
754 default:
755 err = EINVAL;
756 break;
757 }
758
759 if (err == 0 && (err = ifnet_set_output_sched_model(interface: lo_ifp, model: i)) == 0) {
760 lo_sched_model = i;
761 }
762
763 return err;
764}
765
766static int
767sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS
768{
769#pragma unused(arg1, arg2)
770 u_int32_t i;
771 int err;
772
773 i = lo_dequeue_scidx;
774
775 err = sysctl_handle_int(oidp, arg1: &i, arg2: 0, req);
776 if (err != 0 || req->newptr == USER_ADDR_NULL) {
777 return err;
778 }
779
780 if (!MBUF_VALID_SCIDX(i)) {
781 return EINVAL;
782 }
783
784 if (lo_sched_model != IFNET_SCHED_MODEL_DRIVER_MANAGED) {
785 return ENODEV;
786 }
787
788 lo_dequeue_sc = m_service_class_from_idx(i);
789 lo_dequeue_scidx = MBUF_SCIDX(lo_dequeue_sc);
790
791 return err;
792}
793