ng_tty.c revision 140164
15480Swollman/* 250476Speter * ng_tty.c 31638Srgrimes */ 4156813Sru 5156813Sru/*- 65480Swollman * Copyright (c) 1996-1999 Whistle Communications, Inc. 735155Sjkh * All rights reserved. 85480Swollman * 91638Srgrimes * Subject to the following obligations and disclaimer of warranty, use and 105480Swollman * redistribution of this software, in source or object code forms, with or 115480Swollman * without modifications are expressly permitted by Whistle Communications; 121638Srgrimes * provided, however, that: 13124750Sru * 1. Any and all reproductions of the source or object code must include the 14124750Sru * copyright notice above and the following disclaimer of warranties; and 15124750Sru * 2. No rights are granted, in any manner or form, to use Whistle 16124750Sru * Communications, Inc. trademarks, including the mark "WHISTLE 17124750Sru * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 18124750Sru * such appears in the above copyright notice or in the software. 19124750Sru * 20124750Sru * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 21239739Sjhb * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 22124750Sru * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 23124750Sru * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 24124750Sru * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 25124750Sru * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 261638Srgrimes * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 27156813Sru * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 28124750Sru * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 2986252Sgshapiro * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 3086252Sgshapiro * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31239739Sjhb * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 32239739Sjhb * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 33239739Sjhb * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34239739Sjhb * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35291792Sbdrewery * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 36291792Sbdrewery * OF SUCH DAMAGE. 371638Srgrimes * 38 * Author: Archie Cobbs <archie@freebsd.org> 39 * 40 * $FreeBSD: head/sys/netgraph/ng_tty.c 140164 2005-01-13 07:43:12Z glebius $ 41 * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $ 42 */ 43 44/* 45 * This file implements a terminal line discipline that is also a 46 * netgraph node. Installing this line discipline on a terminal device 47 * instantiates a new netgraph node of this type, which allows access 48 * to the device via the "hook" hook of the node. 49 * 50 * Once the line discipline is installed, you can find out the name 51 * of the corresponding netgraph node via a NGIOCGINFO ioctl(). 52 * 53 * Incoming characters are delievered to the hook one at a time, each 54 * in its own mbuf. You may optionally define a ``hotchar,'' which causes 55 * incoming characters to be buffered up until either the hotchar is 56 * seen or the mbuf is full (MHLEN bytes). Then all buffered characters 57 * are immediately delivered. 58 */ 59 60#include <sys/param.h> 61#include <sys/systm.h> 62#include <sys/conf.h> 63#include <sys/errno.h> 64#include <sys/fcntl.h> 65#include <sys/ioccom.h> 66#include <sys/kernel.h> 67#include <sys/malloc.h> 68#include <sys/mbuf.h> 69#include <sys/socket.h> 70#include <sys/syslog.h> 71#include <sys/tty.h> 72#include <sys/ttycom.h> 73 74#include <net/if.h> 75#include <net/if_var.h> 76 77#include <netgraph/ng_message.h> 78#include <netgraph/netgraph.h> 79#include <netgraph/ng_tty.h> 80 81/* Misc defs */ 82#define MAX_MBUFQ 3 /* Max number of queued mbufs */ 83#define NGT_HIWATER 400 /* High water mark on output */ 84 85/* Per-node private info */ 86struct ngt_sc { 87 struct tty *tp; /* Terminal device */ 88 node_p node; /* Netgraph node */ 89 hook_p hook; /* Netgraph hook */ 90 struct ifqueue outq; /* Queue of outgoing data */ 91 struct mbuf *m; /* Incoming data buffer */ 92 short hotchar; /* Hotchar, or -1 if none */ 93 u_int flags; /* Flags */ 94 struct callout chand; /* See man timeout(9) */ 95}; 96typedef struct ngt_sc *sc_p; 97 98/* Flags */ 99#define FLG_DEBUG 0x0002 100#define FLG_DIE 0x0004 101 102/* Line discipline methods */ 103static int ngt_open(struct cdev *dev, struct tty *tp); 104static int ngt_close(struct tty *tp, int flag); 105static int ngt_read(struct tty *tp, struct uio *uio, int flag); 106static int ngt_write(struct tty *tp, struct uio *uio, int flag); 107static int ngt_tioctl(struct tty *tp, 108 u_long cmd, caddr_t data, int flag, struct thread *); 109static int ngt_input(int c, struct tty *tp); 110static int ngt_start(struct tty *tp); 111 112/* Netgraph methods */ 113static ng_constructor_t ngt_constructor; 114static ng_rcvmsg_t ngt_rcvmsg; 115static ng_shutdown_t ngt_shutdown; 116static ng_newhook_t ngt_newhook; 117static ng_connect_t ngt_connect; 118static ng_rcvdata_t ngt_rcvdata; 119static ng_disconnect_t ngt_disconnect; 120static int ngt_mod_event(module_t mod, int event, void *data); 121 122/* Other stuff */ 123static void ngt_timeout(node_p node, hook_p hook, void *arg1, int arg2); 124 125#define ERROUT(x) do { error = (x); goto done; } while (0) 126 127/* Line discipline descriptor */ 128static struct linesw ngt_disc = { 129 .l_open = ngt_open, 130 .l_close = ngt_close, 131 .l_read = ngt_read, 132 .l_write = ngt_write, 133 .l_ioctl = ngt_tioctl, 134 .l_rint = ngt_input, 135 .l_start = ngt_start, 136 .l_modem = ttymodem, 137}; 138 139/* Netgraph node type descriptor */ 140static struct ng_type typestruct = { 141 .version = NG_ABI_VERSION, 142 .name = NG_TTY_NODE_TYPE, 143 .mod_event = ngt_mod_event, 144 .constructor = ngt_constructor, 145 .rcvmsg = ngt_rcvmsg, 146 .shutdown = ngt_shutdown, 147 .newhook = ngt_newhook, 148 .connect = ngt_connect, 149 .rcvdata = ngt_rcvdata, 150 .disconnect = ngt_disconnect, 151}; 152NETGRAPH_INIT(tty, &typestruct); 153 154/* 155 * Locking: 156 * 157 * - node private data and tp->t_lsc is protected by mutex in struct 158 * ifqueue, locking is done using IF_XXX() macros. 159 * - in all tty methods we should acquire node ifqueue mutex, when accessing 160 * private data. 161 * - in _rcvdata() we should use locked versions of IF_{EN,DE}QUEUE() since 162 * we may have multiple _rcvdata() threads. 163 * - when calling any of tty methods from netgraph methods, we should 164 * acquire tty locking (now Giant). 165 * 166 * - ngt_unit is incremented atomically. 167 */ 168 169#define NGTLOCK(sc) IF_LOCK(&sc->outq) 170#define NGTUNLOCK(sc) IF_UNLOCK(&sc->outq) 171 172static int ngt_unit; 173static int ngt_ldisc; 174 175/****************************************************************** 176 LINE DISCIPLINE METHODS 177******************************************************************/ 178 179/* 180 * Set our line discipline on the tty. 181 * Called from device open routine or ttioctl() 182 */ 183static int 184ngt_open(struct cdev *dev, struct tty *tp) 185{ 186 struct thread *const td = curthread; /* XXX */ 187 char name[sizeof(NG_TTY_NODE_TYPE) + 8]; 188 sc_p sc; 189 int error; 190 191 /* Super-user only */ 192 if ((error = suser(td))) 193 return (error); 194 195 /* Initialize private struct */ 196 MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO); 197 if (sc == NULL) 198 return (ENOMEM); 199 200 sc->tp = tp; 201 sc->hotchar = tp->t_hotchar = NG_TTY_DFL_HOTCHAR; 202 mtx_init(&sc->outq.ifq_mtx, "ng_tty node+queue", NULL, MTX_DEF); 203 IFQ_SET_MAXLEN(&sc->outq, MAX_MBUFQ); 204 205 NGTLOCK(sc); 206 207 /* Setup netgraph node */ 208 error = ng_make_node_common(&typestruct, &sc->node); 209 if (error) { 210 NGTUNLOCK(sc); 211 FREE(sc, M_NETGRAPH); 212 return (error); 213 } 214 215 atomic_add_int(&ngt_unit, 1); 216 snprintf(name, sizeof(name), "%s%d", typestruct.name, ngt_unit); 217 218 /* Assign node its name */ 219 if ((error = ng_name_node(sc->node, name))) { 220 sc->flags |= FLG_DIE; 221 NGTUNLOCK(sc); 222 NG_NODE_UNREF(sc->node); 223 log(LOG_ERR, "%s: node name exists?\n", name); 224 return (error); 225 } 226 227 /* Set back pointers */ 228 NG_NODE_SET_PRIVATE(sc->node, sc); 229 tp->t_lsc = sc; 230 231 ng_callout_init(&sc->chand); 232 233 /* 234 * Pre-allocate cblocks to the an appropriate amount. 235 * I'm not sure what is appropriate. 236 */ 237 ttyflush(tp, FREAD | FWRITE); 238 clist_alloc_cblocks(&tp->t_canq, 0, 0); 239 clist_alloc_cblocks(&tp->t_rawq, 0, 0); 240 clist_alloc_cblocks(&tp->t_outq, 241 MLEN + NGT_HIWATER, MLEN + NGT_HIWATER); 242 243 NGTUNLOCK(sc); 244 245 return (0); 246} 247 248/* 249 * Line specific close routine, called from device close routine 250 * and from ttioctl. This causes the node to be destroyed as well. 251 */ 252static int 253ngt_close(struct tty *tp, int flag) 254{ 255 const sc_p sc = (sc_p) tp->t_lsc; 256 257 ttyflush(tp, FREAD | FWRITE); 258 clist_free_cblocks(&tp->t_outq); 259 if (sc != NULL) { 260 NGTLOCK(sc); 261 if (callout_pending(&sc->chand)) 262 ng_uncallout(&sc->chand, sc->node); 263 tp->t_lsc = NULL; 264 sc->flags |= FLG_DIE; 265 NGTUNLOCK(sc); 266 ng_rmnode_self(sc->node); 267 } 268 return (0); 269} 270 271/* 272 * Once the device has been turned into a node, we don't allow reading. 273 */ 274static int 275ngt_read(struct tty *tp, struct uio *uio, int flag) 276{ 277 return (EIO); 278} 279 280/* 281 * Once the device has been turned into a node, we don't allow writing. 282 */ 283static int 284ngt_write(struct tty *tp, struct uio *uio, int flag) 285{ 286 return (EIO); 287} 288 289/* 290 * We implement the NGIOCGINFO ioctl() defined in ng_message.h. 291 */ 292static int 293ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct thread *td) 294{ 295 const sc_p sc = (sc_p) tp->t_lsc; 296 297 if (sc == NULL) 298 /* No node attached */ 299 return (0); 300 301 switch (cmd) { 302 case NGIOCGINFO: 303 { 304 struct nodeinfo *const ni = (struct nodeinfo *) data; 305 const node_p node = sc->node; 306 307 bzero(ni, sizeof(*ni)); 308 NGTLOCK(sc); 309 if (NG_NODE_HAS_NAME(node)) 310 strncpy(ni->name, NG_NODE_NAME(node), sizeof(ni->name) - 1); 311 strncpy(ni->type, node->nd_type->name, sizeof(ni->type) - 1); 312 ni->id = (u_int32_t) ng_node2ID(node); 313 ni->hooks = NG_NODE_NUMHOOKS(node); 314 NGTUNLOCK(sc); 315 break; 316 } 317 default: 318 return (ENOIOCTL); 319 } 320 321 return (0); 322} 323 324/* 325 * Receive data coming from the device. We get one character at 326 * a time, which is kindof silly. 327 * 328 * Full locking of softc is not required, since we are the only 329 * user of sc->m. 330 */ 331static int 332ngt_input(int c, struct tty *tp) 333{ 334 const sc_p sc = (sc_p) tp->t_lsc; 335 const node_p node = sc->node; 336 struct mbuf *m; 337 int error = 0; 338 339 if (sc == NULL) 340 /* No node attached */ 341 return (0); 342 343 if (tp != sc->tp) 344 panic("ngt_input"); 345 346 /* Check for error conditions */ 347 if ((tp->t_state & TS_CONNECTED) == 0) { 348 if (sc->flags & FLG_DEBUG) 349 log(LOG_DEBUG, "%s: no carrier\n", NG_NODE_NAME(node)); 350 return (0); 351 } 352 if (c & TTY_ERRORMASK) { 353 /* framing error or overrun on this char */ 354 if (sc->flags & FLG_DEBUG) 355 log(LOG_DEBUG, "%s: line error %x\n", 356 NG_NODE_NAME(node), c & TTY_ERRORMASK); 357 return (0); 358 } 359 c &= TTY_CHARMASK; 360 361 /* Get a new header mbuf if we need one */ 362 if (!(m = sc->m)) { 363 MGETHDR(m, M_DONTWAIT, MT_DATA); 364 if (!m) { 365 if (sc->flags & FLG_DEBUG) 366 log(LOG_ERR, 367 "%s: can't get mbuf\n", NG_NODE_NAME(node)); 368 return (ENOBUFS); 369 } 370 m->m_len = m->m_pkthdr.len = 0; 371 m->m_pkthdr.rcvif = NULL; 372 sc->m = m; 373 } 374 375 /* Add char to mbuf */ 376 *mtod(m, u_char *) = c; 377 m->m_data++; 378 m->m_len++; 379 m->m_pkthdr.len++; 380 381 /* Ship off mbuf if it's time */ 382 if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) { 383 m->m_data = m->m_pktdat; 384 sc->m = NULL; 385 386 /* 387 * We have built our mbuf without checking that we actually 388 * have a hook to send it. This was done to avoid 389 * acquiring mutex on each character. Check now. 390 * 391 */ 392 393 NGTLOCK(sc); 394 if (sc->hook == NULL) { 395 NGTUNLOCK(sc); 396 m_freem(m); 397 return (0); /* XXX: original behavior */ 398 } 399 NG_SEND_DATA_ONLY(error, sc->hook, m); /* Will queue */ 400 NGTUNLOCK(sc); 401 } 402 403 return (error); 404} 405 406/* 407 * This is called when the device driver is ready for more output. 408 * Also called from ngt_rcv_data() when a new mbuf is available for output. 409 */ 410static int 411ngt_start(struct tty *tp) 412{ 413 const sc_p sc = (sc_p) tp->t_lsc; 414 415 while (tp->t_outq.c_cc < NGT_HIWATER) { /* XXX 2.2 specific ? */ 416 struct mbuf *m; 417 418 /* Remove first mbuf from queue */ 419 IF_DEQUEUE(&sc->outq, m); 420 if (m == NULL) 421 break; 422 423 /* Send as much of it as possible */ 424 while (m != NULL) { 425 int sent; 426 427 sent = m->m_len 428 - b_to_q(mtod(m, u_char *), m->m_len, &tp->t_outq); 429 m->m_data += sent; 430 m->m_len -= sent; 431 if (m->m_len > 0) 432 break; /* device can't take no more */ 433 m = m_free(m); 434 } 435 436 /* Put remainder of mbuf chain (if any) back on queue */ 437 if (m != NULL) { 438 IF_PREPEND(&sc->outq, m); 439 break; 440 } 441 } 442 443 /* Call output process whether or not there is any output. We are 444 * being called in lieu of ttstart and must do what it would. */ 445 if (tp->t_oproc != NULL) 446 (*tp->t_oproc) (tp); 447 448 /* This timeout is needed for operation on a pseudo-tty, because the 449 * pty code doesn't call pppstart after it has drained the t_outq. */ 450 /* XXX: outq not locked */ 451 if (!IFQ_IS_EMPTY(&sc->outq) && !callout_pending(&sc->chand)) 452 ng_callout(&sc->chand, sc->node, NULL, 1, ngt_timeout, NULL, 0); 453 454 return (0); 455} 456 457/* 458 * We still have data to output to the device, so try sending more. 459 */ 460static void 461ngt_timeout(node_p node, hook_p hook, void *arg1, int arg2) 462{ 463 const sc_p sc = NG_NODE_PRIVATE(node); 464 465 mtx_lock(&Giant); 466 ngt_start(sc->tp); 467 mtx_unlock(&Giant); 468} 469 470/****************************************************************** 471 NETGRAPH NODE METHODS 472******************************************************************/ 473 474/* 475 * Initialize a new node of this type. 476 * 477 * We only allow nodes to be created as a result of setting 478 * the line discipline on a tty, so always return an error if not. 479 */ 480static int 481ngt_constructor(node_p node) 482{ 483 return (EOPNOTSUPP); 484} 485 486/* 487 * Add a new hook. There can only be one. 488 */ 489static int 490ngt_newhook(node_p node, hook_p hook, const char *name) 491{ 492 const sc_p sc = NG_NODE_PRIVATE(node); 493 494 if (strcmp(name, NG_TTY_HOOK)) 495 return (EINVAL); 496 497 if (sc->hook) 498 return (EISCONN); 499 500 NGTLOCK(sc); 501 sc->hook = hook; 502 NGTUNLOCK(sc); 503 504 return (0); 505} 506 507/* 508 * Set the hook into queueing mode (for outgoing packets), 509 * so that we wont deliver mbuf thru the whole graph holding 510 * tty locks. 511 */ 512static int 513ngt_connect(hook_p hook) 514{ 515 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); 516 /* 517 * XXX: While ngt_start() is Giant-locked, queue incoming 518 * packets, too. Otherwise we acquire Giant holding some 519 * IP stack locks, e.g. divinp, and this makes WITNESS scream. 520 */ 521 NG_HOOK_FORCE_QUEUE(hook); 522 return (0); 523} 524 525/* 526 * Disconnect the hook 527 */ 528static int 529ngt_disconnect(hook_p hook) 530{ 531 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 532 533 if (hook != sc->hook) 534 panic(__func__); 535 536 NGTLOCK(sc); 537 sc->hook = NULL; 538 NGTUNLOCK(sc); 539 540 return (0); 541} 542 543/* 544 * Remove this node. The does the netgraph portion of the shutdown. 545 * This should only be called indirectly from ngt_close(). 546 * 547 * tp->t_lsc is already NULL, so we should be protected from 548 * tty calls now. 549 */ 550static int 551ngt_shutdown(node_p node) 552{ 553 const sc_p sc = NG_NODE_PRIVATE(node); 554 555 NGTLOCK(sc); 556 if (!(sc->flags & FLG_DIE)) { 557 NGTUNLOCK(sc); 558 return (EOPNOTSUPP); 559 } 560 NGTUNLOCK(sc); 561 562 /* Free resources */ 563 _IF_DRAIN(&sc->outq); 564 mtx_destroy(&(sc)->outq.ifq_mtx); 565 m_freem(sc->m); 566 NG_NODE_UNREF(sc->node); 567 FREE(sc, M_NETGRAPH); 568 569 return (0); 570} 571 572/* 573 * Receive incoming data from netgraph system. Put it on our 574 * output queue and start output if necessary. 575 */ 576static int 577ngt_rcvdata(hook_p hook, item_p item) 578{ 579 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 580 struct mbuf *m; 581 int qlen; 582 583 if (hook != sc->hook) 584 panic(__func__); 585 586 NGI_GET_M(item, m); 587 NG_FREE_ITEM(item); 588 589 IF_LOCK(&sc->outq); 590 if (_IF_QFULL(&sc->outq)) { 591 _IF_DROP(&sc->outq); 592 IF_UNLOCK(&sc->outq); 593 NG_FREE_M(m); 594 return (ENOBUFS); 595 } 596 597 _IF_ENQUEUE(&sc->outq, m); 598 qlen = sc->outq.ifq_len; 599 IF_UNLOCK(&sc->outq); 600 601 /* 602 * If qlen > 1, then we should already have a scheduled callout. 603 */ 604 if (qlen == 1) { 605 mtx_lock(&Giant); 606 ngt_start(sc->tp); 607 mtx_unlock(&Giant); 608 } 609 610 return (0); 611} 612 613/* 614 * Receive control message 615 */ 616static int 617ngt_rcvmsg(node_p node, item_p item, hook_p lasthook) 618{ 619 const sc_p sc = NG_NODE_PRIVATE(node); 620 struct ng_mesg *msg, *resp = NULL; 621 int error = 0; 622 623 NGI_GET_MSG(item, msg); 624 switch (msg->header.typecookie) { 625 case NGM_TTY_COOKIE: 626 switch (msg->header.cmd) { 627 case NGM_TTY_SET_HOTCHAR: 628 { 629 int hotchar; 630 631 if (msg->header.arglen != sizeof(int)) 632 ERROUT(EINVAL); 633 hotchar = *((int *) msg->data); 634 if (hotchar != (u_char) hotchar && hotchar != -1) 635 ERROUT(EINVAL); 636 sc->hotchar = hotchar; /* race condition is OK */ 637 break; 638 } 639 case NGM_TTY_GET_HOTCHAR: 640 NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT); 641 if (!resp) 642 ERROUT(ENOMEM); 643 /* Race condition here is OK */ 644 *((int *) resp->data) = sc->hotchar; 645 break; 646 default: 647 ERROUT(EINVAL); 648 } 649 break; 650 default: 651 ERROUT(EINVAL); 652 } 653done: 654 NG_RESPOND_MSG(error, node, item, resp); 655 NG_FREE_MSG(msg); 656 return (error); 657} 658 659/****************************************************************** 660 INITIALIZATION 661******************************************************************/ 662 663/* 664 * Handle loading and unloading for this node type 665 */ 666static int 667ngt_mod_event(module_t mod, int event, void *data) 668{ 669 int error = 0; 670 671 switch (event) { 672 case MOD_LOAD: 673 674 /* Register line discipline */ 675 mtx_lock(&Giant); 676 if ((ngt_ldisc = ldisc_register(NETGRAPHDISC, &ngt_disc)) < 0) { 677 mtx_unlock(&Giant); 678 log(LOG_ERR, "%s: can't register line discipline", 679 __func__); 680 return (EIO); 681 } 682 mtx_unlock(&Giant); 683 break; 684 685 case MOD_UNLOAD: 686 687 /* Unregister line discipline */ 688 mtx_lock(&Giant); 689 ldisc_deregister(ngt_ldisc); 690 mtx_unlock(&Giant); 691 break; 692 693 default: 694 error = EOPNOTSUPP; 695 break; 696 } 697 return (error); 698} 699