![[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 XNU] / XNU / bsd / netat|
Return to adsp_Read.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
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: * ! 24: * dspRead.c ! 25: * ! 26: * From v01.17 08/22/90 mbs ! 27: * Modified for MP, 1996 by Tuyen Nguyen ! 28: * Modified, April 9, 1997 by Tuyen Nguyen for MacOSX. ! 29: */ ! 30: ! 31: #include <sys/errno.h> ! 32: #include <sys/types.h> ! 33: #include <sys/param.h> ! 34: #include <machine/spl.h> ! 35: #include <sys/systm.h> ! 36: #include <sys/kernel.h> ! 37: #include <sys/proc.h> ! 38: #include <sys/filedesc.h> ! 39: #include <sys/fcntl.h> ! 40: #include <sys/mbuf.h> ! 41: #include <sys/socket.h> ! 42: #include <sys/socketvar.h> ! 43: ! 44: #include <netat/sysglue.h> ! 45: #include <netat/appletalk.h> ! 46: #include <netat/at_pcb.h> ! 47: #include <netat/debug.h> ! 48: #include <netat/adsp.h> ! 49: #include <netat/adsp_internal.h> ! 50: ! 51: /* ! 52: * CheckReadQueue ! 53: * ! 54: * Checks to see if there is any data in the receive queue. If there ! 55: * is data, a pb and the data are queued to the user. ! 56: * ! 57: * ! 58: */ ! 59: extern int adsp_check; ! 60: ! 61: int CheckReadQueue(sp) /* (CCBPtr sp) */ ! 62: register CCBPtr sp; ! 63: { ! 64: register struct adspcmd *pb; ! 65: int s; ! 66: unsigned short cnt; ! 67: char eom = 0; ! 68: register gbuf_t *mp; ! 69: register gbuf_t *tmp; ! 70: gref_t *gref; ! 71: ! 72: dPrintf(D_M_ADSP, D_L_TRACE, ("CheckReadQueue: sp=0x%x\n", (unsigned)sp)); ! 73: KERNEL_DEBUG(DBG_ADSP_READ, 0, sp, sp->rbuf_mb, sp->rpb, sp->delay); ! 74: trace_mbufs(D_M_ADSP_LOW, " bCQR m", sp->rbuf_mb); ! 75: ATDISABLE(s, sp->lock); ! 76: ! 77: while (sp->rData && (pb = sp->rpb)) { /* have data */ ! 78: dPrintf(D_M_ADSP, D_L_TRACE, ! 79: (" pb=0x%x, gref=0x%x, ioc=0x%x, reqCount=%d (have data)\n", ! 80: pb, pb->gref, pb->ioc, pb->u.ioParams.reqCount)); ! 81: KERNEL_DEBUG(DBG_ADSP_READ, 1, pb, pb->gref, pb->ioc, pb->u.ioParams.reqCount); ! 82: if (pb->u.ioParams.reqCount == 0) { ! 83: pb->ioResult = 0; ! 84: sp->rpb = pb->qLink; ! 85: if (pb->ioc) { ! 86: KERNEL_DEBUG(DBG_ADSP_READ, 2, pb, pb->gref, pb->ioc, 0); ! 87: adspioc_ack(0, pb->ioc, pb->gref); ! 88: } else { ! 89: KERNEL_DEBUG(DBG_ADSP_READ, 3, pb, pb->gref, 0, 0); ! 90: completepb(sp, pb); ! 91: } ! 92: continue; ! 93: } ! 94: ! 95: /* take the first packet off of sp->rbuf_mb or sp->crbuf_mb */ ! 96: if (mp = sp->rbuf_mb) { /* Get header for oldest data */ ! 97: KERNEL_DEBUG(DBG_ADSP_READ, 4, pb, mp, gbuf_msgsize(mp), gbuf_next(mp)); ! 98: sp->rbuf_mb = gbuf_next(mp); ! 99: gbuf_next(mp) = 0; ! 100: eom = 1; ! 101: } else if (mp = sp->crbuf_mb) { ! 102: KERNEL_DEBUG(DBG_ADSP_READ, 5, pb, mp, gbuf_msgsize(mp), gbuf_next(mp)); ! 103: sp->crbuf_mb = 0; ! 104: eom = 0; ! 105: } ! 106: ! 107: /* Get the first (reqCount-actCount) bytes and tack them onto ! 108: the end of pb->mp. If eom is set, put the remainder of the ! 109: data onto the front of sp->rbuf_mb, otherwise sp->crbuf_mb. */ ! 110: cnt = gbuf_msgsize(mp); /* # of data bytes in it. */ ! 111: if (cnt > (unsigned short)(pb->u.ioParams.reqCount - pb->u.ioParams.actCount)) { ! 112: cnt = pb->u.ioParams.reqCount - pb->u.ioParams.actCount; ! 113: /* m_split returns the tail */ ! 114: if (!(tmp = (gbuf_t *)m_split(mp, cnt, M_DONTWAIT))) { ! 115: cnt = 0; ! 116: tmp = mp; ! 117: } ! 118: if (eom) { ! 119: gbuf_next(tmp) = sp->rbuf_mb; ! 120: sp->rbuf_mb = tmp; ! 121: eom = 0; ! 122: } else ! 123: sp->crbuf_mb = tmp; ! 124: } ! 125: if (cnt) { ! 126: pb->u.ioParams.actCount += cnt; ! 127: gbuf_linkb(pb->mp, mp); ! 128: } ! 129: ! 130: pb->u.ioParams.eom = eom; ! 131: /* ! 132: * Now clean up receive buffer to remove all of the data ! 133: * we just copied ! 134: */ ! 135: if ((sp->rbuf_mb == 0) && ! 136: (sp->crbuf_mb == 0)) /* no more data blocks */ ! 137: sp->rData = 0; ! 138: /* ! 139: * If we've filled the parameter block, unlink it from read ! 140: * queue and complete it. We also need to do this if the connection ! 141: * is closed && there is no more stuff to read. ! 142: */ ! 143: if (eom || (pb->u.ioParams.actCount >= pb->u.ioParams.reqCount) || ! 144: ((sp->state == sClosed) && (!sp->rData)) ) { ! 145: /* end of message, message is full, connection ! 146: * is closed and all data has been delivered, ! 147: * or we are not to "delay" data delivery. ! 148: */ ! 149: pb->ioResult = 0; ! 150: sp->rpb = pb->qLink; /* dequeue request */ ! 151: if (pb->ioc) { /* data to be delivered at the time of the */ ! 152: mp = gbuf_cont(pb->mp); /* ioctl call */ ! 153: gbuf_cont(pb->mp) = 0; ! 154: gref = (gref_t *)pb->gref; ! 155: adspioc_ack(0, pb->ioc, pb->gref); ! 156: dPrintf(D_M_ADSP, D_L_TRACE, (" (pb->ioc) mp=%x\n", mp)); ! 157: KERNEL_DEBUG(DBG_ADSP_READ, 0x0A, pb, mp, ! 158: gbuf_next(mp), gbuf_cont(mp)); ! 159: SndMsgUp(gref, mp); ! 160: dPrintf(D_M_ADSP, D_L_TRACE, ! 161: (" (data) size req=%d\n", pb->u.ioParams.actCount)); ! 162: KERNEL_DEBUG(DBG_ADSP_READ, 0x0B, pb, pb->ioc, ! 163: pb->u.ioParams.reqCount, pb->u.ioParams.actCount); ! 164: } else { /* complete an queued async request */ ! 165: KERNEL_DEBUG(DBG_ADSP_READ, 0x0C, pb, sp, ! 166: pb->u.ioParams.actCount, sp->delay); ! 167: completepb(sp, pb); ! 168: } ! 169: } ! 170: } /* while */ ! 171: ! 172: if (pb = sp->rpb) { /* if there is an outstanding request */ ! 173: dPrintf(D_M_ADSP, D_L_TRACE, ! 174: (" pb=0x%x, ioc=0x%x, reqCount=%d (no more data)\n", ! 175: pb, pb->ioc, pb->u.ioParams.reqCount)); ! 176: KERNEL_DEBUG(DBG_ADSP_READ, 0x0D, pb, pb->ioc, ! 177: pb->u.ioParams.reqCount, pb->u.ioParams.actCount); ! 178: ! 179: if (sp->state == sClosed) { ! 180: while (pb) { ! 181: KERNEL_DEBUG(DBG_ADSP_READ, 0x0E, pb, sp, pb->ioc, 0); ! 182: pb->ioResult = 0; ! 183: pb->u.ioParams.actCount = 0; ! 184: pb->u.ioParams.eom = 0; ! 185: sp->rpb = pb->qLink; ! 186: if (pb->ioc) { ! 187: adspioc_ack(0, pb->ioc, pb->gref); ! 188: } else { ! 189: completepb(sp, pb); ! 190: } ! 191: pb = sp->rpb; ! 192: } ! 193: } else if (pb->ioc) { /* if request not complete and this ! 194: * is an active ioctl, release user */ ! 195: sp->rpb = pb->qLink; ! 196: pb->ioResult = 1; ! 197: tmp = gbuf_cont(pb->mp); /* detatch perhaps delayed data */ ! 198: gbuf_cont(pb->mp) = 0; ! 199: if (mp = gbuf_copym(pb->mp)) { /* otherwise, duplicate user request */ ! 200: KERNEL_DEBUG(DBG_ADSP_READ, 0x0F, pb, sp, pb->mp, 0); ! 201: adspioc_ack(0, pb->ioc, pb->gref); /* release user */ ! 202: pb = (struct adspcmd *)gbuf_rptr(mp); /* get new parameter block */ ! 203: pb->ioc = 0; ! 204: pb->mp = mp; ! 205: gbuf_cont(pb->mp) = tmp; /* reattach data */ ! 206: pb->qLink = sp->rpb; /* requeue the duplicate at the head */ ! 207: sp->rpb = pb; ! 208: } else { /* there is no data left, but no space ! 209: * to duplicate the parameter block, so ! 210: * put what must be a non EOM message ! 211: * back on the current receive queue, and ! 212: * error out the user ! 213: */ ! 214: KERNEL_DEBUG(DBG_ADSP_READ, 0x10, pb, sp, pb->mp, 0); ! 215: if (tmp) { ! 216: sp->crbuf_mb = tmp; ! 217: sp->rData = 1; ! 218: } ! 219: pb->ioResult = errDSPQueueSize; ! 220: adspioc_ack(ENOBUFS, pb->ioc, pb->gref); ! 221: } ! 222: } ! 223: } ! 224: /* ! 225: * The receive window has opened. If was previously closed, then we ! 226: * need to notify the other guy that we now have room to receive more ! 227: * data. But, in order to cut down on lots of small data packets, ! 228: * we'll wait until the recieve buffer is /14 empy before telling ! 229: * him that there's room in our receive buffer. ! 230: */ ! 231: if (sp->rbufFull && (CalcRecvWdw(sp) > (sp->rbuflen >> 2))) { ! 232: sp->rbufFull = 0; ! 233: sp->sendDataAck = 1; ! 234: sp->callSend = 1; ! 235: } ! 236: ATENABLE(s, sp->lock); ! 237: ! 238: KERNEL_DEBUG(DBG_ADSP_READ, 0x11, sp, 0, 0, 0); ! 239: trace_mbufs(D_M_ADSP_LOW, " eCQR m", sp->rbuf_mb); ! 240: return 0; ! 241: } ! 242: ! 243: /* ! 244: * CheckAttn ! 245: * ! 246: * Checks to see if there is any attention data and passes the data back ! 247: * in the passed in pb. ! 248: * ! 249: * INPUTS: ! 250: * sp ! 251: * pb ! 252: * ! 253: * OUTPUTS: ! 254: * ! 255: */ ! 256: int CheckAttn(sp, pb) /* (CCBPtr sp) */ ! 257: register CCBPtr sp; ! 258: register struct adspcmd *pb; ! 259: { ! 260: int s; ! 261: gbuf_t *mp; ! 262: gref_t *gref; ! 263: ! 264: dPrintf(D_M_ADSP, D_L_TRACE, ! 265: ("CheckAttn: sp=0x%x, pb=0x%x\n", (unsigned)sp, (unsigned)pb)); ! 266: ! 267: ATDISABLE(s, sp->lock); ! 268: if (mp = sp->attn_mb) { ! 269: ! 270: /* ! 271: * Deliver the attention data to the user. ! 272: */ ! 273: gref = (gref_t *)pb->gref; ! 274: pb->u.attnParams.attnSize = sp->attnSize; ! 275: pb->u.attnParams.attnCode = sp->attnCode; ! 276: if (!sp->attnSize) { ! 277: gbuf_freem(mp); ! 278: mp = 0; ! 279: } ! 280: sp->userFlags &= ~eAttention; ! 281: /* ! 282: * Now clean up receive buffer to remove all of the data ! 283: * we just copied ! 284: */ ! 285: sp->attn_mb = 0; ! 286: pb->ioResult = 0; ! 287: } else { ! 288: /* ! 289: * No data... ! 290: */ ! 291: pb->u.attnParams.attnSize = 0; ! 292: pb->u.attnParams.attnCode = 0; ! 293: pb->ioResult = 1; /* not done */ ! 294: } ! 295: adspioc_ack(0, pb->ioc, pb->gref); ! 296: if (mp) { ! 297: SndMsgUp(gref, mp); ! 298: } ! 299: ATENABLE(s, sp->lock); ! 300: return 0; ! 301: } ! 302: ! 303: /* ! 304: * adspRead ! 305: * ! 306: * INPUTS: ! 307: * --> sp stream pointer ! 308: * --> pb user request parameter block ! 309: * ! 310: * OUTPUTS: ! 311: * <-- actCount actual number of bytes read ! 312: * <-- eom one if end-of-message, zero otherwise ! 313: * ! 314: * ERRORS: ! 315: * errRefNum bad connection refnum ! 316: * errState ! 317: * errFwdReset read terminated by forward reset ! 318: * errAborted request aborted by Remove or Close call ! 319: */ ! 320: int adspRead(sp, pb) /* (DSPPBPtr pb) */ ! 321: register CCBPtr sp; ! 322: register struct adspcmd *pb; ! 323: { ! 324: register gbuf_t *mp; ! 325: int s; ! 326: ! 327: dPrintf(D_M_ADSP, D_L_TRACE, ! 328: ("adspRead: sp=0x%x, pb=0x%x\n", (unsigned)sp, (unsigned)pb)); ! 329: ! 330: KERNEL_DEBUG(DBG_ADSP_READ, 0x12, sp, pb, sp->state, sp->rData); ! 331: ! 332: if (sp == 0) { ! 333: pb->ioResult = errRefNum; ! 334: return EINVAL; ! 335: } ! 336: ! 337: /* ! 338: * It's OK to read on a closed, or closing session ! 339: */ ! 340: ATDISABLE(s, sp->lock); ! 341: if (sp->state != sOpen && sp->state != sClosing && sp->state != sClosed) { ! 342: ATENABLE(s, sp->lock); ! 343: pb->ioResult = errState; ! 344: return EINVAL; ! 345: } ! 346: if (sp->rData && (sp->rpb == 0)) { /* if data, and no queue of pbs */ ! 347: qAddToEnd(&sp->rpb, pb); /* deliver data to user directly */ ! 348: ATENABLE(s, sp->lock); ! 349: CheckReadQueue(sp); ! 350: } else if ((pb->u.ioParams.reqCount == 0) && (sp->rpb == 0)) { ! 351: /* empty read */ ! 352: ATENABLE(s, sp->lock); ! 353: pb->ioResult = 0; ! 354: adspioc_ack(0, pb->ioc, pb->gref); ! 355: return 0; ! 356: } else { ! 357: pb->ioResult = 1; ! 358: if (mp = gbuf_copym(pb->mp)) { /* otherwise, duplicate user request */ ! 359: adspioc_ack(0, pb->ioc, pb->gref); /* release user */ ! 360: pb = (struct adspcmd *)gbuf_rptr(mp); /* get new parameter block */ ! 361: pb->ioc = 0; ! 362: pb->mp = mp; ! 363: qAddToEnd(&sp->rpb, pb); /* and queue it for later */ ! 364: ATENABLE(s, sp->lock); ! 365: } else { ! 366: ATENABLE(s, sp->lock); ! 367: pb->ioResult = errDSPQueueSize; ! 368: return ENOBUFS; ! 369: } ! 370: } ! 371: ! 372: if (sp->callSend) { ! 373: CheckSend(sp); /* If recv window opened, we might */ ! 374: /* send an unsolicited ACK. */ ! 375: } ! 376: return 0; ! 377: } ! 378: ! 379: /* ! 380: * dspReadAttention ! 381: * ! 382: * INPUTS: ! 383: * --> sp stream pointer ! 384: * --> pb user request parameter block ! 385: * ! 386: * OUTPUTS: ! 387: * <-- NONE ! 388: * ! 389: * ERRORS: ! 390: * errRefNum bad connection refnum ! 391: * errState connection is not in the right state ! 392: */ ! 393: int adspReadAttention(sp, pb) /* (DSPPBPtr pb) */ ! 394: register CCBPtr sp; ! 395: register struct adspcmd *pb; ! 396: { ! 397: dPrintf(D_M_ADSP, D_L_TRACE, ! 398: ("adspReadAttention: sp=0x%x, pb=0x%x\n", (unsigned)sp, (unsigned)pb)); ! 399: if (sp == 0) { ! 400: pb->ioResult = errRefNum; ! 401: return EINVAL; ! 402: } ! 403: ! 404: /* ! 405: * It's OK to read on a closed, or closing session ! 406: */ ! 407: if (sp->state != sOpen && sp->state != sClosing && sp->state != sClosed) { ! 408: pb->ioResult = errState; ! 409: return EINVAL; ! 410: } ! 411: ! 412: CheckAttn(sp, pb); /* Anything in the attention queue */ ! 413: CheckReadQueue(sp); /* check to see if receive window has opened */ ! 414: if (sp->callSend) { ! 415: CheckSend(sp); /* If recv window opened, we might */ ! 416: /* send an unsolicited ACK. */ ! 417: } ! 418: return 0; ! 419: } /* adspReadAttention */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.