1 /* 2 * Copyright (c) 2007 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Sepherosa Ziehau <sepherosa@gmail.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sys/net/dummynet/ip_dummynet_glue.c,v 1.4 2007/11/18 13:00:28 sephe Exp $ 35 */ 36 37 #include <sys/param.h> 38 #include <sys/kernel.h> 39 #include <sys/mbuf.h> 40 #include <sys/msgport.h> 41 #include <sys/socketvar.h> 42 #include <sys/sysctl.h> 43 44 #include <net/if.h> 45 #include <net/if_var.h> 46 #include <net/route.h> 47 #include <net/ethernet.h> 48 #include <net/netisr.h> 49 #include <net/netmsg2.h> 50 51 #include <netinet/in.h> 52 #include <netinet/in_var.h> 53 #include <netinet/ip.h> 54 #include <netinet/ip_var.h> 55 56 #include <net/dummynet/ip_dummynet.h> 57 58 static void ip_dn_ether_output(struct netmsg *); 59 static void ip_dn_ether_demux(struct netmsg *); 60 static void ip_dn_ip_input(struct netmsg *); 61 static void ip_dn_ip_output(struct netmsg *); 62 63 static void ip_dn_sockopt_dispatch(struct netmsg *); 64 static void ip_dn_freepkt_dispatch(struct netmsg *); 65 static void ip_dn_dispatch(struct netmsg *); 66 67 static void ip_dn_freepkt(struct dn_pkt *); 68 69 static int ip_dn_sockopt_flush(struct sockopt *); 70 static int ip_dn_sockopt_get(struct sockopt *); 71 static int ip_dn_sockopt_config(struct sockopt *); 72 73 ip_dn_io_t *ip_dn_io_ptr; 74 int ip_dn_cpu = 0; 75 76 TUNABLE_INT("net.inet.ip.dummynet.cpu", &ip_dn_cpu); 77 78 SYSCTL_NODE(_net_inet_ip, OID_AUTO, dummynet, CTLFLAG_RW, 0, "Dummynet"); 79 SYSCTL_INT(_net_inet_ip_dummynet, OID_AUTO, cpu, CTLFLAG_RD, 80 &ip_dn_cpu, 0, "CPU to run dummynet"); 81 82 void 83 ip_dn_queue(struct mbuf *m) 84 { 85 struct netmsg_packet *nmp; 86 lwkt_port_t port; 87 88 KASSERT(m->m_type != MT_TAG, ("mbuf contains old style tag!\n")); 89 M_ASSERTPKTHDR(m); 90 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 91 ("mbuf is not tagged for dummynet!\n")); 92 93 nmp = &m->m_hdr.mh_netmsg; 94 netmsg_init(&nmp->nm_netmsg, &netisr_apanic_rport, 0, 95 ip_dn_dispatch); 96 nmp->nm_packet = m; 97 98 port = cpu_portfn(ip_dn_cpu); 99 lwkt_sendmsg(port, &nmp->nm_netmsg.nm_lmsg); 100 } 101 102 void 103 ip_dn_packet_free(struct dn_pkt *pkt) 104 { 105 struct netmsg_packet *nmp; 106 lwkt_port_t port; 107 struct mbuf *m = pkt->dn_m; 108 109 KASSERT(m->m_type != MT_TAG, ("mbuf contains old style tag!\n")); 110 M_ASSERTPKTHDR(m); 111 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 112 ("mbuf is not tagged for dummynet!\n")); 113 114 if (pkt->cpuid == mycpuid) { 115 ip_dn_freepkt(pkt); 116 return; 117 } 118 119 nmp = &m->m_hdr.mh_netmsg; 120 netmsg_init(&nmp->nm_netmsg, &netisr_apanic_rport, 0, 121 ip_dn_freepkt_dispatch); 122 nmp->nm_packet = m; 123 124 port = cpu_portfn(pkt->cpuid); 125 lwkt_sendmsg(port, &nmp->nm_netmsg.nm_lmsg); 126 } 127 128 void 129 ip_dn_packet_redispatch(struct dn_pkt *pkt) 130 { 131 static const netisr_fn_t dispatches[DN_TO_MAX] = { 132 [DN_TO_IP_OUT] = ip_dn_ip_output, 133 [DN_TO_IP_IN] = ip_dn_ip_input, 134 [DN_TO_ETH_DEMUX] = ip_dn_ether_demux, 135 [DN_TO_ETH_OUT] = ip_dn_ether_output 136 }; 137 138 struct netmsg_packet *nmp; 139 struct mbuf *m; 140 netisr_fn_t dispatch; 141 lwkt_port_t port; 142 int dir; 143 144 dir = (pkt->dn_flags & DN_FLAGS_DIR_MASK); 145 KASSERT(dir < DN_TO_MAX, 146 ("unknown dummynet redispatch dir %d\n", dir)); 147 148 dispatch = dispatches[dir]; 149 KASSERT(dispatch != NULL, 150 ("unsupported dummynet redispatch dir %d\n", dir)); 151 152 m = pkt->dn_m; 153 KASSERT(m->m_type != MT_TAG, ("mbuf contains old style tag!\n")); 154 M_ASSERTPKTHDR(m); 155 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 156 ("mbuf is not tagged for dummynet!\n")); 157 158 nmp = &m->m_hdr.mh_netmsg; 159 netmsg_init(&nmp->nm_netmsg, &netisr_apanic_rport, 0, dispatch); 160 nmp->nm_packet = m; 161 162 port = cpu_portfn(pkt->cpuid); 163 lwkt_sendmsg(port, &nmp->nm_netmsg.nm_lmsg); 164 } 165 166 int 167 ip_dn_sockopt(struct sockopt *sopt) 168 { 169 int error = 0; 170 171 /* Disallow sets in really-really secure mode. */ 172 if (sopt->sopt_dir == SOPT_SET) { 173 if (securelevel >= 3) 174 return EPERM; 175 } 176 177 switch (sopt->sopt_name) { 178 case IP_DUMMYNET_GET: 179 error = ip_dn_sockopt_get(sopt); 180 break; 181 182 case IP_DUMMYNET_FLUSH: 183 error = ip_dn_sockopt_flush(sopt); 184 break; 185 186 case IP_DUMMYNET_DEL: 187 case IP_DUMMYNET_CONFIGURE: 188 error = ip_dn_sockopt_config(sopt); 189 break; 190 191 default: 192 kprintf("%s -- unknown option %d\n", __func__, sopt->sopt_name); 193 error = EINVAL; 194 break; 195 } 196 return error; 197 } 198 199 static void 200 ip_dn_freepkt(struct dn_pkt *pkt) 201 { 202 struct rtentry *rt = pkt->ro.ro_rt; 203 204 /* Unreference route entry */ 205 if (rt != NULL) { 206 if (rt->rt_refcnt <= 0) { /* XXX assert? */ 207 kprintf("-- warning, refcnt now %ld, decreasing\n", 208 rt->rt_refcnt); 209 } 210 RTFREE(rt); 211 } 212 213 /* Unreference packet private data */ 214 if (pkt->dn_unref_priv) 215 pkt->dn_unref_priv(pkt->dn_priv); 216 217 /* Free the parent mbuf, this will free 'pkt' as well */ 218 m_freem(pkt->dn_m); 219 } 220 221 static void 222 ip_dn_freepkt_dispatch(struct netmsg *nmsg) 223 { 224 struct netmsg_packet *nmp; 225 struct mbuf *m; 226 struct m_tag *mtag; 227 struct dn_pkt *pkt; 228 229 nmp = (struct netmsg_packet *)nmsg; 230 m = nmp->nm_packet; 231 M_ASSERTPKTHDR(m); 232 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 233 ("mbuf is not tagged for dummynet!\n")); 234 235 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 236 KKASSERT(mtag != NULL); 237 238 pkt = m_tag_data(mtag); 239 KASSERT(pkt->cpuid == mycpuid, 240 ("%s: dummynet packet was delivered to wrong cpu! " 241 "target cpuid %d, mycpuid %d\n", __func__, 242 pkt->cpuid, mycpuid)); 243 244 ip_dn_freepkt(pkt); 245 } 246 247 static void 248 ip_dn_dispatch(struct netmsg *nmsg) 249 { 250 struct netmsg_packet *nmp; 251 struct mbuf *m; 252 struct m_tag *mtag; 253 struct dn_pkt *pkt; 254 255 KASSERT(ip_dn_cpu == mycpuid, 256 ("%s: dummynet packet was delivered to wrong cpu! " 257 "dummynet cpuid %d, mycpuid %d\n", __func__, 258 ip_dn_cpu, mycpuid)); 259 260 nmp = (struct netmsg_packet *)nmsg; 261 m = nmp->nm_packet; 262 M_ASSERTPKTHDR(m); 263 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 264 ("mbuf is not tagged for dummynet!\n")); 265 266 if (DUMMYNET_LOADED) { 267 if (ip_dn_io_ptr(m) == 0) 268 return; 269 } 270 271 /* 272 * ip_dn_io_ptr() failed or dummynet(4) is not loaded 273 */ 274 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 275 KKASSERT(mtag != NULL); 276 277 pkt = m_tag_data(mtag); 278 ip_dn_packet_free(pkt); 279 } 280 281 static void 282 ip_dn_ip_output(struct netmsg *nmsg) 283 { 284 struct netmsg_packet *nmp; 285 struct mbuf *m; 286 struct m_tag *mtag; 287 struct dn_pkt *pkt; 288 struct rtentry *rt; 289 ip_dn_unref_priv_t unref_priv; 290 void *priv; 291 292 nmp = (struct netmsg_packet *)nmsg; 293 m = nmp->nm_packet; 294 M_ASSERTPKTHDR(m); 295 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 296 ("mbuf is not tagged for dummynet!\n")); 297 298 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 299 KKASSERT(mtag != NULL); 300 301 pkt = m_tag_data(mtag); 302 KASSERT(pkt->cpuid == mycpuid, 303 ("%s: dummynet packet was delivered to wrong cpu! " 304 "target cpuid %d, mycpuid %d\n", __func__, 305 pkt->cpuid, mycpuid)); 306 KASSERT((pkt->dn_flags & DN_FLAGS_DIR_MASK) == DN_TO_IP_OUT, 307 ("wrong direction %d, should be %d\n", 308 (pkt->dn_flags & DN_FLAGS_DIR_MASK), DN_TO_IP_OUT)); 309 310 priv = pkt->dn_priv; 311 unref_priv = pkt->dn_unref_priv; 312 rt = pkt->ro.ro_rt; 313 314 if (rt != NULL && !(rt->rt_flags & RTF_UP)) { 315 /* 316 * Recorded rtentry is gone, when the packet 317 * was on delay line. 318 */ 319 ip_dn_freepkt(pkt); 320 return; 321 } 322 323 ip_output(pkt->dn_m, NULL, NULL, 0, NULL, NULL); 324 325 if (rt != NULL) { 326 if (rt->rt_refcnt <= 0) { /* XXX assert? */ 327 kprintf("-- warning, refcnt now %ld, decreasing\n", 328 rt->rt_refcnt); 329 } 330 RTFREE(rt); 331 } 332 if (unref_priv) 333 unref_priv(priv); 334 } 335 336 static void 337 ip_dn_ip_input(struct netmsg *nmsg) 338 { 339 struct netmsg_packet *nmp; 340 struct mbuf *m; 341 struct m_tag *mtag; 342 struct dn_pkt *pkt; 343 ip_dn_unref_priv_t unref_priv; 344 void *priv; 345 346 nmp = (struct netmsg_packet *)nmsg; 347 m = nmp->nm_packet; 348 M_ASSERTPKTHDR(m); 349 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 350 ("mbuf is not tagged for dummynet!\n")); 351 352 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 353 KKASSERT(mtag != NULL); 354 355 pkt = m_tag_data(mtag); 356 KASSERT(pkt->cpuid == mycpuid, 357 ("%s: dummynet packet was delivered to wrong cpu! " 358 "target cpuid %d, mycpuid %d\n", __func__, 359 pkt->cpuid, mycpuid)); 360 KASSERT(pkt->ro.ro_rt == NULL, 361 ("route entry is not NULL for ip_input\n")); 362 KASSERT((pkt->dn_flags & DN_FLAGS_DIR_MASK) == DN_TO_IP_IN, 363 ("wrong direction %d, should be %d\n", 364 (pkt->dn_flags & DN_FLAGS_DIR_MASK), DN_TO_IP_IN)); 365 366 priv = pkt->dn_priv; 367 unref_priv = pkt->dn_unref_priv; 368 369 ip_input(m); 370 371 if (unref_priv) 372 unref_priv(priv); 373 } 374 375 static void 376 ip_dn_ether_demux(struct netmsg *nmsg) 377 { 378 struct netmsg_packet *nmp; 379 struct mbuf *m; 380 struct m_tag *mtag; 381 struct dn_pkt *pkt; 382 struct ether_header *eh; 383 ip_dn_unref_priv_t unref_priv; 384 void *priv; 385 386 nmp = (struct netmsg_packet *)nmsg; 387 m = nmp->nm_packet; 388 M_ASSERTPKTHDR(m); 389 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 390 ("mbuf is not tagged for dummynet!\n")); 391 392 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 393 KKASSERT(mtag != NULL); 394 395 pkt = m_tag_data(mtag); 396 KASSERT(pkt->cpuid == mycpuid, 397 ("%s: dummynet packet was delivered to wrong cpu! " 398 "target cpuid %d, mycpuid %d\n", __func__, 399 pkt->cpuid, mycpuid)); 400 KASSERT(pkt->ro.ro_rt == NULL, 401 ("route entry is not NULL for ether_demux\n")); 402 KASSERT((pkt->dn_flags & DN_FLAGS_DIR_MASK) == DN_TO_ETH_DEMUX, 403 ("wrong direction %d, should be %d\n", 404 (pkt->dn_flags & DN_FLAGS_DIR_MASK), DN_TO_ETH_DEMUX)); 405 406 priv = pkt->dn_priv; 407 unref_priv = pkt->dn_unref_priv; 408 409 if (m->m_len < ETHER_HDR_LEN && 410 (m = m_pullup(m, ETHER_HDR_LEN)) == NULL) { 411 kprintf("%s: pullup fail, dropping pkt\n", __func__); 412 goto back; 413 } 414 415 /* 416 * Same as ether_input, make eh be a pointer into the mbuf 417 */ 418 eh = mtod(m, struct ether_header *); 419 m_adj(m, ETHER_HDR_LEN); 420 ether_demux(NULL, eh, m); 421 back: 422 if (unref_priv) 423 unref_priv(priv); 424 } 425 426 static void 427 ip_dn_ether_output(struct netmsg *nmsg) 428 { 429 struct netmsg_packet *nmp; 430 struct mbuf *m; 431 struct m_tag *mtag; 432 struct dn_pkt *pkt; 433 ip_dn_unref_priv_t unref_priv; 434 void *priv; 435 436 nmp = (struct netmsg_packet *)nmsg; 437 m = nmp->nm_packet; 438 M_ASSERTPKTHDR(m); 439 KASSERT(m->m_pkthdr.fw_flags & DUMMYNET_MBUF_TAGGED, 440 ("mbuf is not tagged for dummynet!\n")); 441 442 mtag = m_tag_find(m, PACKET_TAG_DUMMYNET, NULL); 443 KKASSERT(mtag != NULL); 444 445 pkt = m_tag_data(mtag); 446 KASSERT(pkt->cpuid == mycpuid, 447 ("%s: dummynet packet was delivered to wrong cpu! " 448 "target cpuid %d, mycpuid %d\n", __func__, 449 pkt->cpuid, mycpuid)); 450 KASSERT(pkt->ro.ro_rt == NULL, 451 ("route entry is not NULL for ether_output_frame\n")); 452 KASSERT((pkt->dn_flags & DN_FLAGS_DIR_MASK) == DN_TO_ETH_OUT, 453 ("wrong direction %d, should be %d\n", 454 (pkt->dn_flags & DN_FLAGS_DIR_MASK), DN_TO_ETH_OUT)); 455 456 priv = pkt->dn_priv; 457 unref_priv = pkt->dn_unref_priv; 458 459 ether_output_frame(pkt->ifp, m); 460 461 if (unref_priv) 462 unref_priv(priv); 463 } 464 465 static void 466 ip_dn_sockopt_dispatch(struct netmsg *nmsg) 467 { 468 lwkt_msg *msg = &nmsg->nm_lmsg; 469 struct dn_sopt *dn_sopt = msg->u.ms_resultp; 470 int error; 471 472 KASSERT(ip_dn_cpu == mycpuid, 473 ("%s: dummynet sockopt is done on wrong cpu! " 474 "dummynet cpuid %d, mycpuid %d\n", __func__, 475 ip_dn_cpu, mycpuid)); 476 477 if (DUMMYNET_LOADED) 478 error = ip_dn_ctl_ptr(dn_sopt); 479 else 480 error = ENOPROTOOPT; 481 lwkt_replymsg(msg, error); 482 } 483 484 static int 485 ip_dn_sockopt_flush(struct sockopt *sopt) 486 { 487 struct dn_sopt dn_sopt; 488 struct netmsg smsg; 489 490 bzero(&dn_sopt, sizeof(dn_sopt)); 491 dn_sopt.dn_sopt_name = sopt->sopt_name; 492 493 netmsg_init(&smsg, &curthread->td_msgport, 0, ip_dn_sockopt_dispatch); 494 smsg.nm_lmsg.u.ms_resultp = &dn_sopt; 495 lwkt_domsg(cpu_portfn(ip_dn_cpu), &smsg.nm_lmsg, 0); 496 497 return smsg.nm_lmsg.ms_error; 498 } 499 500 static int 501 ip_dn_sockopt_get(struct sockopt *sopt) 502 { 503 struct dn_sopt dn_sopt; 504 struct netmsg smsg; 505 int error; 506 507 bzero(&dn_sopt, sizeof(dn_sopt)); 508 dn_sopt.dn_sopt_name = sopt->sopt_name; 509 510 netmsg_init(&smsg, &curthread->td_msgport, 0, ip_dn_sockopt_dispatch); 511 smsg.nm_lmsg.u.ms_resultp = &dn_sopt; 512 lwkt_domsg(cpu_portfn(ip_dn_cpu), &smsg.nm_lmsg, 0); 513 514 error = smsg.nm_lmsg.ms_error; 515 if (error) { 516 KKASSERT(dn_sopt.dn_sopt_arg == NULL); 517 KKASSERT(dn_sopt.dn_sopt_arglen == 0); 518 return error; 519 } 520 521 error = sooptcopyout(sopt, dn_sopt.dn_sopt_arg, dn_sopt.dn_sopt_arglen); 522 kfree(dn_sopt.dn_sopt_arg, M_TEMP); 523 return error; 524 } 525 526 static int 527 ip_dn_sockopt_config(struct sockopt *sopt) 528 { 529 struct dn_ioc_pipe tmp_ioc_pipe; 530 struct dn_sopt dn_sopt; 531 struct netmsg smsg; 532 int error; 533 534 error = sooptcopyin(sopt, &tmp_ioc_pipe, sizeof(tmp_ioc_pipe), 535 sizeof(tmp_ioc_pipe)); 536 if (error) 537 return error; 538 539 bzero(&dn_sopt, sizeof(dn_sopt)); 540 dn_sopt.dn_sopt_name = sopt->sopt_name; 541 dn_sopt.dn_sopt_arg = &tmp_ioc_pipe; 542 dn_sopt.dn_sopt_arglen = sizeof(tmp_ioc_pipe); 543 544 netmsg_init(&smsg, &curthread->td_msgport, 0, ip_dn_sockopt_dispatch); 545 smsg.nm_lmsg.u.ms_resultp = &dn_sopt; 546 lwkt_domsg(cpu_portfn(ip_dn_cpu), &smsg.nm_lmsg, 0); 547 548 return smsg.nm_lmsg.ms_error; 549 } 550