1 /* 2 * ng_source.c 3 * 4 * Copyright 2002 Sandvine Inc. 5 * All rights reserved. 6 * 7 * Subject to the following obligations and disclaimer of warranty, use and 8 * redistribution of this software, in source or object code forms, with or 9 * without modifications are expressly permitted by Sandvine Inc.; provided, 10 * however, that: 11 * 1. Any and all reproductions of the source or object code must include the 12 * copyright notice above and the following disclaimer of warranties; and 13 * 2. No rights are granted, in any manner or form, to use Sandvine Inc. 14 * trademarks, including the mark "SANDVINE" on advertising, endorsements, 15 * or otherwise except as such appears in the above copyright notice or in 16 * the software. 17 * 18 * THIS SOFTWARE IS BEING PROVIDED BY SANDVINE "AS IS", AND TO THE MAXIMUM 19 * EXTENT PERMITTED BY LAW, SANDVINE MAKES NO REPRESENTATIONS OR WARRANTIES, 20 * EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, 21 * ANY AND ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 22 * PURPOSE, OR NON-INFRINGEMENT. SANDVINE DOES NOT WARRANT, GUARANTEE, OR 23 * MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE 24 * USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY 25 * OR OTHERWISE. IN NO EVENT SHALL SANDVINE BE LIABLE FOR ANY DAMAGES 26 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 27 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 28 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 29 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 32 * THIS SOFTWARE, EVEN IF SANDVINE IS ADVISED OF THE POSSIBILITY OF SUCH 33 * DAMAGE. 34 * 35 * Author: Dave Chapeskie <dchapeskie@sandvine.com> 36 * 37 * $FreeBSD$ 38 */ 39 40 /* 41 * This node is used for high speed packet geneneration. It queues 42 * all data recieved on it's 'input' hook and when told to start via 43 * a control message it sends the packets out it's 'output' hook. In 44 * this way this node can be preloaded with a packet stream which is 45 * continuously sent. 46 * 47 * Currently it just copies the mbufs as required. It could do various 48 * tricks to try and avoid this. Probably the best performance would 49 * be achieved by modifying the appropriate drivers to be told to 50 * self-re-enqueue packets (e.g. the if_bge driver could reuse the same 51 * transmit descriptors) under control of this node; perhaps via some 52 * flag in the mbuf or some such. The node would peak at an appropriate 53 * ifnet flag to see if such support is available for the connected 54 * interface. 55 */ 56 57 #include <sys/param.h> 58 #include <sys/systm.h> 59 #include <sys/errno.h> 60 #include <sys/kernel.h> 61 #include <sys/malloc.h> 62 #include <sys/mbuf.h> 63 #include <sys/socket.h> 64 #include <net/if.h> 65 #include <net/if_var.h> 66 #include <netgraph/ng_message.h> 67 #include <netgraph/netgraph.h> 68 #include <netgraph/ng_parse.h> 69 #include <netgraph/ng_ether.h> 70 #include <netgraph/ng_source.h> 71 72 #define NG_SOURCE_INTR_TICKS 1 73 #define NG_SOURCE_DRIVER_IFQ_MAXLEN (4*1024) 74 75 76 /* Per hook info */ 77 struct source_hookinfo { 78 hook_p hook; 79 }; 80 81 /* Per node info */ 82 struct privdata { 83 node_p node; 84 struct source_hookinfo input; 85 struct source_hookinfo output; 86 struct ng_source_stats stats; 87 struct ifqueue snd_queue; /* packets to send */ 88 struct ifnet *output_ifp; 89 struct callout_handle intr_ch; 90 u_int64_t packets; /* packets to send */ 91 u_int32_t queueOctets; 92 }; 93 typedef struct privdata *sc_p; 94 95 /* Node flags */ 96 #define NG_SOURCE_ACTIVE (NGF_TYPE1) 97 98 /* XXX */ 99 #if 1 100 #undef KASSERT 101 #define KASSERT(expr,msg) do { \ 102 if (!(expr)) { \ 103 printf msg ; \ 104 panic("Assertion"); \ 105 } \ 106 } while(0) 107 #endif 108 109 /* Netgraph methods */ 110 static ng_constructor_t ng_source_constructor; 111 static ng_rcvmsg_t ng_source_rcvmsg; 112 static ng_shutdown_t ng_source_rmnode; 113 static ng_newhook_t ng_source_newhook; 114 static ng_rcvdata_t ng_source_rcvdata; 115 static ng_disconnect_t ng_source_disconnect; 116 117 /* Other functions */ 118 static timeout_t ng_source_intr; 119 static int ng_source_get_output_ifp (sc_p); 120 static void ng_source_clr_data (sc_p); 121 static void ng_source_start (sc_p); 122 static void ng_source_stop (sc_p); 123 static int ng_source_send (sc_p, int, int *); 124 125 126 /* Parse type for timeval */ 127 static const struct ng_parse_struct_field ng_source_timeval_type_fields[] = 128 { 129 { "tv_sec", &ng_parse_int32_type }, 130 { "tv_usec", &ng_parse_int32_type }, 131 { NULL } 132 }; 133 const struct ng_parse_type ng_source_timeval_type = { 134 &ng_parse_struct_type, 135 &ng_source_timeval_type_fields 136 }; 137 138 /* Parse type for struct ng_source_stats */ 139 static const struct ng_parse_struct_field ng_source_stats_type_fields[] 140 = NG_SOURCE_STATS_TYPE_INFO; 141 static const struct ng_parse_type ng_source_stats_type = { 142 &ng_parse_struct_type, 143 &ng_source_stats_type_fields 144 }; 145 146 /* List of commands and how to convert arguments to/from ASCII */ 147 static const struct ng_cmdlist ng_source_cmds[] = { 148 { 149 NGM_SOURCE_COOKIE, 150 NGM_SOURCE_GET_STATS, 151 "getstats", 152 NULL, 153 &ng_source_stats_type 154 }, 155 { 156 NGM_SOURCE_COOKIE, 157 NGM_SOURCE_CLR_STATS, 158 "clrstats", 159 NULL, 160 NULL 161 }, 162 { 163 NGM_SOURCE_COOKIE, 164 NGM_SOURCE_GETCLR_STATS, 165 "getclrstats", 166 NULL, 167 &ng_source_stats_type 168 }, 169 { 170 NGM_SOURCE_COOKIE, 171 NGM_SOURCE_START, 172 "start", 173 &ng_parse_uint64_type, 174 NULL 175 }, 176 { 177 NGM_SOURCE_COOKIE, 178 NGM_SOURCE_STOP, 179 "stop", 180 NULL, 181 NULL 182 }, 183 { 184 NGM_SOURCE_COOKIE, 185 NGM_SOURCE_CLR_DATA, 186 "clrdata", 187 NULL, 188 NULL 189 }, 190 { 0 } 191 }; 192 193 /* Netgraph type descriptor */ 194 static struct ng_type ng_source_typestruct = { 195 NG_VERSION, 196 NG_SOURCE_NODE_TYPE, 197 NULL, /* module event handler */ 198 ng_source_constructor, 199 ng_source_rcvmsg, 200 ng_source_rmnode, 201 ng_source_newhook, 202 NULL, /* findhook */ 203 NULL, 204 ng_source_rcvdata, /* rcvdata */ 205 ng_source_disconnect, 206 ng_source_cmds 207 }; 208 NETGRAPH_INIT(source, &ng_source_typestruct); 209 210 /* 211 * Node constructor 212 */ 213 static int 214 ng_source_constructor(node_p node) 215 { 216 sc_p sc; 217 218 MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_NOWAIT); 219 if (sc == NULL) 220 return (ENOMEM); 221 bzero(sc, sizeof(*sc)); 222 223 NG_NODE_SET_PRIVATE(node, sc); 224 sc->node = node; 225 sc->snd_queue.ifq_maxlen = 2048; /* XXX not checked */ 226 callout_handle_init(&sc->intr_ch); /* XXX fix.. will 227 cause problems. */ 228 return (0); 229 } 230 231 /* 232 * Add a hook 233 */ 234 static int 235 ng_source_newhook(node_p node, hook_p hook, const char *name) 236 { 237 sc_p sc; 238 239 sc = NG_NODE_PRIVATE(node); 240 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 241 if (strcmp(name, NG_SOURCE_HOOK_INPUT) == 0) { 242 sc->input.hook = hook; 243 NG_HOOK_SET_PRIVATE(hook, &sc->input); 244 } else if (strcmp(name, NG_SOURCE_HOOK_OUTPUT) == 0) { 245 sc->output.hook = hook; 246 NG_HOOK_SET_PRIVATE(hook, &sc->output); 247 sc->output_ifp = 0; 248 bzero(&sc->stats, sizeof(sc->stats)); 249 } else 250 return (EINVAL); 251 return (0); 252 } 253 254 /* 255 * Receive a control message 256 */ 257 static int 258 ng_source_rcvmsg(node_p node, item_p item, hook_p lasthook) 259 { 260 sc_p sc; 261 struct ng_mesg *resp = NULL; 262 int error = 0; 263 struct ng_mesg *msg; 264 265 sc = NG_NODE_PRIVATE(node); 266 NGI_GET_MSG(item, msg); 267 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 268 switch (msg->header.typecookie) { 269 case NGM_SOURCE_COOKIE: 270 switch (msg->header.cmd) { 271 case NGM_SOURCE_GET_STATS: 272 case NGM_SOURCE_CLR_STATS: 273 case NGM_SOURCE_GETCLR_STATS: 274 { 275 struct ng_source_stats *stats; 276 277 if (msg->header.cmd != NGM_SOURCE_CLR_STATS) { 278 NG_MKRESPONSE(resp, msg, 279 sizeof(*stats), M_NOWAIT); 280 if (resp == NULL) { 281 error = ENOMEM; 282 goto done; 283 } 284 sc->stats.queueOctets = sc->queueOctets; 285 sc->stats.queueFrames = sc->snd_queue.ifq_len; 286 if ((sc->node->nd_flags & NG_SOURCE_ACTIVE) 287 && !timevalisset(&sc->stats.endTime)) { 288 getmicrotime(&sc->stats.elapsedTime); 289 timevalsub(&sc->stats.elapsedTime, 290 &sc->stats.startTime); 291 } 292 stats = (struct ng_source_stats *)resp->data; 293 bcopy(&sc->stats, stats, sizeof(* stats)); 294 } 295 if (msg->header.cmd != NGM_SOURCE_GET_STATS) 296 bzero(&sc->stats, sizeof(sc->stats)); 297 } 298 break; 299 case NGM_SOURCE_START: 300 { 301 u_int64_t packets = *(u_int64_t *)msg->data; 302 if (sc->output.hook == NULL) { 303 printf("%s: start on node with no output hook\n" 304 , __FUNCTION__); 305 error = EINVAL; 306 break; 307 } 308 /* TODO validation of packets */ 309 sc->packets = packets; 310 ng_source_start(sc); 311 } 312 break; 313 case NGM_SOURCE_STOP: 314 ng_source_stop(sc); 315 break; 316 case NGM_SOURCE_CLR_DATA: 317 ng_source_clr_data(sc); 318 break; 319 default: 320 error = EINVAL; 321 break; 322 } 323 break; 324 default: 325 error = EINVAL; 326 break; 327 } 328 329 done: 330 /* Take care of synchronous response, if any */ 331 NG_RESPOND_MSG(error, node, item, resp); 332 /* Free the message and return */ 333 NG_FREE_MSG(msg); 334 return (error); 335 } 336 337 /* 338 * Receive data on a hook 339 * 340 * If data comes in the input hook, enqueue it on the send queue. 341 * If data comes in the output hook, discard it. 342 */ 343 static int 344 ng_source_rcvdata(hook_p hook, item_p item) 345 { 346 sc_p sc; 347 struct source_hookinfo *hinfo; 348 int error = 0; 349 struct mbuf *m; 350 351 sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 352 NGI_GET_M(item, m); 353 NG_FREE_ITEM(item); 354 hinfo = NG_HOOK_PRIVATE(hook); 355 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 356 KASSERT(hinfo != NULL, ("%s: null hook info", __FUNCTION__)); 357 358 /* Which hook? */ 359 if (hinfo == &sc->output) { 360 /* discard */ 361 NG_FREE_M(m); 362 return (error); 363 } 364 KASSERT(hinfo == &sc->input, ("%s: no hook!", __FUNCTION__)); 365 366 if ((m->m_flags & M_PKTHDR) == 0) { 367 printf("%s: mbuf without PKTHDR\n", __FUNCTION__); 368 NG_FREE_M(m); 369 return (EINVAL); 370 } 371 372 /* enque packet */ 373 /* XXX should we check IF_QFULL() ? */ 374 IF_ENQUEUE(&sc->snd_queue, m); 375 sc->queueOctets += m->m_pkthdr.len; 376 377 return (0); 378 } 379 380 /* 381 * Shutdown processing 382 */ 383 static int 384 ng_source_rmnode(node_p node) 385 { 386 sc_p sc; 387 388 sc = NG_NODE_PRIVATE(node); 389 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 390 node->nd_flags |= NG_INVALID; 391 ng_source_stop(sc); 392 ng_source_clr_data(sc); 393 NG_NODE_SET_PRIVATE(node, NULL); 394 NG_NODE_UNREF(node); 395 FREE(sc, M_NETGRAPH); 396 return (0); 397 } 398 399 /* 400 * Hook disconnection 401 */ 402 static int 403 ng_source_disconnect(hook_p hook) 404 { 405 struct source_hookinfo *hinfo; 406 sc_p sc; 407 408 hinfo = NG_HOOK_PRIVATE(hook); 409 sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 410 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 411 hinfo->hook = NULL; 412 if (NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0 || hinfo == &sc->output) 413 ng_rmnode_self(NG_HOOK_NODE(hook)); 414 return (0); 415 } 416 417 /* 418 * Set sc->output_ifp to point to the the struct ifnet of the interface 419 * reached via our output hook. 420 */ 421 static int 422 ng_source_get_output_ifp(sc_p sc) 423 { 424 struct ng_mesg *msg, *rsp; 425 struct ifnet *ifp; 426 u_int32_t if_index; 427 int error = 0; 428 int s; 429 430 sc->output_ifp = NULL; 431 432 /* Ask the attached node for the connected interface's index */ 433 NG_MKMESSAGE(msg, NGM_ETHER_COOKIE, NGM_ETHER_GET_IFINDEX, 0, M_NOWAIT); 434 if (msg == NULL) 435 return (ENOBUFS); 436 437 NG_SEND_MSG_HOOK(error, sc->node, msg, sc->output.hook, NULL); 438 /* error = ng_send_msg(sc->node, msg, NG_SOURCE_HOOK_OUTPUT, &rsp); */ 439 #warn "oiks" 440 if (error != 0) 441 return (error); 442 443 if (rsp == NULL) 444 return (EINVAL); 445 446 if (rsp->header.arglen < sizeof(u_int32_t)) 447 return (EINVAL); 448 449 if_index = *(u_int32_t *)rsp->data; 450 /* Could use ifindex2ifnet[if_index] except that we have no 451 * way of verifying if_index is valid since if_indexlim is 452 * local to if_attach() 453 */ 454 TAILQ_FOREACH(ifp, &ifnet, if_link) { 455 if (ifp->if_index == if_index) 456 break; 457 } 458 459 if (ifp == NULL) { 460 printf("%s: can't find interface %d\n", __FUNCTION__, if_index); 461 return (EINVAL); 462 } 463 sc->output_ifp = ifp; 464 465 #if 1 466 /* XXX mucking with a drivers ifqueue size is ugly but we need it 467 * to queue a lot of packets to get close to line rate on a gigabit 468 * interface with small packets. 469 * XXX we should restore the original value at stop or disconnect 470 */ 471 s = splimp(); /* XXX is this required? */ 472 if (ifp->if_snd.ifq_maxlen < NG_SOURCE_DRIVER_IFQ_MAXLEN) 473 { 474 printf("ng_source: changing ifq_maxlen from %d to %d\n", 475 ifp->if_snd.ifq_maxlen, NG_SOURCE_DRIVER_IFQ_MAXLEN); 476 ifp->if_snd.ifq_maxlen = NG_SOURCE_DRIVER_IFQ_MAXLEN; 477 } 478 splx(s); 479 #endif 480 return (0); 481 } 482 483 /* 484 * Set the attached ethernet node's ethernet source address override flag. 485 */ 486 static int 487 ng_source_set_autosrc(sc_p sc, u_int32_t flag) 488 { 489 struct ng_mesg *msg; 490 int error = 0; 491 492 NG_MKMESSAGE(msg, NGM_ETHER_COOKIE, NGM_ETHER_SET_AUTOSRC, 493 sizeof (u_int32_t), M_NOWAIT); 494 if (msg == NULL) 495 return(ENOBUFS); 496 497 *(u_int32_t *)msg->data = flag; 498 NG_SEND_MSG_HOOK(error, sc->node, msg, sc->output.hook, NULL); 499 return (error); 500 } 501 502 /* 503 * Clear out the data we've queued 504 */ 505 static void 506 ng_source_clr_data (sc_p sc) 507 { 508 struct mbuf *m; 509 510 for (;;) { 511 IF_DEQUEUE(&sc->snd_queue, m); 512 if (m == NULL) 513 break; 514 NG_FREE_M(m); 515 } 516 sc->queueOctets = 0; 517 } 518 519 /* 520 * Start sending queued data out the output hook 521 */ 522 static void 523 ng_source_start (sc_p sc) 524 { 525 KASSERT(sc->output.hook != NULL, 526 ("%s: output hook unconnected", __FUNCTION__)); 527 if ((sc->node->nd_flags & NG_SOURCE_ACTIVE) == 0) { 528 if (sc->output_ifp == NULL && ng_source_get_output_ifp(sc) != 0) 529 return; 530 ng_source_set_autosrc(sc, 0); 531 sc->node->nd_flags |= NG_SOURCE_ACTIVE; 532 timevalclear(&sc->stats.elapsedTime); 533 timevalclear(&sc->stats.endTime); 534 getmicrotime(&sc->stats.startTime); 535 sc->intr_ch = timeout(ng_source_intr, sc, 0); 536 } 537 } 538 539 /* 540 * Stop sending queued data out the output hook 541 */ 542 static void 543 ng_source_stop (sc_p sc) 544 { 545 if (sc->node->nd_flags & NG_SOURCE_ACTIVE) { 546 untimeout(ng_source_intr, sc, sc->intr_ch); 547 sc->node->nd_flags &= ~NG_SOURCE_ACTIVE; 548 getmicrotime(&sc->stats.endTime); 549 sc->stats.elapsedTime = sc->stats.endTime; 550 timevalsub(&sc->stats.elapsedTime, &sc->stats.startTime); 551 /* XXX should set this to the initial value instead */ 552 ng_source_set_autosrc(sc, 1); 553 } 554 } 555 556 /* 557 * While active called every NG_SOURCE_INTR_TICKS ticks. 558 * Sends as many packets as the interface connected to our 559 * output hook is able to enqueue. 560 */ 561 static void 562 ng_source_intr (void *arg) 563 { 564 sc_p sc = (sc_p) arg; 565 struct ifqueue *ifq; 566 int packets; 567 568 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 569 570 callout_handle_init(&sc->intr_ch); 571 if (sc->packets == 0 || sc->output.hook == NULL 572 || (sc->node->nd_flags & NG_SOURCE_ACTIVE) == 0) { 573 ng_source_stop(sc); 574 return; 575 } 576 577 ifq = &sc->output_ifp->if_snd; 578 packets = ifq->ifq_maxlen - ifq->ifq_len; 579 ng_source_send(sc, packets, NULL); 580 if (sc->packets == 0) { 581 int s = splnet(); 582 ng_source_stop(sc); 583 splx(s); 584 } else 585 sc->intr_ch = timeout(ng_source_intr, sc, NG_SOURCE_INTR_TICKS); 586 } 587 588 /* 589 * Send packets out our output hook 590 */ 591 static int 592 ng_source_send (sc_p sc, int tosend, int *sent_p) 593 { 594 struct ifqueue tmp_queue; 595 struct mbuf *m, *m2; 596 int sent = 0; 597 int error = 0; 598 int s, s2; 599 600 KASSERT(sc != NULL, ("%s: null node private", __FUNCTION__)); 601 KASSERT(tosend >= 0, ("%s: negative tosend param", __FUNCTION__)); 602 KASSERT(sc->node->nd_flags & NG_SOURCE_ACTIVE, 603 ("%s: inactive node", __FUNCTION__)); 604 605 if ((u_int64_t)tosend > sc->packets) 606 tosend = sc->packets; 607 608 /* Copy the required number of packets to a temporary queue */ 609 bzero (&tmp_queue, sizeof (tmp_queue)); 610 for (sent = 0; error == 0 && sent < tosend; ++sent) { 611 s = splnet(); 612 IF_DEQUEUE(&sc->snd_queue, m); 613 splx(s); 614 if (m == NULL) 615 break; 616 617 /* duplicate the packet */ 618 m2 = m_copypacket(m, M_NOWAIT); 619 if (m2 == NULL) { 620 s = splnet(); 621 IF_PREPEND(&sc->snd_queue, m); 622 splx(s); 623 error = ENOBUFS; 624 break; 625 } 626 627 /* re-enqueue the original packet for us */ 628 s = splnet(); 629 IF_ENQUEUE(&sc->snd_queue, m); 630 splx(s); 631 632 /* queue the copy for sending at smplimp */ 633 IF_ENQUEUE(&tmp_queue, m2); 634 } 635 636 sent = 0; 637 s = splimp(); 638 for (;;) { 639 IF_DEQUEUE(&tmp_queue, m2); 640 if (m2 == NULL) 641 break; 642 if (error == 0) { 643 ++sent; 644 sc->stats.outFrames++; 645 sc->stats.outOctets += m2->m_pkthdr.len; 646 s2 = splnet(); 647 NG_SEND_DATA_ONLY(error, sc->output.hook, m2); 648 splx(s2); 649 } else { 650 NG_FREE_M(m2); 651 } 652 } 653 splx(s); 654 655 sc->packets -= sent; 656 if (sent_p != NULL) 657 *sent_p = sent; 658 return (error); 659 } 660