bsd/net/if_loop.c

   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
 130 struct lo_statics_str {
 131         int             bpf_mode;
 132         bpf_packet_func bpf_callback;
 133 };
 134
 135 static struct lo_statics_str lo_statics[NLOOP];
 136 static int lo_txstart = 0;
 137
 138 struct ifnet *lo_ifp = NULL;
 139
 140 struct  loopback_header {
 141         protocol_family_t       protocol;
 142 };
 143
 144 /* Local forward declerations */
 145 void loopattach(void);
 146 static errno_t lo_demux(struct ifnet *, struct mbuf *, char *,
 147     protocol_family_t *);
 148 static errno_t
 149 lo_framer(struct ifnet *, struct mbuf **, const struct sockaddr *,
 150     const char *, const char *, u_int32_t *, u_int32_t *);
 151 static errno_t lo_add_proto(struct ifnet *, protocol_family_t,
 152     const struct ifnet_demux_desc *, u_int32_t);
 153 static errno_t lo_del_proto(struct ifnet *, protocol_family_t);
 154 static int lo_output(struct ifnet *, struct mbuf *);
 155 static errno_t lo_pre_enqueue(struct ifnet *, struct mbuf *);
 156 static void lo_start(struct ifnet *);
 157 static errno_t lo_pre_output(struct ifnet *, protocol_family_t, struct mbuf **,
 158     const struct sockaddr *, void *, char *, char *);
 159 static errno_t lo_input(struct ifnet *, protocol_family_t, struct mbuf *);
 160 static void lo_rtrequest(int, struct rtentry *, struct sockaddr *);
 161 static errno_t lo_ioctl(struct ifnet *, u_long, void *);
 162 static errno_t lo_attach_proto(struct ifnet *, protocol_family_t);
 163 static void lo_reg_if_mods(void);
 164 static errno_t lo_set_bpf_tap(struct ifnet *, bpf_tap_mode, bpf_packet_func);
 165 static int sysctl_dequeue_max SYSCTL_HANDLER_ARGS;
 166 static int sysctl_sched_model SYSCTL_HANDLER_ARGS;
 167 static int sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS;
 168
 169 SYSCTL_DECL(_net_link);
 170
 171 SYSCTL_NODE(_net_link, OID_AUTO, loopback, CTLFLAG_RW | CTLFLAG_LOCKED, 0,
 172     "loopback interface");
 173
 174 static u_int32_t lo_dequeue_max = LOSNDQ_MAXLEN;
 175 SYSCTL_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
 179 static u_int32_t lo_sched_model = IFNET_SCHED_MODEL_NORMAL;
 180 SYSCTL_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
 184 static u_int32_t lo_dequeue_sc = MBUF_SC_BE;
 185 static int lo_dequeue_scidx = MBUF_SCIDX(MBUF_SC_BE);
 186 SYSCTL_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
 190 static errno_t
 191 lo_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
 203 static errno_t
 204 lo_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(frame_type, &header->protocol, sizeof(u_int32_t));
 226         return 0;
 227 }
 228
 229 static errno_t
 230 lo_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
 237 static errno_t
 238 lo_del_proto(struct ifnet *ifp, protocol_family_t protocol)
 239 {
 240 #pragma unused(ifp, protocol)
 241         return 0;
 242 }
 243
 244 static void
 245 lo_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(m, &requested);
 253                 if (requested) {
 254                         struct timespec now;
 255                         u_int64_t ts;
 256
 257                         nanouptime(&now);
 258                         net_timernsec(&now, &ts);
 259
 260                         error = mbuf_set_timestamp(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(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  */
 281 static int
 282 lo_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, 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(ifp, m_list, m_tail, &s);
 328 }
 329
 330 /*
 331  * Pre-enqueue callback.
 332  *
 333  * This routine is called only when lo_txstart is enabled.
 334  */
 335 static errno_t
 336 lo_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(ifp, 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  */
 389 static void
 390 lo_start(struct ifnet *ifp)
 391 {
 392         struct ifnet_stat_increment_param s;
 393
 394         bzero(&s, 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(ifp, lo_dequeue_max, &m,
 402                             &m_tail, &cnt, &len) != 0) {
 403                                 break;
 404                         }
 405                 } else {
 406                         if (ifnet_dequeue_service_class_multi(ifp,
 407                             lo_dequeue_sc, lo_dequeue_max, &m,
 408                             &m_tail, &cnt, &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(ifp, m, m_tail, &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  */
 430 static errno_t
 431 lo_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(&protocol_family, frame_type, 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  */
 464 static errno_t
 465 lo_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(&now);
 475                 net_timernsec(&now, &ts);
 476
 477                 error = mbuf_set_timestamp(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_family, m) != 0) {
 485                 m_freem(m);
 486         }
 487         return 0;
 488 }
 489
 490 /* ARGSUSED */
 491 static void
 492 lo_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  */
 510 static errno_t
 511 lo_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(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(&ifr->ifr_mtu, &ifp->if_mtu, 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
 573 static errno_t
 574 lo_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(&proto, sizeof(proto));
 580         proto.input = lo_input;
 581         proto.pre_output = lo_pre_output;
 582
 583         result = ifnet_attach_protocol_v2(ifp, protocol_family, &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
 593 static void
 594 lo_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, 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, lo_attach_proto, NULL)) != 0) {
 607                 printf("proto_register_plumber failed for AF_INET6 "
 608                     "error=%d\n", error);
 609         }
 610 }
 611
 612 static errno_t
 613 lo_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 */
 636 void
 637 loopattach(void)
 638 {
 639         struct ifnet_init_eparams lo_init;
 640         errno_t result = 0;
 641
 642         PE_parse_boot_argn("lo_txstart", &lo_txstart, 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(&lo_init, 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(&lo_init, &lo_ifp);
 676         if (result != 0) {
 677                 panic("%s: couldn't allocate loopback ifnet (%d)\n",
 678                     __func__, result);
 679                 /* NOTREACHED */
 680         }
 681
 682         ifnet_set_mtu(lo_ifp, LOMTU);
 683         ifnet_set_flags(lo_ifp, IFF_LOOPBACK | IFF_MULTICAST,
 684             IFF_LOOPBACK | IFF_MULTICAST);
 685         ifnet_set_offload(lo_ifp,
 686             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(lo_ifp, sizeof(struct loopback_header));
 691         ifnet_set_eflags(lo_ifp, IFEF_SENDLIST, IFEF_SENDLIST);
 692
 693         result = ifnet_attach(lo_ifp, NULL);
 694         if (result != 0) {
 695                 panic("%s: couldn't attach loopback ifnet (%d)\n",
 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(lo_ifp, DLT_NULL, sizeof(u_int32_t));
 707 }
 708
 709 static int
 710 sysctl_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, &i, 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
 734 static int
 735 sysctl_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, &i, 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(lo_ifp, i)) == 0) {
 760                 lo_sched_model = i;
 761         }
 762
 763         return err;
 764 }
 765
 766 static int
 767 sysctl_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, &i, 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 }