Return to adsp_Close.c CVS log

Up to [Apple XNU] / XNU / bsd / netat

Annotation of XNU/bsd/netat/adsp_Close.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * The contents of this file constitute Original Code as defined in and
        !             7:  * are subject to the Apple Public Source License Version 1.1 (the
        !             8:  * "License").  You may not use this file except in compliance with the
        !             9:  * License.  Please obtain a copy of the License at
        !            10:  * http://www.apple.com/publicsource and read it before using this file.
        !            11:  * 
        !            12:  * This Original Code and all software distributed under the License are
        !            13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            17:  * License for the specific language governing rights and limitations
        !            18:  * under the License.
        !            19:  * 
        !            20:  * @APPLE_LICENSE_HEADER_END@
        !            21:  */
        !            22: /*
        !            23:  *     Copyright (c) 1990, 1995-1998 Apple Computer, Inc.
        !            24:  *     All Rights Reserved.
        !            25:  */
        !            26: 
        !            27: /* dspClose.c 
        !            28:  * From Mike Shoemaker v01.16 06/29/90 mbs
        !            29:  */
        !            30: /*
        !            31:  * Change log:
        !            32:  *   06/29/95 - Modified to handle flow control for writing (Tuyen Nguyen)
        !            33:  *    Modified for MP, 1996 by Tuyen Nguyen
        !            34:  *    Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
        !            35:  */
        !            36: 
        !            37: #include <sys/errno.h>
        !            38: #include <sys/types.h>
        !            39: #include <sys/param.h>
        !            40: #include <machine/spl.h>
        !            41: #include <sys/systm.h>
        !            42: #include <sys/kernel.h>
        !            43: #include <sys/proc.h>
        !            44: #include <sys/filedesc.h>
        !            45: #include <sys/fcntl.h>
        !            46: #include <sys/mbuf.h>
        !            47: #include <sys/socket.h>
        !            48: #include <sys/socketvar.h>
        !            49: #include <sys/time.h>
        !            50: 
        !            51: #include <netat/sysglue.h>
        !            52: #include <netat/appletalk.h>
        !            53: #include <netat/ddp.h>
        !            54: #include <netat/at_pcb.h>
        !            55: #include <netat/debug.h>
        !            56: #include <netat/adsp.h>
        !            57: #include <netat/adsp_internal.h>
        !            58: 
        !            59: extern atlock_t adspall_lock;
        !            60: 
        !            61: static void qRemove(CCBPtr, CCBPtr);
        !            62: 
        !            63: 
        !            64: /*
        !            65:  * CheckOkToClose
        !            66:  * 
        !            67:  * Check to see if it is OK to close this connection cleanly.
        !            68:  *
        !            69:  * INPUTS:
        !            70:  *             Stream pointer
        !            71:  * OUTPUTS:
        !            72:  *             True if no outstanding transactions and we can close cleanly
        !            73:  */
        !            74: int CheckOkToClose(sp)         /* (CCBPtr sp) */
        !            75:     CCBPtr sp;
        !            76: {
        !            77:     
        !            78:     if (sp->sData)             /* Outstanding data ? */
        !            79:        return 0;
        !            80: 
        !            81:     if (sp->sapb)              /* Outstanding send attention ? */
        !            82:        return 0;
        !            83: 
        !            84:     if (sp->frpb)              /* Outstanding forward reset ? */
        !            85:        return 0;
        !            86:                
        !            87:     if (sp->sendAttnAck)
        !            88:        return 0;
        !            89:                
        !            90:     if (sp->sendDataAck)
        !            91:        return 0;
        !            92:        
        !            93:     /*
        !            94:      * Must be OK to close
        !            95:      */
        !            96:     sp->sendCtl        |= B_CTL_CLOSE; /* So, need to send close advice */
        !            97:     sp->callSend = 1;
        !            98: 
        !            99:     return 1;                  /* It's OK to close */
        !           100: }
        !           101: 
        !           102: 
        !           103: /*
        !           104:  * CompleteQueue
        !           105:  * 
        !           106:  * Given the address of the head of a queue of DSP parameter blocks, zero 
        !           107:  * the queue, and complete each item on the queue with the given result 
        !           108:  * code.
        !           109:  *
        !           110:  * INPUTS:
        !           111:  *             qhead           Address of ptr to first queue element
        !           112:  *             code            The result code
        !           113:  * OUTPUTS:
        !           114:  *             none
        !           115:  */
        !           116: int  CompleteQueue(qhead, code)        /* (DSPPBPtr FPTR qhead, OSErr code) */
        !           117:     struct adspcmd **qhead;
        !           118:     int code;
        !           119: {
        !           120:     register struct adspcmd *p;
        !           121:     register struct adspcmd *n;
        !           122:     register gref_t *gref;
        !           123:     register int    total = 0;
        !           124:     CCBPtr sp = 0;
        !           125:     int s;
        !           126: 
        !           127:     n = *qhead;                        /* Get first item */
        !           128:     *qhead = 0;                        /* Zero out the queue */
        !           129:     if (n) {
        !           130:        gref = n->gref;
        !           131:        if (gref->info) {
        !           132:            sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
        !           133:            atalk_flush(sp->gref);
        !           134:            ATDISABLE(s, sp->lock);
        !           135:            }
        !           136:     }
        !           137: 
        !           138:     while (p = n) {            /* while items left */
        !           139:        n = (struct adspcmd *)(p->qLink); /* Save next guy */
        !           140:        p->ioResult = code;
        !           141:        if (sp) {
        !           142:            completepb(sp, p);  /* complete the copy of the request */
        !           143:            total++;
        !           144:        } else
        !           145:            gbuf_freem(p->mp);
        !           146:     }                          /* while */
        !           147:     if (sp)
        !           148:        ATENABLE(s, sp->lock);
        !           149:     return(total);
        !           150: }
        !           151: 
        !           152: /*
        !           153:  * RemoveCCB
        !           154:  * 
        !           155:  * Called from do close to free up the user's CCB.  So, we remove the 
        !           156:  * CCB from the list of CCB's.
        !           157:  *
        !           158:  * INPUTS:
        !           159:  *             sp      pointer to ccb
        !           160:  *             pb      a remove param block to complete when done
        !           161:  * OUTPUTS:
        !           162:  *             none
        !           163:  */
        !           164: 
        !           165: void RemoveCCB(sp, pb)         /* (CCBPtr sp, DSPPBPtr pb) */
        !           166:     CCBPtr sp;
        !           167:     struct adspcmd *pb;
        !           168: {
        !           169:        gref_t *gref;
        !           170:        
        !           171:        if (sp->gref == 0)
        !           172:                return;
        !           173:     /*
        !           174:      * Unlink CCB from list
        !           175:      */
        !           176:     qRemove(AT_ADSP_STREAMS, sp); /* remove sp from active streams queue */
        !           177: 
        !           178:     if (pb) {
        !           179:        pb->ioResult = 0;
        !           180:        if (pb->ioc)            /* is this a current or queued request */
        !           181:            adspioc_ack(0, pb->ioc, pb->gref);  /* current */
        !           182:        else {
        !           183:            completepb(sp, pb); /* queued */
        !           184:        }
        !           185:        
        !           186:        if (sp->opb && (pb != sp->opb)) { /* if the pb requested is not the */
        !           187:            pb = sp->opb;               /* waiting open pb, complete it too */
        !           188:            sp->opb = 0;
        !           189:            pb->ioResult = 0;
        !           190:            completepb(sp, pb);
        !           191:        } else {
        !           192:            sp->opb = 0;
        !           193:         }
        !           194:     }
        !           195:     gref = sp->gref;
        !           196:     sp->gref = 0;
        !           197:     if (gref->info == (char *)sp->sp_mp) { /* queue head is still valid */
        !           198:            unsigned char skt;
        !           199: 
        !           200:            if ((skt = sp->localSocket) != 0) {
        !           201:              if (adspDeassignSocket(sp) == 0)
        !           202:                  ddp_notify_nbp(skt, sp->pid, DDP_ADSP);
        !           203:            }
        !           204: 
        !           205:          if (gref->info) {
        !           206:            gbuf_freem((gbuf_t *)gref->info);   /* free the CCB */
        !           207:            gref->info = 0;
        !           208:          }
        !           209:     } else
        !           210:        gbuf_freem(sp->sp_mp);  /* our head is already gone, be sure
        !           211:                                 * to release our resources too */
        !           212: }
        !           213: 
        !           214: int  AbortIO(sp, err)
        !           215:     CCBPtr sp;
        !           216:     short err;
        !           217: {
        !           218:     register int    total;
        !           219: 
        !           220:        if (sp->gref == 0)
        !           221:                return 0;
        !           222:     /*
        !           223:      * Complete all outstanding transactions.  
        !           224:      */
        !           225:     total += CompleteQueue(&sp->sapb, err); /* Abort outstanding send attentions */
        !           226:     CompleteQueue(&sp->frpb, err); /* Abort outstanding forward resets */
        !           227: 
        !           228:     if (sp->sbuf_mb) { /* clear the send queue */
        !           229:        gbuf_freel(sp->sbuf_mb);
        !           230:        sp->sbuf_mb = 0;
        !           231:     }
        !           232: 
        !           233:     if (sp->csbuf_mb) {
        !           234:        gbuf_freem(sp->csbuf_mb);
        !           235:        sp->csbuf_mb = 0;
        !           236:     }
        !           237:     sp->sData = 0;
        !           238:     
        !           239:     return(total);
        !           240: }
        !           241: 
        !           242: /*
        !           243:  * DoClose
        !           244:  * 
        !           245:  * Called from several places (probe timeout, recv close advice, 
        !           246:  * dspRemove, etc.) to change state of connection to closed and 
        !           247:  * complete all outstanding I/O.
        !           248:  *
        !           249:  * Will also remove the CCB if there is a dsp remove pending.
        !           250:  *
        !           251:  * INPUTS:
        !           252:  *             sp              An ADSP stream
        !           253:  * OUTPUTS:
        !           254:  *             none
        !           255:  */
        !           256: void DoClose(sp, err, force_abort)     /* (CCBPtr sp, OSErr err) */
        !           257:     register CCBPtr sp;
        !           258:     int err;
        !           259: {
        !           260:     register struct adspcmd *pb, *np;
        !           261:     register gbuf_t *mp;
        !           262:     int      aborted_count;
        !           263:        
        !           264:     dPrintf(D_M_ADSP, D_L_TRACE, ("DoClose: pid=%d,e=%d,a=%d,s=%d,r=%d\n",
        !           265:                sp->pid, err, force_abort, sp->localSocket, sp->removing));
        !           266:     sp->userFlags |= eClosed; /* Set flag */
        !           267:     sp->state = sClosed;
        !           268:     sp->openState = O_STATE_NOTHING;
        !           269: 
        !           270:     /*
        !           271:      * Clean up any timer elements
        !           272:      */
        !           273:     RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer);
        !           274:     RemoveTimerElem(&adspGlobal.fastTimers, &sp->FlushTimer);
        !           275:     RemoveTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer);
        !           276:     RemoveTimerElem(&adspGlobal.fastTimers, &sp->AttnTimer);
        !           277:     RemoveTimerElem(&adspGlobal.fastTimers, &sp->ResetTimer);
        !           278: 
        !           279:     aborted_count = AbortIO(sp, err);
        !           280:     np = sp->opb;              /* Get list of close/removes to complete */
        !           281:     sp->opb = 0;               /* set this list null */
        !           282:        
        !           283:     while (pb = np) {          /* Handle all of the close/remove param blks */
        !           284:        np = (struct adspcmd *)pb->qLink; /* Get next guy (if any) */
        !           285:        pb->qLink = 0;
        !           286:        pb->ioResult = err;
        !           287:        completepb(sp, pb);
        !           288:     }
        !           289:     if (sp->removing && (force_abort >= 0)) {        /* Abort outstanding receives */
        !           290:        aborted_count += CompleteQueue(&sp->rpb, err);
        !           291: 
        !           292:        if (sp->deferred_mb) {
        !           293:                gbuf_freel(sp->deferred_mb);
        !           294:                sp->deferred_mb = 0;
        !           295:        }
        !           296:        if (sp->attn_mb) {
        !           297:                gbuf_freem(sp->attn_mb);
        !           298:                sp->attn_mb = 0;
        !           299:        }
        !           300:        if (sp->rbuf_mb) { /* clear the rcv queue */
        !           301:                gbuf_freem(sp->rbuf_mb);
        !           302:                sp->rbuf_mb = 0;
        !           303:        }
        !           304:        if (sp->crbuf_mb) {
        !           305:                gbuf_freem(sp->crbuf_mb);
        !           306:                sp->crbuf_mb = 0;
        !           307:        }
        !           308:        sp->rData = 0;
        !           309: 
        !           310:        /* if our connection has been timed out */
        !           311:        /* and the user wasn't notified of the TearDown */
        !           312:        /* because of pending requests on this socket */
        !           313:        /* then fake a read completion to force the notification */
        !           314: 
        !           315:        if (force_abort && aborted_count == 0) {
        !           316:            if (mp = gbuf_alloc(sizeof(struct adspcmd), PRI_HI)) {
        !           317:                pb = (struct adspcmd *)gbuf_rptr(mp);
        !           318:                gbuf_wset(mp,sizeof(struct adspcmd));
        !           319: 
        !           320:                bzero((caddr_t) pb, sizeof(struct adspcmd));
        !           321:                pb->mp = mp;
        !           322:                pb->csCode = dspRead;
        !           323:                pb->ioResult = errAborted;
        !           324:                completepb(sp, pb);             /* send fake read completion */
        !           325:            }
        !           326:        }
        !           327:        sp->removing = 0;
        !           328:        RemoveCCB(sp, 0); /* Will call completion routine */
        !           329:     }
        !           330:     sp->userFlags &= ~eClosed;
        !           331: }
        !           332: 
        !           333: 
        !           334: /*
        !           335:  * dspClose
        !           336:  * 
        !           337:  * Also called for dspRemove and dspCLRemove.
        !           338:  * Must handle case of multiple close calls being issued (without 
        !           339:  * abort bit set) Can only allow one pending remove though.
        !           340:  *
        !           341:  * INPUTS:
        !           342:  *     -->     ccbRefNum               refnum of connection end
        !           343:  *     -->     abort                   abort the connection
        !           344:  *
        !           345:  * OUTPUTS:
        !           346:  *     none
        !           347:  *
        !           348:  * ERRORS:
        !           349:  *             errRefNum               Bad connection Refnum
        !           350:  */
        !           351: int adspClose(sp, pb)          /* (DSPPBPtr pb) */
        !           352:     register CCBPtr sp;
        !           353:     register struct adspcmd *pb;
        !           354: {
        !           355:     int        s;
        !           356:     register gbuf_t *mp;
        !           357:        
        !           358:     /* Must execute nearly all of this with ints off because user could 
        !           359:      * be issuing a second dspRemove while the first is pending.  Until 
        !           360:      * we can detect this, we must not allow interrupts.
        !           361:      * Also, we can't handle the case where a close was issued earlier, 
        !           362:      * and now this is the remove.  If the write completion for the 
        !           363:      * close advice packet occurs in the middle of this, we might
        !           364:      * foul up.
        !           365:      */
        !           366: 
        !           367:     if (sp == 0) {
        !           368:        pb->ioResult = errRefNum;
        !           369:        return EINVAL;
        !           370:     }
        !           371: 
        !           372:     /*
        !           373:      * Handle dspCLRemove
        !           374:      */
        !           375:     if (pb->csCode == (short)dspCLRemove) { /* Remove connection listener */
        !           376:        if (sp->state != (short)sListening) { /* But it's not a listener! */
        !           377:            pb->ioResult = errState;
        !           378:            return EINVAL;
        !           379:        }
        !           380:        CompleteQueue(&sp->opb, errAborted); /* Complete all dspListens */
        !           381:        RemoveCCB(sp, pb);      /* Will call completion routine */
        !           382:        return 0;
        !           383:     }
        !           384: 
        !           385: 
        !           386:     /*
        !           387:      * Either dspClose or dspRemove
        !           388:      */
        !           389: 
        !           390:     if (sp->removing) {                /* Don't allow dspRemove or dspClose */
        !           391:                                /* after one dspRemove has been issued. */
        !           392:        pb->ioResult = errState;
        !           393:        return EINVAL;
        !           394:     }
        !           395: 
        !           396: 
        !           397:     /*
        !           398:      * The previous Macintosh ADSP allowed you to call close on a 
        !           399:      * connection that was in the process of opening or passively 
        !           400:      * waiting for an open request. It is also legal to close a 
        !           401:      * connection that is already closed.  No error will be generated.
        !           402:      *
        !           403:      * It is also legal to issue a second close call while the first 
        !           404:      * is still pending.
        !           405:      */
        !           406:     if (pb->csCode == (short)dspClose) {
        !           407:        ATDISABLE(s, sp->lock);
        !           408:        if ((sp->state == (short)sPassive) || (sp->state == (short)sOpening)) {
        !           409:            sp->state = sClosed;
        !           410:            ATENABLE(s, sp->lock);
        !           411:            DoClose(sp, errAborted, 0);
        !           412:            pb->ioResult = 0;
        !           413:            adspioc_ack(0, pb->ioc, pb->gref);
        !           414:            return 0;
        !           415:        }
        !           416:                
        !           417:        if (sp->state == (word)sClosed) { /* Ok to close a closed connection */
        !           418:            ATENABLE(s, sp->lock);
        !           419:            pb->ioResult = 0;
        !           420:            adspioc_ack(0, pb->ioc, pb->gref);
        !           421:            return 0;
        !           422:        }
        !           423:        if ((sp->state != (word)sOpen) && (sp->state != (word)sClosing)) {
        !           424:            ATENABLE(s, sp->lock);
        !           425:            pb->ioResult = errState;
        !           426:            return EINVAL;
        !           427:        }
        !           428:                
        !           429:        sp->state = sClosing;   /* No matter what, we're closing */
        !           430:        ATENABLE(s, sp->lock);
        !           431:     }                          /* dspClose */
        !           432:     
        !           433:     else {                     /* dspRemove */
        !           434:        ATDISABLE(s, sp->lock);
        !           435:        sp->removing = 1;       /* Prevent allowing another dspClose. */
        !           436:                                /* Tells completion routine of close */
        !           437:                                /* packet to remove us. */
        !           438: 
        !           439:        if (sp->state == sPassive || sp->state == sClosed || 
        !           440:            sp->state == sOpening) {
        !           441:            sp->state = sClosed;
        !           442:            ATENABLE(s, sp->lock);
        !           443:            DoClose(sp, errAborted, 0); /* Will remove CCB! */
        !           444:            return 0;
        !           445:        } else {                        /* sClosing & sOpen */
        !           446:            sp->state = sClosing;
        !           447:            ATENABLE(s, sp->lock);
        !           448:        }
        !           449:        
        !           450:     }                          /* dspRemove */
        !           451: 
        !           452:     if (pb->u.closeParams.abort || CheckOkToClose(sp)) /* going to close */
        !           453:     {
        !           454:        AbortIO(sp, errAborted);
        !           455:        sp->sendCtl = B_CTL_CLOSE; /* Send close advice */
        !           456:     }
        !           457: 
        !           458:     pb->ioResult = 1;
        !           459:     if ( (mp = gbuf_copym(pb->mp)) ) { /* duplicate user request */
        !           460:            adspioc_ack(0, pb->ioc, pb->gref); /* release user */
        !           461:            pb = (struct adspcmd *)gbuf_rptr(mp); /* get new parameter block */
        !           462:            pb->ioc = 0;
        !           463:            pb->mp = mp;
        !           464:            ATDISABLE(s, sp->lock);
        !           465:            qAddToEnd(&sp->opb, pb);    /* and save it */
        !           466:            ATENABLE(s, sp->lock);
        !           467:     } else {
        !           468:            pb->ioResult = 0;
        !           469:            adspioc_ack(0, pb->ioc, pb->gref); /* release user, and keep no copy
        !           470:                                             * for kernel bookkeeping, yetch!
        !           471:                                             */
        !           472:     }
        !           473:     CheckSend(sp);
        !           474: 
        !           475:     return 0;
        !           476: }
        !           477: 
        !           478: static void qRemove(qptr, elem)
        !           479:     register CCBPtr qptr;
        !           480:     register CCBPtr elem;
        !           481: {
        !           482:        int s;
        !           483: 
        !           484:        ATDISABLE(s, adspall_lock);
        !           485:     while(qptr->ccbLink) {
        !           486:        if ((DSPPBPtr)(qptr->ccbLink) == (DSPPBPtr)elem) {
        !           487:            qptr->ccbLink = elem->ccbLink;
        !           488:            elem->ccbLink = 0;
        !           489:            ATENABLE(s, adspall_lock);
        !           490:            return;
        !           491:        }
        !           492:        qptr = qptr->ccbLink;
        !           493:     }
        !           494:        ATENABLE(s, adspall_lock);
        !           495: }
        !           496: 
        !           497: int RxClose(sp)
        !           498:     register CCBPtr sp;
        !           499: {
        !           500:     register gbuf_t *mp;
        !           501:     register struct adspcmd *pb;
        !           502:        int s, l;
        !           503: 
        !           504:        ATDISABLE(l, sp->lockClose);
        !           505:        ATDISABLE(s, sp->lock);
        !           506:        if ((sp->state == sClosing) || (sp->state == sClosed)) {
        !           507:                ATENABLE(s, sp->lock);
        !           508:                ATENABLE(l, sp->lockClose);
        !           509:                return 0;
        !           510:        }
        !           511:     sp->state = sClosed;
        !           512:        ATENABLE(s, sp->lock);
        !           513:     CheckReadQueue(sp);                /* try to deliver all remaining data */
        !           514: 
        !           515:     if ( (mp = gbuf_alloc(sizeof(struct adspcmd), PRI_HI)) ) {
        !           516:         pb = (struct adspcmd *)gbuf_rptr(mp);
        !           517:        gbuf_wset(mp,sizeof(struct adspcmd));
        !           518:        pb->ioc = 0;
        !           519:        pb->mp = mp;
        !           520: 
        !           521:        pb->csCode = dspClose;
        !           522:        pb->ioResult = 0;
        !           523:        completepb(sp, pb);             /* send close completion */
        !           524:     }
        !           525: 
        !           526: if ((sp->userFlags & eClosed) == 0)
        !           527:     DoClose(sp, errAborted, -1);       /* abort send requests and timers */
        !           528: 
        !           529:        ATENABLE(l, sp->lockClose);
        !           530:     return 0;
        !           531: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.