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