bsd/netat/adsp_Control.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*
  24  *      Copyright (c) 1990, 1995-1998 Apple Computer, Inc.
  25  *      All Rights Reserved.
  26  */
  27
  28 /* Control.c
  29  * From Mike Shoemaker v01.25 07/02/90 for MacOS
  30  * 09/07/95 - Modified for performance (Tuyen Nguyen)
  31  *    Modified for MP, 1996 by Tuyen Nguyen
  32  *   Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
  33  */
  34
  35 #include <sys/errno.h>
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38 #include <machine/spl.h>
  39 #include <sys/systm.h>
  40 #include <sys/kernel.h>
  41 #include <sys/proc.h>
  42 #include <sys/filedesc.h>
  43 #include <sys/fcntl.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/time.h>
  46 #include <sys/socket.h>
  47
  48 #include <netat/sysglue.h>
  49 #include <netat/appletalk.h>
  50 #include <netat/ddp.h>
  51 #include <netat/at_pcb.h>
  52 #include <netat/debug.h>
  53 #include <netat/adsp.h>
  54 #include <netat/adsp_internal.h>
  55
  56 /* # of additional ticks to add to any timer that we're queuing up.  For
  57  * very short delays (1 and 2), the timer fires before the transmit
  58  * even takes place */
  59 #define TX_DLY  2
  60
  61 int adsp_window = 1;
  62
  63 /*
  64  * CalcRecvWdw
  65  *
  66  * INPUTS:
  67  *              sp              ADSP Stream
  68  * OUTPUTS:
  69  *              # of bytes in avail in local receive queue
  70  */
  71 int CalcRecvWdw(sp)             /* (CCBPtr sp) */
  72     CCBPtr sp;
  73 {
  74     int bytes;
  75
  76     bytes = calcRecvQ(sp);
  77     bytes = sp->rbuflen - bytes; /* get what is left */
  78
  79     if (bytes <= 16) {          /* %%% this should be zero */
  80         sp->rbufFull = 1;       /* Save flag that our recv buf is full */
  81         return 0;
  82     }
  83     else
  84         return ((bytes+bytes+bytes) >> 2) + 1; /* %%% */
  85 }
  86
  87 calcRecvQ(sp)
  88     CCBPtr sp;
  89 {
  90     int bytes = 0;
  91 #ifdef AT_Socket
  92     register struct mbuf *m, *p;
  93
  94     if (((sp->gref)->so)->so_rcv.sb_mb)
  95       for (p = ((sp->gref)->so)->so_rcv.sb_mb; p; p = p->m_nextpkt)
  96         for (m = p; m; m = m->m_next)
  97           bytes += m->m_len;
  98 #else
  99     register gbuf_t *mb;
 100
 101     if (sp->rData) {            /* There is data in buffer */
 102         if (mb = sp->rbuf_mb) {
 103             do {
 104                 bytes += gbuf_msgsize(mb);
 105                 mb = gbuf_next(mb);
 106             } while (mb);
 107         }
 108         if (mb = sp->crbuf_mb)
 109             bytes += gbuf_msgsize(mb);
 110     }
 111 #endif
 112     return bytes;
 113 }
 114
 115 /*
 116  * CheckSend
 117  *
 118  * Check to see if the transmit PB is available and if there is anything
 119  * to transmit. Start off any pending transmit.
 120  *
 121  * Normally called from the write completion routine
 122  *
 123  * INPUTS:
 124  *              sp              Connection control block
 125  * OUTPUTS:
 126  *              true if sent a packet
 127  */
 128 void CheckSend(sp)              /* (CCBPtr sp) */
 129     register CCBPtr sp;
 130 {
 131     int i;
 132     int attnMsg;                /* True if attention message */
 133     int s;
 134     register gbuf_t *mp;        /* send message block */
 135 #ifdef notdef
 136     register gbuf_t *tmp;
 137     u_char current;
 138 #endif
 139     char *dp;                   /* a data pointer */
 140     int use_attention_code;
 141     int len;                    /* length used in allocd mblk */
 142     int datalen;                /* amount of data attached to mblk */
 143     gbuf_t *mprev, *mlist = 0;
 144
 145 top:
 146
 147     if (sp->state == sClosed)
 148         return;
 149
 150                                 /* get a message block to hold DDP and
 151                                  * ADSP headers + 2 bytes of attention
 152                                  * code if necessary */
 153     if ((mp = gbuf_alloc(AT_WR_OFFSET + DDPL_FRAME_LEN + ADSP_FRAME_LEN + ADSP_OPEN_FRAME_LEN + 2,
 154                      PRI_LO)) == 0) {
 155         if (mlist)
 156                 gbuf_freel(mlist);
 157         return;         /* can't get buffers... do nothing! */
 158     }
 159     ATDISABLE(s, sp->lock);
 160     sp->callSend = 0;           /* Clear flag */
 161     use_attention_code = 0;
 162     len = 0;
 163     datalen = 0;
 164
 165     gbuf_rinc(mp,AT_WR_OFFSET);
 166     gbuf_wset(mp,DDPL_FRAME_LEN); /* leave room for DDP header */
 167
 168     if (sp->sendCtl) {
 169         short mask = 0;
 170
 171         i = sp->sendCtl;        /* get local copy bitmap of */
 172                                 /* which ctl packets to send. */
 173         attnMsg = 0;
 174
 175         if (i & 0x1E)           /* One of the open ctrl packets */
 176         {
 177
 178             /* point past ADSP header (no attention) */
 179             dp = ((char *) gbuf_wptr(mp)) + ADSP_FRAME_LEN;
 180             UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->firstRtmtSeq));
 181
 182             UAS_ASSIGN(sp->of.version, netw(0x0100)); /* Fill in open connection parms */
 183             UAS_ASSIGN(sp->of.dstCID, sp->remCID);      /* Destination CID */
 184             UAL_ASSIGN(sp->of.pktAttnRecvSeq, netdw(sp->attnRecvSeq));
 185             bcopy((caddr_t) &sp->of, (caddr_t) dp, ADSP_OPEN_FRAME_LEN);
 186             len += ADSP_OPEN_FRAME_LEN;
 187
 188             if (i & B_CTL_OREQ) {
 189                 UAS_ASSIGN(sp->f.CID, sp->locCID);
 190                 mask = B_CTL_OREQ;
 191                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQ;
 192             } else if (i & B_CTL_OACK) {
 193                 UAS_ASSIGN(sp->f.CID, sp->locCID);
 194                 mask = B_CTL_OACK;
 195                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OACK;
 196             } else if (i & B_CTL_OREQACK) {
 197                 UAS_ASSIGN(sp->f.CID, sp->locCID);
 198                 mask = B_CTL_OREQACK;
 199                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQACK;
 200             } else              /* Deny */
 201             {
 202                 UAS_ASSIGN(sp->f.CID, 0);
 203                 mask = B_CTL_ODENY;
 204                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_ODENY;
 205                 UAL_ASSIGN(sp->f.pktFirstByteSeq, 0);
 206             }
 207
 208             if (i & (B_CTL_OREQ | B_CTL_OREQACK))
 209                 /* Need to start up a timer for it */
 210             {
 211                 /* It's possible that we've received a duplicate
 212                  * open request.  In this case, there will already be
 213                  * a timer queued up for the request+ack
 214                  *  packet we sent the first time.  So remove the timer
 215                  * and start another.
 216                  */
 217                 RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer);
 218                 InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer,
 219                                 sp->openInterval+1);
 220             }
 221         } else {
 222             /* seq # of next byte to send */
 223             UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq));
 224
 225             if (i & B_CTL_CLOSE) {
 226                 sp->state = sClosed; /* Now we're closed */
 227                 mask = B_CTL_CLOSE;
 228                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_CLOSE;
 229             } else if (i & B_CTL_PROBE) {
 230                 mask = B_CTL_PROBE;
 231                 sp->f.descriptor =
 232                     ADSP_CONTROL_BIT | ADSP_CTL_PROBE | ADSP_ACK_REQ_BIT;
 233             } else if (i & B_CTL_FRESET) {
 234                 mask = B_CTL_FRESET;
 235                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET;
 236                 InsertTimerElem(&adspGlobal.fastTimers,
 237                                 &sp->ResetTimer, sp->rtmtInterval+TX_DLY);
 238             } else if (i & B_CTL_FRESETACK) {
 239                 mask = B_CTL_FRESETACK;
 240                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET_ACK;
 241             }
 242             else if (i & B_CTL_RETRANSMIT) {
 243                 mask = B_CTL_RETRANSMIT;
 244                 sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_RETRANSMIT;
 245             }
 246             else {
 247                 dPrintf(D_M_ADSP, D_L_ERROR, ("CheckSend: Control bit error\n"));
 248            }
 249         }                       /* non open control packet */
 250
 251         sp->sendCtl &= ~mask;
 252         goto sendit;
 253     }                           /* send control packet */
 254
 255     if (sp->sendAttnData)       /* Send attn ready to go? */
 256     {
 257         sp->sendAttnData = 0;   /* Clear Flags */
 258         if (sp->sapb) {
 259             sp->sendAttnAck  = 0; /* This will also do an Attn Ack */
 260
 261             attnMsg = 1;
 262             sp->f.descriptor = ADSP_ATTENTION_BIT | ADSP_ACK_REQ_BIT;
 263             if (gbuf_cont(sp->sapb->mp)) {
 264                 gbuf_cont(mp) = gbuf_dupm(gbuf_cont(sp->sapb->mp));
 265                 /* Major hack here.  The ADSP Attn code is butted up against
 266                  * the end of the adsp packet header, and the length is
 267                  * increased by 2.  (There is a pad field behind the adsp
 268                  * header in the CCB just for this purpose.)
 269                  */
 270             }
 271             use_attention_code++;
 272
 273             sp->f.data[0] = high(sp->sapb->u.attnParams.attnCode);
 274             sp->f.data[1] = low(sp->sapb->u.attnParams.attnCode);
 275             InsertTimerElem(&adspGlobal.fastTimers, &sp->AttnTimer,
 276                                                      sp->rtmtInterval+TX_DLY);
 277             goto sendit;
 278         }
 279     }                           /* attn data */
 280
 281     if (sp->sendAttnAck)        /* Send attn ack ready to go? */
 282     {
 283         attnMsg = 1;
 284         sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_ATTENTION_BIT;
 285         sp->sendAttnAck = 0;
 286         goto sendit;
 287     }                           /* attn ack */
 288
 289     if ((sp->state == sOpen || sp->state == sClosing) && /* Correct state */
 290         (!sp->waitingAck) &&    /* not waiting for an ACK */
 291         (sp->sData) &&          /* have data to send */
 292         (GTE(sp->sendWdwSeq,sp->sendSeq)) && /* he has room to accept it */
 293         (sp->pktSendCnt < sp->pktSendMax)) /* haven't sent too many pkts
 294                                             * in a row. */
 295     {
 296         attnMsg = 0;
 297         if (datalen = attachData(sp, mp)) /* attach data to mp */
 298             goto sendit;        /* if successful, sendit */
 299     }
 300
 301     if (sp->sendDataAck) {
 302         UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq)); /* seq # of next byte */
 303         attnMsg = 0;
 304         sp->f.descriptor = ADSP_CONTROL_BIT;
 305         goto sendit;
 306     }
 307
 308     /*
 309      * Nothing left to do...
 310      */
 311     if (mp)
 312         gbuf_freem(mp);
 313     ATENABLE(s, sp->lock);
 314     if (mlist)
 315         adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP);
 316     return;
 317
 318 sendit:
 319
 320     if (attnMsg) {
 321         UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->attnSendSeq));
 322         UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->attnRecvSeq));
 323         UAS_ASSIGN(sp->f.pktRecvWdw, 0);        /* Always zero in attn pkt */
 324     } else {
 325         sp->sendDataAck = 0;
 326         UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->recvSeq));
 327         UAS_ASSIGN(sp->f.pktRecvWdw, netw(CalcRecvWdw(sp)));
 328     }
 329     if (use_attention_code) {
 330         bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN + 2);
 331         len += ADSP_FRAME_LEN + 2;
 332     } else {
 333         bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN);
 334         len += ADSP_FRAME_LEN;
 335     }
 336     gbuf_winc(mp,len);          /* update mblk length  */
 337     if (mlist)
 338         gbuf_next(mprev) = mp;
 339     else
 340         mlist = mp;
 341     mprev = mp;
 342
 343     if (sp->state == sClosed) { /* must have sent a close advice */
 344                                 /* send header + data */
 345         ATENABLE(s, sp->lock);
 346         adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP);
 347         DoClose(sp, 0, -1);     /* complete close! */
 348         return;
 349     }
 350     ATENABLE(s, sp->lock);
 351     if (sp->state == sClosing) /* See if we were waiting on this write */
 352         CheckOkToClose(sp);
 353     goto top;
 354 }
 355
 356 /*
 357  * completepb delivers a paramater block with all its appropriate fields
 358  * set back to the user.
 359  *
 360  * The assumptions here are that the PB is not linked to any queue,
 361  * that the fields including ioResult are set, and that the
 362  * kernel is no longer interested in the mblks that may or
 363  * maynot be linked to this pb.
 364  */
 365 void completepb(sp, pb)
 366     register CCBPtr sp;
 367     register struct adspcmd *pb;
 368 {
 369     if (sp->gref && (sp->gref->info == (caddr_t)sp->sp_mp)) {
 370         if (gbuf_len(pb->mp) > sizeof(struct adspcmd))
 371                 gbuf_wset(pb->mp,sizeof(struct adspcmd));
 372         SndMsgUp(sp->gref, pb->mp);
 373         NotifyUser(sp);
 374     } else
 375         gbuf_freem(pb->mp);
 376 }
 377
 378 attachData(sp, mp)
 379     register CCBPtr sp;
 380     register gbuf_t *mp;
 381 {
 382     int seq;
 383     int cnt;
 384     char eom = 0;
 385     int bsize;
 386     int diff;
 387     char sendAckReq;
 388     int partial = 0;            /* flag for a partial send */
 389     int tcnt = 0;
 390     register gbuf_t *smp;       /* send data message block */
 391     register gbuf_t *psmp;      /* previous message block */
 392
 393     sendAckReq = 0;
 394
 395     if (LT(sp->sendSeq, sp->firstRtmtSeq)) /* Sanity check on send seq */
 396         sp->sendSeq = sp->firstRtmtSeq; /* seq must be oldest in buffer. */
 397
 398     /* This test and assignment was necessary because the retry VBL could
 399      * have fired and reset send Seq to first Rtmt Seq, and then an
 400      * expected ACK comes in that bumps first Rtmt Seq up.  Then we
 401      * have the problem that send Seq is less than first Rtmt Seq.
 402      * The easiest fix to this timing dilemma seems to be to reset
 403      * sendSeq to first Rtmt Seq if we're sending the first packet.
 404      */
 405     UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq));
 406
 407     if (smp = sp->sbuf_mb) /* Get oldest header */
 408         eom = 1;
 409     else if (smp = sp->csbuf_mb)
 410         eom = 0;
 411
 412     if (smp == 0) {             /* this shouldn't happen... */
 413             sp->sData = 0;
 414             return 0;
 415     }
 416     /*
 417      * Must find next byte to transmit
 418      */
 419     seq = sp->firstRtmtSeq;     /* Seq # of oldest in buffer */
 420     while ((diff = (sp->sendSeq - seq)) >= ((bsize = gbuf_msgsize(smp)) + eom)) {
 421         seq += bsize + eom;     /* update sequence # */
 422         if (gbuf_next(smp)) { /* if another send buffer */
 423             smp = gbuf_next(smp);
 424             eom = 1;
 425         } else if (smp == sp->csbuf_mb) { /* seen the current one? */
 426             smp = 0;
 427             break;
 428         } else if (sp->csbuf_mb) { /* look at it */
 429             smp = sp->csbuf_mb;
 430             eom = 0;
 431         } else {                /* no more buffers */
 432             smp = 0;
 433             break;
 434         }
 435     }                   /* while */
 436
 437     if (smp) {
 438         if (gbuf_next(smp) == 0)        /* last block */
 439             sendAckReq = 1;
 440         cnt = bsize - diff;     /* # of bytes in this block */
 441     } else
 442         cnt = 0;
 443
 444     /*
 445      * Check to see if the number of bytes is less than the 'send
 446      * Blocking' setting. If so, then we won't send this data unless
 447      * we're flushing.  So we set up a timer to force a flush later.
 448      */
 449     if ((cnt < sp->sendBlocking) && !sp->writeFlush) {
 450         InsertTimerElem(&adspGlobal.fastTimers, &sp->FlushTimer,
 451                                                  sp->sendInterval);
 452         return 0;               /* no data to send */
 453     }
 454
 455     if (cnt > ADSP_MAX_DATA_LEN) { /* truncate to one packet */
 456         cnt = ADSP_MAX_DATA_LEN;
 457         eom = 0;
 458         sendAckReq = 0; /* Won't send ack because end of data */
 459         partial++;
 460     }
 461
 462     if (smp) {
 463         /* trim extra bytes off the beginning of the "block" before the copy */
 464         while (diff) {
 465             if (gbuf_len(smp) > diff)
 466                 break;
 467             else
 468                 diff -= gbuf_len(smp);
 469             smp = gbuf_cont(smp);
 470         }
 471         if((gbuf_cont(mp) = gbuf_dupm(smp)) == 0) /* copy the data */
 472             return 0;
 473         smp = gbuf_cont(mp);    /* use the new message blocks */
 474         gbuf_rinc(smp,diff);    /* and get to the first byte of data to send */
 475     }
 476     /*
 477      * Check to see if this many bytes will close the other end's
 478      * receive window. If so, we need to send an ack request along
 479      * with this.  sendWdwSeq is the seq # of the last byte that
 480      * the remote has room for
 481      */
 482     if ((diff = sp->sendWdwSeq + 1 - sp->sendSeq) <= cnt) {
 483         if (diff < cnt) { /* Won't fit exactly */
 484             eom = 0;    /* so can't send EOM */
 485             cnt = diff;
 486             partial++;
 487         }
 488         sendAckReq = 1;         /* Make him tell us new recv. window */
 489         sp->noXmitFlow = 1;     /* Don't do flow control calc. */
 490     }
 491
 492     /* trim extra bytes off the tail of the "block" after the copy */
 493     if (partial && smp) {
 494         psmp = smp;
 495         tcnt = cnt;
 496         while (tcnt && smp) { /* while there are message blocks and data */
 497             if (tcnt >= gbuf_len(smp)) {
 498                 tcnt -= gbuf_len(smp);
 499                 if (tcnt) {
 500                     psmp = smp;
 501                     smp = gbuf_cont(smp);
 502                 } else {
 503                     if (psmp != smp) { /* not the first item on the list */
 504                         gbuf_cont(psmp) = 0;
 505                         gbuf_freem(smp);
 506                         smp = psmp;
 507                     } else {
 508                         gbuf_freem(gbuf_cont(smp));
 509                         gbuf_cont(smp) = 0;
 510                     }
 511                     break;
 512                 }
 513             } else {
 514                 gbuf_wset(smp,tcnt);
 515                 if (gbuf_cont(smp)) {
 516                     gbuf_freem(gbuf_cont(smp));
 517                     gbuf_cont(smp) = 0;
 518                 }
 519                 break;
 520             }
 521         }
 522     }
 523
 524     sp->sendSeq += cnt + eom;   /* Update sendSeq field */
 525
 526     if (GT(sp->sendSeq, sp->maxSendSeq)) /* Keep track of >st ever sent */
 527         sp->maxSendSeq = sp->sendSeq;
 528
 529     if (eom)
 530         sp->f.descriptor = ADSP_EOM_BIT;
 531     else
 532         sp->f.descriptor = 0;
 533
 534     if (sendAckReq || (++sp->pktSendCnt >= sp->pktSendMax)) {
 535         /* Last packet in a series */
 536         sp->f.descriptor |= ADSP_ACK_REQ_BIT; /* We want an ack to this */
 537         sp->waitingAck = 1;     /* Flag that we're waiting */
 538         sp->sendStamp = SysTicks(); /* Save time we sent request */
 539         sp->timerSeq = sp->sendSeq; /* Save seq # we want acked */
 540         InsertTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer,
 541                         sp->rtmtInterval+TX_DLY);
 542     }
 543     return cnt + eom;
 544 }
 545
 546
 547