X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=modules%2Fppp_comp.c;h=96713709b97570ebf04b7bc6a1da3da3ff94bee0;hp=03140f8b3aa2a09cf95eab5903a8624881e8a224;hb=d0d16c4ba18e31f76e891201e5e106887f87bbf0;hpb=cac90e238d9c18c513cf0d45dfdd1e217df2a176 diff --git a/modules/ppp_comp.c b/modules/ppp_comp.c index 03140f8..9671370 100644 --- a/modules/ppp_comp.c +++ b/modules/ppp_comp.c @@ -24,7 +24,7 @@ * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, * OR MODIFICATIONS. * - * $Id: ppp_comp.c,v 1.7 1997/03/04 03:31:51 paulus Exp $ + * $Id: ppp_comp.c,v 1.11 1999/04/12 06:20:22 paulus Exp $ */ /* @@ -42,6 +42,9 @@ #include #else #include +#ifdef __osf__ +#include +#endif #endif /* SVR4 */ #include @@ -109,11 +112,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 @@ -160,7 +162,7 @@ extern task_t first_task; extern struct compressor ppp_bsd_compress; #endif #if DO_DEFLATE -extern struct compressor ppp_deflate; +extern struct compressor ppp_deflate, ppp_deflate_draft; #endif struct compressor *ppp_compressors[] = { @@ -169,6 +171,7 @@ struct compressor *ppp_compressors[] = { #endif #if DO_DEFLATE &ppp_deflate, + &ppp_deflate_draft, #endif NULL }; @@ -187,20 +190,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; } @@ -220,7 +223,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; @@ -241,12 +244,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. @@ -258,30 +262,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; } } @@ -323,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: @@ -338,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); @@ -364,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) @@ -378,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) @@ -388,8 +409,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. @@ -398,106 +419,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); + 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; } - - /* 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; - } -#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); + 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; } - if ((error = cp->memreq.ret) != EAGAIN) { - cp->rstate = cp->memreq.mem; - cp->memreq.mem = 0; - cp->memreq.ret = 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; @@ -547,6 +534,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); @@ -599,6 +590,8 @@ ppp_comp_wput(q, mp) default: putnext(q, mp); } + + return 0; } static int @@ -612,15 +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) */ #ifdef PRIOQ - if (!bcanputnext(q,mp->b_band)) { + if (!bcanputnext(q,mp->b_band)) #else - if (!canputnext(q)) { + if (!canputnext(q)) #endif PRIOQ + { putbq(q, mp); - return; + break; } /* @@ -691,7 +690,7 @@ 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; @@ -720,6 +719,8 @@ ppp_comp_wsrv(q) cp->stats.ppp_obytes += msgdsize(mp); putnext(q, mp); } + + return 0; } static int @@ -732,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: @@ -770,6 +777,8 @@ ppp_comp_rput(q, mp) default: putnext(q, mp); } + + return 0; } static int @@ -784,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); @@ -1010,6 +1024,8 @@ ppp_comp_rsrv(q) cp->stats.ppp_ierrors++; putctl1(q->q_next, M_CTL, PPPCTL_IERROR); } + + return 0; } /*