X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=modules%2Fppp.c;h=0ed435b9904404a888415698076fd640b14ea70f;hp=2734cd6aec6a5c7af61acb87c0ee61ca089bec36;hb=da44517ffef30eb2c170bb97cd6435f6d4e61a0e;hpb=63526107ef91931ac8ef8c242b9cbcdf7da96520;ds=sidebyside diff --git a/modules/ppp.c b/modules/ppp.c index 2734cd6..0ed435b 100644 --- a/modules/ppp.c +++ b/modules/ppp.c @@ -24,7 +24,7 @@ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, * OR MODIFICATIONS. * - * $Id: ppp.c,v 1.15 1998/05/04 06:11:35 paulus Exp $ + * $Id: ppp.c,v 1.25 1999/10/08 01:10:12 masputra Exp $ */ /* @@ -51,8 +51,10 @@ #include #include #ifdef SOL2 +#include #include #include +#include #else #include #include @@ -71,9 +73,10 @@ * interactive traffic, and are due to Marko Zec . */ #ifdef PRIOQ -#include #endif /* PRIOQ */ +#include /* leave this outside of PRIOQ for htons */ + #ifdef __STDC__ #define __P(x) x #else @@ -87,8 +90,75 @@ #define ETHERTYPE_IP 0x800 #endif +#if !defined(ETHERTYPE_IPV6) +#define ETHERTYPE_IPV6 0x86dd +#endif /* !defined(ETHERTYPE_IPV6) */ + +#if !defined(ETHERTYPE_ALLSAP) && defined(SOL2) +#define ETHERTYPE_ALLSAP 0 +#endif /* !defined(ETHERTYPE_ALLSAP) && defined(SOL2) */ + +#if !defined(PPP_ALLSAP) && defined(SOL2) +#define PPP_ALLSAP PPP_ALLSTATIONS +#endif /* !defined(PPP_ALLSAP) && defined(SOL2) */ + extern time_t time; +#ifdef SOL2 +/* + * We use this reader-writer lock to ensure that the lower streams + * stay connected to the upper streams while the lower-side put and + * service procedures are running. Essentially it is an existence + * lock for the upper stream associated with each lower stream. + */ +krwlock_t ppp_lower_lock; +#define LOCK_LOWER_W rw_enter(&ppp_lower_lock, RW_WRITER) +#define LOCK_LOWER_R rw_enter(&ppp_lower_lock, RW_READER) +#define TRYLOCK_LOWER_R rw_tryenter(&ppp_lower_lock, RW_READER) +#define UNLOCK_LOWER rw_exit(&ppp_lower_lock) + +#define MT_ENTER(x) mutex_enter(x) +#define MT_EXIT(x) mutex_exit(x) + +/* + * Notes on multithreaded implementation for Solaris 2: + * + * We use an inner perimeter around each queue pair and an outer + * perimeter around the whole driver. The inner perimeter is + * entered exclusively for all entry points (open, close, put, + * service). The outer perimeter is entered exclusively for open + * and close and shared for put and service. This is all done for + * us by the streams framework. + * + * I used to think that the perimeters were entered for the lower + * streams' put and service routines as well as for the upper streams'. + * Because of problems experienced by people, and after reading the + * documentation more closely, I now don't think that is true. So we + * now use ppp_lower_lock to give us an existence guarantee on the + * upper stream controlling each lower stream. + * + * Shared entry to the outer perimeter protects the existence of all + * the upper streams and their upperstr_t structures, and guarantees + * that the following fields of any upperstr_t won't change: + * nextmn, next, nextppa. It guarantees that the lowerq field of an + * upperstr_t won't go from non-zero to zero, that the global `ppas' + * won't change and that the no lower stream will get unlinked. + * + * Shared (reader) access to ppa_lower_lock guarantees that no lower + * stream will be unlinked and that the lowerq field of all upperstr_t + * structures won't change. + */ + +#else /* SOL2 */ +#define LOCK_LOWER_W 0 +#define LOCK_LOWER_R 0 +#define TRYLOCK_LOWER_R 1 +#define UNLOCK_LOWER 0 +#define MT_ENTER(x) 0 +#define MT_EXIT(x) 0 + +#endif /* SOL2 */ + /* * Private information; one per upper stream. */ @@ -104,6 +174,8 @@ typedef struct upperstr { struct upperstr *next; /* next stream for this ppa */ uint ioc_id; /* last ioctl ID for this stream */ enum NPmode npmode; /* what to do with packets on this SAP */ + unsigned char rblocked; /* flow control has blocked upper read strm */ + /* N.B. rblocked is only changed by control stream's put/srv procs */ /* * There is exactly one control stream for each PPA. * The following fields are only used for control streams. @@ -117,6 +189,7 @@ typedef struct upperstr { time_t last_sent; /* time last NP packet sent */ time_t last_recv; /* time last NP packet rcvd */ #ifdef SOL2 + kmutex_t stats_lock; /* lock for stats updates */ kstat_t *kstats; /* stats for netstat */ #endif /* SOL2 */ #ifdef LACHTCP @@ -132,7 +205,14 @@ typedef struct upperstr { #define US_BLOCKED 4 /* flow ctrl has blocked lower write stream */ #define US_LASTMOD 8 /* no PPP modules below us */ #define US_DBGLOG 0x10 /* log various occurrences */ +#define US_RBLOCKED 0x20 /* flow ctrl has blocked upper read stream */ +#if defined(SOL2) +#if DL_CURRENT_VERSION >= 2 +#define US_PROMISC 0x40 /* stream is promiscuous */ +#endif /* DL_CURRENT_VERSION >= 2 */ +#define US_RAWDATA 0x80 /* raw M_DATA, no DLPI header */ +#endif /* defined(SOL2) */ #ifdef PRIOQ static u_char max_band=0; @@ -172,6 +252,7 @@ static int pppclose __P((queue_t *, int, cred_t *)); static int pppopen __P((queue_t *, int, int, int)); static int pppclose __P((queue_t *, int)); #endif /* SVR4 */ +static int pppurput __P((queue_t *, mblk_t *)); static int pppuwput __P((queue_t *, mblk_t *)); static int pppursrv __P((queue_t *)); static int pppuwsrv __P((queue_t *)); @@ -188,12 +269,21 @@ static int send_data __P((mblk_t *, upperstr_t *)); static void new_ppa __P((queue_t *, mblk_t *)); static void attach_ppa __P((queue_t *, mblk_t *)); static void detach_ppa __P((queue_t *, mblk_t *)); +static void detach_lower __P((queue_t *, mblk_t *)); static void debug_dump __P((queue_t *, mblk_t *)); static upperstr_t *find_dest __P((upperstr_t *, int)); +#if defined(SOL2) +static upperstr_t *find_promisc __P((upperstr_t *, int)); +static mblk_t *prepend_ether __P((upperstr_t *, mblk_t *, int)); +static mblk_t *prepend_udind __P((upperstr_t *, mblk_t *, int)); +static void promisc_sendup __P((upperstr_t *, mblk_t *, int, int)); +#endif /* defined(SOL2) */ static int putctl2 __P((queue_t *, int, int, int)); static int putctl4 __P((queue_t *, int, int, int)); static int pass_packet __P((upperstr_t *ppa, mblk_t *mp, int outbound)); +#ifdef FILTER_PACKETS static int ip_hard_filter __P((upperstr_t *ppa, mblk_t *mp, int outbound)); +#endif /* FILTER_PACKETS */ #define PPP_ID 0xb1a6 static struct module_info ppp_info = { @@ -205,7 +295,7 @@ static struct module_info ppp_info = { }; static struct qinit pppurint = { - NULL, pppursrv, pppopen, pppclose, NULL, &ppp_info, NULL + pppurput, pppursrv, pppopen, pppclose, NULL, &ppp_info, NULL }; static struct qinit pppuwint = { @@ -366,6 +456,9 @@ pppopen(q, dev, oflag, sflag) q->q_ptr = (caddr_t) up; WR(q)->q_ptr = (caddr_t) up; noenable(WR(q)); +#ifdef SOL2 + mutex_init(&up->stats_lock, NULL, MUTEX_DRIVER, NULL); +#endif ++ppp_count; qprocson(q); @@ -401,6 +494,17 @@ pppclose(q, flag) #ifdef LACHTCP struct ifstats *ifp, *pifp; #endif + if (up->lowerq != 0) { + /* Gack! the lower stream should have be unlinked earlier! */ + DPRINT1("ppp%d: lower stream still connected on close?\n", + up->mn); + LOCK_LOWER_W; + up->lowerq->q_ptr = 0; + RD(up->lowerq)->q_ptr = 0; + up->lowerq = 0; + UNLOCK_LOWER; + } + /* * This stream represents a PPA: * For all streams attached to the PPA, clear their @@ -451,6 +555,7 @@ pppclose(q, flag) #ifdef SOL2 if (up->kstats) kstat_delete(up->kstats); + mutex_destroy(&up->stats_lock); #endif q->q_ptr = NULL; @@ -479,7 +584,7 @@ pppuwput(q, mp) queue_t *q; mblk_t *mp; { - upperstr_t *us, *usnext, *ppa, *os, *nps; + upperstr_t *us, *ppa, *nps; struct iocblk *iop; struct linkblk *lb; #ifdef LACHTCP @@ -490,10 +595,12 @@ pppuwput(q, mp) int error, n, sap; mblk_t *mq; struct ppp_idle *pip; - int len; #ifdef PRIOQ queue_t *tlq; #endif /* PRIOQ */ +#ifdef NO_DLPI + upperstr_t *os; +#endif us = (upperstr_t *) q->q_ptr; if (us == 0) { @@ -544,6 +651,12 @@ pppuwput(q, mp) DPRINT3("ppp/%d: ioctl %x count=%d\n", us->mn, iop->ioc_cmd, iop->ioc_count); switch (iop->ioc_cmd) { +#if defined(SOL2) + case DLIOCRAW: /* raw M_DATA mode */ + us->flags |= US_RAWDATA; + error = 0; + break; +#endif /* defined(SOL2) */ case I_LINK: if ((us->flags & US_CONTROL) == 0 || us->lowerq != 0) break; @@ -552,20 +665,21 @@ pppuwput(q, mp) break; } lb = (struct linkblk *) mp->b_cont->b_rptr; - us->lowerq = lq = lb->l_qbot; + lq = lb->l_qbot; if (lq == 0) { DPRINT1("pppuwput/%d: ioctl I_LINK l_qbot = 0!\n", us->mn); break; } - lq->q_ptr = (caddr_t) us; - RD(lq)->q_ptr = (caddr_t) us; - noenable(RD(lq)); - flushq(RD(lq), FLUSHALL); + LOCK_LOWER_W; + us->lowerq = lq; + lq->q_ptr = (caddr_t) q; + RD(lq)->q_ptr = (caddr_t) us->q; + UNLOCK_LOWER; iop->ioc_count = 0; error = 0; us->flags &= ~US_LASTMOD; /* Unblock upper streams which now feed this lower stream. */ - qenable(lq); + qenable(q); /* Send useful information down to the modules which are now linked below us. */ putctl2(lq, M_CTL, PPPCTL_UNIT, us->ppa_id); @@ -598,11 +712,9 @@ pppuwput(q, mp) break; } #endif - us->lowerq = 0; iop->ioc_count = 0; - error = 0; - /* Unblock streams which now feed back up the control stream. */ - qenable(us->q); + qwriter(q, mp, detach_lower, PERIM_OUTER); + error = -1; break; case PPPIO_NEWPPA: @@ -733,7 +845,7 @@ pppuwput(q, mp) if (n == PPPDBG_DUMP + PPPDBG_DRIVER) { qwriter(q, NULL, debug_dump, PERIM_OUTER); iop->ioc_count = 0; - error = 0; + error = -1; } else if (n == PPPDBG_LOG + PPPDBG_DRIVER) { DPRINT1("ppp/%d: debug log enabled\n", us->mn); us->flags |= US_DBGLOG; @@ -757,19 +869,20 @@ pppuwput(q, mp) break; } sap = ((int *)mp->b_cont->b_rptr)[0]; - for (nps = us->next; nps != 0; nps = nps->next) + for (nps = us->next; nps != 0; nps = nps->next) { + if (us->flags & US_DBGLOG) + DPRINT2("us = 0x%x, us->next->sap = 0x%x\n", nps, nps->sap); if (nps->sap == sap) break; + } if (nps == 0) { if (us->flags & US_DBGLOG) DPRINT2("ppp/%d: no stream for sap %x\n", us->mn, sap); break; } + /* XXX possibly should use qwriter here */ nps->npmode = (enum NPmode) ((int *)mp->b_cont->b_rptr)[1]; - if (nps->npmode == NPMODE_DROP || nps->npmode == NPMODE_ERROR) - flushq(WR(nps->q), FLUSHDATA); - else if (nps->npmode == NPMODE_PASS && qsize(WR(nps->q)) > 0 - && (nps->flags & US_BLOCKED) == 0) + if (nps->npmode != NPMODE_QUEUE && (nps->flags & US_BLOCKED) != 0) qenable(WR(nps->q)); iop->ioc_count = 0; error = 0; @@ -968,9 +1081,13 @@ dlpi_request(q, mp, us) int size = mp->b_wptr - mp->b_rptr; mblk_t *reply, *np; upperstr_t *ppa, *os; - int sap, *ip, len; + int sap, len; dl_info_ack_t *info; dl_bind_ack_t *ackp; +#if DL_CURRENT_VERSION >= 2 + dl_phys_addr_ack_t *paddrack; + static struct ether_addr eaddr = {0}; +#endif if (us->flags & US_DBGLOG) DPRINT3("ppp/%d: dlpi prim %x len=%d\n", us->mn, @@ -989,11 +1106,7 @@ dlpi_request(q, mp, us) info->dl_max_sdu = us->ppa? us->ppa->mtu: PPP_MAXMTU; info->dl_min_sdu = 1; info->dl_addr_length = sizeof(uint); -#ifdef DL_OTHER - info->dl_mac_type = DL_OTHER; -#else - info->dl_mac_type = DL_HDLC; /* a lie */ -#endif + info->dl_mac_type = DL_ETHER; /* a bigger lie */ info->dl_current_state = us->state; info->dl_service_mode = DL_CLDLS; info->dl_provider_style = DL_STYLE2; @@ -1020,7 +1133,7 @@ dlpi_request(q, mp, us) } us->ppa = ppa; qwriter(q, mp, attach_ppa, PERIM_OUTER); - break; + return; case DL_DETACH_REQ: if (size < sizeof(dl_detach_req_t)) @@ -1030,7 +1143,7 @@ dlpi_request(q, mp, us) break; } qwriter(q, mp, detach_ppa, PERIM_OUTER); - break; + return; case DL_BIND_REQ: if (size < sizeof(dl_bind_req_t)) @@ -1051,12 +1164,30 @@ dlpi_request(q, mp, us) except that we accept ETHERTYPE_IP in place of PPP_IP. */ sap = d->bind_req.dl_sap; us->req_sap = sap; + +#if defined(SOL2) + if (us->flags & US_DBGLOG) + DPRINT2("DL_BIND_REQ: ip gives sap = 0x%x, us = 0x%x", sap, us); + + if (sap == ETHERTYPE_IP) /* normal IFF_IPV4 */ + sap = PPP_IP; + else if (sap == ETHERTYPE_IPV6) /* when IFF_IPV6 is set */ + sap = PPP_IPV6; + else if (sap == ETHERTYPE_ALLSAP) /* snoop gives sap of 0 */ + sap = PPP_ALLSAP; + else { + DPRINT2("DL_BIND_REQ: unrecognized sap = 0x%x, us = 0x%x", sap, us); + dlpi_error(q, us, DL_BIND_REQ, DL_BADADDR, 0); + break; + } +#else if (sap == ETHERTYPE_IP) sap = PPP_IP; if (sap < 0x21 || sap > 0x3fff || (sap & 0x101) != 1) { dlpi_error(q, us, DL_BIND_REQ, DL_BADADDR, 0); break; } +#endif /* defined(SOL2) */ /* check that no other stream is bound to this sap already. */ for (os = us->ppa; os != 0; os = os->next) @@ -1116,6 +1247,16 @@ dlpi_request(q, mp, us) DPRINT2("dlpi data too large (%d > %d)\n", len, ppa->mtu); break; } + +#if defined(SOL2) + /* + * Should there be any promiscuous stream(s), send the data + * up for each promiscuous stream that we recognize. + */ + if (mp->b_cont) + promisc_sendup(ppa, mp->b_cont, us->sap, 0); +#endif /* defined(SOL2) */ + mp->b_band = 0; #ifdef PRIOQ /* Extract s_port & d_port from IP-packet, the code is a bit @@ -1203,14 +1344,55 @@ dlpi_request(q, mp, us) return; #if DL_CURRENT_VERSION >= 2 + case DL_PHYS_ADDR_REQ: + if (size < sizeof(dl_phys_addr_req_t)) + goto badprim; + + /* + * Don't check state because ifconfig sends this one down too + */ + + if ((reply = allocb(sizeof(dl_phys_addr_ack_t)+ETHERADDRL, + BPRI_HI)) == 0) + break; /* should do bufcall */ + reply->b_datap->db_type = M_PCPROTO; + paddrack = (dl_phys_addr_ack_t *) reply->b_wptr; + reply->b_wptr += sizeof(dl_phys_addr_ack_t); + bzero((caddr_t) paddrack, sizeof(dl_phys_addr_ack_t)+ETHERADDRL); + paddrack->dl_primitive = DL_PHYS_ADDR_ACK; + paddrack->dl_addr_length = ETHERADDRL; + paddrack->dl_addr_offset = sizeof(dl_phys_addr_ack_t); + bcopy(&eaddr, reply->b_wptr, ETHERADDRL); + reply->b_wptr += ETHERADDRL; + qreply(q, reply); + break; + +#if defined(SOL2) + case DL_PROMISCON_REQ: + if (size < sizeof(dl_promiscon_req_t)) + goto badprim; + us->flags |= US_PROMISC; + dlpi_ok(q, DL_PROMISCON_REQ); + break; + + case DL_PROMISCOFF_REQ: + if (size < sizeof(dl_promiscoff_req_t)) + goto badprim; + us->flags &= ~US_PROMISC; + dlpi_ok(q, DL_PROMISCOFF_REQ); + break; +#else + case DL_PROMISCON_REQ: /* fall thru */ + case DL_PROMISCOFF_REQ: /* fall thru */ +#endif /* defined(SOL2) */ +#endif /* DL_CURRENT_VERSION >= 2 */ + +#if DL_CURRENT_VERSION >= 2 + case DL_SET_PHYS_ADDR_REQ: case DL_SUBS_BIND_REQ: case DL_SUBS_UNBIND_REQ: case DL_ENABMULTI_REQ: case DL_DISABMULTI_REQ: - case DL_PROMISCON_REQ: - case DL_PROMISCOFF_REQ: - case DL_PHYS_ADDR_REQ: - case DL_SET_PHYS_ADDR_REQ: case DL_XID_REQ: case DL_TEST_REQ: case DL_REPLY_UPDATE_REQ: @@ -1334,12 +1516,17 @@ pass_packet(us, mp, outbound) return pass; } +/* + * We have some data to send down to the lower stream (or up the + * control stream, if we don't have a lower stream attached). + * Returns 1 if the message was dealt with, 0 if it wasn't able + * to be sent on and should therefore be queued up. + */ static int send_data(mp, us) mblk_t *mp; upperstr_t *us; { - queue_t *q; upperstr_t *ppa; if ((us->flags & US_BLOCKED) || us->npmode == NPMODE_QUEUE) @@ -1351,7 +1538,7 @@ send_data(mp, us) freemsg(mp); return 1; } - if ((q = ppa->lowerq) == 0) { + if (ppa->lowerq == 0) { /* try to send it up the control stream */ if (bcanputnext(ppa->q, mp->b_band)) { /* @@ -1366,13 +1553,19 @@ send_data(mp, us) } } else { if (bcanputnext(ppa->lowerq, mp->b_band)) { + MT_ENTER(&ppa->stats_lock); + ppa->stats.ppp_opackets++; + ppa->stats.ppp_obytes += msgdsize(mp); +#ifdef INCR_OPACKETS + INCR_OPACKETS(ppa); +#endif + MT_EXIT(&ppa->stats_lock); /* - * The lower write queue's put procedure just updates counters - * and does a putnext. We call it so that on SMP systems, we - * enter the lower queues' perimeter so that the counter - * updates are serialized. + * The lower queue is only ever detached while holding an + * exclusive lock on the whole driver. So we can be confident + * that the lower queue is still there. */ - put(ppa->lowerq, mp); + putnext(ppa->lowerq, mp); return 1; } } @@ -1390,16 +1583,21 @@ new_ppa(q, mp) queue_t *q; mblk_t *mp; { - upperstr_t *us, **usp; + upperstr_t *us, *up, **usp; int ppa_id; + us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("new_ppa: q_ptr = 0!\n"); + return; + } + usp = &ppas; ppa_id = 0; - while ((us = *usp) != 0 && ppa_id == us->ppa_id) { + while ((up = *usp) != 0 && ppa_id == up->ppa_id) { ++ppa_id; - usp = &us->nextppa; + usp = &up->nextppa; } - us = (upperstr_t *) q->q_ptr; us->ppa_id = ppa_id; us->ppa = us; us->next = 0; @@ -1450,6 +1648,11 @@ attach_ppa(q, mp) upperstr_t *us, *t; us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("attach_ppa: q_ptr = 0!\n"); + return; + } + #ifndef NO_DLPI us->state = DL_UNBOUND; #endif @@ -1475,6 +1678,11 @@ detach_ppa(q, mp) upperstr_t *us, *t; us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("detach_ppa: q_ptr = 0!\n"); + return; + } + for (t = us->ppa; t->next != 0; t = t->next) if (t->next == us) { t->next = us->next; @@ -1488,16 +1696,63 @@ detach_ppa(q, mp) #endif } +/* + * We call this with qwriter in order to give the upper queue procedures + * the guarantee that the lower queue is not going to go away while + * they are executing. + */ +static void +detach_lower(q, mp) + queue_t *q; + mblk_t *mp; +{ + upperstr_t *us; + + us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("detach_lower: q_ptr = 0!\n"); + return; + } + + LOCK_LOWER_W; + us->lowerq->q_ptr = 0; + RD(us->lowerq)->q_ptr = 0; + us->lowerq = 0; + UNLOCK_LOWER; + + /* Unblock streams which now feed back up the control stream. */ + qenable(us->q); + + mp->b_datap->db_type = M_IOCACK; + qreply(q, mp); +} + static int pppuwsrv(q) queue_t *q; { - upperstr_t *us; - struct lowerstr *ls; - queue_t *lwq; + upperstr_t *us, *as; mblk_t *mp; us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("pppuwsrv: q_ptr = 0!\n"); + return 0; + } + + /* + * If this is a control stream, then this service procedure + * probably got enabled because of flow control in the lower + * stream being enabled (or because of the lower stream going + * away). Therefore we enable the service procedure of all + * attached upper streams. + */ + if (us->flags & US_CONTROL) { + for (as = us->next; as != 0; as = as->next) + qenable(WR(as->q)); + } + + /* Try to send on any data queued here. */ us->flags &= ~US_BLOCKED; while ((mp = getq(q)) != 0) { if (!send_data(mp, us)) { @@ -1505,24 +1760,16 @@ pppuwsrv(q) break; } } + return 0; } +/* should never get called... */ static int ppplwput(q, mp) queue_t *q; mblk_t *mp; { - upperstr_t *ppa; - - ppa = (upperstr_t *) q->q_ptr; - if (ppa != 0) { /* why wouldn't it? */ - ppa->stats.ppp_opackets++; - ppa->stats.ppp_obytes += msgdsize(mp); -#ifdef INCR_OPACKETS - INCR_OPACKETS(ppa); -#endif - } putnext(q, mp); return 0; } @@ -1531,16 +1778,151 @@ static int ppplwsrv(q) queue_t *q; { - upperstr_t *us; + queue_t *uq; /* * Flow control has back-enabled this stream: - * enable the write service procedures of all upper - * streams feeding this lower stream. + * enable the upper write service procedure for + * the upper control stream for this lower stream. */ - for (us = (upperstr_t *) q->q_ptr; us != NULL; us = us->next) - if (us->flags & US_BLOCKED) - qenable(WR(us->q)); + LOCK_LOWER_R; + uq = (queue_t *) q->q_ptr; + if (uq != 0) + qenable(uq); + UNLOCK_LOWER; + return 0; +} + +/* + * This should only get called for control streams. + */ +static int +pppurput(q, mp) + queue_t *q; + mblk_t *mp; +{ + upperstr_t *ppa, *us; + int proto, len; + struct iocblk *iop; + + ppa = (upperstr_t *) q->q_ptr; + if (ppa == 0) { + DPRINT("pppurput: q_ptr = 0!\n"); + return 0; + } + + switch (mp->b_datap->db_type) { + case M_CTL: + MT_ENTER(&ppa->stats_lock); + switch (*mp->b_rptr) { + case PPPCTL_IERROR: +#ifdef INCR_IERRORS + INCR_IERRORS(ppa); +#endif + ppa->stats.ppp_ierrors++; + break; + case PPPCTL_OERROR: +#ifdef INCR_OERRORS + INCR_OERRORS(ppa); +#endif + ppa->stats.ppp_oerrors++; + break; + } + MT_EXIT(&ppa->stats_lock); + freemsg(mp); + break; + + case M_IOCACK: + case M_IOCNAK: + /* + * Attempt to match up the response with the stream + * that the request came from. + */ + iop = (struct iocblk *) mp->b_rptr; + for (us = ppa; us != 0; us = us->next) + if (us->ioc_id == iop->ioc_id) + break; + if (us == 0) + freemsg(mp); + else + putnext(us->q, mp); + break; + + case M_HANGUP: + /* + * The serial device has hung up. We don't want to send + * the M_HANGUP message up to pppd because that will stop + * us from using the control stream any more. Instead we + * send a zero-length message as an end-of-file indication. + */ + freemsg(mp); + mp = allocb(1, BPRI_HI); + if (mp == 0) { + DPRINT1("ppp/%d: couldn't allocate eof message!\n", ppa->mn); + break; + } + putnext(ppa->q, mp); + break; + + default: + if (mp->b_datap->db_type == M_DATA) { + len = msgdsize(mp); + if (mp->b_wptr - mp->b_rptr < PPP_HDRLEN) { + PULLUP(mp, PPP_HDRLEN); + if (mp == 0) { + DPRINT1("ppp_urput: msgpullup failed (len=%d)\n", len); + break; + } + } + MT_ENTER(&ppa->stats_lock); + ppa->stats.ppp_ipackets++; + ppa->stats.ppp_ibytes += len; +#ifdef INCR_IPACKETS + INCR_IPACKETS(ppa); +#endif + MT_EXIT(&ppa->stats_lock); + + proto = PPP_PROTOCOL(mp->b_rptr); + +#if defined(SOL2) + /* + * Should there be any promiscuous stream(s), send the data + * up for each promiscuous stream that we recognize. + */ + promisc_sendup(ppa, mp, proto, 1); +#endif /* defined(SOL2) */ + + if (proto < 0x8000 && (us = find_dest(ppa, proto)) != 0) { + /* + * A data packet for some network protocol. + * Queue it on the upper stream for that protocol. + * XXX could we just putnext it? (would require thought) + * The rblocked flag is there to ensure that we keep + * messages in order for each network protocol. + */ + if (!pass_packet(us, mp, 0)) + break; + if (!us->rblocked && !canput(us->q)) + us->rblocked = 1; + if (!us->rblocked) + putq(us->q, mp); + else + putq(q, mp); + break; + } + } + /* + * A control frame, a frame for an unknown protocol, + * or some other message type. + * Send it up to pppd via the control stream. + */ + if (queclass(mp) == QPCTL || canputnext(ppa->q)) + putnext(ppa->q, mp); + else + putq(q, mp); + break; + } + return 0; } @@ -1556,6 +1938,11 @@ pppursrv(q) int proto; us = (upperstr_t *) q->q_ptr; + if (us == 0) { + DPRINT("pppursrv: q_ptr = 0!\n"); + return 0; + } + if (us->flags & US_CONTROL) { /* * A control stream. @@ -1570,6 +1957,44 @@ pppursrv(q) as = as->next; } while (as != 0); } + + /* + * Messages get queued on this stream's read queue if they + * can't be queued on the read queue of the attached stream + * that they are destined for. This is for flow control - + * when this queue fills up, the lower read put procedure will + * queue messages there and the flow control will propagate + * down from there. + */ + while ((mp = getq(q)) != 0) { + proto = PPP_PROTOCOL(mp->b_rptr); + if (proto < 0x8000 && (as = find_dest(us, proto)) != 0) { + if (!canput(as->q)) + break; + putq(as->q, mp); + } else { + if (!canputnext(q)) + break; + putnext(q, mp); + } + } + if (mp) { + putbq(q, mp); + } else { + /* can now put stuff directly on network protocol streams again */ + for (as = us->next; as != 0; as = as->next) + as->rblocked = 0; + } + + /* + * If this stream has a lower stream attached, + * enable the read queue's service routine. + * XXX we should really only do this if the queue length + * has dropped below the low-water mark. + */ + if (us->lowerq != 0) + qenable(RD(us->lowerq)); + } else { /* * A network protocol stream. Put a DLPI header on each @@ -1614,17 +2039,16 @@ pppursrv(q) putnext(q, mp); #endif /* NO_DLPI */ } + /* + * Now that we have consumed some packets from this queue, + * enable the control stream's read service routine so that we + * can process any packets for us that might have got queued + * there for flow control reasons. + */ + if (us->ppa) + qenable(us->ppa->q); } - /* - * If this stream is attached to a PPA with a lower queue pair, - * enable the read queue's service routine if it has data queued. - * XXX there is a possibility that packets could get out of order - * if ppplrput now runs before ppplrsrv. - */ - if (us->ppa != 0 && us->ppa->lowerq != 0) - qenable(RD(us->ppa->lowerq)); - return 0; } @@ -1641,124 +2065,212 @@ find_dest(ppa, proto) return us; } +#if defined (SOL2) +/* + * Test upstream promiscuous conditions. As of now, only pass IPv4 and + * Ipv6 packets upstream (let PPP packets be decoded elsewhere). + */ +static upperstr_t * +find_promisc(us, proto) + upperstr_t *us; + int proto; +{ + + if ((proto != PPP_IP) && (proto != PPP_IPV6)) + return (upperstr_t *)0; + + for ( ; us; us = us->next) { + if ((us->flags & US_PROMISC) && (us->state == DL_IDLE)) + return us; + } + + return (upperstr_t *)0; +} + +/* + * Prepend an empty Ethernet header to msg for snoop, et al. + */ +static mblk_t * +prepend_ether(us, mp, proto) + upperstr_t *us; + mblk_t *mp; + int proto; +{ + mblk_t *eh; + int type; + + if ((eh = allocb(sizeof(struct ether_header), BPRI_HI)) == 0) { + freemsg(mp); + return (mblk_t *)0; + } + + if (proto == PPP_IP) + type = ETHERTYPE_IP; + else if (proto == PPP_IPV6) + type = ETHERTYPE_IPV6; + else + type = proto; /* What else? Let decoder decide */ + + eh->b_wptr += sizeof(struct ether_header); + bzero((caddr_t)eh->b_rptr, sizeof(struct ether_header)); + ((struct ether_header *)eh->b_rptr)->ether_type = htons((short)type); + eh->b_cont = mp; + return (eh); +} + +/* + * Prepend DL_UNITDATA_IND mblk to msg + */ +static mblk_t * +prepend_udind(us, mp, proto) + upperstr_t *us; + mblk_t *mp; + int proto; +{ + dl_unitdata_ind_t *dlu; + mblk_t *dh; + size_t size; + + size = sizeof(dl_unitdata_ind_t); + if ((dh = allocb(size, BPRI_MED)) == 0) { + freemsg(mp); + return (mblk_t *)0; + } + + dh->b_datap->db_type = M_PROTO; + dh->b_wptr = dh->b_datap->db_lim; + dh->b_rptr = dh->b_wptr - size; + + dlu = (dl_unitdata_ind_t *)dh->b_rptr; + dlu->dl_primitive = DL_UNITDATA_IND; + dlu->dl_dest_addr_length = 0; + dlu->dl_dest_addr_offset = sizeof(dl_unitdata_ind_t); + dlu->dl_src_addr_length = 0; + dlu->dl_src_addr_offset = sizeof(dl_unitdata_ind_t); + dlu->dl_group_address = 0; + + dh->b_cont = mp; + return (dh); +} + +/* + * For any recognized promiscuous streams, send data upstream + */ +static void +promisc_sendup(ppa, mp, proto, skip) + upperstr_t *ppa; + mblk_t *mp; + int proto, skip; +{ + mblk_t *dup_mp, *dup_dup_mp; + upperstr_t *prus, *nprus; + + if ((prus = find_promisc(ppa, proto)) != 0) { + if (dup_mp = dupmsg(mp)) { + + if (skip) + dup_mp->b_rptr += PPP_HDRLEN; + + for ( ; nprus = find_promisc(prus->next, proto); + prus = nprus) { + + if (dup_dup_mp = dupmsg(dup_mp)) { + if (canputnext(prus->q)) { + if (prus->flags & US_RAWDATA) { + dup_dup_mp = prepend_ether(prus, dup_dup_mp, proto); + putnext(prus->q, dup_dup_mp); + } else { + dup_dup_mp = prepend_udind(prus, dup_dup_mp, proto); + putnext(prus->q, dup_dup_mp); + } + } else { + DPRINT("ppp_urput: data to promisc q dropped\n"); + freemsg(dup_dup_mp); + } + } + } + + if (canputnext(prus->q)) { + if (prus->flags & US_RAWDATA) { + dup_mp = prepend_ether(prus, dup_mp, proto); + putnext(prus->q, dup_mp); + } else { + dup_mp = prepend_udind(prus, dup_mp, proto); + putnext(prus->q, dup_mp); + } + } else { + DPRINT("ppp_urput: data to promisc q dropped\n"); + freemsg(dup_mp); + } + } + } +} +#endif /* defined(SOL2) */ + +/* + * We simply put the message on to the associated upper control stream + * (either here or in ppplrsrv). That way we enter the perimeters + * before looking through the list of attached streams to decide which + * stream it should go up. + */ static int ppplrput(q, mp) queue_t *q; mblk_t *mp; { - upperstr_t *ppa, *us; queue_t *uq; - int proto, len; - mblk_t *np; struct iocblk *iop; - ppa = (upperstr_t *) q->q_ptr; - if (ppa == 0) { - DPRINT1("ppplrput: q = %x, ppa = 0??\n", q); - freemsg(mp); - return 0; - } switch (mp->b_datap->db_type) { + case M_IOCTL: + iop = (struct iocblk *) mp->b_rptr; + iop->ioc_error = EINVAL; + mp->b_datap->db_type = M_IOCNAK; + qreply(q, mp); + return 0; case M_FLUSH: + if (*mp->b_rptr & FLUSHR) + flushq(q, FLUSHDATA); if (*mp->b_rptr & FLUSHW) { *mp->b_rptr &= ~FLUSHR; qreply(q, mp); } else freemsg(mp); - break; - - case M_CTL: - switch (*mp->b_rptr) { - case PPPCTL_IERROR: -#ifdef INCR_IERRORS - INCR_IERRORS(ppa); -#endif - ppa->stats.ppp_ierrors++; - break; - case PPPCTL_OERROR: -#ifdef INCR_OERRORS - INCR_OERRORS(ppa); -#endif - ppa->stats.ppp_oerrors++; - break; - } - freemsg(mp); - break; + return 0; + } - case M_IOCACK: - case M_IOCNAK: - /* - * Attempt to match up the response with the stream - * that the request came from. - */ - iop = (struct iocblk *) mp->b_rptr; - for (us = ppa; us != 0; us = us->next) - if (us->ioc_id == iop->ioc_id) - break; - if (us == 0) - freemsg(mp); - else - putnext(us->q, mp); - break; + /* + * If we can't get the lower lock straight away, queue this one + * rather than blocking, to avoid the possibility of deadlock. + */ + if (!TRYLOCK_LOWER_R) { + putq(q, mp); + return 0; + } - case M_HANGUP: - /* - * The serial device has hung up. We don't want to send - * the M_HANGUP message up to pppd because that will stop - * us from using the control stream any more. Instead we - * send a zero-length message as an end-of-file indication. - */ + /* + * Check that we're still connected to the driver. + */ + uq = (queue_t *) q->q_ptr; + if (uq == 0) { + UNLOCK_LOWER; + DPRINT1("ppplrput: q = %x, uq = 0??\n", q); freemsg(mp); - mp = allocb(1, BPRI_HI); - if (mp == 0) { - DPRINT1("ppp/%d: couldn't allocate eof message!\n", ppa->mn); - break; - } - putnext(ppa->q, mp); - break; - - default: - if (mp->b_datap->db_type == M_DATA) { - len = msgdsize(mp); - if (mp->b_wptr - mp->b_rptr < PPP_HDRLEN) { - PULLUP(mp, PPP_HDRLEN); - if (mp == 0) { - DPRINT1("ppp_lrput: msgpullup failed (len=%d)\n", len); - break; - } - } - ppa->stats.ppp_ipackets++; - ppa->stats.ppp_ibytes += len; -#ifdef INCR_IPACKETS - INCR_IPACKETS(ppa); -#endif - proto = PPP_PROTOCOL(mp->b_rptr); - if (proto < 0x8000 && (us = find_dest(ppa, proto)) != 0) { - /* - * A data packet for some network protocol. - * Queue it on the upper stream for that protocol. - */ - if (!pass_packet(us, mp, 0)) - break; - if (canput(us->q)) - putq(us->q, mp); - else - putq(q, mp); - break; - } - } - /* - * A control frame, a frame for an unknown protocol, - * or some other message type. - * Send it up to pppd via the control stream. - */ - if (queclass(mp) == QPCTL || canputnext(ppa->q)) - putnext(ppa->q, mp); - else - putq(q, mp); - break; + return 0; } + /* + * Try to forward the message to the put routine for the upper + * control stream for this lower stream. + * If there are already messages queued here, queue this one so + * they don't get out of order. + */ + if (queclass(mp) == QPCTL || (qsize(q) == 0 && canput(uq))) + put(uq, mp); + else + putq(q, mp); + + UNLOCK_LOWER; return 0; } @@ -1767,32 +2279,30 @@ ppplrsrv(q) queue_t *q; { mblk_t *mp; - upperstr_t *ppa, *us; - int proto; + queue_t *uq; /* - * Packets only get queued here for flow control reasons. + * Packets get queued here for flow control reasons + * or if the lrput routine couldn't get the lower lock + * without blocking. */ - ppa = (upperstr_t *) q->q_ptr; + LOCK_LOWER_R; + uq = (queue_t *) q->q_ptr; + if (uq == 0) { + UNLOCK_LOWER; + flushq(q, FLUSHALL); + DPRINT1("ppplrsrv: q = %x, uq = 0??\n", q); + return 0; + } while ((mp = getq(q)) != 0) { - if (mp->b_datap->db_type == M_DATA - && (proto = PPP_PROTOCOL(mp->b_rptr)) < 0x8000 - && (us = find_dest(ppa, proto)) != 0) { - if (canput(us->q)) - putq(us->q, mp); - else { - putbq(q, mp); - break; - } - } else { - if (canputnext(ppa->q)) - putnext(ppa->q, mp); - else { - putbq(q, mp); - break; - } + if (queclass(mp) == QPCTL || canput(uq)) + put(uq, mp); + else { + putbq(q, mp); + break; } } + UNLOCK_LOWER; return 0; } @@ -1834,8 +2344,8 @@ putctl4(q, type, code, val) static void debug_dump(q, mp) - queue_t *q; /* not used */ - mblk_t *mp; /* not used either */ + queue_t *q; + mblk_t *mp; { upperstr_t *us; queue_t *uq, *lq; @@ -1861,6 +2371,8 @@ debug_dump(q, mp) (lq? qsize(lq): 0), us->mru, us->mtu); } } + mp->b_datap->db_type = M_IOCACK; + qreply(q, mp); } #ifdef FILTER_PACKETS