ng_tty.c revision 151085
1/* 2 * ng_tty.c 3 */ 4 5/*- 6 * Copyright (c) 1996-1999 Whistle Communications, Inc. 7 * All rights reserved. 8 * 9 * Subject to the following obligations and disclaimer of warranty, use and 10 * redistribution of this software, in source or object code forms, with or 11 * without modifications are expressly permitted by Whistle Communications; 12 * provided, however, that: 13 * 1. Any and all reproductions of the source or object code must include the 14 * copyright notice above and the following disclaimer of warranties; and 15 * 2. No rights are granted, in any manner or form, to use Whistle 16 * Communications, Inc. trademarks, including the mark "WHISTLE 17 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 18 * such appears in the above copyright notice or in the software. 19 * 20 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 21 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 22 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 23 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 25 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 26 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 27 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 28 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 29 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 30 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 32 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 36 * OF SUCH DAMAGE. 37 * 38 * Author: Archie Cobbs <archie@freebsd.org> 39 * 40 * $FreeBSD: head/sys/netgraph/ng_tty.c 151085 2005-10-08 11:03:29Z tanimura $ 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 sc_p sc; 335 node_p node; 336 struct mbuf *m; 337 int error = 0; 338 339 sc = (sc_p) tp->t_lsc; 340 if (sc == NULL) 341 /* No node attached */ 342 return (0); 343 344 node = sc->node; 345 346 if (tp != sc->tp) 347 panic("ngt_input"); 348 349 /* Check for error conditions */ 350 if ((tp->t_state & TS_CONNECTED) == 0) { 351 if (sc->flags & FLG_DEBUG) 352 log(LOG_DEBUG, "%s: no carrier\n", NG_NODE_NAME(node)); 353 return (0); 354 } 355 if (c & TTY_ERRORMASK) { 356 /* framing error or overrun on this char */ 357 if (sc->flags & FLG_DEBUG) 358 log(LOG_DEBUG, "%s: line error %x\n", 359 NG_NODE_NAME(node), c & TTY_ERRORMASK); 360 return (0); 361 } 362 c &= TTY_CHARMASK; 363 364 /* Get a new header mbuf if we need one */ 365 if (!(m = sc->m)) { 366 MGETHDR(m, M_DONTWAIT, MT_DATA); 367 if (!m) { 368 if (sc->flags & FLG_DEBUG) 369 log(LOG_ERR, 370 "%s: can't get mbuf\n", NG_NODE_NAME(node)); 371 return (ENOBUFS); 372 } 373 m->m_len = m->m_pkthdr.len = 0; 374 m->m_pkthdr.rcvif = NULL; 375 sc->m = m; 376 } 377 378 /* Add char to mbuf */ 379 *mtod(m, u_char *) = c; 380 m->m_data++; 381 m->m_len++; 382 m->m_pkthdr.len++; 383 384 /* Ship off mbuf if it's time */ 385 if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) { 386 m->m_data = m->m_pktdat; 387 sc->m = NULL; 388 389 /* 390 * We have built our mbuf without checking that we actually 391 * have a hook to send it. This was done to avoid 392 * acquiring mutex on each character. Check now. 393 * 394 */ 395 396 NGTLOCK(sc); 397 if (sc->hook == NULL) { 398 NGTUNLOCK(sc); 399 m_freem(m); 400 return (0); /* XXX: original behavior */ 401 } 402 NG_SEND_DATA_ONLY(error, sc->hook, m); /* Will queue */ 403 NGTUNLOCK(sc); 404 } 405 406 return (error); 407} 408 409/* 410 * This is called when the device driver is ready for more output. 411 * Also called from ngt_rcv_data() when a new mbuf is available for output. 412 */ 413static int 414ngt_start(struct tty *tp) 415{ 416 const sc_p sc = (sc_p) tp->t_lsc; 417 418 while (tp->t_outq.c_cc < NGT_HIWATER) { /* XXX 2.2 specific ? */ 419 struct mbuf *m; 420 421 /* Remove first mbuf from queue */ 422 IF_DEQUEUE(&sc->outq, m); 423 if (m == NULL) 424 break; 425 426 /* Send as much of it as possible */ 427 while (m != NULL) { 428 int sent; 429 430 sent = m->m_len 431 - b_to_q(mtod(m, u_char *), m->m_len, &tp->t_outq); 432 m->m_data += sent; 433 m->m_len -= sent; 434 if (m->m_len > 0) 435 break; /* device can't take no more */ 436 m = m_free(m); 437 } 438 439 /* Put remainder of mbuf chain (if any) back on queue */ 440 if (m != NULL) { 441 IF_PREPEND(&sc->outq, m); 442 break; 443 } 444 } 445 446 /* Call output process whether or not there is any output. We are 447 * being called in lieu of ttstart and must do what it would. */ 448 if (tp->t_oproc != NULL) 449 (*tp->t_oproc) (tp); 450 451 /* This timeout is needed for operation on a pseudo-tty, because the 452 * pty code doesn't call pppstart after it has drained the t_outq. */ 453 /* XXX: outq not locked */ 454 if (!IFQ_IS_EMPTY(&sc->outq) && !callout_pending(&sc->chand)) 455 ng_callout(&sc->chand, sc->node, NULL, 1, ngt_timeout, NULL, 0); 456 457 return (0); 458} 459 460/* 461 * We still have data to output to the device, so try sending more. 462 */ 463static void 464ngt_timeout(node_p node, hook_p hook, void *arg1, int arg2) 465{ 466 const sc_p sc = NG_NODE_PRIVATE(node); 467 468 mtx_lock(&Giant); 469 ngt_start(sc->tp); 470 mtx_unlock(&Giant); 471} 472 473/****************************************************************** 474 NETGRAPH NODE METHODS 475******************************************************************/ 476 477/* 478 * Initialize a new node of this type. 479 * 480 * We only allow nodes to be created as a result of setting 481 * the line discipline on a tty, so always return an error if not. 482 */ 483static int 484ngt_constructor(node_p node) 485{ 486 return (EOPNOTSUPP); 487} 488 489/* 490 * Add a new hook. There can only be one. 491 */ 492static int 493ngt_newhook(node_p node, hook_p hook, const char *name) 494{ 495 const sc_p sc = NG_NODE_PRIVATE(node); 496 497 if (strcmp(name, NG_TTY_HOOK)) 498 return (EINVAL); 499 500 if (sc->hook) 501 return (EISCONN); 502 503 NGTLOCK(sc); 504 sc->hook = hook; 505 NGTUNLOCK(sc); 506 507 return (0); 508} 509 510/* 511 * Set the hook into queueing mode (for outgoing packets), 512 * so that we wont deliver mbuf thru the whole graph holding 513 * tty locks. 514 */ 515static int 516ngt_connect(hook_p hook) 517{ 518 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); 519 /* 520 * XXX: While ngt_start() is Giant-locked, queue incoming 521 * packets, too. Otherwise we acquire Giant holding some 522 * IP stack locks, e.g. divinp, and this makes WITNESS scream. 523 */ 524 NG_HOOK_FORCE_QUEUE(hook); 525 return (0); 526} 527 528/* 529 * Disconnect the hook 530 */ 531static int 532ngt_disconnect(hook_p hook) 533{ 534 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 535 536 if (hook != sc->hook) 537 panic(__func__); 538 539 NGTLOCK(sc); 540 sc->hook = NULL; 541 NGTUNLOCK(sc); 542 543 return (0); 544} 545 546/* 547 * Remove this node. The does the netgraph portion of the shutdown. 548 * This should only be called indirectly from ngt_close(). 549 * 550 * tp->t_lsc is already NULL, so we should be protected from 551 * tty calls now. 552 */ 553static int 554ngt_shutdown(node_p node) 555{ 556 const sc_p sc = NG_NODE_PRIVATE(node); 557 558 NGTLOCK(sc); 559 if (!(sc->flags & FLG_DIE)) { 560 NGTUNLOCK(sc); 561 return (EOPNOTSUPP); 562 } 563 NGTUNLOCK(sc); 564 565 /* Free resources */ 566 _IF_DRAIN(&sc->outq); 567 mtx_destroy(&(sc)->outq.ifq_mtx); 568 m_freem(sc->m); 569 NG_NODE_UNREF(sc->node); 570 FREE(sc, M_NETGRAPH); 571 572 return (0); 573} 574 575/* 576 * Receive incoming data from netgraph system. Put it on our 577 * output queue and start output if necessary. 578 */ 579static int 580ngt_rcvdata(hook_p hook, item_p item) 581{ 582 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 583 struct mbuf *m; 584 int qlen; 585 586 if (hook != sc->hook) 587 panic(__func__); 588 589 NGI_GET_M(item, m); 590 NG_FREE_ITEM(item); 591 592 IF_LOCK(&sc->outq); 593 if (_IF_QFULL(&sc->outq)) { 594 _IF_DROP(&sc->outq); 595 IF_UNLOCK(&sc->outq); 596 NG_FREE_M(m); 597 return (ENOBUFS); 598 } 599 600 _IF_ENQUEUE(&sc->outq, m); 601 qlen = sc->outq.ifq_len; 602 IF_UNLOCK(&sc->outq); 603 604 /* 605 * If qlen > 1, then we should already have a scheduled callout. 606 */ 607 if (qlen == 1) { 608 mtx_lock(&Giant); 609 ngt_start(sc->tp); 610 mtx_unlock(&Giant); 611 } 612 613 return (0); 614} 615 616/* 617 * Receive control message 618 */ 619static int 620ngt_rcvmsg(node_p node, item_p item, hook_p lasthook) 621{ 622 const sc_p sc = NG_NODE_PRIVATE(node); 623 struct ng_mesg *msg, *resp = NULL; 624 int error = 0; 625 626 NGI_GET_MSG(item, msg); 627 switch (msg->header.typecookie) { 628 case NGM_TTY_COOKIE: 629 switch (msg->header.cmd) { 630 case NGM_TTY_SET_HOTCHAR: 631 { 632 int hotchar; 633 634 if (msg->header.arglen != sizeof(int)) 635 ERROUT(EINVAL); 636 hotchar = *((int *) msg->data); 637 if (hotchar != (u_char) hotchar && hotchar != -1) 638 ERROUT(EINVAL); 639 sc->hotchar = hotchar; /* race condition is OK */ 640 break; 641 } 642 case NGM_TTY_GET_HOTCHAR: 643 NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT); 644 if (!resp) 645 ERROUT(ENOMEM); 646 /* Race condition here is OK */ 647 *((int *) resp->data) = sc->hotchar; 648 break; 649 default: 650 ERROUT(EINVAL); 651 } 652 break; 653 default: 654 ERROUT(EINVAL); 655 } 656done: 657 NG_RESPOND_MSG(error, node, item, resp); 658 NG_FREE_MSG(msg); 659 return (error); 660} 661 662/****************************************************************** 663 INITIALIZATION 664******************************************************************/ 665 666/* 667 * Handle loading and unloading for this node type 668 */ 669static int 670ngt_mod_event(module_t mod, int event, void *data) 671{ 672 int error = 0; 673 674 switch (event) { 675 case MOD_LOAD: 676 677 /* Register line discipline */ 678 mtx_lock(&Giant); 679 if ((ngt_ldisc = ldisc_register(NETGRAPHDISC, &ngt_disc)) < 0) { 680 mtx_unlock(&Giant); 681 log(LOG_ERR, "%s: can't register line discipline", 682 __func__); 683 return (EIO); 684 } 685 mtx_unlock(&Giant); 686 break; 687 688 case MOD_UNLOAD: 689 690 /* Unregister line discipline */ 691 mtx_lock(&Giant); 692 ldisc_deregister(ngt_ldisc); 693 mtx_unlock(&Giant); 694 break; 695 696 default: 697 error = EOPNOTSUPP; 698 break; 699 } 700 return (error); 701} 702