1 /* 2 * ng_h4.c 3 */ 4 5 /*- 6 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $Id: ng_h4.c,v 1.10 2005/10/31 17:57:43 max Exp $ 31 * $FreeBSD: src/sys/netgraph/bluetooth/drivers/h4/ng_h4.c,v 1.17 2007/08/13 17:19:28 emax Exp $ 32 * $DragonFly: src/sys/netgraph7/bluetooth/drivers/h4/ng_h4.c,v 1.2 2008/06/26 23:05:40 dillon Exp $ 33 * $DragonFly: src/sys/netgraph7/bluetooth/drivers/h4/ng_h4.c,v 1.2 2008/06/26 23:05:40 dillon Exp $ 34 * 35 * Based on: 36 * --------- 37 * 38 * FreeBSD: src/sys/netgraph/ng_tty.c 39 * Author: Archie Cobbs <archie@freebsd.org> 40 * 41 */ 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/conf.h> 47 #include <sys/endian.h> 48 #include <sys/errno.h> 49 #include <sys/fcntl.h> 50 #include <sys/ioccom.h> 51 #include <sys/malloc.h> 52 #include <sys/mbuf.h> 53 #include <sys/priv.h> 54 #include <sys/socket.h> 55 #include <sys/tty.h> 56 #include <sys/ttycom.h> 57 #include <net/if.h> 58 #include <net/if_var.h> 59 #include "ng_message.h" 60 #include "netgraph.h" 61 #include "ng_parse.h" 62 #include "bluetooth/include/ng_bluetooth.h" 63 #include "bluetooth/include/ng_hci.h" 64 #include "bluetooth/include/ng_h4.h" 65 #include "bluetooth/drivers/h4/ng_h4_var.h" 66 #include "bluetooth/drivers/h4/ng_h4_prse.h" 67 68 /***************************************************************************** 69 ***************************************************************************** 70 ** This node implements a Bluetooth HCI UART transport layer as per chapter 71 ** H4 of the Bluetooth Specification Book v1.1. It is a terminal line 72 ** discipline that is also a netgraph node. Installing this line discipline 73 ** on a terminal device instantiates a new netgraph node of this type, which 74 ** allows access to the device via the "hook" hook of the node. 75 ** 76 ** Once the line discipline is installed, you can find out the name of the 77 ** corresponding netgraph node via a NGIOCGINFO ioctl(). 78 ***************************************************************************** 79 *****************************************************************************/ 80 81 /* MALLOC define */ 82 #ifndef NG_SEPARATE_MALLOC 83 MALLOC_DEFINE(M_NETGRAPH_H4, "netgraph_h4", "Netgraph Bluetooth H4 node"); 84 #else 85 #define M_NETGRAPH_H4 M_NETGRAPH 86 #endif /* NG_SEPARATE_MALLOC */ 87 88 /* Line discipline methods */ 89 static int ng_h4_open (struct cdev *, struct tty *); 90 static int ng_h4_close (struct tty *, int); 91 static int ng_h4_read (struct tty *, struct uio *, int); 92 static int ng_h4_write (struct tty *, struct uio *, int); 93 static int ng_h4_input (int, struct tty *); 94 static int ng_h4_start (struct tty *); 95 static int ng_h4_ioctl (struct tty *, u_long, caddr_t, 96 int, struct thread *); 97 98 /* Line discipline descriptor */ 99 static struct linesw ng_h4_disc = { 100 ng_h4_open, /* open */ 101 ng_h4_close, /* close */ 102 ng_h4_read, /* read */ 103 ng_h4_write, /* write */ 104 ng_h4_ioctl, /* ioctl */ 105 ng_h4_input, /* input */ 106 ng_h4_start, /* start */ 107 ttymodem /* modem */ 108 }; 109 110 /* Netgraph methods */ 111 static ng_constructor_t ng_h4_constructor; 112 static ng_rcvmsg_t ng_h4_rcvmsg; 113 static ng_shutdown_t ng_h4_shutdown; 114 static ng_newhook_t ng_h4_newhook; 115 static ng_connect_t ng_h4_connect; 116 static ng_rcvdata_t ng_h4_rcvdata; 117 static ng_disconnect_t ng_h4_disconnect; 118 119 /* Other stuff */ 120 static void ng_h4_process_timeout (node_p, hook_p, void *, int); 121 static int ng_h4_mod_event (module_t, int, void *); 122 123 /* Netgraph node type descriptor */ 124 static struct ng_type typestruct = { 125 .version = NG_ABI_VERSION, 126 .name = NG_H4_NODE_TYPE, 127 .mod_event = ng_h4_mod_event, 128 .constructor = ng_h4_constructor, 129 .rcvmsg = ng_h4_rcvmsg, 130 .shutdown = ng_h4_shutdown, 131 .newhook = ng_h4_newhook, 132 .connect = ng_h4_connect, 133 .rcvdata = ng_h4_rcvdata, 134 .disconnect = ng_h4_disconnect, 135 .cmdlist = ng_h4_cmdlist 136 }; 137 NETGRAPH_INIT(h4, &typestruct); 138 MODULE_VERSION(ng_h4, NG_BLUETOOTH_VERSION); 139 140 static int ng_h4_node = 0; 141 142 /***************************************************************************** 143 ***************************************************************************** 144 ** Line discipline methods 145 ***************************************************************************** 146 *****************************************************************************/ 147 148 /* 149 * Set our line discipline on the tty. 150 */ 151 152 static int 153 ng_h4_open(struct cdev *dev, struct tty *tp) 154 { 155 struct thread *td = curthread; 156 char name[NG_NODESIZ]; 157 ng_h4_info_p sc = NULL; 158 int error; 159 160 /* Super-user only */ 161 error = priv_check(td, PRIV_NETGRAPH_TTY); /* XXX */ 162 if (error != 0) 163 return (error); 164 165 /* Initialize private struct */ 166 MALLOC(sc, ng_h4_info_p, sizeof(*sc), M_NETGRAPH_H4, M_WAITOK | M_NULLOK | M_ZERO); 167 if (sc == NULL) 168 return (ENOMEM); 169 170 sc->tp = tp; 171 sc->debug = NG_H4_WARN_LEVEL; 172 173 sc->state = NG_H4_W4_PKT_IND; 174 sc->want = 1; 175 sc->got = 0; 176 177 mtx_init(&sc->outq.ifq_mtx, "ng_h4 node+queue", NULL, MTX_DEF); 178 IFQ_SET_MAXLEN(&sc->outq, NG_H4_DEFAULTQLEN); 179 ng_callout_init(&sc->timo); 180 181 NG_H4_LOCK(sc); 182 183 /* Setup netgraph node */ 184 error = ng_make_node_common(&typestruct, &sc->node); 185 if (error != 0) { 186 NG_H4_UNLOCK(sc); 187 188 printf("%s: Unable to create new node!\n", __func__); 189 190 mtx_destroy(&sc->outq.ifq_mtx); 191 bzero(sc, sizeof(*sc)); 192 FREE(sc, M_NETGRAPH_H4); 193 194 return (error); 195 } 196 197 /* Assign node its name */ 198 snprintf(name, sizeof(name), "%s%d", typestruct.name, ng_h4_node ++); 199 200 error = ng_name_node(sc->node, name); 201 if (error != 0) { 202 NG_H4_UNLOCK(sc); 203 204 printf("%s: %s - node name exists?\n", __func__, name); 205 206 NG_NODE_UNREF(sc->node); 207 mtx_destroy(&sc->outq.ifq_mtx); 208 bzero(sc, sizeof(*sc)); 209 FREE(sc, M_NETGRAPH_H4); 210 211 return (error); 212 } 213 214 /* Set back pointers */ 215 NG_NODE_SET_PRIVATE(sc->node, sc); 216 tp->t_lsc = (caddr_t) sc; 217 218 /* The node has to be a WRITER because data can change node status */ 219 NG_NODE_FORCE_WRITER(sc->node); 220 221 /* 222 * Pre-allocate cblocks to the an appropriate amount. 223 * I'm not sure what is appropriate. 224 */ 225 226 ttyflush(tp, FREAD | FWRITE); 227 clist_alloc_cblocks(&tp->t_canq, 0, 0); 228 clist_alloc_cblocks(&tp->t_rawq, 0, 0); 229 clist_alloc_cblocks(&tp->t_outq, 230 MLEN + NG_H4_HIWATER, MLEN + NG_H4_HIWATER); 231 232 NG_H4_UNLOCK(sc); 233 234 return (error); 235 } /* ng_h4_open */ 236 237 /* 238 * Line specific close routine, called from device close routine 239 * and from ttioctl. This causes the node to be destroyed as well. 240 */ 241 242 static int 243 ng_h4_close(struct tty *tp, int flag) 244 { 245 ng_h4_info_p sc = (ng_h4_info_p) tp->t_lsc; 246 247 ttyflush(tp, FREAD | FWRITE); 248 clist_free_cblocks(&tp->t_outq); 249 250 if (sc != NULL) { 251 NG_H4_LOCK(sc); 252 253 if (callout_pending(&sc->timo)) 254 ng_uncallout(&sc->timo, sc->node); 255 256 tp->t_lsc = NULL; 257 sc->dying = 1; 258 259 NG_H4_UNLOCK(sc); 260 261 ng_rmnode_self(sc->node); 262 } 263 264 return (0); 265 } /* ng_h4_close */ 266 267 /* 268 * Once the device has been turned into a node, we don't allow reading. 269 */ 270 271 static int 272 ng_h4_read(struct tty *tp, struct uio *uio, int flag) 273 { 274 return (EIO); 275 } /* ng_h4_read */ 276 277 /* 278 * Once the device has been turned into a node, we don't allow writing. 279 */ 280 281 static int 282 ng_h4_write(struct tty *tp, struct uio *uio, int flag) 283 { 284 return (EIO); 285 } /* ng_h4_write */ 286 287 /* 288 * We implement the NGIOCGINFO ioctl() defined in ng_message.h. 289 */ 290 291 static int 292 ng_h4_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, 293 struct thread *td) 294 { 295 ng_h4_info_p sc = (ng_h4_info_p) tp->t_lsc; 296 int error = 0; 297 298 if (sc == NULL) 299 return (ENXIO); 300 301 NG_H4_LOCK(sc); 302 303 switch (cmd) { 304 case NGIOCGINFO: 305 #undef NI 306 #define NI(x) ((struct nodeinfo *)(x)) 307 308 bzero(data, sizeof(*NI(data))); 309 310 if (NG_NODE_HAS_NAME(sc->node)) 311 strncpy(NI(data)->name, NG_NODE_NAME(sc->node), 312 sizeof(NI(data)->name) - 1); 313 314 strncpy(NI(data)->type, sc->node->nd_type->name, 315 sizeof(NI(data)->type) - 1); 316 317 NI(data)->id = (u_int32_t) ng_node2ID(sc->node); 318 NI(data)->hooks = NG_NODE_NUMHOOKS(sc->node); 319 break; 320 321 default: 322 error = ENOIOCTL; 323 break; 324 } 325 326 NG_H4_UNLOCK(sc); 327 328 return (error); 329 } /* ng_h4_ioctl */ 330 331 /* 332 * Receive data coming from the device. We get one character at a time, which 333 * is kindof silly. 334 */ 335 336 static int 337 ng_h4_input(int c, struct tty *tp) 338 { 339 ng_h4_info_p sc = (ng_h4_info_p) tp->t_lsc; 340 341 if (sc == NULL || tp != sc->tp || 342 sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) 343 return (0); 344 345 NG_H4_LOCK(sc); 346 347 /* Check for error conditions */ 348 if ((tp->t_state & TS_CONNECTED) == 0) { 349 NG_H4_INFO("%s: %s - no carrier\n", __func__, 350 NG_NODE_NAME(sc->node)); 351 352 sc->state = NG_H4_W4_PKT_IND; 353 sc->want = 1; 354 sc->got = 0; 355 356 NG_H4_UNLOCK(sc); 357 358 return (0); /* XXX Loss of synchronization here! */ 359 } 360 361 /* Check for framing error or overrun on this char */ 362 if (c & TTY_ERRORMASK) { 363 NG_H4_ERR("%s: %s - line error %#x, c=%#x\n", __func__, 364 NG_NODE_NAME(sc->node), c & TTY_ERRORMASK, 365 c & TTY_CHARMASK); 366 367 NG_H4_STAT_IERROR(sc->stat); 368 369 sc->state = NG_H4_W4_PKT_IND; 370 sc->want = 1; 371 sc->got = 0; 372 373 NG_H4_UNLOCK(sc); 374 375 return (0); /* XXX Loss of synchronization here! */ 376 } 377 378 NG_H4_STAT_BYTES_RECV(sc->stat, 1); 379 380 /* Append char to mbuf */ 381 if (sc->got >= sizeof(sc->ibuf)) { 382 NG_H4_ALERT("%s: %s - input buffer overflow, c=%#x, got=%d\n", 383 __func__, NG_NODE_NAME(sc->node), c & TTY_CHARMASK, 384 sc->got); 385 386 NG_H4_STAT_IERROR(sc->stat); 387 388 sc->state = NG_H4_W4_PKT_IND; 389 sc->want = 1; 390 sc->got = 0; 391 392 NG_H4_UNLOCK(sc); 393 394 return (0); /* XXX Loss of synchronization here! */ 395 } 396 397 sc->ibuf[sc->got ++] = (c & TTY_CHARMASK); 398 399 NG_H4_INFO("%s: %s - got char %#x, want=%d, got=%d\n", __func__, 400 NG_NODE_NAME(sc->node), c, sc->want, sc->got); 401 402 if (sc->got < sc->want) { 403 NG_H4_UNLOCK(sc); 404 405 return (0); /* Wait for more */ 406 } 407 408 switch (sc->state) { 409 /* Got packet indicator */ 410 case NG_H4_W4_PKT_IND: 411 NG_H4_INFO("%s: %s - got packet indicator %#x\n", __func__, 412 NG_NODE_NAME(sc->node), sc->ibuf[0]); 413 414 sc->state = NG_H4_W4_PKT_HDR; 415 416 /* 417 * Since packet indicator included in the packet header 418 * just set sc->want to sizeof(packet header). 419 */ 420 421 switch (sc->ibuf[0]) { 422 case NG_HCI_ACL_DATA_PKT: 423 sc->want = sizeof(ng_hci_acldata_pkt_t); 424 break; 425 426 case NG_HCI_SCO_DATA_PKT: 427 sc->want = sizeof(ng_hci_scodata_pkt_t); 428 break; 429 430 case NG_HCI_EVENT_PKT: 431 sc->want = sizeof(ng_hci_event_pkt_t); 432 break; 433 434 default: 435 NG_H4_WARN("%s: %s - ignoring unknown packet " \ 436 "type=%#x\n", __func__, NG_NODE_NAME(sc->node), 437 sc->ibuf[0]); 438 439 NG_H4_STAT_IERROR(sc->stat); 440 441 sc->state = NG_H4_W4_PKT_IND; 442 sc->want = 1; 443 sc->got = 0; 444 break; 445 } 446 break; 447 448 /* Got packet header */ 449 case NG_H4_W4_PKT_HDR: 450 sc->state = NG_H4_W4_PKT_DATA; 451 452 switch (sc->ibuf[0]) { 453 case NG_HCI_ACL_DATA_PKT: 454 c = le16toh(((ng_hci_acldata_pkt_t *) 455 (sc->ibuf))->length); 456 break; 457 458 case NG_HCI_SCO_DATA_PKT: 459 c = ((ng_hci_scodata_pkt_t *)(sc->ibuf))->length; 460 break; 461 462 case NG_HCI_EVENT_PKT: 463 c = ((ng_hci_event_pkt_t *)(sc->ibuf))->length; 464 break; 465 466 default: 467 KASSERT((0), ("Invalid packet type=%#x\n", 468 sc->ibuf[0])); 469 break; 470 } 471 472 NG_H4_INFO("%s: %s - got packet header, packet type=%#x, " \ 473 "packet size=%d, payload size=%d\n", __func__, 474 NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got, c); 475 476 if (c > 0) { 477 sc->want += c; 478 479 /* 480 * Try to prevent possible buffer overrun 481 * 482 * XXX I'm *really* confused here. It turns out 483 * that Xircom card sends us packets with length 484 * greater then 512 bytes! This is greater then 485 * our old receive buffer (ibuf) size. In the same 486 * time the card demands from us *not* to send 487 * packets greater then 192 bytes. Weird! How the 488 * hell i should know how big *receive* buffer 489 * should be? For now increase receiving buffer 490 * size to 1K and add the following check. 491 */ 492 493 if (sc->want >= sizeof(sc->ibuf)) { 494 int b; 495 496 NG_H4_ALERT("%s: %s - packet too big for " \ 497 "buffer, type=%#x, got=%d, want=%d, " \ 498 "length=%d\n", __func__, 499 NG_NODE_NAME(sc->node), sc->ibuf[0], 500 sc->got, sc->want, c); 501 502 NG_H4_ALERT("Packet header:\n"); 503 for (b = 0; b < sc->got; b++) 504 NG_H4_ALERT("%#x ", sc->ibuf[b]); 505 NG_H4_ALERT("\n"); 506 507 /* Reset state */ 508 NG_H4_STAT_IERROR(sc->stat); 509 510 sc->state = NG_H4_W4_PKT_IND; 511 sc->want = 1; 512 sc->got = 0; 513 } 514 515 break; 516 } 517 518 /* else FALLTHROUGH and deliver frame */ 519 /* XXX Is this true? Should we deliver empty frame? */ 520 521 /* Got packet data */ 522 case NG_H4_W4_PKT_DATA: 523 NG_H4_INFO("%s: %s - got full packet, packet type=%#x, " \ 524 "packet size=%d\n", __func__, 525 NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got); 526 527 if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) { 528 struct mbuf *m = NULL; 529 530 MGETHDR(m, MB_DONTWAIT, MT_DATA); 531 if (m != NULL) { 532 m->m_pkthdr.len = 0; 533 534 /* XXX m_copyback() is stupid */ 535 m->m_len = min(MHLEN, sc->got); 536 537 m_copyback(m, 0, sc->got, sc->ibuf); 538 NG_SEND_DATA_ONLY(c, sc->hook, m); 539 } else { 540 NG_H4_ERR("%s: %s - could not get mbuf\n", 541 __func__, NG_NODE_NAME(sc->node)); 542 543 NG_H4_STAT_IERROR(sc->stat); 544 } 545 } 546 547 sc->state = NG_H4_W4_PKT_IND; 548 sc->want = 1; 549 sc->got = 0; 550 551 NG_H4_STAT_PCKTS_RECV(sc->stat); 552 break; 553 554 default: 555 KASSERT((0), ("Invalid H4 node state=%d", sc->state)); 556 break; 557 } 558 559 NG_H4_UNLOCK(sc); 560 561 return (0); 562 } /* ng_h4_input */ 563 564 /* 565 * This is called when the device driver is ready for more output. Called from 566 * tty system. 567 */ 568 569 static int 570 ng_h4_start(struct tty *tp) 571 { 572 ng_h4_info_p sc = (ng_h4_info_p) tp->t_lsc; 573 struct mbuf *m = NULL; 574 int size; 575 576 if (sc == NULL || tp != sc->tp || 577 sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) 578 return (0); 579 580 #if 0 581 while (tp->t_outq.c_cc < NG_H4_HIWATER) { /* XXX 2.2 specific ? */ 582 #else 583 while (1) { 584 #endif 585 /* Remove first mbuf from queue */ 586 IF_DEQUEUE(&sc->outq, m); 587 if (m == NULL) 588 break; 589 590 /* Send as much of it as possible */ 591 while (m != NULL) { 592 size = m->m_len - b_to_q(mtod(m, u_char *), 593 m->m_len, &tp->t_outq); 594 595 NG_H4_LOCK(sc); 596 NG_H4_STAT_BYTES_SENT(sc->stat, size); 597 NG_H4_UNLOCK(sc); 598 599 m->m_data += size; 600 m->m_len -= size; 601 if (m->m_len > 0) 602 break; /* device can't take no more */ 603 604 m = m_free(m); 605 } 606 607 /* Put remainder of mbuf chain (if any) back on queue */ 608 if (m != NULL) { 609 IF_PREPEND(&sc->outq, m); 610 break; 611 } 612 613 /* Full packet has been sent */ 614 NG_H4_LOCK(sc); 615 NG_H4_STAT_PCKTS_SENT(sc->stat); 616 NG_H4_UNLOCK(sc); 617 } 618 619 /* 620 * Call output process whether or not there is any output. We are 621 * being called in lieu of ttstart and must do what it would. 622 */ 623 624 tt_oproc(sc->tp); 625 626 /* 627 * This timeout is needed for operation on a pseudo-tty, because the 628 * pty code doesn't call pppstart after it has drained the t_outq. 629 */ 630 631 NG_H4_LOCK(sc); 632 633 if (!IFQ_IS_EMPTY(&sc->outq) && !callout_pending(&sc->timo)) 634 ng_callout(&sc->timo, sc->node, NULL, 1, 635 ng_h4_process_timeout, NULL, 0); 636 637 NG_H4_UNLOCK(sc); 638 639 return (0); 640 } /* ng_h4_start */ 641 642 /***************************************************************************** 643 ***************************************************************************** 644 ** Netgraph node methods 645 ***************************************************************************** 646 *****************************************************************************/ 647 648 /* 649 * Initialize a new node of this type. We only allow nodes to be created as 650 * a result of setting the line discipline on a tty, so always return an error 651 * if not. 652 */ 653 654 static int 655 ng_h4_constructor(node_p node) 656 { 657 return (EOPNOTSUPP); 658 } /* ng_h4_constructor */ 659 660 /* 661 * Add a new hook. There can only be one. 662 */ 663 664 static int 665 ng_h4_newhook(node_p node, hook_p hook, const char *name) 666 { 667 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 668 669 if (strcmp(name, NG_H4_HOOK) != 0) 670 return (EINVAL); 671 672 NG_H4_LOCK(sc); 673 674 if (sc->hook != NULL) { 675 NG_H4_UNLOCK(sc); 676 return (EISCONN); 677 } 678 sc->hook = hook; 679 680 NG_H4_UNLOCK(sc); 681 682 return (0); 683 } /* ng_h4_newhook */ 684 685 /* 686 * Connect hook. Just say yes. 687 */ 688 689 static int 690 ng_h4_connect(hook_p hook) 691 { 692 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 693 694 if (hook != sc->hook) 695 panic("%s: hook != sc->hook\n", __func__); 696 697 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); 698 NG_HOOK_FORCE_QUEUE(hook); 699 700 return (0); 701 } /* ng_h4_connect */ 702 703 /* 704 * Disconnect the hook 705 */ 706 707 static int 708 ng_h4_disconnect(hook_p hook) 709 { 710 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 711 712 /* 713 * We need to check for sc != NULL because we can be called from 714 * ng_h4_close() via ng_rmnode_self() 715 */ 716 717 if (sc != NULL) { 718 if (hook != sc->hook) 719 panic("%s: hook != sc->hook\n", __func__); 720 721 NG_H4_LOCK(sc); 722 723 /* XXX do we have to untimeout and drain out queue? */ 724 if (callout_pending(&sc->timo)) 725 ng_uncallout(&sc->timo, sc->node); 726 727 _IF_DRAIN(&sc->outq); 728 729 sc->state = NG_H4_W4_PKT_IND; 730 sc->want = 1; 731 sc->got = 0; 732 733 sc->hook = NULL; 734 735 NG_H4_UNLOCK(sc); 736 } 737 738 return (0); 739 } /* ng_h4_disconnect */ 740 741 /* 742 * Remove this node. The does the netgraph portion of the shutdown. 743 * This should only be called indirectly from ng_h4_close(). 744 */ 745 746 static int 747 ng_h4_shutdown(node_p node) 748 { 749 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 750 751 NG_H4_LOCK(sc); 752 753 if (!sc->dying) { 754 NG_H4_UNLOCK(sc); 755 756 NG_NODE_REVIVE(node); /* we will persist */ 757 758 return (EOPNOTSUPP); 759 } 760 761 NG_H4_UNLOCK(sc); 762 763 NG_NODE_SET_PRIVATE(node, NULL); 764 765 _IF_DRAIN(&sc->outq); 766 767 NG_NODE_UNREF(node); 768 mtx_destroy(&sc->outq.ifq_mtx); 769 bzero(sc, sizeof(*sc)); 770 FREE(sc, M_NETGRAPH_H4); 771 772 return (0); 773 } /* ng_h4_shutdown */ 774 775 /* 776 * Receive incoming data from Netgraph system. Put it on our 777 * output queue and start output if necessary. 778 */ 779 780 static int 781 ng_h4_rcvdata(hook_p hook, item_p item) 782 { 783 ng_h4_info_p sc = (ng_h4_info_p)NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 784 struct mbuf *m = NULL; 785 int qlen; 786 787 if (sc == NULL) 788 return (EHOSTDOWN); 789 790 if (hook != sc->hook) 791 panic("%s: hook != sc->hook\n", __func__); 792 793 NGI_GET_M(item, m); 794 NG_FREE_ITEM(item); 795 796 NG_H4_LOCK(sc); 797 798 if (_IF_QFULL(&sc->outq)) { 799 NG_H4_ERR("%s: %s - dropping mbuf, len=%d\n", __func__, 800 NG_NODE_NAME(sc->node), m->m_pkthdr.len); 801 802 NG_H4_STAT_OERROR(sc->stat); 803 _IF_DROP(&sc->outq); 804 805 NG_H4_UNLOCK(sc); 806 807 NG_FREE_M(m); 808 809 return (ENOBUFS); 810 } 811 812 NG_H4_INFO("%s: %s - queue mbuf, len=%d\n", __func__, 813 NG_NODE_NAME(sc->node), m->m_pkthdr.len); 814 815 _IF_ENQUEUE(&sc->outq, m); 816 qlen = _IF_QLEN(&sc->outq); 817 818 NG_H4_UNLOCK(sc); 819 820 /* 821 * If qlen > 1, then we should already have a scheduled callout 822 */ 823 824 if (qlen == 1) { 825 mtx_lock(&Giant); 826 ng_h4_start(sc->tp); 827 mtx_unlock(&Giant); 828 } 829 830 return (0); 831 } /* ng_h4_rcvdata */ 832 833 /* 834 * Receive control message 835 */ 836 837 static int 838 ng_h4_rcvmsg(node_p node, item_p item, hook_p lasthook) 839 { 840 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 841 struct ng_mesg *msg = NULL, *resp = NULL; 842 int error = 0; 843 844 if (sc == NULL) 845 return (EHOSTDOWN); 846 847 NGI_GET_MSG(item, msg); 848 NG_H4_LOCK(sc); 849 850 switch (msg->header.typecookie) { 851 case NGM_GENERIC_COOKIE: 852 switch (msg->header.cmd) { 853 case NGM_TEXT_STATUS: 854 NG_MKRESPONSE(resp, msg, NG_TEXTRESPONSE, M_WAITOK | M_NULLOK); 855 if (resp == NULL) 856 error = ENOMEM; 857 else 858 snprintf(resp->data, NG_TEXTRESPONSE, 859 "Hook: %s\n" \ 860 "Debug: %d\n" \ 861 "State: %d\n" \ 862 "Queue: [have:%d,max:%d]\n" \ 863 "Input: [got:%d,want:%d]", 864 (sc->hook != NULL)? NG_H4_HOOK : "", 865 sc->debug, 866 sc->state, 867 _IF_QLEN(&sc->outq), 868 sc->outq.ifq_maxlen, 869 sc->got, 870 sc->want); 871 break; 872 873 default: 874 error = EINVAL; 875 break; 876 } 877 break; 878 879 case NGM_H4_COOKIE: 880 switch (msg->header.cmd) { 881 case NGM_H4_NODE_RESET: 882 _IF_DRAIN(&sc->outq); 883 sc->state = NG_H4_W4_PKT_IND; 884 sc->want = 1; 885 sc->got = 0; 886 break; 887 888 case NGM_H4_NODE_GET_STATE: 889 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_state_ep), 890 M_WAITOK | M_NULLOK); 891 if (resp == NULL) 892 error = ENOMEM; 893 else 894 *((ng_h4_node_state_ep *)(resp->data)) = 895 sc->state; 896 break; 897 898 case NGM_H4_NODE_GET_DEBUG: 899 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_debug_ep), 900 M_WAITOK | M_NULLOK); 901 if (resp == NULL) 902 error = ENOMEM; 903 else 904 *((ng_h4_node_debug_ep *)(resp->data)) = 905 sc->debug; 906 break; 907 908 case NGM_H4_NODE_SET_DEBUG: 909 if (msg->header.arglen != sizeof(ng_h4_node_debug_ep)) 910 error = EMSGSIZE; 911 else 912 sc->debug = 913 *((ng_h4_node_debug_ep *)(msg->data)); 914 break; 915 916 case NGM_H4_NODE_GET_QLEN: 917 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_qlen_ep), 918 M_WAITOK | M_NULLOK); 919 if (resp == NULL) 920 error = ENOMEM; 921 else 922 *((ng_h4_node_qlen_ep *)(resp->data)) = 923 sc->outq.ifq_maxlen; 924 break; 925 926 case NGM_H4_NODE_SET_QLEN: 927 if (msg->header.arglen != sizeof(ng_h4_node_qlen_ep)) 928 error = EMSGSIZE; 929 else if (*((ng_h4_node_qlen_ep *)(msg->data)) <= 0) 930 error = EINVAL; 931 else 932 IFQ_SET_MAXLEN(&sc->outq, 933 *((ng_h4_node_qlen_ep *)(msg->data))); 934 break; 935 936 case NGM_H4_NODE_GET_STAT: 937 NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_stat_ep), 938 M_WAITOK | M_NULLOK); 939 if (resp == NULL) 940 error = ENOMEM; 941 else 942 bcopy(&sc->stat, resp->data, 943 sizeof(ng_h4_node_stat_ep)); 944 break; 945 946 case NGM_H4_NODE_RESET_STAT: 947 NG_H4_STAT_RESET(sc->stat); 948 break; 949 950 default: 951 error = EINVAL; 952 break; 953 } 954 break; 955 956 default: 957 error = EINVAL; 958 break; 959 } 960 961 NG_H4_UNLOCK(sc); 962 963 NG_RESPOND_MSG(error, node, item, resp); 964 NG_FREE_MSG(msg); 965 966 return (error); 967 } /* ng_h4_rcvmsg */ 968 969 /* 970 * Timeout processing function. 971 * We still have data to output to the device, so try sending more. 972 */ 973 974 static void 975 ng_h4_process_timeout(node_p node, hook_p hook, void *arg1, int arg2) 976 { 977 ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); 978 979 mtx_lock(&Giant); 980 ng_h4_start(sc->tp); 981 mtx_unlock(&Giant); 982 } /* ng_h4_process_timeout */ 983 984 /* 985 * Handle loading and unloading for this node type 986 */ 987 988 static int 989 ng_h4_mod_event(module_t mod, int event, void *data) 990 { 991 static int ng_h4_ldisc; 992 int error = 0; 993 994 switch (event) { 995 case MOD_LOAD: 996 /* Register line discipline */ 997 mtx_lock(&Giant); 998 ng_h4_ldisc = ldisc_register(H4DISC, &ng_h4_disc); 999 mtx_unlock(&Giant); 1000 1001 if (ng_h4_ldisc < 0) { 1002 printf("%s: can't register H4 line discipline\n", 1003 __func__); 1004 error = EIO; 1005 } 1006 break; 1007 1008 case MOD_UNLOAD: 1009 /* Unregister line discipline */ 1010 mtx_lock(&Giant); 1011 ldisc_deregister(ng_h4_ldisc); 1012 mtx_unlock(&Giant); 1013 break; 1014 1015 default: 1016 error = EOPNOTSUPP; 1017 break; 1018 } 1019 1020 return (error); 1021 } /* ng_h4_mod_event */ 1022 1023