--- /dev/null
+/*
+ * Copyright (c) 2009-2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/types.h>
+#include <sys/filedesc.h>
+#include <sys/file_internal.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/errno.h>
+#include <sys/protosw.h>
+#include <sys/domain.h>
+#include <sys/mbuf.h>
+#include <sys/queue.h>
+
+#include <net/if.h>
+#include <net/route.h>
+
+#include <netinet/in.h>
+#include <netinet/in_var.h>
+#include <netinet/in_pcb.h>
+#include <netinet/ip.h>
+#include <netinet/ip_var.h>
+#include <netinet/ip6.h>
+#include <netinet6/ip6_var.h>
+#include <netinet/udp.h>
+#include <netinet/udp_var.h>
+#include <netinet/tcp.h>
+#include <netinet/tcp_var.h>
+#include <netinet/tcp_cc.h>
+
+extern char *proc_name_address(void *p);
+
+static int tfp_count = 0;
+
+static TAILQ_HEAD(, tclass_for_proc) tfp_head = TAILQ_HEAD_INITIALIZER(tfp_head);
+
+struct tclass_for_proc {
+ TAILQ_ENTRY(tclass_for_proc) tfp_link;
+ int tfp_class;
+ pid_t tfp_pid;
+ char tfp_pname[MAXCOMLEN + 1];
+};
+
+extern void tcp_set_background_cc(struct socket *);
+extern void tcp_set_foreground_cc(struct socket *);
+
+int dscp_code_from_mbuf_tclass(int );
+
+static int get_pid_tclass(pid_t , int *);
+static int get_pname_tclass(const char * , int *);
+static int set_pid_tclass(pid_t , int );
+static int set_pname_tclass(const char * , int );
+static int purge_tclass_for_proc(void);
+static int flush_tclass_for_proc(void);
+
+
+static lck_grp_attr_t *tclass_lck_grp_attr = NULL; /* mutex group attributes */
+static lck_grp_t *tclass_lck_grp = NULL; /* mutex group definition */
+static lck_attr_t *tclass_lck_attr = NULL; /* mutex attributes */
+static lck_mtx_t *tclass_lock = NULL;
+
+/*
+ * Must be called with tclass_lock held
+ */
+static struct tclass_for_proc *
+find_tfp_by_pid(pid_t pid)
+{
+ struct tclass_for_proc *tfp;
+
+ TAILQ_FOREACH(tfp, &tfp_head, tfp_link) {
+ if (tfp->tfp_pid == pid)
+ break;
+ }
+ return tfp;
+}
+
+/*
+ * Must be called with tclass_lock held
+ */
+static struct tclass_for_proc *
+find_tfp_by_pname(const char *pname)
+{
+ struct tclass_for_proc *tfp;
+
+ TAILQ_FOREACH(tfp, &tfp_head, tfp_link) {
+ if (strncmp(pname, tfp->tfp_pname, sizeof(tfp->tfp_pname)) == 0)
+ break;
+ }
+ return tfp;
+}
+
+static int
+get_tclass_for_curr_proc(void)
+{
+ struct tclass_for_proc *tfp;
+ int sotc = SO_TC_BE;
+ proc_t p = current_proc(); /* Not ref counted */
+ pid_t pid = proc_pid(p);
+ char *pname = proc_name_address(p);
+
+ lck_mtx_lock(tclass_lock);
+
+ TAILQ_FOREACH(tfp, &tfp_head, tfp_link) {
+ if ((tfp->tfp_pid == pid) ||
+ (tfp->tfp_pid == -1 && strncmp(pname, tfp->tfp_pname, sizeof(tfp->tfp_pname)) == 0)) {
+ sotc = tfp->tfp_class;
+ break;
+ }
+ }
+
+ lck_mtx_unlock(tclass_lock);
+
+ return sotc;
+}
+
+/*
+ * Purge entries with PIDs of exited processes
+ */
+int
+purge_tclass_for_proc(void)
+{
+ int error = 0;
+ struct tclass_for_proc *tfp, *tvar;
+
+ lck_mtx_lock(tclass_lock);
+
+ TAILQ_FOREACH_SAFE(tfp, &tfp_head, tfp_link, tvar) {
+ proc_t p;
+
+ if (tfp->tfp_pid == -1)
+ continue;
+ if ((p = proc_find(tfp->tfp_pid)) == NULL) {
+ tfp_count--;
+ TAILQ_REMOVE(&tfp_head, tfp, tfp_link);
+
+ _FREE(tfp, M_TEMP);
+ } else {
+ proc_rele(p);
+ }
+ }
+
+ lck_mtx_unlock(tclass_lock);
+
+ return error;
+}
+
+/*
+ * Remove one entry
+ * Must be called with tclass_lock held
+ */
+static void
+free_tclass_for_proc(struct tclass_for_proc *tfp)
+{
+ if (tfp == NULL)
+ return;
+ tfp_count--;
+ TAILQ_REMOVE(&tfp_head, tfp, tfp_link);
+ _FREE(tfp, M_TEMP);
+}
+
+/*
+ * Remove all entries
+ */
+int
+flush_tclass_for_proc(void)
+{
+ int error = 0;
+ struct tclass_for_proc *tfp, *tvar;
+
+ lck_mtx_lock(tclass_lock);
+
+ TAILQ_FOREACH_SAFE(tfp, &tfp_head, tfp_link, tvar) {
+ free_tclass_for_proc(tfp);
+ }
+
+ lck_mtx_unlock(tclass_lock);
+
+ return error;
+
+}
+
+/*
+ * Must be called with tclass_lock held
+ */
+static struct tclass_for_proc *
+alloc_tclass_for_proc(pid_t pid, const char *pname, int tclass)
+{
+ struct tclass_for_proc *tfp;
+
+ if (pid == -1 && pname == NULL)
+ return NULL;
+
+ tfp = _MALLOC(sizeof(struct tclass_for_proc), M_TEMP, M_NOWAIT | M_ZERO);
+ if (tfp == NULL)
+ return NULL;
+
+ tfp->tfp_pid = pid;
+ tfp->tfp_class = tclass;
+ /*
+ * Add per pid entries before per proc name so we can find
+ * a specific instance of a process before the general name base entry.
+ */
+ if (pid != -1) {
+ TAILQ_INSERT_HEAD(&tfp_head, tfp, tfp_link);
+ } else {
+ strlcpy(tfp->tfp_pname, pname, sizeof(tfp->tfp_pname));
+ TAILQ_INSERT_TAIL(&tfp_head, tfp, tfp_link);
+ }
+
+ tfp_count++;
+
+ return tfp;
+}
+
+/*
+ * -1 for tclass means to remove the entry
+ */
+int
+set_pid_tclass(pid_t pid, int tclass)
+{
+ int error = EINVAL;
+ proc_t p = NULL;
+ struct filedesc *fdp;
+ struct fileproc *fp;
+ struct tclass_for_proc *tfp;
+ int i;
+
+ p = proc_find(pid);
+ if (p == NULL) {
+ printf("set_pid_tclass proc_find(%d) \n", pid);
+ goto done;
+ }
+
+ /* Need a tfp */
+ lck_mtx_lock(tclass_lock);
+
+ tfp = find_tfp_by_pid(pid);
+ if (tclass == -1) {
+ if (tfp != NULL) {
+ free_tclass_for_proc(tfp);
+ error = 0;
+ }
+ lck_mtx_unlock(tclass_lock);
+ goto done;
+ } else {
+ if (tfp == NULL) {
+ tfp = alloc_tclass_for_proc(pid, NULL, tclass);
+ if (tfp == NULL) {
+ lck_mtx_unlock(tclass_lock);
+ error = ENOBUFS;
+ goto done;
+ }
+ } else {
+ tfp->tfp_class = tclass;
+ }
+ }
+ lck_mtx_unlock(tclass_lock);
+
+ if (tfp != NULL) {
+ proc_fdlock(p);
+
+ fdp = p->p_fd;
+ for (i = 0; i < fdp->fd_nfiles; i++) {
+ struct socket *so;
+
+ fp = fdp->fd_ofiles[i];
+ if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0 ||
+ fp->f_fglob->fg_type != DTYPE_SOCKET)
+ continue;
+
+ so = (struct socket *)fp->f_fglob->fg_data;
+ if (so->so_proto->pr_domain->dom_family != AF_INET &&
+ so->so_proto->pr_domain->dom_family != AF_INET6)
+ continue;
+ socket_lock(so, 1);
+ error = so_set_traffic_class(so, tclass != -1 ? tclass : SO_TC_BE);
+ socket_unlock(so, 1);
+ if (error != 0) {
+ printf("set_pid_tclass so_set_traffic_class(%p, %d) failed %d\n", so, tclass, error);
+ error = 0;
+ }
+ }
+
+ proc_fdunlock(p);
+ }
+
+ error = 0;
+done:
+ if (p != NULL)
+ proc_rele(p);
+
+ return error;
+}
+
+int
+set_pname_tclass(const char *pname, int tclass)
+{
+ int error = EINVAL;
+ struct tclass_for_proc *tfp;
+
+ lck_mtx_lock(tclass_lock);
+
+ tfp = find_tfp_by_pname(pname);
+ if (tclass == -1) {
+ if (tfp != NULL)
+ free_tclass_for_proc(tfp);
+ } else {
+ if (tfp == NULL) {
+ tfp = alloc_tclass_for_proc(-1, pname, tclass);
+ if (tfp == NULL) {
+ lck_mtx_unlock(tclass_lock);
+ error = ENOBUFS;
+ goto done;
+ }
+ } else {
+ tfp->tfp_class = tclass;
+ }
+ }
+ lck_mtx_unlock(tclass_lock);
+
+ error = 0;
+done:
+
+ return error;
+}
+
+int
+get_pid_tclass(pid_t pid, int *tclass)
+{
+ int error = EINVAL;
+ proc_t p = NULL;
+ struct tclass_for_proc *tfp;
+
+ *tclass = -1; /* Means not set */
+
+ p = proc_find(pid);
+ if (p == NULL) {
+ printf("get_pid_tclass proc_find(%d) \n", pid);
+ goto done;
+ }
+
+ /* Need a tfp */
+ lck_mtx_lock(tclass_lock);
+
+ tfp = find_tfp_by_pid(pid);
+ if (tfp != NULL) {
+ *tclass = tfp->tfp_class ;
+ error = 0;
+ }
+ lck_mtx_unlock(tclass_lock);
+done:
+ if (p != NULL)
+ proc_rele(p);
+
+ return error;
+}
+
+int
+get_pname_tclass(const char *pname, int *tclass)
+{
+ int error = EINVAL;
+ struct tclass_for_proc *tfp;
+
+ *tclass = -1; /* Means not set */
+
+ /* Need a tfp */
+ lck_mtx_lock(tclass_lock);
+
+ tfp = find_tfp_by_pname(pname);
+ if (tfp != NULL) {
+ *tclass = tfp->tfp_class ;
+ error = 0;
+ }
+ lck_mtx_unlock(tclass_lock);
+
+ return error;
+}
+
+
+
+/*
+ * Setting options requires privileges
+ */
+__private_extern__ int
+so_set_tcdbg(struct socket *so, struct so_tcdbg *so_tcdbg)
+{
+ int error = 0;
+
+ if ((so->so_state & SS_PRIV) == 0)
+ return EPERM;
+
+ socket_unlock(so, 0);
+
+ switch (so_tcdbg->so_tcdbg_cmd) {
+ case SO_TCDBG_PID:
+ error = set_pid_tclass(so_tcdbg->so_tcdbg_pid, so_tcdbg->so_tcdbg_tclass);
+ break;
+
+ case SO_TCDBG_PNAME:
+ error = set_pname_tclass(so_tcdbg->so_tcdbg_pname, so_tcdbg->so_tcdbg_tclass);
+ break;
+
+ case SO_TCDBG_PURGE:
+ error = purge_tclass_for_proc();
+ break;
+
+ case SO_TCDBG_FLUSH:
+ error = flush_tclass_for_proc();
+ break;
+
+ default:
+ error = EINVAL;
+ break;
+
+ }
+
+ socket_lock(so, 0);
+
+ return error;
+}
+
+/*
+ * Not required to be privileged to get
+ */
+__private_extern__ int
+sogetopt_tcdbg(struct socket *so, struct sockopt *sopt)
+{
+ int error = 0;
+ struct so_tcdbg so_tcdbg;
+ void *buf = NULL;
+ size_t len = sopt->sopt_valsize;
+
+ error = sooptcopyin(sopt, &so_tcdbg, sizeof(struct so_tcdbg), sizeof(struct so_tcdbg));
+ if (error != 0)
+ return error;
+
+ sopt->sopt_valsize = len;
+
+ socket_unlock(so, 0);
+
+ switch (so_tcdbg.so_tcdbg_cmd) {
+ case SO_TCDBG_PID:
+ error = get_pid_tclass(so_tcdbg.so_tcdbg_pid, &so_tcdbg.so_tcdbg_tclass);
+ break;
+
+ case SO_TCDBG_PNAME:
+ error = get_pname_tclass(so_tcdbg.so_tcdbg_pname, &so_tcdbg.so_tcdbg_tclass);
+ break;
+
+ case SO_TCDBG_COUNT:
+ lck_mtx_lock(tclass_lock);
+ so_tcdbg.so_tcdbg_count = tfp_count;
+ lck_mtx_unlock(tclass_lock);
+ break;
+
+ case SO_TCDBG_LIST: {
+ struct tclass_for_proc *tfp;
+ int n, alloc_count;
+ struct so_tcdbg *ptr;
+
+ lck_mtx_lock(tclass_lock);
+ if ((alloc_count = tfp_count) == 0) {
+ lck_mtx_unlock(tclass_lock);
+ error = EINVAL;
+ break;
+ }
+ len = alloc_count * sizeof(struct so_tcdbg);
+ lck_mtx_unlock(tclass_lock);
+
+ buf = _MALLOC(len, M_TEMP, M_WAITOK | M_ZERO);
+ if (buf == NULL) {
+ error = ENOBUFS;
+ break;
+ }
+
+ lck_mtx_lock(tclass_lock);
+ n = 0;
+ ptr = (struct so_tcdbg *)buf;
+ TAILQ_FOREACH(tfp, &tfp_head, tfp_link) {
+ if (++n > alloc_count)
+ break;
+ if (tfp->tfp_pid != -1) {
+ ptr->so_tcdbg_cmd = SO_TCDBG_PID;
+ ptr->so_tcdbg_pid = tfp->tfp_pid;
+ } else {
+ ptr->so_tcdbg_cmd = SO_TCDBG_PNAME;
+ ptr->so_tcdbg_pid = -1;
+ strlcpy(ptr->so_tcdbg_pname, tfp->tfp_pname, sizeof(ptr->so_tcdbg_pname));
+ }
+ ptr->so_tcdbg_tclass = tfp->tfp_class;
+ ptr++;
+ }
+
+ lck_mtx_unlock(tclass_lock);
+ }
+ break;
+
+ default:
+ error = EINVAL;
+ break;
+
+ }
+
+ socket_lock(so, 0);
+
+ if (error == 0) {
+ if (buf == NULL) {
+ error = sooptcopyout(sopt, &so_tcdbg, sizeof(struct so_tcdbg));
+ } else {
+ error = sooptcopyout(sopt, buf, len);
+ _FREE(buf, M_TEMP);
+ }
+ }
+ return error;
+}
+
+
+__private_extern__ int
+so_set_traffic_class(struct socket *so, int optval)
+{
+ int error = 0;
+
+ if (optval < SO_TC_BE || optval > SO_TC_VO) {
+ error = EINVAL;
+ } else {
+ so->so_traffic_class = optval;
+
+ if ((INP_SOCKAF(so) == AF_INET || INP_SOCKAF(so) == AF_INET6) &&
+ INP_SOCKTYPE(so) == SOCK_STREAM) {
+ set_tcp_stream_priority(so);
+ }
+ }
+ return error;
+}
+
+__private_extern__ void
+so_set_default_traffic_class(struct socket *so)
+{
+ int sotc = SO_TC_BE;
+
+ if (tfp_count > 0 && (INP_SOCKAF(so) == AF_INET || INP_SOCKAF(so) == AF_INET6)) {
+ sotc = get_tclass_for_curr_proc();
+ }
+
+ so->so_traffic_class = sotc;
+
+ return;
+}
+
+
+__private_extern__ int
+mbuf_traffic_class_from_control(struct mbuf *control)
+{
+ struct cmsghdr *cm;
+
+ for (cm = M_FIRST_CMSGHDR(control);
+ cm != NULL;
+ cm = M_NXT_CMSGHDR(control, cm)) {
+ int tc;
+
+ if (cm->cmsg_len < sizeof(struct cmsghdr))
+ break;
+
+ if (cm->cmsg_level != SOL_SOCKET ||
+ cm->cmsg_type != SO_TRAFFIC_CLASS)
+ continue;
+ if (cm->cmsg_len != CMSG_LEN(sizeof(int)))
+ continue;
+
+ tc = *(int *)CMSG_DATA(cm);
+
+ switch (tc) {
+ case SO_TC_BE:
+ return MBUF_TC_BE;
+ case SO_TC_BK:
+ return MBUF_TC_BK;
+ case SO_TC_VI:
+ return MBUF_TC_VI;
+ case SO_TC_VO:
+ return MBUF_TC_VO;
+ default:
+ break;
+ }
+ }
+
+ return MBUF_TC_UNSPEC;
+}
+
+__private_extern__ int
+dscp_code_from_mbuf_tclass(int mtc)
+{
+ int dscp_code;
+
+ switch (mtc) {
+ default:
+ case MBUF_TC_BE:
+ dscp_code = 0;
+ break;
+ case MBUF_TC_BK:
+ dscp_code = 0x08;
+ break;
+ case MBUF_TC_VI:
+ dscp_code = 0x20;
+ break;
+ case MBUF_TC_VO:
+ dscp_code = 0x30;
+ break;
+ }
+
+ return dscp_code;
+}
+
+__private_extern__ void
+so_recv_data_stat(struct socket *so, struct mbuf *m, size_t off)
+{
+ uint32_t sotc = m->m_pkthdr.prio;
+
+ if (sotc >= SO_TC_STATS_MAX)
+ sotc = SO_TC_BE;
+
+ so->so_tc_stats[sotc].rxpackets += 1;
+ so->so_tc_stats[sotc].rxbytes += ((m->m_flags & M_PKTHDR) ? m->m_pkthdr.len : 0) + off;
+
+ return;
+}
+
+__private_extern__ void
+set_tcp_stream_priority(struct socket *so)
+{
+ struct tcpcb *tp = intotcpcb(sotoinpcb(so));
+
+ /* If the socket was marked as a background socket or if the
+ * traffic class is set to background with traffic class socket
+ * option then make both send and recv side of the stream to be
+ * background. The variable sotcdb which can be set with sysctl
+ * is used to disable these settings for testing.
+ */
+ if (soisbackground(so) || so->so_traffic_class == SO_TC_BK) {
+ if ((sotcdb & SOTCDB_NO_SENDTCPBG) != 0) {
+ if (tp->tcp_cc_index == TCP_CC_ALGO_BACKGROUND_INDEX)
+ tcp_set_foreground_cc(so);
+ } else {
+ if (tp->tcp_cc_index != TCP_CC_ALGO_BACKGROUND_INDEX)
+ tcp_set_background_cc(so);
+ }
+
+ /* Set receive side background flags */
+ if ((sotcdb & SOTCDB_NO_RECVTCPBG) != 0) {
+ so->so_traffic_mgt_flags &= ~(TRAFFIC_MGT_TCP_RECVBG);
+ } else {
+ so->so_traffic_mgt_flags |= TRAFFIC_MGT_TCP_RECVBG;
+ }
+ } else {
+ so->so_traffic_mgt_flags &= ~(TRAFFIC_MGT_TCP_RECVBG);
+ if (tp->tcp_cc_index == TCP_CC_ALGO_BACKGROUND_INDEX)
+ tcp_set_foreground_cc(so);
+ }
+ return;
+}
+
+/*
+ * Set traffic class to an IPv4 or IPv6 packet
+ * - mark the mbuf
+ * - set the DSCP code following the WMM mapping
+ */
+__private_extern__ void
+set_packet_tclass(struct mbuf *m, struct socket *so, int in_mtc, int isipv6)
+{
+ int mtc = MBUF_TC_BE; /* Best effort by default */
+ struct inpcb *inp = sotoinpcb(so); /* in6pcb and inpcb are the same */
+ struct ip *ip = mtod(m, struct ip *);
+#if INET6
+ struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
+#endif /* INET6 */
+
+ if (!(m->m_flags & M_PKTHDR))
+ return;
+
+ /*
+ * Here is the precedence:
+ * 1) TRAFFIC_MGT_SO_BACKGROUND trumps all
+ * 2) Traffic class passed via ancillary data to sendmsdg(2)
+ * 3) Traffic class socket option last
+ */
+ if (soisbackground(so)) {
+ mtc = MBUF_TC_BK;
+ } else if (in_mtc != MBUF_TC_UNSPEC) {
+ if (in_mtc >= MBUF_TC_BE && in_mtc <= MBUF_TC_VO)
+ mtc = in_mtc;
+ } else {
+ switch (so->so_traffic_class) {
+ case SO_TC_BE:
+ mtc = MBUF_TC_BE;
+ break;
+ case SO_TC_BK:
+ mtc = MBUF_TC_BK;
+ break;
+ case SO_TC_VI:
+ mtc = MBUF_TC_VI;
+ break;
+ case SO_TC_VO:
+ mtc = MBUF_TC_VO;
+ break;
+ default:
+ break;
+ }
+ }
+
+ /*
+ * Set the traffic class in the mbuf packet header prio field
+ */
+ if ((sotcdb & SOTCDB_NO_MTC))
+ goto no_mbtc;
+ m->m_pkthdr.prio = mtc;
+
+no_mbtc:
+ /*
+ * Quick exit when best effort
+ */
+ if (mtc == MBUF_TC_BE)
+ goto no_dscp;
+ /*
+ * Now let set the DSCP code in IPv4 or IPv6 header
+ * By default do this only for local traffic if a code is not already set
+ */
+ if ((sotcdb & SOTCDB_NO_DSCP))
+ goto no_dscp;
+
+ /*
+ * Test if a IP TOS or IPV6 TCLASS has already been set on the socket or the raw packet
+ */
+ if ((sotcdb & SOTCDB_NO_DSCPTST) == 0) {
+#if INET6
+ if (isipv6)
+ {
+ if ((so->so_type == SOCK_RAW && (ip6->ip6_flow & htonl(0xff << 20)) != 0) ||
+ (inp->in6p_outputopts && inp->in6p_outputopts->ip6po_tclass != -1))
+ goto no_dscp;
+ }
+ else
+#endif /* INET6 */
+ {
+ if ((so->so_type == SOCK_RAW && (inp->inp_flags & INP_HDRINCL)) ||
+ inp->inp_ip_tos != 0)
+ goto no_dscp;
+ }
+ }
+
+ /*
+ * Test if destination is local
+ */
+ if ((sotcdb & SOTCDB_NO_LCLTST) == 0) {
+ int islocal = 0;
+ struct route *ro = &inp->inp_route;
+
+ if (so->so_type == SOCK_STREAM) {
+ struct tcpcb *tp = intotcpcb(inp);
+
+ if ((tp->t_flags & TF_LOCAL))
+ islocal = 1;
+ }
+ else
+#if INET6
+ if (isipv6)
+ {
+ if ((ro != NULL && ro->ro_rt != NULL &&
+ (ro->ro_rt->rt_gateway->sa_family == AF_LINK ||
+ (ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK))) ||
+ in6addr_local(&ip6->ip6_dst))
+ islocal = 1;
+ }
+ else
+#endif /* INET6 */
+ {
+ if ((ro != NULL && ro->ro_rt != NULL &&
+ (ro->ro_rt->rt_gateway->sa_family == AF_LINK ||
+ (ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK))) ||
+ inaddr_local(ip->ip_dst))
+ islocal = 1;
+ }
+ if (islocal == 0)
+ goto no_dscp;
+ }
+
+#if INET6
+ if (isipv6)
+ ip6->ip6_flow |=
+ htonl(dscp_code_from_mbuf_tclass(m->m_pkthdr.prio) << 20);
+ else
+#endif /* INET6 */
+ ip->ip_tos |= dscp_code_from_mbuf_tclass(m->m_pkthdr.prio) << 2;
+
+no_dscp:
+ /*
+ * For TCP with background traffic class switch CC algo based on sysctl
+ */
+ if (so->so_type == SOCK_STREAM) {
+ set_tcp_stream_priority(so);
+ }
+
+ /*
+ * Assume socket and mbuf traffic class values are the same
+ * Also assume the socket lock is held
+ */
+ so->so_tc_stats[mtc].txpackets += 1;
+ so->so_tc_stats[mtc].txbytes += m->m_pkthdr.len;
+
+ return;
+}
+
+__private_extern__ void
+socket_tclass_init(void)
+{
+ tclass_lck_grp_attr = lck_grp_attr_alloc_init();
+ tclass_lck_grp = lck_grp_alloc_init("tclass", tclass_lck_grp_attr);
+ tclass_lck_attr = lck_attr_alloc_init();
+ if ((tclass_lock = lck_mtx_alloc_init(tclass_lck_grp, tclass_lck_attr)) == NULL) {
+ panic("failed to allocate memory for tclass\n");
+ }
+}
+
+
projects / apple / xnu.git / blobdiff