![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_imp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netimp|
Return to if_imp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netimp |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)if_imp.c 7.13 (Berkeley) 6/28/90 ! 21: */ ! 22: ! 23: #include "imp.h" ! 24: #if NIMP > 0 ! 25: /* ! 26: * ARPANET IMP (PSN) interface driver. ! 27: * ! 28: * The IMP-host protocol (AHIP) is handled here, leaving ! 29: * hardware specifics to the lower level interface driver. ! 30: */ ! 31: #include "param.h" ! 32: #include "systm.h" ! 33: #include "mbuf.h" ! 34: #include "buf.h" ! 35: #include "protosw.h" ! 36: #include "socket.h" ! 37: #include "time.h" ! 38: #include "kernel.h" ! 39: #include "errno.h" ! 40: #include "ioctl.h" ! 41: #include "syslog.h" ! 42: ! 43: #include "machine/mtpr.h" ! 44: ! 45: #include "../net/if.h" ! 46: #include "../net/netisr.h" ! 47: #include "../netinet/in.h" ! 48: #include "../netinet/in_systm.h" ! 49: #include "../netinet/in_var.h" ! 50: #include "../netinet/ip.h" ! 51: #include "../netinet/ip_var.h" ! 52: #define IMPMESSAGES ! 53: /* define IMPLEADERS here to get leader printing code */ ! 54: #include "if_imp.h" ! 55: #include "if_imphost.h" ! 56: ! 57: struct imp_softc imp_softc[NIMP]; ! 58: #ifndef lint ! 59: int nimp = NIMP; /* for netstat */ ! 60: #endif ! 61: struct ifqueue impintrq; ! 62: int impqmaxlen = IFQ_MAXLEN; ! 63: int imphqlen = 12 + IMP_MAXHOSTMSG; /* max packets to queue per host */ ! 64: ! 65: int imppri = LOG_ERR; ! 66: #ifdef IMPLEADERS ! 67: int impprintfs = 0; ! 68: #endif ! 69: #ifdef IMPINIT ! 70: int imptraceinit = 0; ! 71: #endif ! 72: ! 73: ! 74: #define HOSTDEADTIMER (30 * PR_SLOWHZ) /* How long to wait when down */ ! 75: ! 76: int impdown(), impinit(), impioctl(), impoutput(), imptimo(); ! 77: ! 78: /* ! 79: * IMP attach routine. Called from hardware device attach routine ! 80: * at configuration time with a pointer to the device structure. ! 81: * Sets up local state and returns pointer to base of ifnet+impcb ! 82: * structures. This is then used by the device's attach routine ! 83: * set up its back pointers. ! 84: */ ! 85: struct imp_softc * ! 86: impattach(hwname, hwunit, reset) ! 87: char *hwname; ! 88: int hwunit; ! 89: int (*reset)(); ! 90: { ! 91: struct imp_softc *sc; ! 92: register struct ifnet *ifp; ! 93: static int impunit; ! 94: ! 95: #ifdef lint ! 96: impintr(); ! 97: #endif ! 98: if (impunit >= NIMP) { ! 99: printf("imp%d: not configured\n", impunit++); ! 100: return (0); ! 101: } ! 102: sc = &imp_softc[impunit]; ! 103: ifp = &sc->imp_if; ! 104: sc->imp_cb.ic_hwname = hwname; ! 105: sc->imp_cb.ic_hwunit = hwunit; ! 106: ifp->if_unit = impunit; ! 107: ifp->if_name = "imp"; ! 108: ifp->if_mtu = IMPMTU - sizeof(struct imp_leader); ! 109: ifp->if_reset = reset; ! 110: ifp->if_init = impinit; ! 111: ifp->if_ioctl = impioctl; ! 112: ifp->if_output = impoutput; ! 113: ifp->if_watchdog = imptimo; ! 114: if_attach(ifp); ! 115: impunit++; ! 116: return (sc); ! 117: } ! 118: ! 119: /* ! 120: * IMP initialization routine: call hardware module to ! 121: * setup resources, init state and get ready for ! 122: * NOOPs the IMP should send us, and that we want to drop. ! 123: */ ! 124: impinit(unit) ! 125: int unit; ! 126: { ! 127: int s; ! 128: register struct imp_softc *sc = &imp_softc[unit]; ! 129: ! 130: if (sc->imp_if.if_addrlist == 0) ! 131: return; ! 132: s = splimp(); ! 133: #ifdef IMPINIT ! 134: if (imptraceinit) ! 135: log(imppri, "impinit\n"); ! 136: #endif ! 137: sc->imp_state = IMPS_WINIT; ! 138: if ((*sc->imp_cb.ic_init)(sc->imp_cb.ic_hwunit) == 0) ! 139: sc->imp_if.if_flags &= ~IFF_UP; ! 140: impintrq.ifq_maxlen = impqmaxlen; ! 141: splx(s); ! 142: } ! 143: ! 144: /* ! 145: * ARPAnet 1822/AHIP input routine. ! 146: * Called from hardware input interrupt routine to handle 1822 ! 147: * IMP-host messages. Data messages are passed to higher-level ! 148: * protocol processors on the basis of link number. ! 149: * Other type messages (control) are handled here. ! 150: */ ! 151: impinput(unit, m) ! 152: int unit; ! 153: register struct mbuf *m; ! 154: { ! 155: register struct control_leader *cp; ! 156: #define ip ((struct imp_leader *)cp) ! 157: register struct imp_softc *sc = &imp_softc[unit]; ! 158: struct ifnet *ifp; ! 159: register struct host *hp; ! 160: register struct ifqueue *inq; ! 161: struct sockaddr_in *sin; ! 162: int s; ! 163: ! 164: /* ! 165: * Pull the interface pointer out of the mbuf ! 166: * and save for later; adjust mbuf to look at rest of data. ! 167: */ ! 168: if ((m->m_flags && M_PKTHDR) == 0) ! 169: panic("No header in impinput"); ! 170: ifp = m->m_pkthdr.rcvif; ! 171: /* verify leader length. */ ! 172: if (m->m_len < sizeof(struct control_leader) && ! 173: (m = m_pullup(m, sizeof(struct control_leader))) == 0) ! 174: return; ! 175: cp = mtod(m, struct control_leader *); ! 176: if (cp->dl_mtype == IMPTYPE_DATA && ! 177: m->m_len < sizeof(struct imp_leader)) { ! 178: if ((m = m_pullup(m, sizeof(struct imp_leader))) == 0) ! 179: return; ! 180: cp = mtod(m, struct control_leader *); ! 181: } ! 182: #ifdef IMPLEADERS ! 183: if (impprintfs) ! 184: printleader("impinput", ip); ! 185: #endif ! 186: inq = &impintrq; ! 187: ! 188: /* check leader type */ ! 189: if (cp->dl_format != IMP_NFF) { ! 190: /* ! 191: * We get 1822L NOOPs and RESET ! 192: * at initialization. ! 193: */ ! 194: #ifdef IMPINIT ! 195: if (imptraceinit) ! 196: log(imppri, "input, format %x mtype %d\n", ! 197: cp->dl_format, cp->dl_mtype); ! 198: #endif ! 199: if (cp->dl_format != IMP_1822L_I2H || ! 200: (cp->dl_mtype != IMPTYPE_NOOP && ! 201: cp->dl_mtype != IMPTYPE_RESET)) { ! 202: sc->imp_garbage++; ! 203: sc->imp_if.if_collisions++; /* XXX */ ! 204: } ! 205: } else switch (cp->dl_mtype) { ! 206: ! 207: case IMPTYPE_DATA: ! 208: /* ! 209: * Data for a protocol. Dispatch to the appropriate ! 210: * protocol routine (running at software interrupt). ! 211: * If this isn't a raw interface, advance pointer ! 212: * into mbuf past leader. ! 213: */ ! 214: switch (cp->dl_link) { ! 215: ! 216: case IMPLINK_IP: ! 217: m->m_len -= sizeof(struct imp_leader); ! 218: if (m->m_flags & M_PKTHDR) ! 219: m->m_pkthdr.len -= sizeof(struct imp_leader); ! 220: m->m_data += sizeof(struct imp_leader); ! 221: schednetisr(NETISR_IP); ! 222: inq = &ipintrq; ! 223: break; ! 224: ! 225: default: ! 226: break; ! 227: } ! 228: break; ! 229: ! 230: /* ! 231: * IMP leader error. Reset the IMP and discard the packet. ! 232: */ ! 233: case IMPTYPE_BADLEADER: ! 234: /* ! 235: * According to 1822 document, this message ! 236: * will be generated in response to the ! 237: * first noop sent to the IMP after ! 238: * the host resets the IMP interface. ! 239: */ ! 240: #ifdef IMPINIT ! 241: if (imptraceinit) ! 242: log(imppri, "badleader\n"); ! 243: #endif ! 244: if (sc->imp_state != IMPS_INIT) { ! 245: impmsg(sc, "leader error"); ! 246: sc->imp_msgready = 0; ! 247: hostreset(unit); ! 248: impnoops(sc); ! 249: sc->imp_garbage++; ! 250: } ! 251: break; ! 252: ! 253: /* ! 254: * IMP going down. Print message, and if not immediate, ! 255: * set off a timer to insure things will be reset at the ! 256: * appropriate time. ! 257: */ ! 258: case IMPTYPE_DOWN: ! 259: { int type, when; ! 260: ! 261: type = cp->dl_link & IMP_DMASK; ! 262: when = (cp->dl_link & IMPDOWN_WHENMASK) >> IMPDOWN_WHENSHIFT; ! 263: #ifdef IMPINIT ! 264: if (imptraceinit) ! 265: log(imppri, "input DOWN %s %d\n", ! 266: impmessage[type], when * IMPDOWN_WHENUNIT); ! 267: #endif ! 268: if (type != IMPDOWN_GOING && when) ! 269: impmsg(sc, "going down %s in %d minutes", ! 270: (u_int)impmessage[type], when * IMPDOWN_WHENUNIT); ! 271: else ! 272: impmsg(sc, "going down %s", (u_int)impmessage[type]); ! 273: if (sc->imp_state != IMPS_UP) ! 274: break; ! 275: if (type == IMPDOWN_GOING) { ! 276: sc->imp_state = IMPS_GOINGDOWN; ! 277: timeout(impdown, (caddr_t)sc, IMPTV_DOWN * hz); ! 278: } else if (when == 0) ! 279: sc->imp_state = IMPS_WINIT; ! 280: sc->imp_dropcnt = 0; ! 281: break; ! 282: } ! 283: ! 284: /* ! 285: * A NOP, usually seen during the initialization sequence. ! 286: * Compare the local address with that in the message. ! 287: * Reset the local address notion if it doesn't match. ! 288: */ ! 289: case IMPTYPE_NOOP: ! 290: #ifdef IMPINIT ! 291: if (imptraceinit) ! 292: log(imppri, "noop\n"); ! 293: #endif ! 294: if (sc->imp_state == IMPS_WINIT) { ! 295: sc->imp_dropcnt = 0; ! 296: impnoops(sc); ! 297: sc->imp_state = IMPS_INIT; ! 298: } ! 299: sc->imp_dropcnt++; ! 300: if (sc->imp_state == IMPS_INIT && cp->dl_imp != 0) { ! 301: struct in_addr leader_addr; ! 302: ! 303: sin = (struct sockaddr_in *)&sc->imp_if.if_addrlist->ifa_addr; ! 304: imp_leader_to_addr(&leader_addr, cp, &sc->imp_if); ! 305: if (sin->sin_addr.s_addr != leader_addr.s_addr) { ! 306: impmsg(sc, "address reset to x%x (%d/%d)", ! 307: ntohl(leader_addr.s_addr), ! 308: (u_int)cp->dl_host, ! 309: ntohs(cp->dl_imp)); ! 310: sin->sin_addr.s_addr = leader_addr.s_addr; ! 311: } ! 312: } ! 313: break; ! 314: ! 315: /* ! 316: * RFNM or INCOMPLETE message, decrement rfnm count ! 317: * and prepare to send next message. ! 318: * If the rfnm allows another queued ! 319: * message to be sent, bump msgready ! 320: * and start IMP if idle. ! 321: * We could pass incomplete's up to the next level, ! 322: * but this currently isn't needed. ! 323: * Pass "bad" incompletes and rfnms to the raw socket. ! 324: */ ! 325: case IMPTYPE_INCOMPLETE: ! 326: sc->imp_incomplete++; ! 327: /* FALL THROUGH */ ! 328: case IMPTYPE_RFNM: ! 329: if ((hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, ! 330: unit)) == 0 || hp->h_rfnm == 0) { ! 331: sc->imp_badrfnm++; ! 332: if (hp) ! 333: hostfree(hp); ! 334: break; ! 335: } ! 336: imprestarthost(sc, hp); ! 337: if (cp->dl_mtype == IMPTYPE_RFNM) ! 338: goto drop; ! 339: break; ! 340: ! 341: /* ! 342: * Host or IMP can't be reached. Flush any packets ! 343: * awaiting transmission and release the host structure. ! 344: * Enqueue for notifying protocols at software interrupt time. ! 345: */ ! 346: case IMPTYPE_HOSTDEAD: ! 347: case IMPTYPE_HOSTUNREACH: ! 348: if (hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, unit)) { ! 349: hp->h_flags |= (1 << (int)cp->dl_mtype); ! 350: sc->imp_msgready -= ! 351: MIN(hp->h_qcnt, IMP_MAXHOSTMSG - hp->h_rfnm); ! 352: hp->h_rfnm = 0; ! 353: hostflush(hp); ! 354: hp->h_timer = HOSTDEADTIMER; ! 355: } ! 356: break; ! 357: ! 358: /* ! 359: * Error in data. Clear RFNM status for this host and send ! 360: * noops to the IMP to clear the interface. ! 361: */ ! 362: case IMPTYPE_BADDATA: ! 363: impmsg(sc, "data error"); ! 364: if (hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, unit)) { ! 365: sc->imp_msgready -= ! 366: MIN(hp->h_qcnt, IMP_MAXHOSTMSG - hp->h_rfnm); ! 367: if (hp->h_rfnm) ! 368: hostrelease(hp); ! 369: else ! 370: hostfree(hp); ! 371: } ! 372: impnoops(sc); ! 373: break; ! 374: ! 375: /* ! 376: * Interface reset. ! 377: */ ! 378: case IMPTYPE_RESET: ! 379: #ifdef IMPINIT ! 380: if (imptraceinit) ! 381: log(imppri, "reset complete\n"); ! 382: #endif ! 383: if (sc->imp_state != IMPS_INIT) { ! 384: impmsg(sc, "interface reset"); ! 385: impnoops(sc); ! 386: } ! 387: /* clear RFNM counts */ ! 388: sc->imp_msgready = 0; ! 389: hostreset(unit); ! 390: if (sc->imp_state != IMPS_DOWN) { ! 391: sc->imp_state = IMPS_UP; ! 392: sc->imp_if.if_flags |= IFF_UP; ! 393: #ifdef IMPINIT ! 394: if (imptraceinit) ! 395: log(imppri, "IMP UP\n"); ! 396: #endif ! 397: } ! 398: break; ! 399: ! 400: default: ! 401: sc->imp_garbage++; ! 402: sc->imp_if.if_collisions++; /* XXX */ ! 403: break; ! 404: } ! 405: ! 406: if (inq == &impintrq) ! 407: schednetisr(NETISR_IMP); ! 408: s = splimp(); ! 409: if (!IF_QFULL(inq)) { ! 410: IF_ENQUEUE(inq, m); ! 411: splx(s); ! 412: return; ! 413: } ! 414: splx(s); ! 415: IF_DROP(inq); ! 416: drop: ! 417: m_freem(m); ! 418: #undef ip ! 419: } ! 420: ! 421: /* ! 422: * Bring the IMP down after notification. ! 423: */ ! 424: impdown(sc) ! 425: struct imp_softc *sc; ! 426: { ! 427: int s = splimp(); ! 428: ! 429: if (sc->imp_state == IMPS_GOINGDOWN) { ! 430: sc->imp_state = IMPS_WINIT; ! 431: impmsg(sc, "marked down"); ! 432: sc->imp_msgready = 0; ! 433: hostreset(sc->imp_if.if_unit); ! 434: if_down(&sc->imp_if); ! 435: } ! 436: #ifdef IMPINIT ! 437: else if (imptraceinit) ! 438: log(imppri, "impdown, state now %d (ignored)\n", sc->imp_state); ! 439: #endif ! 440: splx(s); ! 441: } ! 442: ! 443: /*VARARGS2*/ ! 444: impmsg(sc, fmt, a1) ! 445: struct imp_softc *sc; ! 446: char *fmt; ! 447: u_int a1; ! 448: { ! 449: ! 450: log(imppri, "imp%d: %r\n", sc->imp_if.if_unit, fmt, &a1); ! 451: } ! 452: ! 453: struct sockproto impproto = { PF_IMPLINK }; ! 454: struct sockaddr_in impdst = { sizeof (impdst), AF_INET }; ! 455: struct sockaddr_in impsrc = { sizeof (impsrc), AF_INET }; ! 456: ! 457: /* ! 458: * Pick up the IMP "error" messages enqueued earlier, ! 459: * passing these up to the higher level protocol ! 460: * and the raw interface. ! 461: */ ! 462: impintr() ! 463: { ! 464: register struct mbuf *m; ! 465: register struct control_leader *cp; ! 466: struct ifnet *ifp; ! 467: int s, code; ! 468: ! 469: for (;;) { ! 470: s = splimp(); ! 471: IF_DEQUEUEIF(&impintrq, m, ifp); ! 472: splx(s); ! 473: if (m == 0) ! 474: return; ! 475: ! 476: cp = mtod(m, struct control_leader *); ! 477: imp_leader_to_addr(&impsrc.sin_addr, cp, ifp); ! 478: impproto.sp_protocol = cp->dl_link; ! 479: impdst.sin_addr = IA_SIN(ifp->if_addrlist)->sin_addr; ! 480: ! 481: if (cp->dl_mtype == IMPTYPE_HOSTDEAD || ! 482: cp->dl_mtype == IMPTYPE_HOSTUNREACH) { ! 483: code = (cp->dl_mtype == IMPTYPE_HOSTDEAD) ? ! 484: PRC_HOSTDEAD : PRC_UNREACH_HOST; ! 485: switch (cp->dl_link) { ! 486: ! 487: case IMPLINK_IP: ! 488: pfctlinput(code, (struct sockaddr *)&impsrc); ! 489: break; ! 490: default: ! 491: raw_ctlinput(code, (struct sockaddr *)&impsrc); ! 492: break; ! 493: } ! 494: } ! 495: ! 496: raw_input(m, &impproto, (struct sockaddr *)&impsrc, ! 497: (struct sockaddr *)&impdst); ! 498: } ! 499: } ! 500: ! 501: /* ! 502: * ARPAnet 1822 output routine. ! 503: * Called from higher level protocol routines to set up messages for ! 504: * transmission to the imp. Sets up the header and calls impsnd to ! 505: * enqueue the message for this IMP's hardware driver. ! 506: */ ! 507: impoutput(ifp, m0, dst) ! 508: register struct ifnet *ifp; ! 509: struct mbuf *m0; ! 510: struct sockaddr *dst; ! 511: { ! 512: register struct imp_leader *imp; ! 513: register struct mbuf *m = m0; ! 514: caddr_t pkt = mtod(m, caddr_t); ! 515: int error = 0; ! 516: ! 517: /* ! 518: * Don't even try if the IMP is unavailable. ! 519: */ ! 520: if (!IMPS_RUNNING(imp_softc[ifp->if_unit].imp_state)) { ! 521: error = ENETDOWN; ! 522: goto drop; ! 523: } ! 524: ! 525: /* ! 526: * If AF_IMPLINK, leader exists; just send. ! 527: * Otherwise, construct leader according to address family. ! 528: */ ! 529: if (dst->sa_family != AF_IMPLINK) { ! 530: /* ! 531: * Add IMP leader. If there's not enough space in the ! 532: * first mbuf, allocate another. If that should fail, we ! 533: * drop this sucker. ! 534: */ ! 535: M_PREPEND(m, sizeof(struct imp_leadr), M_DONTWAIT); ! 536: imp = mtod(m, struct imp_leader *); ! 537: imp->il_format = IMP_NFF; ! 538: imp->il_mtype = IMPTYPE_DATA; ! 539: imp->il_flags = 0; ! 540: imp->il_htype = 0; ! 541: imp->il_subtype = 0; ! 542: ! 543: switch (dst->sa_family) { ! 544: ! 545: case AF_INET: ! 546: imp->il_link = IMPLINK_IP; ! 547: imp_addr_to_leader((struct control_leader *)imp, ! 548: ((struct sockaddr_in *)dst)->sin_addr.s_addr); ! 549: imp->il_length = htons(ntohs((u_short) ! 550: ((struct ip *)pkt)->ip_len) << 3); ! 551: break; ! 552: ! 553: default: ! 554: printf("imp%d: can't handle af%d\n", ifp->if_unit, ! 555: dst->sa_family); ! 556: error = EAFNOSUPPORT; ! 557: m0 = m; ! 558: goto drop; ! 559: } ! 560: } ! 561: return (impsnd(ifp, m)); ! 562: drop: ! 563: m_freem(m0); ! 564: return (error); ! 565: } ! 566: ! 567: /* ! 568: * Put a message on an interface's output queue. ! 569: * Perform RFNM counting: no more than 8 message may be ! 570: * in flight to any one host. ! 571: */ ! 572: impsnd(ifp, m) ! 573: struct ifnet *ifp; ! 574: struct mbuf *m; ! 575: { ! 576: register struct control_leader *imp; ! 577: register struct host *hp; ! 578: register struct imp_softc *sc = &imp_softc[ifp->if_unit]; ! 579: int s, error = 0; ! 580: ! 581: imp = mtod(m, struct control_leader *); ! 582: ! 583: /* ! 584: * Do RFNM counting for data messages ! 585: * (no more than 8 outstanding to any host). ! 586: * Queue data messages per host if 8 are already outstanding ! 587: * or if the hardware interface is already doing output. ! 588: * Increment imp_msgready if the message could be sent now, ! 589: * but must be queued because the imp output is busy. ! 590: */ ! 591: s = splimp(); ! 592: if (imp->dl_mtype == IMPTYPE_DATA) { ! 593: hp = hostenter((int)imp->dl_imp, (int)imp->dl_host, ! 594: ifp->if_unit); ! 595: if (hp) { ! 596: if (hp->h_flags & (HF_DEAD|HF_UNREACH)) ! 597: error = hp->h_flags & HF_DEAD ? ! 598: EHOSTDOWN : EHOSTUNREACH; ! 599: else if (hp->h_rfnm < IMP_MAXHOSTMSG && ! 600: sc->imp_cb.ic_oactive == 0) { ! 601: /* ! 602: * Send without queuing; ! 603: * adjust rfnm count and timer. ! 604: */ ! 605: if (hp->h_rfnm++ == 0) ! 606: hp->h_timer = RFNMTIMER; ! 607: goto send; ! 608: } else if (hp->h_rfnm + hp->h_qcnt < imphqlen) { ! 609: HOST_ENQUE(hp, m); ! 610: if (hp->h_rfnm + hp->h_qcnt <= IMP_MAXHOSTMSG) ! 611: sc->imp_msgready++; ! 612: } else { ! 613: error = ENOBUFS; ! 614: IF_DROP(&ifp->if_snd); ! 615: } ! 616: } else ! 617: error = ENOBUFS; ! 618: } else if (sc->imp_cb.ic_oactive == 0) ! 619: goto send; ! 620: else ! 621: IF_ENQUEUE(&ifp->if_snd, m); ! 622: ! 623: splx(s); ! 624: if (error) ! 625: m_freem(m); ! 626: return (error); ! 627: ! 628: send: ! 629: sc->imp_if.if_timer = IMP_OTIMER; ! 630: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 631: splx(s); ! 632: return (0); ! 633: } ! 634: ! 635: /* ! 636: * Start another output operation on IMP; called from hardware ! 637: * transmit-complete interrupt routine at splimp or from imp routines ! 638: * when output is not in progress. If there are any packets on shared ! 639: * output queue, send them, otherwise send the next data packet for a host. ! 640: * Host data packets are sent round-robin based on destination by walking ! 641: * the host list. ! 642: */ ! 643: impstart(sc) ! 644: register struct imp_softc *sc; ! 645: { ! 646: register struct mbuf *m; ! 647: int first = 1; /* XXX */ ! 648: register struct host *hp; ! 649: int index; ! 650: ! 651: IF_DEQUEUE(&sc->imp_if.if_snd, m); ! 652: if (m) { ! 653: sc->imp_if.if_timer = IMP_OTIMER; ! 654: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 655: return; ! 656: } ! 657: if (sc->imp_msgready) { ! 658: if ((m = sc->imp_hostq) == 0 && (m = sc->imp_hosts) == 0) ! 659: panic("imp msgready"); ! 660: index = sc->imp_hostent; ! 661: for (hp = &mtod(m, struct hmbuf *)->hm_hosts[index]; ; ! 662: hp++, index++) { ! 663: if (index >= HPMBUF) { ! 664: if ((m = m->m_next) == 0) ! 665: m = sc->imp_hosts; ! 666: index = 0; ! 667: hp = mtod(m, struct hmbuf *)->hm_hosts; ! 668: first = 0; /* XXX */ ! 669: } ! 670: if (hp->h_qcnt && hp->h_rfnm < IMP_MAXHOSTMSG) { ! 671: /* ! 672: * Found host entry with another message ! 673: * to send. Deliver it to the IMP. ! 674: * Start with succeeding host next time. ! 675: */ ! 676: impstarthost(sc, hp); ! 677: sc->imp_hostq = m; ! 678: sc->imp_hostent = index + 1; ! 679: return; ! 680: } ! 681: if (m == sc->imp_hostq && !first && ! 682: index + 1 >= sc->imp_hostent) { /* XXX */ ! 683: log(imppri, "imp: can't find %d msgready\n", ! 684: sc->imp_msgready); ! 685: sc->imp_msgready = 0; ! 686: break; ! 687: } ! 688: } ! 689: } ! 690: sc->imp_if.if_timer = 0; ! 691: } ! 692: ! 693: /* ! 694: * Restart output for a host that has received a RFNM ! 695: * or incomplete or has timed out while waiting for a RFNM. ! 696: * Must be called at splimp. ! 697: */ ! 698: imprestarthost(sc, hp) ! 699: register struct imp_softc *sc; ! 700: struct host *hp; ! 701: { ! 702: ! 703: if (--hp->h_rfnm > 0) ! 704: hp->h_timer = RFNMTIMER; ! 705: /* ! 706: * If the RFNM moved a queued message into the window, ! 707: * update msgready and start IMP if idle. ! 708: */ ! 709: if (hp->h_qcnt > IMP_MAXHOSTMSG - 1 - hp->h_rfnm) { ! 710: sc->imp_msgready++; ! 711: if (sc->imp_cb.ic_oactive == 0) ! 712: impstarthost(sc, hp); ! 713: } ! 714: if (hp->h_rfnm == 0 && hp->h_qcnt == 0) ! 715: hostidle(hp); ! 716: } ! 717: ! 718: /* ! 719: * Send the next message queued for a host ! 720: * when ready to send another message to the IMP. ! 721: * Called only when output is not in progress. ! 722: * Bump RFNM counter and start RFNM timer ! 723: * when we send the message to the IMP. ! 724: * Must be called at splimp. ! 725: */ ! 726: impstarthost(sc, hp) ! 727: register struct imp_softc *sc; ! 728: register struct host *hp; ! 729: { ! 730: struct mbuf *m; ! 731: ! 732: if (hp->h_rfnm++ == 0) ! 733: hp->h_timer = RFNMTIMER; ! 734: HOST_DEQUE(hp, m); ! 735: sc->imp_if.if_timer = IMP_OTIMER; ! 736: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 737: sc->imp_msgready--; ! 738: } ! 739: ! 740: /* ! 741: * "Watchdog" timeout. When the output timer expires, ! 742: * we assume we have been blocked by the imp. ! 743: * No need to restart, just collect statistics. ! 744: */ ! 745: imptimo(unit) ! 746: int unit; ! 747: { ! 748: ! 749: imp_softc[unit].imp_block++; ! 750: } ! 751: ! 752: /* ! 753: * Put three 1822 NOOPs at the head of the output queue. ! 754: * Part of host-IMP initialization procedure. ! 755: * (Should return success/failure, but noone knows ! 756: * what to do with this, so why bother?) ! 757: * This routine is always called at splimp, so we don't ! 758: * protect the call to IF_PREPEND. ! 759: */ ! 760: impnoops(sc) ! 761: register struct imp_softc *sc; ! 762: { ! 763: register i; ! 764: register struct mbuf *m; ! 765: register struct control_leader *cp; ! 766: ! 767: #ifdef IMPINIT ! 768: if (imptraceinit) ! 769: log(imppri, "impnoops\n"); ! 770: #endif ! 771: for (i = 0; i < IMP_NOOPCNT; i++) { ! 772: if ((m = m_getclr(M_DONTWAIT, MT_HEADER)) == 0) ! 773: return; ! 774: m->m_len = sizeof(struct control_leader); ! 775: cp = mtod(m, struct control_leader *); ! 776: cp->dl_format = IMP_NFF; ! 777: cp->dl_link = i; ! 778: cp->dl_mtype = IMPTYPE_NOOP; ! 779: IF_PREPEND(&sc->imp_if.if_snd, m); ! 780: } ! 781: if (sc->imp_cb.ic_oactive == 0) ! 782: impstart(sc); ! 783: } ! 784: ! 785: /* ! 786: * Process an ioctl request. ! 787: */ ! 788: impioctl(ifp, cmd, data) ! 789: register struct ifnet *ifp; ! 790: int cmd; ! 791: caddr_t data; ! 792: { ! 793: struct ifaddr *ifa = (struct ifaddr *) data; ! 794: int s = splimp(), error = 0; ! 795: #define sc ((struct imp_softc *)ifp) ! 796: ! 797: switch (cmd) { ! 798: ! 799: case SIOCSIFADDR: ! 800: if (ifa->ifa_addr.sa_family != AF_INET) { ! 801: error = EINVAL; ! 802: break; ! 803: } ! 804: if ((ifp->if_flags & IFF_UP) == 0) ! 805: impinit(ifp->if_unit); ! 806: break; ! 807: ! 808: case SIOCSIFFLAGS: ! 809: if ((ifp->if_flags & IFF_UP) == 0 && ! 810: sc->imp_state != IMPS_DOWN) { ! 811: if (sc->imp_cb.ic_down && ! 812: (*sc->imp_cb.ic_down)(sc->imp_cb.ic_hwunit)) { ! 813: sc->imp_state = IMPS_DOWN; ! 814: sc->imp_msgready = 0; ! 815: hostreset(ifp->if_unit); ! 816: if_down(ifp); ! 817: } ! 818: } else if (ifp->if_flags & IFF_UP && sc->imp_state == IMPS_DOWN) ! 819: impinit(ifp->if_unit); ! 820: break; ! 821: ! 822: default: ! 823: error = EINVAL; ! 824: break; ! 825: } ! 826: splx(s); ! 827: return (error); ! 828: } ! 829: ! 830: #ifdef IMPLEADERS ! 831: printleader(routine, ip) ! 832: char *routine; ! 833: register struct imp_leader *ip; ! 834: { ! 835: printf("%s: ", routine); ! 836: printbyte((char *)ip, 12); ! 837: printf("<fmt=%x,net=%x,flags=%x,mtype=", ip->il_format, ip->il_network, ! 838: ip->il_flags); ! 839: if (ip->il_mtype <= IMPTYPE_READY) ! 840: printf("%s,", impleaders[ip->il_mtype]); ! 841: else ! 842: printf("%x,", ip->il_mtype); ! 843: printf("htype=%x,host=%x,imp=%x,link=", ip->il_htype, ip->il_host, ! 844: ntohs(ip->il_imp)); ! 845: if (ip->il_link == IMPLINK_IP) ! 846: printf("ip,"); ! 847: else ! 848: printf("%x,", ip->il_link); ! 849: printf("subtype=%x,len=%x>\n",ip->il_subtype,ntohs(ip->il_length)>>3); ! 850: } ! 851: ! 852: printbyte(cp, n) ! 853: register char *cp; ! 854: int n; ! 855: { ! 856: register i, j, c; ! 857: ! 858: for (i=0; i<n; i++) { ! 859: c = *cp++; ! 860: for (j=0; j<2; j++) ! 861: putchar("0123456789abcdef"[(c>>((1-j)*4))&0xf], 0); ! 862: putchar(' ', 0); ! 863: } ! 864: putchar('\n', 0); ! 865: } ! 866: #endif ! 867: ! 868: /* ! 869: * Routine to convert from IMP Leader to InterNet Address. ! 870: * ! 871: * This procedure is necessary because IMPs may be assigned Class A, B, or C ! 872: * network numbers, but only have 8 bits in the leader to reflect the ! 873: * IMP "network number". The strategy is to take the network number from ! 874: * the ifnet structure, and blend in the host-on-imp and imp-on-net numbers ! 875: * from the leader. ! 876: * ! 877: * There is no support for "Logical Hosts". ! 878: * ! 879: * Class A: Net.Host.0.Imp ! 880: * Class B: Net.net.Host.Imp ! 881: * Class C: Net.net.net.(Host4|Imp4) ! 882: */ ! 883: imp_leader_to_addr(ap, cp, ifp) ! 884: struct in_addr *ap; ! 885: register struct control_leader *cp; ! 886: struct ifnet *ifp; ! 887: { ! 888: register u_long final; ! 889: register struct sockaddr_in *sin; ! 890: int imp = ntohs(cp->dl_imp); ! 891: ! 892: sin = (struct sockaddr_in *)(&ifp->if_addrlist->ifa_addr); ! 893: final = ntohl(sin->sin_addr.s_addr); ! 894: ! 895: if (IN_CLASSA(final)) { ! 896: final &= IN_CLASSA_NET; ! 897: final |= (imp & 0xFF) | ((cp->dl_host & 0xFF)<<16); ! 898: } else if (IN_CLASSB(final)) { ! 899: final &= IN_CLASSB_NET; ! 900: final |= (imp & 0xFF) | ((cp->dl_host & 0xFF)<<8); ! 901: } else { ! 902: final &= IN_CLASSC_NET; ! 903: final |= (imp & 0x0F) | ((cp->dl_host & 0x0F)<<4); ! 904: } ! 905: ap->s_addr = htonl(final); ! 906: } ! 907: ! 908: /* ! 909: * Function to take InterNet address and fill in IMP leader fields. ! 910: */ ! 911: imp_addr_to_leader(imp, a) ! 912: register struct control_leader *imp; ! 913: u_long a; ! 914: { ! 915: register u_long addr = ntohl(a); ! 916: ! 917: imp->dl_network = 0; /* !! */ ! 918: ! 919: if (IN_CLASSA(addr)) { ! 920: imp->dl_host = ((addr>>16) & 0xFF); ! 921: imp->dl_imp = addr & 0xFF; ! 922: } else if (IN_CLASSB(addr)) { ! 923: imp->dl_host = ((addr>>8) & 0xFF); ! 924: imp->dl_imp = addr & 0xFF; ! 925: } else { ! 926: imp->dl_host = ((addr>>4) & 0xF); ! 927: imp->dl_imp = addr & 0xF; ! 928: } ! 929: imp->dl_imp = htons(imp->dl_imp); ! 930: } ! 931: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.