Add TDF_NETWORK lwkt flag, so various assertion could be performed to make sure
[dragonfly.git] / sys / netinet / ip_demux.c
CommitLineData
bf82f9b7 1/*
380d2ea3
JH
2 * Copyright (c) 2003, 2004 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 2003, 2004 The DragonFly Project. All rights reserved.
f23061d4 4 *
380d2ea3
JH
5 * This code is derived from software contributed to The DragonFly Project
6 * by Jeffrey M. Hsu.
f23061d4 7 *
380d2ea3
JH
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.
f23061d4 19 *
380d2ea3
JH
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.
bf82f9b7 32 *
cbb1e737 33 * $DragonFly: src/sys/netinet/ip_demux.c,v 1.40 2008/09/20 04:31:02 sephe Exp $
bf82f9b7
MD
34 */
35
36#include "opt_inet.h"
37
38#include <sys/param.h>
39#include <sys/systm.h>
40#include <sys/kernel.h>
41#include <sys/socket.h>
42#include <sys/socketvar.h>
43#include <sys/thread.h>
44#include <sys/sysctl.h>
2b57d013 45#include <sys/globaldata.h>
bf82f9b7
MD
46
47#include <net/if.h>
48#include <net/netisr.h>
49
50#include <netinet/in_systm.h>
51#include <netinet/in.h>
52#include <netinet/in_var.h>
53#include <netinet/in_pcb.h>
54#include <netinet/ip.h>
55#include <netinet/ip_var.h>
56#include <netinet/tcp.h>
57#include <netinet/tcpip.h>
58#include <netinet/tcp_var.h>
59#include <netinet/udp.h>
60#include <netinet/udp_var.h>
61
62extern struct thread netisr_cpu[];
63
64static struct thread tcp_thread[MAXCPU];
65static struct thread udp_thread[MAXCPU];
66
37eacd1a
SZ
67static int udp_mpsafe_thread = 0;
68TUNABLE_INT("net.inet.udp.mpsafe_thread", &udp_mpsafe_thread);
69
9eeaa8a9 70static __inline int
e0b7863e
JH
71INP_MPORT_HASH(in_addr_t faddr, in_addr_t laddr,
72 in_port_t fport, in_port_t lport)
bf82f9b7 73{
a00e7525
JH
74 /*
75 * Use low order bytes.
a00e7525 76 */
e3d4c971 77
a00e7525 78#if (BYTE_ORDER == LITTLE_ENDIAN)
e3d4c971 79 KASSERT(ncpus2 < 256, ("need different hash function")); /* XXX JH */
e0b7863e 80 return (((faddr >> 24) ^ (fport >> 8) ^ (laddr >> 24) ^ (lport >> 8)) &
a00e7525
JH
81 ncpus2_mask);
82#else
e0b7863e 83 return ((faddr ^ fport ^ laddr ^ lport) & ncpus2_mask);
a00e7525 84#endif
bf82f9b7
MD
85}
86
1e316d14
JH
87boolean_t
88ip_lengthcheck(struct mbuf **mp)
bf82f9b7 89{
1e316d14 90 struct mbuf *m = *mp;
55d829f8 91 struct ip *ip;
1e316d14 92 int iphlen, iplen;
bf82f9b7 93 struct tcphdr *th;
55d829f8 94 int thoff; /* TCP data offset */
bf82f9b7 95
ead1d3cb 96 /* The packet must be at least the size of an IP header. */
55d829f8
JH
97 if (m->m_pkthdr.len < sizeof(struct ip)) {
98 ipstat.ips_tooshort++;
dd4df7e9 99 goto fail;
55d829f8
JH
100 }
101
ead1d3cb
JH
102 /* The fixed IP header must reside completely in the first mbuf. */
103 if (m->m_len < sizeof(struct ip)) {
104 m = m_pullup(m, sizeof(struct ip));
105 if (m == NULL) {
106 ipstat.ips_toosmall++;
dd4df7e9 107 goto fail;
ead1d3cb 108 }
bf82f9b7 109 }
ead1d3cb 110
55d829f8
JH
111 ip = mtod(m, struct ip *);
112
ead1d3cb 113 /* Bound check the packet's stated IP header length. */
9eeaa8a9 114 iphlen = ip->ip_hl << 2;
9babcab8
JH
115 if (iphlen < sizeof(struct ip)) { /* minimum header length */
116 ipstat.ips_badhlen++;
dd4df7e9 117 goto fail;
9babcab8 118 }
ead1d3cb
JH
119
120 /* The full IP header must reside completely in the one mbuf. */
b01ae44a
MD
121 if (m->m_len < iphlen) {
122 m = m_pullup(m, iphlen);
123 if (m == NULL) {
124 ipstat.ips_badhlen++;
dd4df7e9 125 goto fail;
b01ae44a
MD
126 }
127 ip = mtod(m, struct ip *);
128 }
129
ead1d3cb
JH
130 iplen = ntohs(ip->ip_len);
131
132 /*
133 * Fragments other than the first fragment don't have much
134 * length information.
135 */
136 if (ntohs(ip->ip_off) & IP_OFFMASK)
137 goto ipcheckonly;
138
b01ae44a
MD
139 /*
140 * The TCP/IP or UDP/IP header must be entirely contained within
141 * the first fragment of a packet. Packet filters will break if they
142 * aren't.
ee7990a0
MD
143 *
144 * Since the packet will be trimmed to ip_len we must also make sure
145 * the potentially trimmed down length is still sufficient to hold
146 * the header(s).
b01ae44a 147 */
ead1d3cb
JH
148 switch (ip->ip_p) {
149 case IPPROTO_TCP:
150 if (iplen < iphlen + sizeof(struct tcphdr)) {
151 ++tcpstat.tcps_rcvshort;
dd4df7e9 152 goto fail;
ead1d3cb
JH
153 }
154 if (m->m_len < iphlen + sizeof(struct tcphdr)) {
155 m = m_pullup(m, iphlen + sizeof(struct tcphdr));
156 if (m == NULL) {
157 tcpstat.tcps_rcvshort++;
dd4df7e9 158 goto fail;
ee7990a0 159 }
ead1d3cb 160 ip = mtod(m, struct ip *);
b01ae44a 161 }
9eeaa8a9 162 th = (struct tcphdr *)((caddr_t)ip + iphlen);
55d829f8 163 thoff = th->th_off << 2;
096deca3 164 if (thoff < sizeof(struct tcphdr) ||
cd5e5855 165 thoff + iphlen > ntohs(ip->ip_len)) {
9eeaa8a9 166 tcpstat.tcps_rcvbadoff++;
dd4df7e9 167 goto fail;
9eeaa8a9 168 }
55d829f8
JH
169 if (m->m_len < iphlen + thoff) {
170 m = m_pullup(m, iphlen + thoff);
171 if (m == NULL) {
172 tcpstat.tcps_rcvshort++;
dd4df7e9 173 goto fail;
55d829f8 174 }
bf82f9b7 175 }
1e316d14 176 break;
ead1d3cb
JH
177 case IPPROTO_UDP:
178 if (iplen < iphlen + sizeof(struct udphdr)) {
179 ++udpstat.udps_hdrops;
dd4df7e9 180 goto fail;
ead1d3cb
JH
181 }
182 if (m->m_len < iphlen + sizeof(struct udphdr)) {
183 m = m_pullup(m, iphlen + sizeof(struct udphdr));
184 if (m == NULL) {
185 udpstat.udps_hdrops++;
dd4df7e9 186 goto fail;
ead1d3cb
JH
187 }
188 }
189 break;
190 default:
191ipcheckonly:
192 if (iplen < iphlen) {
193 ++ipstat.ips_badlen;
dd4df7e9 194 goto fail;
ead1d3cb
JH
195 }
196 break;
1e316d14
JH
197 }
198
199 *mp = m;
200 return TRUE;
dd4df7e9
SZ
201
202fail:
203 if (m != NULL)
204 m_freem(m);
205 *mp = NULL;
206 return FALSE;
1e316d14 207}
bf82f9b7 208
1e316d14
JH
209/*
210 * Map a packet to a protocol processing thread and return the thread's port.
211 * If an error occurs, the passed mbuf will be freed, *mptr will be set
212 * to NULL, and NULL will be returned. If no error occurs, the passed mbuf
213 * may be modified and a port pointer will be returned.
214 */
215lwkt_port_t
934c6849 216ip_mport(struct mbuf **mptr, int dir)
1e316d14
JH
217{
218 struct ip *ip;
219 int iphlen;
220 struct tcphdr *th;
221 struct udphdr *uh;
222 struct mbuf *m;
223 int thoff; /* TCP data offset */
224 lwkt_port_t port;
225 int cpu;
226
dd4df7e9 227 if (!ip_lengthcheck(mptr))
1e316d14 228 return (NULL);
1e316d14
JH
229
230 m = *mptr;
231 ip = mtod(m, struct ip *);
232 iphlen = ip->ip_hl << 2;
233
234 /*
235 * XXX generic packet handling defrag on CPU 0 for now.
236 */
237 if (ntohs(ip->ip_off) & (IP_MF | IP_OFFMASK))
238 return (&netisr_cpu[0].td_msgport);
239
240 switch (ip->ip_p) {
241 case IPPROTO_TCP:
242 th = (struct tcphdr *)((caddr_t)ip + iphlen);
243 thoff = th->th_off << 2;
9eeaa8a9
JH
244 cpu = INP_MPORT_HASH(ip->ip_src.s_addr, ip->ip_dst.s_addr,
245 th->th_sport, th->th_dport);
246 port = &tcp_thread[cpu].td_msgport;
bf82f9b7
MD
247 break;
248 case IPPROTO_UDP:
9eeaa8a9
JH
249 uh = (struct udphdr *)((caddr_t)ip + iphlen);
250
251 if (IN_MULTICAST(ntohl(ip->ip_dst.s_addr)) ||
934c6849
SZ
252 (dir == IP_MPORT_IN &&
253 in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif))) {
9eeaa8a9
JH
254 cpu = 0;
255 } else {
256 cpu = INP_MPORT_HASH(ip->ip_src.s_addr,
257 ip->ip_dst.s_addr, uh->uh_sport, uh->uh_dport);
258 }
259 port = &udp_thread[cpu].td_msgport;
bf82f9b7
MD
260 break;
261 default:
262 port = &netisr_cpu[0].td_msgport;
263 break;
264 }
1e316d14 265
bf82f9b7
MD
266 return (port);
267}
268
934c6849
SZ
269lwkt_port_t
270ip_mport_in(struct mbuf **mptr)
271{
272 return ip_mport(mptr, IP_MPORT_IN);
273}
274
9eeaa8a9
JH
275/*
276 * Map a TCP socket to a protocol processing thread.
277 */
bf82f9b7 278lwkt_port_t
934c6849
SZ
279tcp_soport(struct socket *so, struct sockaddr *nam __unused,
280 struct mbuf **dummy __unused, int req)
bf82f9b7 281{
9eeaa8a9
JH
282 struct inpcb *inp;
283
8affadf8
JH
284 /* The following processing all take place on Protocol Thread 0. */
285 if (req == PRU_BIND || req == PRU_CONNECT || req == PRU_ATTACH ||
286 req == PRU_LISTEN)
9eeaa8a9
JH
287 return (&tcp_thread[0].td_msgport);
288
ed894f8c 289 inp = so->so_pcb;
9eeaa8a9
JH
290 if (!inp) /* connection reset by peer */
291 return (&tcp_thread[0].td_msgport);
292
293 /*
8affadf8
JH
294 * Already bound and connected or listening. For TCP connections,
295 * the (faddr, fport, laddr, lport) association cannot change now.
296 *
297 * Note: T/TCP code needs some reorganization to fit into
298 * this model. XXX JH
299 *
9eeaa8a9
JH
300 * Rely on type-stable memory and check in protocol handler
301 * to fix race condition here w/ deallocation of inp. XXX JH
302 */
e0b7863e
JH
303 return (&tcp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr,
304 inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport);
bf82f9b7
MD
305}
306
7fe56515
JH
307lwkt_port_t
308tcp_addrport(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
309{
310 return (&tcp_thread[tcp_addrcpu(faddr, fport,
311 laddr, lport)].td_msgport);
312}
313
9eeaa8a9
JH
314/*
315 * Map a UDP socket to a protocol processing thread.
316 */
bf82f9b7 317lwkt_port_t
934c6849
SZ
318udp_soport(struct socket *so, struct sockaddr *nam __unused,
319 struct mbuf **dummy __unused, int req)
bf82f9b7 320{
9eeaa8a9
JH
321 struct inpcb *inp;
322
323 /*
324 * The following processing all take place on Protocol Thread 0:
9b37b73b 325 * bind()
9eeaa8a9 326 * attach() has a null socket parameter
934c6849 327 * Fast and slow timeouts pass in null socket parameter
9eeaa8a9 328 */
9b37b73b 329 if (req == PRU_BIND || so == NULL)
9eeaa8a9
JH
330 return (&udp_thread[0].td_msgport);
331
ed894f8c 332 inp = so->so_pcb;
9eeaa8a9
JH
333
334 if (IN_MULTICAST(ntohl(inp->inp_laddr.s_addr)))
335 return (&udp_thread[0].td_msgport);
336
337 /*
338 * Rely on type-stable memory and check in protocol handler
339 * to fix race condition here w/ deallocation of inp. XXX JH
340 */
bf82f9b7 341
e0b7863e
JH
342 return (&udp_thread[INP_MPORT_HASH(inp->inp_faddr.s_addr,
343 inp->inp_laddr.s_addr, inp->inp_fport, inp->inp_lport)].td_msgport);
bf82f9b7
MD
344}
345
d371a63a
JH
346/*
347 * Map a network address to a processor.
348 */
349int
e0b7863e 350tcp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
d371a63a 351{
e0b7863e 352 return (INP_MPORT_HASH(faddr, laddr, fport, lport));
d371a63a
JH
353}
354
355int
e0b7863e 356udp_addrcpu(in_addr_t faddr, in_port_t fport, in_addr_t laddr, in_port_t lport)
d371a63a 357{
e0b7863e 358 if (IN_MULTICAST(ntohl(laddr)))
d371a63a
JH
359 return (0);
360 else
e0b7863e 361 return (INP_MPORT_HASH(faddr, laddr, fport, lport));
d371a63a
JH
362}
363
0ddb6032
JH
364/*
365 * Return LWKT port for cpu.
366 */
367lwkt_port_t
368tcp_cport(int cpu)
369{
370 return (&tcp_thread[cpu].td_msgport);
371}
372
bf82f9b7
MD
373void
374tcp_thread_init(void)
375{
376 int cpu;
377
a00e7525 378 for (cpu = 0; cpu < ncpus2; cpu++) {
f23061d4 379 lwkt_create(tcpmsg_service_loop, NULL, NULL,
cbb1e737
SZ
380 &tcp_thread[cpu], TDF_NETWORK, cpu,
381 "tcp_thread %d", cpu);
5c703385 382 netmsg_service_port_init(&tcp_thread[cpu].td_msgport);
bf82f9b7
MD
383 }
384}
385
386void
387udp_thread_init(void)
388{
389 int cpu;
390
a00e7525 391 for (cpu = 0; cpu < ncpus2; cpu++) {
37eacd1a
SZ
392 lwkt_create(udp_mpsafe_thread ?
393 netmsg_service_loop_mpsafe : netmsg_service_loop,
cbb1e737 394 NULL, NULL, &udp_thread[cpu], TDF_NETWORK, cpu,
37eacd1a 395 "udp_thread %d", cpu);
5c703385 396 netmsg_service_port_init(&udp_thread[cpu].td_msgport);
bf82f9b7
MD
397 }
398}