X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=modules%2Fppp_comp.c;h=97d13ebd3bf608b624718e60ed23566f191588e3;hp=4c261e7931146e6561447bb3efce867ff9ee502f;hb=d00f8a0e184cc73b1ca33a9b22c1b1f87292a72f;hpb=bff5da40466cebce6ae413e3ee3d38003e689fb8 diff --git a/modules/ppp_comp.c b/modules/ppp_comp.c index 4c261e7..97d13eb 100644 --- a/modules/ppp_comp.c +++ b/modules/ppp_comp.c @@ -1,30 +1,38 @@ /* * ppp_comp.c - STREAMS module for kernel-level compression and CCP support. * - * Copyright (c) 1994 The Australian National University. - * All rights reserved. + * Copyright (c) 1994 Paul Mackerras. All rights reserved. * - * Permission to use, copy, modify, and distribute this software and its - * documentation is hereby granted, provided that the above copyright - * notice appears in all copies. This software is provided without any - * warranty, express or implied. The Australian National University - * makes no representations about the suitability of this software for - * any purpose. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: * - * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY - * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES - * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF - * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY - * OF SUCH DAMAGE. + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. * - * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS - * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO - * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, - * OR MODIFICATIONS. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. * - * $Id: ppp_comp.c,v 1.5 1996/08/28 06:36:30 paulus Exp $ + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ppp_comp.c,v 1.14 2002/12/06 09:49:15 paulus Exp $ */ /* @@ -42,6 +50,9 @@ #include #else #include +#ifdef __osf__ +#include +#endif #endif /* SVR4 */ #include @@ -79,7 +90,11 @@ static int msg_byte __P((mblk_t *, unsigned int)); #define PPP_COMP_ID 0xbadf static struct module_info minfo = { +#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 = { @@ -91,6 +106,10 @@ 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 }; @@ -101,11 +120,10 @@ int ppp_comp_count; /* number of module instances in use */ static void ppp_comp_alloc __P((comp_state_t *)); typedef struct memreq { - unsigned char *comp; - void *mem; - int len; + unsigned char comp_opts[20]; int cmd; - int ret; + int thread_status; + char *returned_mem; } memreq_t; #endif @@ -148,8 +166,12 @@ extern task_t first_task; * 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 @@ -157,6 +179,7 @@ struct compressor *ppp_compressors[] = { #endif #if DO_DEFLATE &ppp_deflate, + &ppp_deflate_draft, #endif NULL }; @@ -175,20 +198,20 @@ MOD_OPEN(ppp_comp_open) 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); - ++ppp_comp_count; - qprocson(q); #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); } return 0; } @@ -208,7 +231,7 @@ MOD_CLOSE(ppp_comp_close) if (!cp->thread) printf("ppp_comp_close: NULL thread!\n"); else - thread_deallocate(cp->thread); + thread_terminate(cp->thread); #endif FREE(cp, sizeof(comp_state_t)); q->q_ptr = NULL; @@ -229,12 +252,13 @@ MOD_CLOSE(ppp_comp_close) static void ppp_comp_alloc(comp_state_t *cp) { - unsigned char *opt_data; int len, cmd; - struct compressor *comp; + unsigned char *compressor_options; thread_t thread; + void *(*comp_allocator)(); + -#if (MAJOR_VERSION <= 2) +#if defined(MAJOR_VERSION) && (MAJOR_VERSION <= 2) /* In 2.x and earlier the argument gets passed * in the thread structure itself. Yuck. @@ -246,30 +270,29 @@ ppp_comp_alloc(comp_state_t *cp) #endif for (;;) { - assert_wait((vm_offset_t)&cp->memreq.comp, TRUE); + assert_wait((vm_offset_t)&cp->memreq.thread_status, TRUE); thread_block(); - opt_data = cp->memreq.comp; - len = cp->memreq.len; - cmd = cp->memreq.cmd; - if (cmd == PPPIO_XCOMP) { - comp = cp->xcomp; - cp->memreq.mem = (*comp->comp_alloc)(opt_data, len); + 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 { - comp = cp->rcomp; - cp->memreq.mem = (*comp->decomp_alloc)(opt_data, len); + 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; + } } - if (!cp->memreq.mem) - cp->memreq.ret = ENOSR; - else - bcopy(opt_data, cp->memreq.mem, len); - - /* have to free thunk here, since there's - * no guarantee that the user will call the ioctl - * again if we've taken a long time to complete - */ - FREE(opt_data, len); - cp->memreq.ret = 0; } } @@ -311,6 +334,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: @@ -326,6 +355,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); @@ -352,6 +385,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) @@ -366,6 +403,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) @@ -376,8 +417,8 @@ 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) { - /* 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. @@ -386,106 +427,72 @@ ppp_comp_wput(q, mp) (*cp->xcomp->comp_free)(cp->xstate); cp->xstate = NULL; } - -#ifdef __osf__ - /* Account for an orpahned call to get memory. - * Free that memory up and go on. - * - * The trick is that we need to be able to tell - * the difference between an old call that kicked - * off a thread where the memory was subsequently - * orphaned, and the memory we're really interested - * in. The thread helps by stamping the memory it - * allocated with the parameters for the compressor - * it belongs to. If the parameters match then this - * is the memory we want (whether it was an actual - * orphan or not we don't care.) If the parameters - * don't match then this is an orphan. - * - * Note that cp->memreq.ret is the synchronization - * point: we set it to EAGAIN in this function, then - * wait for the thread to set it to something other - * than EAGAIN before we fool with the data structure - * again. Basically, if ret != EAGAIN then the thread - * is working and it owns the memreq struture. + cp->xcomp = *comp; + cp->xstate = (*comp)->comp_alloc(opt_data, len); + if (cp->xstate == NULL) + error = ENOSR; + } else { + 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 (cp->memreq.ret == 0 && cp->memreq.mem != NULL && - bcmp(cp->memreq.mem, opt_data, len)) { - (*cp->xcomp->comp_free)(cp->memreq.mem); - cp->memreq.mem = 0; + 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; } - - /* First time through, prime the pump and kick - * off the thread. Subsequent times though, the thread - * is either busy (ret == EAGAIN) or finsihed (mem != NULL) - * || (ret != 0) + /* fill in request for the thread and kick it off */ - if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) { - cp->memreq.comp = ALLOC_NOSLEEP(len); - if (!cp->memreq.comp) { - printf("gack! can't get memory for thunk\n"); - return ENOSR; - } - bcopy(opt_data, cp->memreq.comp, len); - cp->memreq.len = len; + 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; - cp->memreq.ret = EAGAIN; - thread_wakeup((vm_offset_t)&cp->memreq.comp); - } - - /* Collect results from the thread, and reset the - * mechanism for the next attempt to allocate memory - * If the thread isn't finished (ret == EAGAIN) then - * don't reset and just return. - */ - if ((error = cp->memreq.ret) != EAGAIN) { - cp->xstate = cp->memreq.mem; - cp->memreq.mem = 0; - cp->memreq.ret = 0; + 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 - cp->xcomp = *comp; - cp->xstate = (*comp)->comp_alloc(opt_data, len); - if (cp->xstate == NULL) - error = ENOSR; -#endif } else { - if (cp->rstate != NULL) { + if (cp->rstate) { (*cp->rcomp->decomp_free)(cp->rstate); cp->rstate = NULL; } -#ifdef __osf__ - if (cp->memreq.ret == 0 && cp->memreq.mem != NULL && - bcmp(cp->memreq.mem, opt_data, len)) { - (*cp->rcomp->comp_free)(cp->memreq.mem); - cp->memreq.mem = 0; + 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.ret == 0 && cp->memreq.mem == NULL) { - cp->memreq.comp = ALLOC_NOSLEEP(len); - if (!cp->memreq.comp) { - printf("gack! can't get memory for thunk\n"); - return ENOSR; - } - bcopy(opt_data, cp->memreq.comp, len); - cp->memreq.len = len; + 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; - cp->memreq.ret = EAGAIN; - thread_wakeup((vm_offset_t)&cp->memreq.comp); - } - if ((error = cp->memreq.ret) != EAGAIN) { - cp->rstate = cp->memreq.mem; - cp->memreq.mem = 0; - cp->memreq.ret = 0; + 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; } -#else - cp->rcomp = *comp; - cp->rstate = (*comp)->decomp_alloc(opt_data, len); - if (cp->rstate == NULL) - error = ENOSR; -#endif } +#endif break; } iop->ioc_count = 0; @@ -535,6 +542,10 @@ ppp_comp_wput(q, mp) 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); @@ -587,24 +598,36 @@ ppp_comp_wput(q, mp) default: putnext(q, mp); } + + return 0; } static int ppp_comp_wsrv(q) queue_t *q; { - mblk_t *mp, *cmp = NULL, *np; + mblk_t *mp, *cmp = NULL; comp_state_t *cp; int len, proto, type, hlen, code; struct ip *ip; 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; } /* @@ -675,8 +698,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; } @@ -701,6 +727,8 @@ ppp_comp_wsrv(q) cp->stats.ppp_obytes += msgdsize(mp); putnext(q, mp); } + + return 0; } static int @@ -713,6 +741,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: @@ -751,6 +785,8 @@ ppp_comp_rput(q, mp) default: putnext(q, mp); } + + return 0; } static int @@ -765,11 +801,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); @@ -991,6 +1032,8 @@ ppp_comp_rsrv(q) cp->stats.ppp_ierrors++; putctl1(q->q_next, M_CTL, PPPCTL_IERROR); } + + return 0; } /*