sys/netinet/ip_demux.c

   1 /*
   2  * Copyright (c) 2003, 2004 Jeffrey M. Hsu.  All rights reserved.
   3  * Copyright (c) 2003, 2004 The DragonFly Project.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to The DragonFly Project
   6  * by Jeffrey M. Hsu.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of The DragonFly Project nor the names of its
  17  *    contributors may be used to endorse or promote products derived
  18  *    from this software without specific, prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  30  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $DragonFly: src/sys/netinet/ip_demux.c,v 1.45 2008/11/11 10:46:58 sephe Exp $
  34  */
  35
  36 #include "opt_inet.h"
  37 #include "opt_rss.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/kernel.h>
  42 #include <sys/socket.h>
  43 #include <sys/socketvar.h>
  44 #include <sys/thread.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/globaldata.h>
  47
  48 #include <net/if.h>
  49 #include <net/netisr.h>
  50 #include <net/toeplitz2.h>
  51
  52 #include <netinet/in_systm.h>
  53 #include <netinet/in.h>
  54 #include <netinet/in_var.h>
  55 #include <netinet/in_pcb.h>
  56 #include <netinet/ip.h>
  57 #include <netinet/ip_var.h>
  58 #include <netinet/tcp.h>
  59 #include <netinet/tcpip.h>
  60 #include <netinet/tcp_var.h>
  61 #include <netinet/udp.h>
  62 #include <netinet/udp_var.h>
  63
  64 extern int udp_mpsafe_thread;
  65
  66 /*
  67  * Toeplitz hash functions - the idea is to match the hardware.
  68  */
  69 static __inline int
  70 INP_MPORT_HASH_UDP(in_addr_t faddr, in_addr_t laddr,
  71                    in_port_t fport, in_port_t lport)
  72 {
  73         return toeplitz_hash(toeplitz_rawhash_addr(faddr, laddr));
  74 }
  75
  76 static __inline int
  77 INP_MPORT_HASH_TCP(in_addr_t faddr, in_addr_t laddr,
  78                    in_port_t fport, in_port_t lport)
  79 {
  80         return toeplitz_hash(
  81                toeplitz_rawhash_addrport(faddr, laddr, fport, lport));
  82 }
  83
  84 /*
  85  * Map a network address to a processor.
  86  */
  87 int
  88 tcp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
  89 {
  90         return (INP_MPORT_HASH_TCP(faddr, laddr, fport, lport));
  91 }
  92
  93 /*
  94  * Not implemented yet, use protocol thread 0
  95  */
  96 int
  97 udp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
  98 {
  99         /*return (INP_MPORT_HASH_UDP(faddr, laddr, fport, lport));*/
 100         return 0;
 101 }
 102
 103 /*
 104  * If the packet is a valid IP datagram, upon returning of this function
 105  * following things are promised:
 106  *
 107  * o  IP header (including any possible IP options) is in one mbuf (m_len).
 108  * o  IP header length is not less than the minimum (sizeof(struct ip)).
 109  * o  IP total length is not less than IP header length.
 110  * o  IP datagram resides completely in the mbuf chain,
 111  *    i.e. pkthdr.len >= IP total length.
 112  *
 113  * If the packet is a UDP datagram,
 114  * o  IP header (including any possible IP options) and UDP header are in
 115  *    one mbuf (m_len).
 116  * o  IP total length is not less than (IP header length + UDP header length).
 117  *
 118  * If the packet is a TCP segment,
 119  * o  IP header (including any possible IP options) and TCP header (including
 120  *    any possible TCP options) are in one mbuf (m_len).
 121  * o  TCP header length is not less than the minimum (sizeof(struct tcphdr)).
 122  * o  IP total length is not less than (IP header length + TCP header length).
 123  */
 124 boolean_t
 125 ip_lengthcheck(struct mbuf **mp, int hoff)
 126 {
 127         struct mbuf *m = *mp;
 128         struct ip *ip;
 129         int len, iphlen, iplen;
 130         struct tcphdr *th;
 131         int thoff;                              /* TCP data offset */
 132
 133         len = hoff + sizeof(struct ip);
 134
 135         /* The packet must be at least the size of an IP header. */
 136         if (m->m_pkthdr.len < len) {
 137                 kprintf("pkthdr %d %d < %d\n", (m->m_flags & M_PKTHDR),
 138                         m->m_pkthdr.len, len);
 139                 ipstat.ips_tooshort++;
 140                 goto fail;
 141         }
 142
 143         /* The fixed IP header must reside completely in the first mbuf. */
 144         if (m->m_len < len) {
 145                 m = m_pullup(m, len);
 146                 if (m == NULL) {
 147                         kprintf("can't pullup %d\n", len);
 148                         ipstat.ips_toosmall++;
 149                         goto fail;
 150                 }
 151         }
 152
 153         ip = mtodoff(m, struct ip *, hoff);
 154
 155         /* Bound check the packet's stated IP header length. */
 156         iphlen = ip->ip_hl << 2;
 157         if (iphlen < sizeof(struct ip)) {       /* minimum header length */
 158                 ipstat.ips_badhlen++;
 159                 goto fail;
 160         }
 161
 162         /* The full IP header must reside completely in the one mbuf. */
 163         if (m->m_len < hoff + iphlen) {
 164                 m = m_pullup(m, hoff + iphlen);
 165                 if (m == NULL) {
 166                         ipstat.ips_badhlen++;
 167                         goto fail;
 168                 }
 169                 ip = mtodoff(m, struct ip *, hoff);
 170         }
 171
 172         iplen = ntohs(ip->ip_len);
 173
 174         /*
 175          * Check that the amount of data in the buffers is as
 176          * at least much as the IP header would have us expect.
 177          */
 178         if (m->m_pkthdr.len < hoff + iplen) {
 179                 kprintf("data in buffer not enough %d -  %d vs %d+%d\n",
 180                         (m->m_flags & M_PKTHDR),
 181                         m->m_pkthdr.len, hoff, iplen);
 182                 ipstat.ips_tooshort++;
 183                 goto fail;
 184         }
 185
 186         /*
 187          * Fragments other than the first fragment don't have much
 188          * length information.
 189          */
 190         if (ntohs(ip->ip_off) & IP_OFFMASK)
 191                 goto ipcheckonly;
 192
 193         /*
 194          * The TCP/IP or UDP/IP header must be entirely contained within
 195          * the first fragment of a packet.  Packet filters will break if they
 196          * aren't.
 197          *
 198          * Since the packet will be trimmed to ip_len we must also make sure
 199          * the potentially trimmed down length is still sufficient to hold
 200          * the header(s).
 201          */
 202         switch (ip->ip_p) {
 203         case IPPROTO_TCP:
 204                 if (iplen < iphlen + sizeof(struct tcphdr)) {
 205                         ++tcpstat.tcps_rcvshort;
 206                         goto fail;
 207                 }
 208                 if (m->m_len < hoff + iphlen + sizeof(struct tcphdr)) {
 209                         m = m_pullup(m, hoff + iphlen + sizeof(struct tcphdr));
 210                         if (m == NULL) {
 211                                 tcpstat.tcps_rcvshort++;
 212                                 goto fail;
 213                         }
 214                         ip = mtodoff(m, struct ip *, hoff);
 215                 }
 216                 th = (struct tcphdr *)((caddr_t)ip + iphlen);
 217                 thoff = th->th_off << 2;
 218                 if (thoff < sizeof(struct tcphdr) ||
 219                     thoff + iphlen > ntohs(ip->ip_len)) {
 220                         tcpstat.tcps_rcvbadoff++;
 221                         goto fail;
 222                 }
 223                 if (m->m_len < hoff + iphlen + thoff) {
 224                         m = m_pullup(m, hoff + iphlen + thoff);
 225                         if (m == NULL) {
 226                                 tcpstat.tcps_rcvshort++;
 227                                 goto fail;
 228                         }
 229                 }
 230                 break;
 231         case IPPROTO_UDP:
 232                 if (iplen < iphlen + sizeof(struct udphdr)) {
 233                         ++udpstat.udps_hdrops;
 234                         goto fail;
 235                 }
 236                 if (m->m_len < hoff + iphlen + sizeof(struct udphdr)) {
 237                         m = m_pullup(m, hoff + iphlen + sizeof(struct udphdr));
 238                         if (m == NULL) {
 239                                 udpstat.udps_hdrops++;
 240                                 goto fail;
 241                         }
 242                 }
 243                 break;
 244         default:
 245 ipcheckonly:
 246                 if (iplen < iphlen) {
 247                         ++ipstat.ips_badlen;
 248                         goto fail;
 249                 }
 250                 break;
 251         }
 252
 253         m->m_flags |= M_LENCHECKED;
 254         *mp = m;
 255         return TRUE;
 256
 257 fail:
 258         if (m != NULL)
 259                 m_freem(m);
 260         *mp = NULL;
 261         return FALSE;
 262 }
 263
 264 /*
 265  * Assign a protocol processing thread to a packet.  The IP header is at
 266  * offset (hoff) in the packet (i.e. the mac header might still be intact).
 267  *
 268  * This function can blow away the mbuf if the packet is malformed.
 269  */
 270 void
 271 ip_cpufn(struct mbuf **mptr, int hoff, int dir)
 272 {
 273         struct ip *ip;
 274         int iphlen;
 275         struct tcphdr *th;
 276         struct udphdr *uh;
 277         struct mbuf *m;
 278         int thoff;                              /* TCP data offset */
 279         int cpu;
 280
 281         if (!ip_lengthcheck(mptr, hoff))
 282                 return;
 283
 284         m = *mptr;
 285         ip = mtodoff(m, struct ip *, hoff);
 286         iphlen = ip->ip_hl << 2;
 287
 288         /*
 289          * XXX generic packet handling defrag on CPU 0 for now.
 290          */
 291         if (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK)) {
 292                 cpu = 0;
 293                 goto back;
 294         }
 295
 296         switch (ip->ip_p) {
 297         case IPPROTO_TCP:
 298                 th = (struct tcphdr *)((caddr_t)ip + iphlen);
 299                 thoff = th->th_off << 2;
 300                 cpu = INP_MPORT_HASH_TCP(ip->ip_src.s_addr,
 301                                          ip->ip_dst.s_addr,
 302                                          th->th_sport,
 303                                          th->th_dport);
 304                 break;
 305
 306         case IPPROTO_UDP:
 307                 uh = (struct udphdr *)((caddr_t)ip + iphlen);
 308
 309                 cpu = INP_MPORT_HASH_UDP(ip->ip_src.s_addr,
 310                                          ip->ip_dst.s_addr,
 311                                          uh->uh_sport,
 312                                          uh->uh_dport);
 313                 break;
 314
 315         default:
 316                 cpu = 0;
 317                 break;
 318         }
 319 back:
 320         m->m_flags |= M_HASH;
 321         m->m_pkthdr.hash = cpu;
 322 }
 323
 324 void
 325 ip_cpufn_in(struct mbuf **mptr, int hoff)
 326 {
 327         ip_cpufn(mptr, hoff, IP_MPORT_IN);
 328 }
 329
 330 #if 0
 331
 332 /*
 333  * Map a packet to a protocol processing thread and return the thread's port.
 334  * Unlike ip_cpufn(), the packet content is not accessed.  The packet info
 335  * (pi) and the hash of the packet (m_pkthdr.hash) is used instead.  NULL is
 336  * returned if the packet info does not contain enough information.
 337  *
 338  * Caller has already made sure that m_pkthdr.hash is valid, i.e. m_flags
 339  * has M_HASH set.
 340  */
 341 lwkt_port_t
 342 ip_mport_pktinfo(const struct pktinfo *pi, struct mbuf *m)
 343 {
 344         lwkt_port_t port;
 345
 346         KASSERT(m->m_pkthdr.hash < ncpus2,
 347                 ("invalid packet hash %#x\n", m->m_pkthdr.hash));
 348
 349         /*
 350          * XXX generic packet handling defrag on CPU 0 for now.
 351          */
 352         if (pi->pi_flags & PKTINFO_FLAG_FRAG) {
 353                 m->m_pkthdr.hash = 0;
 354                 return cpu_portfn(0);
 355         }
 356
 357         switch (pi->pi_l3proto) {
 358         case IPPROTO_TCP:
 359                 port = cpu_portfn(m->m_pkthdr.hash);
 360                 break;
 361
 362         case IPPROTO_UDP:
 363                 port = cpu_portfn(m->m_pkthdr.hash);
 364                 break;
 365
 366         default:
 367                 port = NULL;
 368                 break;
 369         }
 370         return port;
 371 }
 372
 373 #endif
 374
 375 /*
 376  * This is used to map a socket to a message port for sendmsg() and friends.
 377  * It is not called for any other purpose.  In the case of TCP we just return
 378  * the port already installed in the socket.
 379  */
 380 lwkt_port_t
 381 tcp_soport(struct socket *so, struct sockaddr *nam,
 382            struct mbuf **dummy __unused)
 383 {
 384         return(so->so_port);
 385 }
 386
 387 /*
 388  * Used to route icmp messages to the proper protocol thread for ctlinput
 389  * operation.
 390  */
 391 lwkt_port_t
 392 tcp_ctlport(int cmd, struct sockaddr *sa, void *vip)
 393 {
 394         struct ip *ip = vip;
 395         struct tcphdr *th;
 396         struct in_addr faddr;
 397         int cpu;
 398
 399         faddr = ((struct sockaddr_in *)sa)->sin_addr;
 400         if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
 401                 return(NULL);
 402         if (ip == NULL || PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) {
 403                 /*
 404                  * Message will be forwarded to all TCP protocol threads
 405                  * in following way:
 406                  *
 407                  * netisr0 (the msgport we return here)
 408                  *    |
 409                  *    |
 410                  *    | domsg <----------------------------+
 411                  *    |                                    |
 412                  *    |                                    | replymsg
 413                  *    |                                    |
 414                  *    V   forwardmsg         forwardmsg    |
 415                  *  tcp0 ------------> tcp1 ------------> tcpN
 416                  */
 417                 return cpu0_ctlport(cmd, sa, vip);
 418         } else {
 419                 th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
 420                 cpu = tcp_addrcpu(faddr.s_addr, th->th_dport,
 421                                   ip->ip_src.s_addr, th->th_sport);
 422         }
 423         return(cpu_portfn(cpu));
 424 }
 425
 426 lwkt_port_t
 427 tcp_addrport(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
 428 {
 429         return(cpu_portfn(tcp_addrcpu(faddr, fport, laddr, lport)));
 430 }
 431
 432 lwkt_port_t
 433 tcp_addrport0(void)
 434 {
 435         return(cpu_portfn(0));
 436 }
 437
 438 lwkt_port_t
 439 udp_addrport(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
 440 {
 441         return(cpu_portfn(udp_addrcpu(faddr, fport, laddr, lport)));
 442 }
 443
 444 /*
 445  * Used to route icmp messages to the proper protocol thread for ctlinput
 446  * operation.
 447  */
 448 lwkt_port_t
 449 udp_ctlport(int cmd, struct sockaddr *sa, void *vip)
 450 {
 451         struct ip *ip = vip;
 452         struct udphdr *uh;
 453         struct in_addr faddr;
 454         int cpu;
 455
 456         faddr = ((struct sockaddr_in *)sa)->sin_addr;
 457         if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
 458                 return(NULL);
 459         if (PRC_IS_REDIRECT(cmd)) {
 460                 /*
 461                  * See the comment in tcp_ctlport; the only difference
 462                  * is that message is forwarded to UDP protocol theads.
 463                  */
 464                 return cpu0_ctlport(cmd, sa, vip);
 465         } else if (ip == NULL || cmd == PRC_HOSTDEAD) {
 466                 /*
 467                  * XXX
 468                  * Once UDP inpcbs are CPU localized, we should do
 469                  * the same forwarding as PRC_IS_REDIRECT(cmd)
 470                  */
 471                 cpu = 0;
 472         } else {
 473                 uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
 474
 475                 cpu = INP_MPORT_HASH_UDP(faddr.s_addr, ip->ip_src.s_addr,
 476                                          uh->uh_dport, uh->uh_sport);
 477         }
 478         return (cpu_portfn(cpu));
 479 }