![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp_Read.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat|
Return to adsp_Read.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: ! 26: #include <adsp_local.h> ! 27: ! 28: /* ! 29: * CheckReadQueue ! 30: * ! 31: * Checks to see if there is any data in the receive queue. If there ! 32: * is data, a pb and the data are queued to the user. ! 33: * ! 34: * ! 35: */ ! 36: extern int adsp_check; ! 37: ! 38: int CheckReadQueue(sp) /* (CCBPtr sp) */ ! 39: register CCBPtr sp; ! 40: { ! 41: register struct adspcmd *pb; ! 42: int s; ! 43: unsigned short cnt; ! 44: char eom; ! 45: register gbuf_t *mp; ! 46: register gbuf_t *tmp; ! 47: gref_t *gref; ! 48: ! 49: ATDISABLE(s, sp->lock); ! 50: while (sp->rData && (pb = sp->rpb)) { /* have data */ ! 51: if (pb->u.ioParams.reqCount == 0) { ! 52: pb->ioResult = 0; ! 53: sp->rpb = pb->qLink; ! 54: if (pb->ioc) { ! 55: adspioc_ack(0, pb->ioc, pb->gref); ! 56: } else { ! 57: completepb(sp, pb); ! 58: } ! 59: continue; ! 60: } ! 61: ! 62: if (mp = sp->rbuf_mb) { /* Get header for oldest data */ ! 63: sp->rbuf_mb = gbuf_next(mp); ! 64: gbuf_next(mp) = 0; ! 65: eom = 1; ! 66: } else if (mp = sp->crbuf_mb) { ! 67: sp->crbuf_mb = 0; ! 68: eom = 0; ! 69: } ! 70: cnt = gbuf_msgsize(mp); /* # of data bytes in it. */ ! 71: if (cnt > (unsigned short) (pb->u.ioParams.reqCount - pb->u.ioParams.actCount)) { ! 72: cnt = pb->u.ioParams.reqCount - pb->u.ioParams.actCount; ! 73: pb->u.ioParams.actCount += cnt; ! 74: while (cnt >= (unsigned short) gbuf_len(mp)) { ! 75: cnt -= gbuf_len(mp); ! 76: tmp = mp; ! 77: mp = gbuf_cont(mp); ! 78: gbuf_cont(tmp) = 0; ! 79: gbuf_linkb(pb->mp,tmp); ! 80: } ! 81: if (cnt) { ! 82: tmp = gbuf_dupb(mp); ! 83: if (tmp == NULL) { ! 84: pb->u.ioParams.actCount -= cnt; /* can't deliver it now */ ! 85: } else { ! 86: gbuf_wset(tmp,cnt); ! 87: gbuf_rinc(mp,cnt); ! 88: gbuf_linkb(pb->mp,tmp); ! 89: } ! 90: } ! 91: if (eom) { ! 92: gbuf_next(mp) = sp->rbuf_mb; ! 93: sp->rbuf_mb = mp; ! 94: eom = 0; ! 95: } else ! 96: sp->crbuf_mb = mp; ! 97: } else { ! 98: pb->u.ioParams.actCount += cnt; ! 99: gbuf_linkb(pb->mp,mp); ! 100: } ! 101: pb->u.ioParams.eom = eom; ! 102: ! 103: /* ! 104: * Now clean up receive buffer to remove all of the data ! 105: * we just copied ! 106: */ ! 107: if ((sp->rbuf_mb == 0) && ! 108: (sp->crbuf_mb == 0)) /* no more data blocks */ ! 109: sp->rData = 0; ! 110: ! 111: /* ! 112: * If we've filled the parameter block, unlink it from read ! 113: * queue and complete it. We also need to do this if the connection ! 114: * is closed && there is no more stuff to read. ! 115: */ ! 116: if (eom || (pb->u.ioParams.actCount >= pb->u.ioParams.reqCount) || ! 117: ((sp->state == sClosed) && (!sp->rData))) { ! 118: /* end of message, message is full, connection ! 119: * is closed and all data has been delivered, ! 120: * or we are not to "delay" data delivery. ! 121: */ ! 122: pb->ioResult = 0; ! 123: sp->rpb = pb->qLink; /* dequeue request */ ! 124: if (pb->ioc) { /* data to be delivered at the time of the */ ! 125: mp = gbuf_cont(pb->mp); /* ioctl call */ ! 126: gbuf_cont(pb->mp) = 0; ! 127: gref = (gref_t *)pb->gref; ! 128: adspioc_ack(0, pb->ioc, pb->gref); ! 129: SndMsgUp(gref, mp); ! 130: } else /* complete an queued async request */ ! 131: completepb(sp, pb); ! 132: } ! 133: } /* while */ ! 134: ! 135: if (pb = sp->rpb) { /* if there is an outstanding request */ ! 136: if (sp->state == sClosed) { ! 137: while (pb) { ! 138: pb->ioResult = 0; ! 139: pb->u.ioParams.actCount = 0; ! 140: pb->u.ioParams.eom = 0; ! 141: sp->rpb = pb->qLink; ! 142: if (pb->ioc) { ! 143: adspioc_ack(0, pb->ioc, pb->gref); ! 144: } else { ! 145: completepb(sp, pb); ! 146: } ! 147: pb = sp->rpb; ! 148: } ! 149: } else if (pb->ioc) { /* if request not complete and this ! 150: * is an active ioctl, release user */ ! 151: sp->rpb = pb->qLink; ! 152: pb->ioResult = 1; ! 153: tmp = gbuf_cont(pb->mp); /* detatch perhaps delayed data */ ! 154: gbuf_cont(pb->mp) = 0; ! 155: if (mp = gbuf_copym(pb->mp)) { /* otherwise, duplicate user request */ ! 156: adspioc_ack(0, pb->ioc, pb->gref); /* release user */ ! 157: pb = (struct adspcmd *)gbuf_rptr(mp); /* get new parameter block */ ! 158: pb->ioc = 0; ! 159: pb->mp = mp; ! 160: gbuf_cont(pb->mp) = tmp; /* reattach data */ ! 161: pb->qLink = sp->rpb; /* requeue the duplicate at the head */ ! 162: sp->rpb = pb; ! 163: } else { /* there is no data left, but no space ! 164: * to duplicate the parameter block, so ! 165: * put what must be a non EOM message ! 166: * back on the current receive queue, and ! 167: * error out the user ! 168: */ ! 169: if (tmp) { ! 170: sp->crbuf_mb = tmp; ! 171: sp->rData = 1; ! 172: } ! 173: pb->ioResult = errDSPQueueSize; ! 174: adspioc_ack(ENOBUFS, pb->ioc, pb->gref); ! 175: } ! 176: } ! 177: } ! 178: /* ! 179: * The receive window has opened. If was previously closed, then we ! 180: * need to notify the other guy that we now have room to receive more ! 181: * data. But, in order to cut down on lots of small data packets, ! 182: * we'll wait until the recieve buffer is /14 empy before telling ! 183: * him that there's room in our receive buffer. ! 184: */ ! 185: if (sp->rbufFull && (CalcRecvWdw(sp) > (sp->rbuflen >> 2))) { ! 186: sp->rbufFull = 0; ! 187: sp->sendDataAck = 1; ! 188: sp->callSend = 1; ! 189: } ! 190: ! 191: ATENABLE(s, sp->lock); ! 192: return 0; ! 193: } ! 194: ! 195: /* ! 196: * CheckAttn ! 197: * ! 198: * Checks to see if there is any attention data and passes the data back ! 199: * in the passed in pb. ! 200: * ! 201: * INPUTS: ! 202: * sp ! 203: * pb ! 204: * ! 205: * OUTPUTS: ! 206: * ! 207: */ ! 208: int CheckAttn(sp, pb) /* (CCBPtr sp) */ ! 209: register CCBPtr sp; ! 210: register struct adspcmd *pb; ! 211: { ! 212: int s; ! 213: gbuf_t *mp; ! 214: gref_t *gref; ! 215: ! 216: ATDISABLE(s, sp->lock); ! 217: if (mp = sp->attn_mb) { ! 218: ! 219: /* ! 220: * Deliver the attention data to the user. ! 221: */ ! 222: gref = (gref_t *)pb->gref; ! 223: pb->u.attnParams.attnSize = sp->attnSize; ! 224: pb->u.attnParams.attnCode = sp->attnCode; ! 225: if (!sp->attnSize) { ! 226: gbuf_freem(mp); ! 227: mp = 0; ! 228: } ! 229: sp->userFlags &= ~eAttention; ! 230: /* ! 231: * Now clean up receive buffer to remove all of the data ! 232: * we just copied ! 233: */ ! 234: sp->attn_mb = 0; ! 235: pb->ioResult = 0; ! 236: } else { ! 237: /* ! 238: * No data... ! 239: */ ! 240: pb->u.attnParams.attnSize = 0; ! 241: pb->u.attnParams.attnCode = 0; ! 242: pb->ioResult = 1; /* not done */ ! 243: } ! 244: adspioc_ack(0, pb->ioc, pb->gref); ! 245: if (mp) { ! 246: SndMsgUp(gref, mp); ! 247: } ! 248: ATENABLE(s, sp->lock); ! 249: return 0; ! 250: } ! 251: ! 252: /* ! 253: * adspRead ! 254: * ! 255: * INPUTS: ! 256: * --> sp stream pointer ! 257: * --> pb user request parameter block ! 258: * ! 259: * OUTPUTS: ! 260: * <-- actCount actual number of bytes read ! 261: * <-- eom one if end-of-message, zero otherwise ! 262: * ! 263: * ERRORS: ! 264: * errRefNum bad connection refnum ! 265: * errState ! 266: * errFwdReset read terminated by forward reset ! 267: * errAborted request aborted by Remove or Close call ! 268: */ ! 269: int adspRead(sp, pb) /* (DSPPBPtr pb) */ ! 270: register CCBPtr sp; ! 271: register struct adspcmd *pb; ! 272: { ! 273: register gbuf_t *mp; ! 274: int s; ! 275: ! 276: if (sp == 0) { ! 277: pb->ioResult = errRefNum; ! 278: return EINVAL; ! 279: } ! 280: ! 281: /* ! 282: * It's OK to read on a closed, or closing session ! 283: */ ! 284: ATDISABLE(s, sp->lock); ! 285: if (sp->state != sOpen && sp->state != sClosing && sp->state != sClosed) { ! 286: ATENABLE(s, sp->lock); ! 287: pb->ioResult = errState; ! 288: return EINVAL; ! 289: } ! 290: ! 291: if (sp->rData && (sp->rpb == 0)) { /* if data, and no queue of pbs */ ! 292: qAddToEnd(&sp->rpb, pb); /* deliver data to user directly */ ! 293: ATENABLE(s, sp->lock); ! 294: CheckReadQueue(sp); ! 295: } else if ((pb->u.ioParams.reqCount == 0) && (sp->rpb == 0)) { ! 296: /* empty read */ ! 297: ATENABLE(s, sp->lock); ! 298: pb->ioResult = 0; ! 299: adspioc_ack(0, pb->ioc, pb->gref); ! 300: return 0; ! 301: } else { ! 302: pb->ioResult = 1; ! 303: if (mp = gbuf_copym(pb->mp)) { /* otherwise, duplicate user request */ ! 304: adspioc_ack(0, pb->ioc, pb->gref); /* release user */ ! 305: pb = (struct adspcmd *)gbuf_rptr(mp); /* get new parameter block */ ! 306: pb->ioc = 0; ! 307: pb->mp = mp; ! 308: qAddToEnd(&sp->rpb, pb); /* and queue it for later */ ! 309: ATENABLE(s, sp->lock); ! 310: } else { ! 311: ATENABLE(s, sp->lock); ! 312: pb->ioResult = errDSPQueueSize; ! 313: return ENOBUFS; ! 314: } ! 315: } ! 316: if (sp->callSend) { ! 317: CheckSend(sp); /* If recv window opened, we might */ ! 318: /* send an unsolicited ACK. */ ! 319: } ! 320: return 0; ! 321: } ! 322: ! 323: /* ! 324: * dspReadAttention ! 325: * ! 326: * INPUTS: ! 327: * --> sp stream pointer ! 328: * --> pb user request parameter block ! 329: * ! 330: * OUTPUTS: ! 331: * <-- NONE ! 332: * ! 333: * ERRORS: ! 334: * errRefNum bad connection refnum ! 335: * errState connection is not in the right state ! 336: */ ! 337: int adspReadAttention(sp, pb) /* (DSPPBPtr pb) */ ! 338: register CCBPtr sp; ! 339: register struct adspcmd *pb; ! 340: { ! 341: OSErr err; ! 342: ! 343: if (sp == 0) { ! 344: pb->ioResult = errRefNum; ! 345: return EINVAL; ! 346: } ! 347: ! 348: /* ! 349: * It's OK to read on a closed, or closing session ! 350: */ ! 351: if (sp->state != sOpen && sp->state != sClosing && sp->state != sClosed) { ! 352: pb->ioResult = errState; ! 353: return EINVAL; ! 354: } ! 355: ! 356: CheckAttn(sp, pb); /* Anything in the attention queue */ ! 357: CheckReadQueue(sp); /* check to see if receive window has opened */ ! 358: if (sp->callSend) { ! 359: CheckSend(sp); /* If recv window opened, we might */ ! 360: /* send an unsolicited ACK. */ ! 361: } ! 362: return 0; ! 363: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.