X-Git-Url: https://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=modules%2Fppp_comp.c;h=96713709b97570ebf04b7bc6a1da3da3ff94bee0;hp=9e20afdf73f85b9db96d806ce764fdbc6e01e7f0;hb=8592783058509b5493a42f3b0432fcbaab55c994;hpb=16193f3505f75cc63f0669b1c9d17794d9d5e9a3 diff --git a/modules/ppp_comp.c b/modules/ppp_comp.c index 9e20afd..9671370 100644 --- a/modules/ppp_comp.c +++ b/modules/ppp_comp.c @@ -24,11 +24,11 @@ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, * OR MODIFICATIONS. * - * $Id: ppp_comp.c,v 1.3 1996/05/28 00:55:44 paulus Exp $ + * $Id: ppp_comp.c,v 1.11 1999/04/12 06:20:22 paulus Exp $ */ /* - * This file is used under SVR4, Solaris 2, SunOS 4, and OSF/1. + * This file is used under SVR4, Solaris 2, SunOS 4, and Digital UNIX. */ #include @@ -42,12 +42,20 @@ #include #else #include +#ifdef __osf__ +#include +#endif #endif /* SVR4 */ #include #include #include "ppp_mod.h" +#ifdef __osf__ +#include +#include +#endif + #include #include #include @@ -72,8 +80,13 @@ static int msg_byte __P((mblk_t *, unsigned int)); /* Is this LCP packet one we have to transmit using LCP defaults? */ #define LCP_USE_DFLT(mp) (1 <= (code = MSG_BYTE((mp), 4)) && code <= 7) +#define PPP_COMP_ID 0xbadf static struct module_info minfo = { - 0xbadf, "ppp_comp", 0, INFPSZ, 16384, 4096, +#ifdef PRIOQ + PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16512, 16384, +#else + PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16384, 4096, +#endif }; static struct qinit r_init = { @@ -85,12 +98,28 @@ static struct qinit w_init = { ppp_comp_wput, ppp_comp_wsrv, NULL, NULL, NULL, &minfo, NULL }; +#if defined(SVR4) && !defined(SOL2) +int pcmpdevflag = 0; +#define ppp_compinfo pcmpinfo +#endif struct streamtab ppp_compinfo = { &r_init, &w_init, NULL, NULL }; int ppp_comp_count; /* number of module instances in use */ +#ifdef __osf__ + +static void ppp_comp_alloc __P((comp_state_t *)); +typedef struct memreq { + unsigned char comp_opts[20]; + int cmd; + int thread_status; + char *returned_mem; +} memreq_t; + +#endif + typedef struct comp_state { int flags; int mru; @@ -103,11 +132,21 @@ typedef struct comp_state { struct vjcompress vj_comp; int vj_last_ierrors; struct pppstat stats; +#ifdef __osf__ + memreq_t memreq; + thread_t thread; +#endif } comp_state_t; + +#ifdef __osf__ +extern task_t first_task; +#endif + /* Bits in flags are as defined in pppio.h. */ #define CCP_ERR (CCP_ERROR | CCP_FATALERROR) #define LAST_MOD 0x1000000 /* no ppp modules below us */ +#define DBGLOG 0x2000000 /* log debugging stuff */ #define MAX_IPHDR 128 /* max TCP/IP header size */ #define MAX_VJHDR 20 /* max VJ compressed header size (?) */ @@ -119,8 +158,12 @@ typedef struct comp_state { * List of compressors we know about. */ +#if DO_BSD_COMPRESS extern struct compressor ppp_bsd_compress; -extern struct compressor ppp_deflate; +#endif +#if DO_DEFLATE +extern struct compressor ppp_deflate, ppp_deflate_draft; +#endif struct compressor *ppp_compressors[] = { #if DO_BSD_COMPRESS @@ -128,6 +171,7 @@ struct compressor *ppp_compressors[] = { #endif #if DO_DEFLATE &ppp_deflate, + &ppp_deflate_draft, #endif NULL }; @@ -138,18 +182,26 @@ struct compressor *ppp_compressors[] = { MOD_OPEN(ppp_comp_open) { comp_state_t *cp; +#ifdef __osf__ + thread_t thread; +#endif if (q->q_ptr == NULL) { cp = (comp_state_t *) ALLOC_SLEEP(sizeof(comp_state_t)); if (cp == NULL) OPEN_ERROR(ENOSR); - WR(q)->q_ptr = q->q_ptr = (caddr_t) cp; bzero((caddr_t)cp, sizeof(comp_state_t)); + WR(q)->q_ptr = q->q_ptr = (caddr_t) cp; cp->mru = PPP_MRU; - cp->mtu = PPP_MRU; + cp->mtu = PPP_MTU; cp->xstate = NULL; cp->rstate = NULL; vj_compress_init(&cp->vj_comp, -1); +#ifdef __osf__ + if (!(thread = kernel_thread_w_arg(first_task, ppp_comp_alloc, (void *)cp))) + OPEN_ERROR(ENOSR); + cp->thread = thread; +#endif ++ppp_comp_count; qprocson(q); } @@ -167,6 +219,12 @@ MOD_CLOSE(ppp_comp_close) (*cp->xcomp->comp_free)(cp->xstate); if (cp->rstate != NULL) (*cp->rcomp->decomp_free)(cp->rstate); +#ifdef __osf__ + if (!cp->thread) + printf("ppp_comp_close: NULL thread!\n"); + else + thread_terminate(cp->thread); +#endif FREE(cp, sizeof(comp_state_t)); q->q_ptr = NULL; OTHERQ(q)->q_ptr = NULL; @@ -175,6 +233,82 @@ MOD_CLOSE(ppp_comp_close) return 0; } +#ifdef __osf__ + +/* thread for calling back to a compressor's memory allocator + * Needed for Digital UNIX since it's VM can't handle requests + * for large amounts of memory without blocking. The thread + * provides a context in which we can call a memory allocator + * that may block. + */ +static void +ppp_comp_alloc(comp_state_t *cp) +{ + int len, cmd; + unsigned char *compressor_options; + thread_t thread; + void *(*comp_allocator)(); + + +#if defined(MAJOR_VERSION) && (MAJOR_VERSION <= 2) + + /* In 2.x and earlier the argument gets passed + * in the thread structure itself. Yuck. + */ + thread = current_thread(); + cp = thread->reply_port; + thread->reply_port = PORT_NULL; + +#endif + + for (;;) { + assert_wait((vm_offset_t)&cp->memreq.thread_status, TRUE); + thread_block(); + + if (thread_should_halt(current_thread())) + thread_halt_self(); + cmd = cp->memreq.cmd; + compressor_options = &cp->memreq.comp_opts[0]; + len = compressor_options[1]; + if (cmd == PPPIO_XCOMP) { + cp->memreq.returned_mem = cp->xcomp->comp_alloc(compressor_options, len); + if (!cp->memreq.returned_mem) { + cp->memreq.thread_status = ENOSR; + } else { + cp->memreq.thread_status = 0; + } + } else { + cp->memreq.returned_mem = cp->rcomp->decomp_alloc(compressor_options, len); + if (!cp->memreq.returned_mem) { + cp->memreq.thread_status = ENOSR; + } else { + cp->memreq.thread_status = 0; + } + } + } +} + +#endif /* __osf__ */ + +/* here's the deal with memory allocation under Digital UNIX. + * Some other may also benefit from this... + * We can't ask for huge chunks of memory in a context where + * the caller can't be put to sleep (like, here.) The alloc + * is likely to fail. Instead we do this: the first time we + * get called, kick off a thread to do the allocation. Return + * immediately to the caller with EAGAIN, as an indication that + * they should send down the ioctl again. By the time the + * second call comes in it's likely that the memory allocation + * thread will have returned with the requested memory. We will + * continue to return EAGAIN however until the thread has completed. + * When it has, we return zero (and the memory) if the allocator + * was successful and ENOSR otherwise. + * + * Callers of the RCOMP and XCOMP ioctls are encouraged (but not + * required) to loop for some number of iterations with a small + * delay in the loop body (for instance a 1/10-th second "sleep" + * via select.) + */ static int ppp_comp_wput(q, mp) queue_t *q; @@ -182,7 +316,7 @@ ppp_comp_wput(q, mp) { struct iocblk *iop; comp_state_t *cp; - int error, len; + int error, len, n; int flags, mask; mblk_t *np; struct compressor **comp; @@ -192,6 +326,12 @@ ppp_comp_wput(q, mp) int nxslots, nrslots; cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_wput\n"); + freemsg(mp); + return 0; + } + switch (mp->b_datap->db_type) { case M_DATA: @@ -207,6 +347,10 @@ ppp_comp_wput(q, mp) /* set/get CCP state */ if (iop->ioc_count != 2 * sizeof(int)) break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_CFLAGS b_cont = 0!\n", cp->unit); + break; + } flags = ((int *) mp->b_cont->b_rptr)[0]; mask = ((int *) mp->b_cont->b_rptr)[1]; cp->flags = (cp->flags & ~mask) | (flags & mask); @@ -233,6 +377,10 @@ ppp_comp_wput(q, mp) */ if (iop->ioc_count != 2) break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_VJINIT b_cont = 0!\n", cp->unit); + break; + } nxslots = mp->b_cont->b_rptr[0] + 1; nrslots = mp->b_cont->b_rptr[1] + 1; if (nxslots > MAX_STATES || nrslots > MAX_STATES) @@ -247,6 +395,10 @@ ppp_comp_wput(q, mp) case PPPIO_RCOMP: if (iop->ioc_count <= 0) break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_[XR]COMP b_cont = 0!\n", cp->unit); + break; + } opt_data = mp->b_cont->b_rptr; len = mp->b_cont->b_wptr - opt_data; if (len > iop->ioc_count) @@ -257,21 +409,82 @@ ppp_comp_wput(q, mp) if ((*comp)->compress_proto == opt_data[0]) { /* here's the handler! */ error = 0; +#ifndef __osf__ if (iop->ioc_cmd == PPPIO_XCOMP) { - if (cp->xstate != NULL) + /* A previous call may have fetched memory for a compressor + * that's now being retired or reset. Free it using it's + * mechanism for freeing stuff. + */ + if (cp->xstate != NULL) { (*cp->xcomp->comp_free)(cp->xstate); + cp->xstate = NULL; + } cp->xcomp = *comp; cp->xstate = (*comp)->comp_alloc(opt_data, len); if (cp->xstate == NULL) error = ENOSR; } else { - if (cp->rstate != NULL) + if (cp->rstate != NULL) { (*cp->rcomp->decomp_free)(cp->rstate); + cp->rstate = NULL; + } cp->rcomp = *comp; cp->rstate = (*comp)->decomp_alloc(opt_data, len); if (cp->rstate == NULL) error = ENOSR; } +#else + if ((error = cp->memreq.thread_status) != EAGAIN) + if (iop->ioc_cmd == PPPIO_XCOMP) { + if (cp->xstate) { + (*cp->xcomp->comp_free)(cp->xstate); + cp->xstate = 0; + } + /* sanity check for compressor options + */ + if (sizeof (cp->memreq.comp_opts) < len) { + printf("can't handle options for compressor %d (%d)\n", opt_data[0], + opt_data[1]); + cp->memreq.thread_status = ENOSR; + cp->memreq.returned_mem = 0; + } + /* fill in request for the thread and kick it off + */ + if (cp->memreq.thread_status == 0 && !cp->memreq.returned_mem) { + bcopy(opt_data, cp->memreq.comp_opts, len); + cp->memreq.cmd = PPPIO_XCOMP; + cp->xcomp = *comp; + error = cp->memreq.thread_status = EAGAIN; + thread_wakeup((vm_offset_t)&cp->memreq.thread_status); + } else { + cp->xstate = cp->memreq.returned_mem; + cp->memreq.returned_mem = 0; + cp->memreq.thread_status = 0; + } + } else { + if (cp->rstate) { + (*cp->rcomp->decomp_free)(cp->rstate); + cp->rstate = NULL; + } + if (sizeof (cp->memreq.comp_opts) < len) { + printf("can't handle options for compressor %d (%d)\n", opt_data[0], + opt_data[1]); + cp->memreq.thread_status = ENOSR; + cp->memreq.returned_mem = 0; + } + if (cp->memreq.thread_status == 0 && !cp->memreq.returned_mem) { + bcopy(opt_data, cp->memreq.comp_opts, len); + cp->memreq.cmd = PPPIO_RCOMP; + cp->rcomp = *comp; + error = cp->memreq.thread_status = EAGAIN; + thread_wakeup((vm_offset_t)&cp->memreq.thread_status); + } else { + cp->rstate = cp->memreq.returned_mem; + cp->memreq.returned_mem = 0; + cp->memreq.thread_status = 0; + } + } +#endif break; } iop->ioc_count = 0; @@ -318,6 +531,24 @@ ppp_comp_wput(q, mp) error = 0; break; + case PPPIO_DEBUG: + if (iop->ioc_count != sizeof(int)) + break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_DEBUG b_cont = 0!\n", cp->unit); + break; + } + n = *(int *)mp->b_cont->b_rptr; + if (n == PPPDBG_LOG + PPPDBG_COMP) { + DPRINT1("ppp_comp%d: debug log enabled\n", cp->unit); + cp->flags |= DBGLOG; + error = 0; + iop->ioc_count = 0; + } else { + error = -1; + } + break; + case PPPIO_LASTMOD: cp->flags |= LAST_MOD; error = 0; @@ -359,6 +590,8 @@ ppp_comp_wput(q, mp) default: putnext(q, mp); } + + return 0; } static int @@ -372,11 +605,21 @@ ppp_comp_wsrv(q) unsigned char *vjhdr, *dp; cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_wsrv\n"); + return 0; + } + while ((mp = getq(q)) != 0) { /* assert(mp->b_datap->db_type == M_DATA) */ - if (!canputnext(q)) { +#ifdef PRIOQ + if (!bcanputnext(q,mp->b_band)) +#else + if (!canputnext(q)) +#endif PRIOQ + { putbq(q, mp); - return; + break; } /* @@ -396,9 +639,9 @@ ppp_comp_wsrv(q) * Make sure we've got enough data in the first mblk * and that we are its only user. */ - if (proto = PPP_CCP) + if (proto == PPP_CCP) hlen = len; - else if (proto = PPP_IP) + else if (proto == PPP_IP) hlen = PPP_HDRLEN + MAX_IPHDR; else hlen = PPP_HDRLEN; @@ -413,7 +656,6 @@ ppp_comp_wsrv(q) continue; } } - proto = PPP_PROTOCOL(mp->b_rptr); /* * Do VJ compression if requested. @@ -448,8 +690,11 @@ ppp_comp_wsrv(q) && cp->xstate != NULL) { len = msgdsize(mp); (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len, - (cp->flags & CCP_ISUP? cp->mtu: 0)); + (cp->flags & CCP_ISUP? cp->mtu + PPP_HDRLEN: 0)); if (cmp != NULL) { +#ifdef PRIOQ + cmp->b_band=mp->b_band; +#endif PRIOQ freemsg(mp); mp = cmp; } @@ -474,6 +719,8 @@ ppp_comp_wsrv(q) cp->stats.ppp_obytes += msgdsize(mp); putnext(q, mp); } + + return 0; } static int @@ -486,6 +733,12 @@ ppp_comp_rput(q, mp) struct ppp_stats *psp; cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_rput\n"); + freemsg(mp); + return 0; + } + switch (mp->b_datap->db_type) { case M_DATA: @@ -524,6 +777,8 @@ ppp_comp_rput(q, mp) default: putnext(q, mp); } + + return 0; } static int @@ -538,11 +793,16 @@ ppp_comp_rsrv(q) u_int iphlen; cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_rsrv\n"); + return 0; + } + while ((mp = getq(q)) != 0) { /* assert(mp->b_datap->db_type == M_DATA) */ if (!canputnext(q)) { putbq(q, mp); - return; + break; } len = msgdsize(mp); @@ -688,14 +948,21 @@ ppp_comp_rsrv(q) * First reset compressor if an input error has occurred. */ if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) { + if (cp->flags & DBGLOG) + DPRINT1("ppp%d: resetting VJ\n", cp->unit); vj_uncompress_err(&cp->vj_comp); cp->vj_last_ierrors = cp->stats.ppp_ierrors; } vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len, &cp->vj_comp, &iphdr, &iphlen); - if (vjlen < 0) + if (vjlen < 0) { + if (cp->flags & DBGLOG) + DPRINT2("ppp%d: vj_uncomp_tcp failed, pkt len %d\n", + cp->unit, len); + ++cp->vj_last_ierrors; /* so we don't reset next time */ goto bad; + } /* drop ppp and vj headers off */ if (mp != np) { @@ -736,8 +1003,14 @@ ppp_comp_rsrv(q) /* * "Decompress" a VJ-uncompressed packet. */ - if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) + cp->vj_last_ierrors = cp->stats.ppp_ierrors; + if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) { + if (cp->flags & DBGLOG) + DPRINT2("ppp%d: vj_uncomp_uncomp failed, pkt len %d\n", + cp->unit, len); + ++cp->vj_last_ierrors; /* don't need to reset next time */ goto bad; + } mp->b_rptr[3] = PPP_IP; /* fix up the PPP protocol field */ } } @@ -751,6 +1024,8 @@ ppp_comp_rsrv(q) cp->stats.ppp_ierrors++; putctl1(q->q_next, M_CTL, PPPCTL_IERROR); } + + return 0; } /* @@ -793,13 +1068,13 @@ ppp_comp_ccp(q, mp, rcvd) if (cp->xstate != NULL && (*cp->xcomp->comp_init) (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN, - cp->unit, 0, 0)) + cp->unit, 0, ((cp->flags & DBGLOG) != 0))) cp->flags |= CCP_COMP_RUN; } else { if (cp->rstate != NULL && (*cp->rcomp->decomp_init) (cp->rstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN, - cp->unit, 0, cp->mru, 0)) + cp->unit, 0, cp->mru, ((cp->flags & DBGLOG) != 0))) cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN; } } @@ -821,7 +1096,7 @@ ppp_comp_ccp(q, mp, rcvd) } } -#if DEBUG +#if 0 dump_msg(mp) mblk_t *mp; {