switch (veth->h_vlan_encapsulated_proto) {
 #ifdef CONFIG_INET
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
 
                /* TODO:  Confirm this will work with VLAN headers... */
                return arp_find(veth->h_dest, skb);
 
                        if (memcmp
                            (skb->data + 6, ethertype_ipv6,
                             sizeof(ethertype_ipv6)) == 0)
-                               skb->protocol = __constant_htons(ETH_P_IPV6);
+                               skb->protocol = htons(ETH_P_IPV6);
                        else if (memcmp
                                 (skb->data + 6, ethertype_ipv4,
                                  sizeof(ethertype_ipv4)) == 0)
-                               skb->protocol = __constant_htons(ETH_P_IP);
+                               skb->protocol = htons(ETH_P_IP);
                        else
                                goto error;
                        skb_pull(skb, sizeof(llc_oui_ipv4));
                        skb_reset_network_header(skb);
                        iph = ip_hdr(skb);
                        if (iph->version == 4)
-                               skb->protocol = __constant_htons(ETH_P_IP);
+                               skb->protocol = htons(ETH_P_IP);
                        else if (iph->version == 6)
-                               skb->protocol = __constant_htons(ETH_P_IPV6);
+                               skb->protocol = htons(ETH_P_IPV6);
                        else
                                goto error;
                        skb->pkt_type = PACKET_HOST;
 
        }
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                ip_proto = ip_hdr(skb)->protocol;
                addr1 = ip_hdr(skb)->saddr;
                addr2 = ip_hdr(skb)->daddr;
                ihl = ip_hdr(skb)->ihl;
                break;
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                ip_proto = ipv6_hdr(skb)->nexthdr;
                addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
                addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
 
 
        switch (eth->h_proto) {
 #ifdef CONFIG_INET
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return arp_find(eth->h_dest, skb);
 #endif
        default:
 
 
        EnterFunction(11);
 
-       af = (skb->protocol == __constant_htons(ETH_P_IP)) ? AF_INET : AF_INET6;
+       af = (skb->protocol == htons(ETH_P_IP)) ? AF_INET : AF_INET6;
 
        if (skb->ipvs_property)
                return NF_ACCEPT;
        struct ip_vs_conn *cp;
        int ret, restart, af;
 
-       af = (skb->protocol == __constant_htons(ETH_P_IP)) ? AF_INET : AF_INET6;
+       af = (skb->protocol == htons(ETH_P_IP)) ? AF_INET : AF_INET6;
 
        ip_vs_fill_iphdr(af, skb_network_header(skb), &iph);
 
 
        }
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                ret = ip4ip6_tnl_xmit(skb, dev);
                break;
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                ret = ip6ip6_tnl_xmit(skb, dev);
                break;
        default:
 
                return skb->priority - 256;
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                dscp = ip_hdr(skb)->tos & 0xfc;
                break;
 
 
 static u32 flow_get_src(const struct sk_buff *skb)
 {
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return ntohl(ip_hdr(skb)->saddr);
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                return ntohl(ipv6_hdr(skb)->saddr.s6_addr32[3]);
        default:
                return addr_fold(skb->sk);
 static u32 flow_get_dst(const struct sk_buff *skb)
 {
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return ntohl(ip_hdr(skb)->daddr);
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                return ntohl(ipv6_hdr(skb)->daddr.s6_addr32[3]);
        default:
                return addr_fold(skb->dst) ^ (__force u16)skb->protocol;
 static u32 flow_get_proto(const struct sk_buff *skb)
 {
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return ip_hdr(skb)->protocol;
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                return ipv6_hdr(skb)->nexthdr;
        default:
                return 0;
        u32 res = 0;
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP): {
+       case htons(ETH_P_IP): {
                struct iphdr *iph = ip_hdr(skb);
 
                if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
                        res = ntohs(*(__be16 *)((void *)iph + iph->ihl * 4));
                break;
        }
-       case __constant_htons(ETH_P_IPV6): {
+       case htons(ETH_P_IPV6): {
                struct ipv6hdr *iph = ipv6_hdr(skb);
 
                if (has_ports(iph->nexthdr))
        u32 res = 0;
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP): {
+       case htons(ETH_P_IP): {
                struct iphdr *iph = ip_hdr(skb);
 
                if (!(iph->frag_off&htons(IP_MF|IP_OFFSET)) &&
                        res = ntohs(*(__be16 *)((void *)iph + iph->ihl * 4 + 2));
                break;
        }
-       case __constant_htons(ETH_P_IPV6): {
+       case htons(ETH_P_IPV6): {
                struct ipv6hdr *iph = ipv6_hdr(skb);
 
                if (has_ports(iph->nexthdr))
 static u32 flow_get_nfct_src(const struct sk_buff *skb)
 {
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return ntohl(CTTUPLE(skb, src.u3.ip));
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                return ntohl(CTTUPLE(skb, src.u3.ip6[3]));
        }
 fallback:
 static u32 flow_get_nfct_dst(const struct sk_buff *skb)
 {
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                return ntohl(CTTUPLE(skb, dst.u3.ip));
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                return ntohl(CTTUPLE(skb, dst.u3.ip6[3]));
        }
 fallback:
 
 
        if (p->set_tc_index) {
                switch (skb->protocol) {
-               case __constant_htons(ETH_P_IP):
+               case htons(ETH_P_IP):
                        if (skb_cow_head(skb, sizeof(struct iphdr)))
                                goto drop;
 
                                & ~INET_ECN_MASK;
                        break;
 
-               case __constant_htons(ETH_P_IPV6):
+               case htons(ETH_P_IPV6):
                        if (skb_cow_head(skb, sizeof(struct ipv6hdr)))
                                goto drop;
 
        pr_debug("index %d->%d\n", skb->tc_index, index);
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
                ipv4_change_dsfield(ip_hdr(skb), p->mask[index],
                                    p->value[index]);
                        break;
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
                ipv6_change_dsfield(ipv6_hdr(skb), p->mask[index],
                                    p->value[index]);
                        break;
 
        u32 h, h2;
 
        switch (skb->protocol) {
-       case __constant_htons(ETH_P_IP):
+       case htons(ETH_P_IP):
        {
                const struct iphdr *iph = ip_hdr(skb);
                h = iph->daddr;
                        h2 ^= *(((u32*)iph) + iph->ihl);
                break;
        }
-       case __constant_htons(ETH_P_IPV6):
+       case htons(ETH_P_IPV6):
        {
                struct ipv6hdr *iph = ipv6_hdr(skb);
                h = iph->daddr.s6_addr32[3];
 
        /* check for expected message types */
        /* The order of some of these tests is important. */
        switch (headerp->rm_type) {
-       case __constant_htonl(RDMA_MSG):
+       case htonl(RDMA_MSG):
                /* never expect read chunks */
                /* never expect reply chunks (two ways to check) */
                /* never expect write chunks without having offered RDMA */
                rpcrdma_inline_fixup(rqst, (char *)iptr, rep->rr_len);
                break;
 
-       case __constant_htonl(RDMA_NOMSG):
+       case htonl(RDMA_NOMSG):
                /* never expect read or write chunks, always reply chunks */
                if (headerp->rm_body.rm_chunks[0] != xdr_zero ||
                    headerp->rm_body.rm_chunks[1] != xdr_zero ||