2 * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
29 * Copyright (c) 1982, 1986, 1993
30 * The Regents of the University of California. All rights reserved.
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
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.
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
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 $
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,
71 * Loopback interface driver for protocol testing and timing.
77 #error "More than one loopback interface is not supported."
80 #include <sys/param.h>
81 #include <sys/systm.h>
82 #include <sys/kernel.h>
84 #include <sys/socket.h>
85 #include <sys/sockio.h>
86 #include <sys/mcache.h>
87 #include <sys/sysctl.h>
90 #include <net/if_types.h>
91 #include <net/route.h>
93 #include <sys/malloc.h>
96 #include <netinet/in.h>
97 #include <netinet/in_var.h>
102 #include <netinet/in.h>
104 #include <netinet6/in6_var.h>
105 #include <netinet/ip6.h>
108 #include <net/dlil.h>
109 #include <net/kpi_protocol.h>
112 #include <security/mac_framework.h>
115 #include <pexpert/pexpert.h>
118 #define LOSNDQ_MAXLEN 256
120 #define LO_BPF_TAP_OUT(_m) { \
121 if (lo_statics[0].bpf_callback != NULL) { \
122 bpf_tap_out(lo_ifp, DLT_NULL, _m, \
123 &((struct loopback_header *)_m->m_pkthdr.pkt_hdr)-> \
124 protocol, sizeof (u_int32_t)); \
128 #define LO_BPF_TAP_OUT_MULTI(_m) { \
129 if (lo_statics[0].bpf_callback != NULL) { \
131 for (_n = _m; _n != NULL; _n = _n->m_nextpkt) \
132 LO_BPF_TAP_OUT(_n); \
136 struct lo_statics_str
{
138 bpf_packet_func bpf_callback
;
141 static struct lo_statics_str lo_statics
[NLOOP
];
142 static int lo_txstart
= 0;
144 struct ifnet
*lo_ifp
= NULL
;
146 struct loopback_header
{
147 protocol_family_t protocol
;
150 /* Local forward declerations */
151 void loopattach(void);
152 static errno_t
lo_demux(struct ifnet
*, struct mbuf
*, char *,
153 protocol_family_t
*);
155 lo_framer(struct ifnet
*, struct mbuf
**, const struct sockaddr
*,
156 const char *, const char *, u_int32_t
*, u_int32_t
*);
157 static errno_t
lo_add_proto(struct ifnet
*, protocol_family_t
,
158 const struct ifnet_demux_desc
*, u_int32_t
);
159 static errno_t
lo_del_proto(struct ifnet
*, protocol_family_t
);
160 static int lo_output(struct ifnet
*, struct mbuf
*);
161 static errno_t
lo_pre_enqueue(struct ifnet
*, struct mbuf
*);
162 static void lo_start(struct ifnet
*);
163 static errno_t
lo_pre_output(struct ifnet
*, protocol_family_t
, struct mbuf
**,
164 const struct sockaddr
*, void *, char *, char *);
165 static errno_t
lo_input(struct ifnet
*, protocol_family_t
, struct mbuf
*);
166 static void lo_rtrequest(int, struct rtentry
*, struct sockaddr
*);
167 static errno_t
lo_ioctl(struct ifnet
*, u_long
, void *);
168 static errno_t
lo_attach_proto(struct ifnet
*, protocol_family_t
);
169 static void lo_reg_if_mods(void);
170 static errno_t
lo_set_bpf_tap(struct ifnet
*, bpf_tap_mode
, bpf_packet_func
);
171 static int sysctl_dequeue_max SYSCTL_HANDLER_ARGS
;
172 static int sysctl_sched_model SYSCTL_HANDLER_ARGS
;
173 static int sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS
;
175 SYSCTL_DECL(_net_link
);
177 SYSCTL_NODE(_net_link
, OID_AUTO
, loopback
, CTLFLAG_RW
| CTLFLAG_LOCKED
, 0,
178 "loopback interface");
180 static u_int32_t lo_dequeue_max
= LOSNDQ_MAXLEN
;
181 SYSCTL_PROC(_net_link_loopback
, OID_AUTO
, max_dequeue
,
182 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_LOCKED
, &lo_dequeue_max
, LOSNDQ_MAXLEN
,
183 sysctl_dequeue_max
, "I", "Maximum number of packets dequeued at a time");
185 static u_int32_t lo_sched_model
= IFNET_SCHED_MODEL_NORMAL
;
186 SYSCTL_PROC(_net_link_loopback
, OID_AUTO
, sched_model
,
187 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_LOCKED
, &lo_sched_model
,
188 IFNET_SCHED_MODEL_NORMAL
, sysctl_sched_model
, "I", "Scheduling model");
190 static u_int32_t lo_dequeue_sc
= MBUF_SC_BE
;
191 static int lo_dequeue_scidx
= MBUF_SCIDX(MBUF_SC_BE
);
192 SYSCTL_PROC(_net_link_loopback
, OID_AUTO
, dequeue_sc
,
193 CTLTYPE_INT
| CTLFLAG_RW
| CTLFLAG_LOCKED
, &lo_dequeue_scidx
,
194 MBUF_SC_BE
, sysctl_dequeue_scidx
, "I", "Dequeue a specific SC index");
197 lo_demux(struct ifnet
*ifp
, struct mbuf
*m
, char *frame_header
,
198 protocol_family_t
*protocol_family
)
200 #pragma unused(ifp, m)
201 struct loopback_header
*header
=
202 (struct loopback_header
*)(void *)frame_header
;
204 *protocol_family
= header
->protocol
;
210 lo_framer(struct ifnet
*ifp
, struct mbuf
**m
, const struct sockaddr
*dest
,
211 const char *dest_linkaddr
, const char *frame_type
,
212 u_int32_t
*prepend_len
, u_int32_t
*postpend_len
)
214 #pragma unused(ifp, dest, dest_linkaddr)
215 struct loopback_header
*header
;
217 M_PREPEND(*m
, sizeof (struct loopback_header
), M_WAITOK
, 1);
219 /* Tell caller not to try to free passed-in mbuf */
220 return (EJUSTRETURN
);
223 if (prepend_len
!= NULL
)
224 *prepend_len
= sizeof (struct loopback_header
);
225 if (postpend_len
!= NULL
)
228 header
= mtod(*m
, struct loopback_header
*);
229 bcopy(frame_type
, &header
->protocol
, sizeof (u_int32_t
));
234 lo_add_proto(struct ifnet
*interface
, protocol_family_t protocol_family
,
235 const struct ifnet_demux_desc
*demux_array
, u_int32_t demux_count
)
237 #pragma unused(interface, protocol_family, demux_array, demux_count)
242 lo_del_proto(struct ifnet
*ifp
, protocol_family_t protocol
)
244 #pragma unused(ifp, protocol)
249 lo_tx_compl(struct ifnet
*ifp
, struct mbuf
*m
)
253 if ((ifp
->if_xflags
& IFXF_TIMESTAMP_ENABLED
) != 0) {
256 error
= mbuf_get_timestamp_requested(m
, &requested
);
262 net_timernsec(&now
, &ts
);
264 error
= mbuf_set_timestamp(m
, ts
, TRUE
);
266 printf("%s: mbuf_set_timestamp() failed %d\n",
270 error
= mbuf_set_status(m
, KERN_SUCCESS
);
272 printf("%s: mbuf_set_status() failed %d\n",
275 ifnet_tx_compl(ifp
, m
);
281 * This routine is called only when lo_txstart is disabled.
284 lo_output(struct ifnet
*ifp
, struct mbuf
*m_list
)
286 struct mbuf
*m
, *m_tail
= NULL
;
287 struct ifnet_stat_increment_param s
;
288 u_int32_t cnt
= 0, len
= 0;
290 bzero(&s
, sizeof(s
));
292 for (m
= m_list
; m
; m
= m
->m_nextpkt
) {
293 VERIFY(m
->m_flags
& M_PKTHDR
);
295 len
+= m
->m_pkthdr
.len
;
298 * Don't overwrite the rcvif field if it is in use.
299 * This is used to match multicast packets, sent looping
300 * back, with the appropriate group record on input.
302 if (m
->m_pkthdr
.rcvif
== NULL
)
303 m
->m_pkthdr
.rcvif
= ifp
;
305 m
->m_pkthdr
.pkt_flags
|= PKTF_LOOP
;
306 m
->m_pkthdr
.pkt_hdr
= mtod(m
, char *);
308 /* loopback checksums are always OK */
309 m
->m_pkthdr
.csum_data
= 0xffff;
310 m
->m_pkthdr
.csum_flags
=
311 CSUM_DATA_VALID
| CSUM_PSEUDO_HDR
|
312 CSUM_IP_CHECKED
| CSUM_IP_VALID
;
314 m_adj(m
, sizeof (struct loopback_header
));
317 if (m
->m_nextpkt
== NULL
) {
328 return (ifnet_input_extended(ifp
, m_list
, m_tail
, &s
));
332 * Pre-enqueue callback.
334 * This routine is called only when lo_txstart is enabled.
337 lo_pre_enqueue(struct ifnet
*ifp
, struct mbuf
*m0
)
339 struct mbuf
*m
= m0
, *n
;
343 VERIFY(m
->m_flags
& M_PKTHDR
);
349 * Don't overwrite the rcvif field if it is in use.
350 * This is used to match multicast packets, sent looping
351 * back, with the appropriate group record on input.
353 if (m
->m_pkthdr
.rcvif
== NULL
)
354 m
->m_pkthdr
.rcvif
= ifp
;
356 m
->m_pkthdr
.pkt_flags
|= PKTF_LOOP
;
357 m
->m_pkthdr
.pkt_hdr
= mtod(m
, char *);
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
;
365 m_adj(m
, sizeof (struct loopback_header
));
368 * Let the callee free it in case of error,
369 * and perform any necessary accounting.
371 (void) ifnet_enqueue(ifp
, m
);
380 * Start output callback.
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
387 * This routine is called only when lo_txstart is enabled.
390 lo_start(struct ifnet
*ifp
)
392 struct ifnet_stat_increment_param s
;
394 bzero(&s
, sizeof (s
));
397 struct mbuf
*m
= NULL
, *m_tail
= NULL
;
398 u_int32_t cnt
, len
= 0;
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)
405 if (ifnet_dequeue_service_class_multi(ifp
,
406 lo_dequeue_sc
, lo_dequeue_max
, &m
,
407 &m_tail
, &cnt
, &len
) != 0)
411 LO_BPF_TAP_OUT_MULTI(m
);
414 /* stats are required for extended variant */
420 (void) ifnet_input_extended(ifp
, m
, m_tail
, &s
);
425 * This is a common pre-output route used by INET and INET6. This could
426 * (should?) be split into separate pre-output routines for each protocol.
429 lo_pre_output(struct ifnet
*ifp
, protocol_family_t protocol_family
,
430 struct mbuf
**m
, const struct sockaddr
*dst
, void *route
, char *frame_type
,
433 #pragma unused(ifp, dst, dst_addr)
434 struct rtentry
*rt
= route
;
436 VERIFY((*m
)->m_flags
& M_PKTHDR
);
438 (*m
)->m_flags
|= M_LOOP
;
441 u_int32_t rt_flags
= rt
->rt_flags
;
442 if (rt_flags
& (RTF_REJECT
| RTF_BLACKHOLE
)) {
443 if (rt_flags
& RTF_BLACKHOLE
) {
445 return (EJUSTRETURN
);
447 return ((rt_flags
& RTF_HOST
) ?
448 EHOSTUNREACH
: ENETUNREACH
);
453 bcopy(&protocol_family
, frame_type
, sizeof (protocol_family
));
459 * lo_input - This should work for all attached protocols that use the
460 * ifq/schednetisr input mechanism.
463 lo_input(struct ifnet
*ifp
, protocol_family_t protocol_family
, struct mbuf
*m
)
465 #pragma unused(ifp, protocol_family)
467 if ((ifp
->if_xflags
& IFXF_TIMESTAMP_ENABLED
) != 0) {
473 net_timernsec(&now
, &ts
);
475 error
= mbuf_set_timestamp(m
, ts
, TRUE
);
477 printf("%s: mbuf_set_timestamp() failed %d\n",
481 if (proto_input(protocol_family
, m
) != 0)
488 lo_rtrequest(int cmd
, struct rtentry
*rt
, struct sockaddr
*sa
)
490 #pragma unused(cmd, sa)
492 RT_LOCK_ASSERT_HELD(rt
);
493 rt
->rt_rmx
.rmx_mtu
= rt
->rt_ifp
->if_mtu
; /* for ISO */
495 * For optimal performance, the send and receive buffers
496 * should be at least twice the MTU plus a little more for
499 rt
->rt_rmx
.rmx_recvpipe
= rt
->rt_rmx
.rmx_sendpipe
= 3 * LOMTU
;
504 * Process an ioctl request.
507 lo_ioctl(struct ifnet
*ifp
, u_long cmd
, void *data
)
513 case SIOCSIFADDR
: { /* struct ifaddr pointer */
514 struct ifaddr
*ifa
= data
;
516 ifnet_set_flags(ifp
, IFF_UP
|IFF_RUNNING
, IFF_UP
|IFF_RUNNING
);
518 ifa
->ifa_rtrequest
= lo_rtrequest
;
521 * Everything else is done at a higher level.
526 case SIOCADDMULTI
: /* struct ifreq */
527 case SIOCDELMULTI
: { /* struct ifreq */
528 struct ifreq
*ifr
= data
;
531 error
= EAFNOSUPPORT
; /* XXX */
534 switch (ifr
->ifr_addr
.sa_family
) {
546 error
= EAFNOSUPPORT
;
552 case SIOCSIFMTU
: { /* struct ifreq */
553 struct ifreq
*ifr
= data
;
555 bcopy(&ifr
->ifr_mtu
, &ifp
->if_mtu
, sizeof (int));
559 case SIOCSIFFLAGS
: /* struct ifreq */
560 case SIOCSIFTIMESTAMPENABLE
:
561 case SIOCSIFTIMESTAMPDISABLE
:
570 #endif /* NLOOP > 0 */
574 lo_attach_proto(struct ifnet
*ifp
, protocol_family_t protocol_family
)
576 struct ifnet_attach_proto_param_v2 proto
;
579 bzero(&proto
, sizeof (proto
));
580 proto
.input
= lo_input
;
581 proto
.pre_output
= lo_pre_output
;
583 result
= ifnet_attach_protocol_v2(ifp
, protocol_family
, &proto
);
585 if (result
&& result
!= EEXIST
) {
586 printf("lo_attach_proto: ifnet_attach_protocol for %u "
587 "returned=%d\n", protocol_family
, result
);
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
);
604 if ((error
= proto_register_plumber(PF_INET6
,
605 APPLE_IF_FAM_LOOPBACK
, lo_attach_proto
, NULL
)) != 0)
606 printf("proto_register_plumber failed for AF_INET6 "
607 "error=%d\n", error
);
611 lo_set_bpf_tap(struct ifnet
*ifp
, bpf_tap_mode mode
,
612 bpf_packet_func bpf_callback
)
614 VERIFY(ifp
== lo_ifp
);
616 lo_statics
[0].bpf_mode
= mode
;
619 case BPF_TAP_DISABLE
:
621 lo_statics
[0].bpf_callback
= NULL
;
625 case BPF_TAP_INPUT_OUTPUT
:
626 lo_statics
[0].bpf_callback
= bpf_callback
;
637 struct ifnet_init_eparams lo_init
;
640 PE_parse_boot_argn("lo_txstart", &lo_txstart
, sizeof (lo_txstart
));
644 lo_statics
[0].bpf_callback
= NULL
;
645 lo_statics
[0].bpf_mode
= BPF_TAP_DISABLE
;
647 bzero(&lo_init
, sizeof (lo_init
));
648 lo_init
.ver
= IFNET_INIT_CURRENT_VERSION
;
649 lo_init
.len
= sizeof (lo_init
);
650 lo_init
.sndq_maxlen
= LOSNDQ_MAXLEN
;
653 lo_init
.pre_enqueue
= lo_pre_enqueue
;
654 lo_init
.start
= lo_start
;
655 lo_init
.output_sched_model
= lo_sched_model
;
657 lo_init
.flags
= IFNET_INIT_LEGACY
;
658 lo_init
.output
= lo_output
;
660 lo_init
.flags
|= IFNET_INIT_NX_NOAUTO
;
663 lo_init
.family
= IFNET_FAMILY_LOOPBACK
;
664 lo_init
.type
= IFT_LOOP
;
665 lo_init
.demux
= lo_demux
;
666 lo_init
.add_proto
= lo_add_proto
;
667 lo_init
.del_proto
= lo_del_proto
;
668 lo_init
.framer_extended
= lo_framer
;
669 lo_init
.softc
= &lo_statics
[0];
670 lo_init
.ioctl
= lo_ioctl
;
671 lo_init
.set_bpf_tap
= lo_set_bpf_tap
;
673 result
= ifnet_allocate_extended(&lo_init
, &lo_ifp
);
675 panic("%s: couldn't allocate loopback ifnet (%d)\n",
680 ifnet_set_mtu(lo_ifp
, LOMTU
);
681 ifnet_set_flags(lo_ifp
, IFF_LOOPBACK
| IFF_MULTICAST
,
682 IFF_LOOPBACK
| IFF_MULTICAST
);
683 ifnet_set_offload(lo_ifp
,
684 IFNET_CSUM_IP
| IFNET_CSUM_TCP
| IFNET_CSUM_UDP
|
685 IFNET_CSUM_TCPIPV6
| IFNET_CSUM_UDPIPV6
| IFNET_IPV6_FRAGMENT
|
686 IFNET_CSUM_FRAGMENT
| IFNET_IP_FRAGMENT
| IFNET_MULTIPAGES
|
687 IFNET_TX_STATUS
| IFNET_SW_TIMESTAMP
);
688 ifnet_set_hdrlen(lo_ifp
, sizeof (struct loopback_header
));
689 ifnet_set_eflags(lo_ifp
, IFEF_SENDLIST
, IFEF_SENDLIST
);
692 mac_ifnet_label_init(ifp
);
695 result
= ifnet_attach(lo_ifp
, NULL
);
697 panic("%s: couldn't attach loopback ifnet (%d)\n",
702 * Disable ECN on loopback as ECN serves no purpose and otherwise
703 * TCP connections are subject to heuristics like SYN retransmits on RST
705 lo_ifp
->if_eflags
&= ~IFEF_ECN_ENABLE
;
706 lo_ifp
->if_eflags
|= IFEF_ECN_DISABLE
;
708 bpfattach(lo_ifp
, DLT_NULL
, sizeof (u_int32_t
));
712 sysctl_dequeue_max SYSCTL_HANDLER_ARGS
714 #pragma unused(arg1, arg2)
720 err
= sysctl_handle_int(oidp
, &i
, 0, req
);
721 if (err
!= 0 || req
->newptr
== USER_ADDR_NULL
)
726 else if (i
> LOSNDQ_MAXLEN
)
735 sysctl_sched_model SYSCTL_HANDLER_ARGS
737 #pragma unused(arg1, arg2)
743 err
= sysctl_handle_int(oidp
, &i
, 0, req
);
744 if (err
!= 0 || req
->newptr
== USER_ADDR_NULL
)
748 case IFNET_SCHED_MODEL_NORMAL
:
749 case IFNET_SCHED_MODEL_DRIVER_MANAGED
:
750 case IFNET_SCHED_MODEL_FQ_CODEL
:
758 if (err
== 0 && (err
= ifnet_set_output_sched_model(lo_ifp
, i
)) == 0)
765 sysctl_dequeue_scidx SYSCTL_HANDLER_ARGS
767 #pragma unused(arg1, arg2)
771 i
= lo_dequeue_scidx
;
773 err
= sysctl_handle_int(oidp
, &i
, 0, req
);
774 if (err
!= 0 || req
->newptr
== USER_ADDR_NULL
)
777 if (!MBUF_VALID_SCIDX(i
))
780 if (lo_sched_model
!= IFNET_SCHED_MODEL_DRIVER_MANAGED
)
783 lo_dequeue_sc
= m_service_class_from_idx(i
);
784 lo_dequeue_scidx
= MBUF_SCIDX(lo_dequeue_sc
);