src/rx/rx_rdwr.c

   1  /*
   2   * Copyright 2000, International Business Machines Corporation and others.
   3   * All Rights Reserved.
   4   *
   5   * This software has been released under the terms of the IBM Public
   6   * License.  For details, see the LICENSE file in the top-level source
   7   * directory or online at http://www.openafs.org/dl/license10.html
   8   */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 #ifdef KERNEL
  14 # ifndef UKERNEL
  15 #  ifdef RX_KERNEL_TRACE
  16 #   include "rx_kcommon.h"
  17 #  endif
  18 #  if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
  19 #   include "afs/sysincludes.h"
  20 #  else
  21 #   include "h/types.h"
  22 #   include "h/time.h"
  23 #   include "h/stat.h"
  24 #   if defined(AFS_AIX_ENV) || defined(AFS_AUX_ENV) || defined(AFS_SUN5_ENV)
  25 #    include "h/systm.h"
  26 #   endif
  27 #   ifdef       AFS_OSF_ENV
  28 #    include <net/net_globals.h>
  29 #   endif /* AFS_OSF_ENV */
  30 #   ifdef AFS_LINUX20_ENV
  31 #    include "h/socket.h"
  32 #   endif
  33 #   include "netinet/in.h"
  34 #   if defined(AFS_SGI_ENV)
  35 #    include "afs/sysincludes.h"
  36 #   endif
  37 #  endif
  38 #  include "afs/afs_args.h"
  39 #  if   (defined(AFS_AUX_ENV) || defined(AFS_AIX_ENV))
  40 #   include "h/systm.h"
  41 #  endif
  42 # else /* !UKERNEL */
  43 #  include "afs/sysincludes.h"
  44 # endif /* !UKERNEL */
  45
  46 # ifdef RXDEBUG
  47 #  undef RXDEBUG                        /* turn off debugging */
  48 # endif /* RXDEBUG */
  49
  50 # include "afs/afs_osi.h"
  51 # include "rx_kmutex.h"
  52 # include "rx/rx_kernel.h"
  53 # include "afs/lock.h"
  54 #else /* KERNEL */
  55 # include <roken.h>
  56 #endif /* KERNEL */
  57
  58 #include "rx.h"
  59 #include "rx_clock.h"
  60 #include "rx_queue.h"
  61 #include "rx_globals.h"
  62
  63 #ifdef RX_LOCKS_DB
  64 /* rxdb_fileID is used to identify the lock location, along with line#. */
  65 static int rxdb_fileID = RXDB_FILE_RX_RDWR;
  66 #endif /* RX_LOCKS_DB */
  67 /* rxi_ReadProc -- internal version.
  68  *
  69  * LOCKS USED -- called at netpri
  70  */
  71 int
  72 rxi_ReadProc(struct rx_call *call, char *buf,
  73              int nbytes)
  74 {
  75     struct rx_packet *cp = call->currentPacket;
  76     struct rx_packet *rp;
  77     int requestCount;
  78     unsigned int t;
  79
  80 /* XXXX took out clock_NewTime from here.  Was it needed? */
  81     requestCount = nbytes;
  82
  83     /* Free any packets from the last call to ReadvProc/WritevProc */
  84     if (queue_IsNotEmpty(&call->iovq)) {
  85 #ifdef RXDEBUG_PACKET
  86         call->iovqc -=
  87 #endif /* RXDEBUG_PACKET */
  88             rxi_FreePackets(0, &call->iovq);
  89     }
  90
  91     do {
  92         if (call->nLeft == 0) {
  93             /* Get next packet */
  94             MUTEX_ENTER(&call->lock);
  95             for (;;) {
  96                 if (call->error || (call->mode != RX_MODE_RECEIVING)) {
  97                     if (call->error) {
  98                         call->mode = RX_MODE_ERROR;
  99                         MUTEX_EXIT(&call->lock);
 100                         return 0;
 101                     }
 102                     if (call->mode == RX_MODE_SENDING) {
 103                         MUTEX_EXIT(&call->lock);
 104                         rxi_FlushWrite(call);
 105                         MUTEX_ENTER(&call->lock);
 106                         continue;
 107                     }
 108                 }
 109                 if (queue_IsNotEmpty(&call->rq)) {
 110                     /* Check that next packet available is next in sequence */
 111                     rp = queue_First(&call->rq, rx_packet);
 112                     if (rp->header.seq == call->rnext) {
 113                         afs_int32 error;
 114                         struct rx_connection *conn = call->conn;
 115                         queue_Remove(rp);
 116 #ifdef RX_TRACK_PACKETS
 117                         rp->flags &= ~RX_PKTFLAG_RQ;
 118 #endif
 119 #ifdef RXDEBUG_PACKET
 120                         call->rqc--;
 121 #endif /* RXDEBUG_PACKET */
 122
 123                         /* RXS_CheckPacket called to undo RXS_PreparePacket's
 124                          * work.  It may reduce the length of the packet by up
 125                          * to conn->maxTrailerSize, to reflect the length of the
 126                          * data + the header. */
 127                         if ((error =
 128                              RXS_CheckPacket(conn->securityObject, call,
 129                                              rp))) {
 130                             /* Used to merely shut down the call, but now we
 131                              * shut down the whole connection since this may
 132                              * indicate an attempt to hijack it */
 133
 134                             MUTEX_EXIT(&call->lock);
 135                             rxi_ConnectionError(conn, error);
 136                             MUTEX_ENTER(&conn->conn_data_lock);
 137                             rp = rxi_SendConnectionAbort(conn, rp, 0, 0);
 138                             MUTEX_EXIT(&conn->conn_data_lock);
 139                             rxi_FreePacket(rp);
 140
 141                             return 0;
 142                         }
 143                         call->rnext++;
 144                         cp = call->currentPacket = rp;
 145 #ifdef RX_TRACK_PACKETS
 146                         call->currentPacket->flags |= RX_PKTFLAG_CP;
 147 #endif
 148                         call->curvec = 1;       /* 0th vec is always header */
 149                         /* begin at the beginning [ more or less ], continue
 150                          * on until the end, then stop. */
 151                         call->curpos =
 152                             (char *)cp->wirevec[1].iov_base +
 153                             call->conn->securityHeaderSize;
 154                         call->curlen =
 155                             cp->wirevec[1].iov_len -
 156                             call->conn->securityHeaderSize;
 157
 158                         /* Notice that this code works correctly if the data
 159                          * size is 0 (which it may be--no reply arguments from
 160                          * server, for example).  This relies heavily on the
 161                          * fact that the code below immediately frees the packet
 162                          * (no yields, etc.).  If it didn't, this would be a
 163                          * problem because a value of zero for call->nLeft
 164                          * normally means that there is no read packet */
 165                         call->nLeft = cp->length;
 166                         hadd32(call->bytesRcvd, cp->length);
 167
 168                         /* Send a hard ack for every rxi_HardAckRate+1 packets
 169                          * consumed. Otherwise schedule an event to send
 170                          * the hard ack later on.
 171                          */
 172                         call->nHardAcks++;
 173                         if (!(call->flags & RX_CALL_RECEIVE_DONE)) {
 174                             if (call->nHardAcks > (u_short) rxi_HardAckRate) {
 175                                 rxevent_Cancel(call->delayedAckEvent, call,
 176                                                RX_CALL_REFCOUNT_DELAY);
 177                                 rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
 178                             } else {
 179                                 /* Delay to consolidate ack packets */
 180                                 rxi_PostDelayedAckEvent(call,
 181                                                         &rx_hardAckDelay);
 182                             }
 183                         }
 184                         break;
 185                     }
 186                 }
 187
 188                 /*
 189                  * If we reach this point either we have no packets in the
 190                  * receive queue or the next packet in the queue is not the
 191                  * one we are looking for.  There is nothing else for us to
 192                  * do but wait for another packet to arrive.
 193                  */
 194
 195                 /* Are there ever going to be any more packets? */
 196                 if (call->flags & RX_CALL_RECEIVE_DONE) {
 197                     MUTEX_EXIT(&call->lock);
 198                     return requestCount - nbytes;
 199                 }
 200                 /* Wait for in-sequence packet */
 201                 call->flags |= RX_CALL_READER_WAIT;
 202                 clock_NewTime();
 203                 call->startWait = clock_Sec();
 204                 while (call->flags & RX_CALL_READER_WAIT) {
 205 #ifdef  RX_ENABLE_LOCKS
 206                     CV_WAIT(&call->cv_rq, &call->lock);
 207 #else
 208                     osi_rxSleep(&call->rq);
 209 #endif
 210                 }
 211                 cp = call->currentPacket;
 212
 213                 call->startWait = 0;
 214 #ifdef RX_ENABLE_LOCKS
 215                 if (call->error) {
 216                     MUTEX_EXIT(&call->lock);
 217                     return 0;
 218                 }
 219 #endif /* RX_ENABLE_LOCKS */
 220             }
 221             MUTEX_EXIT(&call->lock);
 222         } else
 223             /* osi_Assert(cp); */
 224             /* MTUXXX  this should be replaced by some error-recovery code before shipping */
 225             /* yes, the following block is allowed to be the ELSE clause (or not) */
 226             /* It's possible for call->nLeft to be smaller than any particular
 227              * iov_len.  Usually, recvmsg doesn't change the iov_len, since it
 228              * reflects the size of the buffer.  We have to keep track of the
 229              * number of bytes read in the length field of the packet struct.  On
 230              * the final portion of a received packet, it's almost certain that
 231              * call->nLeft will be smaller than the final buffer. */
 232             while (nbytes && cp) {
 233                 t = MIN((int)call->curlen, nbytes);
 234                 t = MIN(t, (int)call->nLeft);
 235                 memcpy(buf, call->curpos, t);
 236                 buf += t;
 237                 nbytes -= t;
 238                 call->curpos += t;
 239                 call->curlen -= t;
 240                 call->nLeft -= t;
 241
 242                 if (!call->nLeft) {
 243                     /* out of packet.  Get another one. */
 244 #ifdef RX_TRACK_PACKETS
 245                     call->currentPacket->flags &= ~RX_PKTFLAG_CP;
 246 #endif
 247                     rxi_FreePacket(cp);
 248                     cp = call->currentPacket = (struct rx_packet *)0;
 249                 } else if (!call->curlen) {
 250                     /* need to get another struct iov */
 251                     if (++call->curvec >= cp->niovecs) {
 252                         /* current packet is exhausted, get ready for another */
 253                         /* don't worry about curvec and stuff, they get set somewhere else */
 254 #ifdef RX_TRACK_PACKETS
 255                         call->currentPacket->flags &= ~RX_PKTFLAG_CP;
 256 #endif
 257                         rxi_FreePacket(cp);
 258                         cp = call->currentPacket = (struct rx_packet *)0;
 259                         call->nLeft = 0;
 260                     } else {
 261                         call->curpos =
 262                             (char *)cp->wirevec[call->curvec].iov_base;
 263                         call->curlen = cp->wirevec[call->curvec].iov_len;
 264                     }
 265                 }
 266             }
 267         if (!nbytes) {
 268             /* user buffer is full, return */
 269             return requestCount;
 270         }
 271
 272     } while (nbytes);
 273
 274     return requestCount;
 275 }
 276
 277 int
 278 rx_ReadProc(struct rx_call *call, char *buf, int nbytes)
 279 {
 280     int bytes;
 281     int tcurlen;
 282     int tnLeft;
 283     char *tcurpos;
 284     SPLVAR;
 285
 286     /* Free any packets from the last call to ReadvProc/WritevProc */
 287     if (!queue_IsEmpty(&call->iovq)) {
 288 #ifdef RXDEBUG_PACKET
 289         call->iovqc -=
 290 #endif /* RXDEBUG_PACKET */
 291             rxi_FreePackets(0, &call->iovq);
 292     }
 293
 294     /*
 295      * Most common case, all of the data is in the current iovec.
 296      * We are relying on nLeft being zero unless the call is in receive mode.
 297      */
 298     tcurlen = call->curlen;
 299     tnLeft = call->nLeft;
 300     if (!call->error && tcurlen > nbytes && tnLeft > nbytes) {
 301         tcurpos = call->curpos;
 302         memcpy(buf, tcurpos, nbytes);
 303
 304         call->curpos = tcurpos + nbytes;
 305         call->curlen = tcurlen - nbytes;
 306         call->nLeft = tnLeft - nbytes;
 307
 308         if (!call->nLeft && call->currentPacket != NULL) {
 309             /* out of packet.  Get another one. */
 310             rxi_FreePacket(call->currentPacket);
 311             call->currentPacket = (struct rx_packet *)0;
 312         }
 313         return nbytes;
 314     }
 315
 316     NETPRI;
 317     bytes = rxi_ReadProc(call, buf, nbytes);
 318     USERPRI;
 319     return bytes;
 320 }
 321
 322 /* Optimization for unmarshalling 32 bit integers */
 323 int
 324 rx_ReadProc32(struct rx_call *call, afs_int32 * value)
 325 {
 326     int bytes;
 327     int tcurlen;
 328     int tnLeft;
 329     char *tcurpos;
 330     SPLVAR;
 331
 332     /* Free any packets from the last call to ReadvProc/WritevProc */
 333     if (!queue_IsEmpty(&call->iovq)) {
 334 #ifdef RXDEBUG_PACKET
 335         call->iovqc -=
 336 #endif /* RXDEBUG_PACKET */
 337             rxi_FreePackets(0, &call->iovq);
 338     }
 339
 340     /*
 341      * Most common case, all of the data is in the current iovec.
 342      * We are relying on nLeft being zero unless the call is in receive mode.
 343      */
 344     tcurlen = call->curlen;
 345     tnLeft = call->nLeft;
 346     if (!call->error && tcurlen >= sizeof(afs_int32)
 347         && tnLeft >= sizeof(afs_int32)) {
 348         tcurpos = call->curpos;
 349
 350         memcpy((char *)value, tcurpos, sizeof(afs_int32));
 351
 352         call->curpos = tcurpos + sizeof(afs_int32);
 353         call->curlen = (u_short)(tcurlen - sizeof(afs_int32));
 354         call->nLeft = (u_short)(tnLeft - sizeof(afs_int32));
 355         if (!call->nLeft && call->currentPacket != NULL) {
 356             /* out of packet.  Get another one. */
 357             rxi_FreePacket(call->currentPacket);
 358             call->currentPacket = (struct rx_packet *)0;
 359         }
 360         return sizeof(afs_int32);
 361     }
 362
 363     NETPRI;
 364     bytes = rxi_ReadProc(call, (char *)value, sizeof(afs_int32));
 365     USERPRI;
 366
 367     return bytes;
 368 }
 369
 370 /* rxi_FillReadVec
 371  *
 372  * Uses packets in the receive queue to fill in as much of the
 373  * current iovec as possible. Does not block if it runs out
 374  * of packets to complete the iovec. Return true if an ack packet
 375  * was sent, otherwise return false */
 376 int
 377 rxi_FillReadVec(struct rx_call *call, afs_uint32 serial)
 378 {
 379     int didConsume = 0;
 380     int didHardAck = 0;
 381     unsigned int t;
 382     struct rx_packet *rp;
 383     struct rx_packet *curp;
 384     struct iovec *call_iov;
 385     struct iovec *cur_iov = NULL;
 386
 387     curp = call->currentPacket;
 388     if (curp) {
 389         cur_iov = &curp->wirevec[call->curvec];
 390     }
 391     call_iov = &call->iov[call->iovNext];
 392
 393     while (!call->error && call->iovNBytes && call->iovNext < call->iovMax) {
 394         if (call->nLeft == 0) {
 395             /* Get next packet */
 396             if (queue_IsNotEmpty(&call->rq)) {
 397                 /* Check that next packet available is next in sequence */
 398                 rp = queue_First(&call->rq, rx_packet);
 399                 if (rp->header.seq == call->rnext) {
 400                     afs_int32 error;
 401                     struct rx_connection *conn = call->conn;
 402                     queue_Remove(rp);
 403 #ifdef RX_TRACK_PACKETS
 404                     rp->flags &= ~RX_PKTFLAG_RQ;
 405 #endif
 406 #ifdef RXDEBUG_PACKET
 407                     call->rqc--;
 408 #endif /* RXDEBUG_PACKET */
 409
 410                     /* RXS_CheckPacket called to undo RXS_PreparePacket's
 411                      * work.  It may reduce the length of the packet by up
 412                      * to conn->maxTrailerSize, to reflect the length of the
 413                      * data + the header. */
 414                     if ((error =
 415                          RXS_CheckPacket(conn->securityObject, call, rp))) {
 416                         /* Used to merely shut down the call, but now we
 417                          * shut down the whole connection since this may
 418                          * indicate an attempt to hijack it */
 419
 420                         MUTEX_EXIT(&call->lock);
 421                         rxi_ConnectionError(conn, error);
 422                         MUTEX_ENTER(&conn->conn_data_lock);
 423                         rp = rxi_SendConnectionAbort(conn, rp, 0, 0);
 424                         MUTEX_EXIT(&conn->conn_data_lock);
 425                         rxi_FreePacket(rp);
 426                         MUTEX_ENTER(&call->lock);
 427
 428                         return 1;
 429                     }
 430                     call->rnext++;
 431                     curp = call->currentPacket = rp;
 432 #ifdef RX_TRACK_PACKETS
 433                     call->currentPacket->flags |= RX_PKTFLAG_CP;
 434 #endif
 435                     call->curvec = 1;   /* 0th vec is always header */
 436                     cur_iov = &curp->wirevec[1];
 437                     /* begin at the beginning [ more or less ], continue
 438                      * on until the end, then stop. */
 439                     call->curpos =
 440                         (char *)curp->wirevec[1].iov_base +
 441                         call->conn->securityHeaderSize;
 442                     call->curlen =
 443                         curp->wirevec[1].iov_len -
 444                         call->conn->securityHeaderSize;
 445
 446                     /* Notice that this code works correctly if the data
 447                      * size is 0 (which it may be--no reply arguments from
 448                      * server, for example).  This relies heavily on the
 449                      * fact that the code below immediately frees the packet
 450                      * (no yields, etc.).  If it didn't, this would be a
 451                      * problem because a value of zero for call->nLeft
 452                      * normally means that there is no read packet */
 453                     call->nLeft = curp->length;
 454                     hadd32(call->bytesRcvd, curp->length);
 455
 456                     /* Send a hard ack for every rxi_HardAckRate+1 packets
 457                      * consumed. Otherwise schedule an event to send
 458                      * the hard ack later on.
 459                      */
 460                     call->nHardAcks++;
 461                     didConsume = 1;
 462                     continue;
 463                 }
 464             }
 465             break;
 466         }
 467
 468         /* It's possible for call->nLeft to be smaller than any particular
 469          * iov_len.  Usually, recvmsg doesn't change the iov_len, since it
 470          * reflects the size of the buffer.  We have to keep track of the
 471          * number of bytes read in the length field of the packet struct.  On
 472          * the final portion of a received packet, it's almost certain that
 473          * call->nLeft will be smaller than the final buffer. */
 474         while (call->iovNBytes && call->iovNext < call->iovMax && curp) {
 475
 476             t = MIN((int)call->curlen, call->iovNBytes);
 477             t = MIN(t, (int)call->nLeft);
 478             call_iov->iov_base = call->curpos;
 479             call_iov->iov_len = t;
 480             call_iov++;
 481             call->iovNext++;
 482             call->iovNBytes -= t;
 483             call->curpos += t;
 484             call->curlen -= t;
 485             call->nLeft -= t;
 486
 487             if (!call->nLeft) {
 488                 /* out of packet.  Get another one. */
 489 #ifdef RX_TRACK_PACKETS
 490                 curp->flags &= ~RX_PKTFLAG_CP;
 491                 curp->flags |= RX_PKTFLAG_IOVQ;
 492 #endif
 493                 queue_Append(&call->iovq, curp);
 494 #ifdef RXDEBUG_PACKET
 495                 call->iovqc++;
 496 #endif /* RXDEBUG_PACKET */
 497                 curp = call->currentPacket = (struct rx_packet *)0;
 498             } else if (!call->curlen) {
 499                 /* need to get another struct iov */
 500                 if (++call->curvec >= curp->niovecs) {
 501                     /* current packet is exhausted, get ready for another */
 502                     /* don't worry about curvec and stuff, they get set somewhere else */
 503 #ifdef RX_TRACK_PACKETS
 504                     curp->flags &= ~RX_PKTFLAG_CP;
 505                     curp->flags |= RX_PKTFLAG_IOVQ;
 506 #endif
 507                     queue_Append(&call->iovq, curp);
 508 #ifdef RXDEBUG_PACKET
 509                     call->iovqc++;
 510 #endif /* RXDEBUG_PACKET */
 511                     curp = call->currentPacket = (struct rx_packet *)0;
 512                     call->nLeft = 0;
 513                 } else {
 514                     cur_iov++;
 515                     call->curpos = (char *)cur_iov->iov_base;
 516                     call->curlen = cur_iov->iov_len;
 517                 }
 518             }
 519         }
 520     }
 521
 522     /* If we consumed any packets then check whether we need to
 523      * send a hard ack. */
 524     if (didConsume && (!(call->flags & RX_CALL_RECEIVE_DONE))) {
 525         if (call->nHardAcks > (u_short) rxi_HardAckRate) {
 526             rxevent_Cancel(call->delayedAckEvent, call,
 527                            RX_CALL_REFCOUNT_DELAY);
 528             rxi_SendAck(call, 0, serial, RX_ACK_DELAY, 0);
 529             didHardAck = 1;
 530         } else {
 531             /* Delay to consolidate ack packets */
 532             rxi_PostDelayedAckEvent(call, &rx_hardAckDelay);
 533         }
 534     }
 535     return didHardAck;
 536 }
 537
 538
 539 /* rxi_ReadvProc -- internal version.
 540  *
 541  * Fills in an iovec with pointers to the packet buffers. All packets
 542  * except the last packet (new current packet) are moved to the iovq
 543  * while the application is processing the data.
 544  *
 545  * LOCKS USED -- called at netpri.
 546  */
 547 int
 548 rxi_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
 549               int nbytes)
 550 {
 551     int bytes;
 552
 553     /* Free any packets from the last call to ReadvProc/WritevProc */
 554     if (queue_IsNotEmpty(&call->iovq)) {
 555 #ifdef RXDEBUG_PACKET
 556         call->iovqc -=
 557 #endif /* RXDEBUG_PACKET */
 558             rxi_FreePackets(0, &call->iovq);
 559     }
 560
 561     if (call->mode == RX_MODE_SENDING) {
 562         rxi_FlushWrite(call);
 563     }
 564
 565     MUTEX_ENTER(&call->lock);
 566     if (call->error)
 567         goto error;
 568
 569     /* Get whatever data is currently available in the receive queue.
 570      * If rxi_FillReadVec sends an ack packet then it is possible
 571      * that we will receive more data while we drop the call lock
 572      * to send the packet. Set the RX_CALL_IOVEC_WAIT flag
 573      * here to avoid a race with the receive thread if we send
 574      * hard acks in rxi_FillReadVec. */
 575     call->flags |= RX_CALL_IOVEC_WAIT;
 576     call->iovNBytes = nbytes;
 577     call->iovMax = maxio;
 578     call->iovNext = 0;
 579     call->iov = iov;
 580     rxi_FillReadVec(call, 0);
 581
 582     /* if we need more data then sleep until the receive thread has
 583      * filled in the rest. */
 584     if (!call->error && call->iovNBytes && call->iovNext < call->iovMax
 585         && !(call->flags & RX_CALL_RECEIVE_DONE)) {
 586         call->flags |= RX_CALL_READER_WAIT;
 587         clock_NewTime();
 588         call->startWait = clock_Sec();
 589         while (call->flags & RX_CALL_READER_WAIT) {
 590 #ifdef  RX_ENABLE_LOCKS
 591             CV_WAIT(&call->cv_rq, &call->lock);
 592 #else
 593             osi_rxSleep(&call->rq);
 594 #endif
 595         }
 596         call->startWait = 0;
 597     }
 598     call->flags &= ~RX_CALL_IOVEC_WAIT;
 599
 600     if (call->error)
 601         goto error;
 602
 603     call->iov = NULL;
 604     *nio = call->iovNext;
 605     bytes = nbytes - call->iovNBytes;
 606     MUTEX_EXIT(&call->lock);
 607     return bytes;
 608
 609   error:
 610     MUTEX_EXIT(&call->lock);
 611     call->mode = RX_MODE_ERROR;
 612     return 0;
 613 }
 614
 615 int
 616 rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
 617              int nbytes)
 618 {
 619     int bytes;
 620     SPLVAR;
 621
 622     NETPRI;
 623     bytes = rxi_ReadvProc(call, iov, nio, maxio, nbytes);
 624     USERPRI;
 625     return bytes;
 626 }
 627
 628 /* rxi_WriteProc -- internal version.
 629  *
 630  * LOCKS USED -- called at netpri
 631  */
 632
 633 int
 634 rxi_WriteProc(struct rx_call *call, char *buf,
 635               int nbytes)
 636 {
 637     struct rx_connection *conn = call->conn;
 638     struct rx_packet *cp = call->currentPacket;
 639     unsigned int t;
 640     int requestCount = nbytes;
 641
 642     /* Free any packets from the last call to ReadvProc/WritevProc */
 643     if (queue_IsNotEmpty(&call->iovq)) {
 644 #ifdef RXDEBUG_PACKET
 645         call->iovqc -=
 646 #endif /* RXDEBUG_PACKET */
 647             rxi_FreePackets(0, &call->iovq);
 648     }
 649
 650     if (call->mode != RX_MODE_SENDING) {
 651         if ((conn->type == RX_SERVER_CONNECTION)
 652             && (call->mode == RX_MODE_RECEIVING)) {
 653             call->mode = RX_MODE_SENDING;
 654             if (cp) {
 655 #ifdef RX_TRACK_PACKETS
 656                 cp->flags &= ~RX_PKTFLAG_CP;
 657 #endif
 658                 rxi_FreePacket(cp);
 659                 cp = call->currentPacket = (struct rx_packet *)0;
 660                 call->nLeft = 0;
 661                 call->nFree = 0;
 662             }
 663         } else {
 664             return 0;
 665         }
 666     }
 667
 668     /* Loop condition is checked at end, so that a write of 0 bytes
 669      * will force a packet to be created--specially for the case where
 670      * there are 0 bytes on the stream, but we must send a packet
 671      * anyway. */
 672     do {
 673         if (call->nFree == 0) {
 674             MUTEX_ENTER(&call->lock);
 675             cp = call->currentPacket;
 676             if (call->error)
 677                 call->mode = RX_MODE_ERROR;
 678             if (!call->error && cp) {
 679                 /* Clear the current packet now so that if
 680                  * we are forced to wait and drop the lock
 681                  * the packet we are planning on using
 682                  * cannot be freed.
 683                  */
 684 #ifdef RX_TRACK_PACKETS
 685                 cp->flags &= ~RX_PKTFLAG_CP;
 686 #endif
 687                 call->currentPacket = (struct rx_packet *)0;
 688                 clock_NewTime();        /* Bogus:  need new time package */
 689                 /* The 0, below, specifies that it is not the last packet:
 690                  * there will be others. PrepareSendPacket may
 691                  * alter the packet length by up to
 692                  * conn->securityMaxTrailerSize */
 693                 hadd32(call->bytesSent, cp->length);
 694                 rxi_PrepareSendPacket(call, cp, 0);
 695 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
 696                 /* PrepareSendPacket drops the call lock */
 697                 rxi_WaitforTQBusy(call);
 698 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
 699 #ifdef RX_TRACK_PACKETS
 700                 cp->flags |= RX_PKTFLAG_TQ;
 701 #endif
 702                 queue_Append(&call->tq, cp);
 703 #ifdef RXDEBUG_PACKET
 704                 call->tqc++;
 705 #endif /* RXDEBUG_PACKET */
 706                 cp = (struct rx_packet *)0;
 707                 /* If the call is in recovery, let it exhaust its current
 708                  * retransmit queue before forcing it to send new packets
 709                  */
 710                 if (!(call->flags & (RX_CALL_FAST_RECOVER))) {
 711                     rxi_Start(call, 0);
 712                 }
 713             } else if (cp) {
 714 #ifdef RX_TRACK_PACKETS
 715                 cp->flags &= ~RX_PKTFLAG_CP;
 716 #endif
 717                 rxi_FreePacket(cp);
 718                 cp = call->currentPacket = (struct rx_packet *)0;
 719             }
 720             /* Wait for transmit window to open up */
 721             while (!call->error
 722                    && call->tnext + 1 > call->tfirst + (2 * call->twind)) {
 723                 clock_NewTime();
 724                 call->startWait = clock_Sec();
 725
 726 #ifdef  RX_ENABLE_LOCKS
 727                 CV_WAIT(&call->cv_twind, &call->lock);
 728 #else
 729                 call->flags |= RX_CALL_WAIT_WINDOW_ALLOC;
 730                 osi_rxSleep(&call->twind);
 731 #endif
 732
 733                 call->startWait = 0;
 734 #ifdef RX_ENABLE_LOCKS
 735                 if (call->error) {
 736                     call->mode = RX_MODE_ERROR;
 737                     MUTEX_EXIT(&call->lock);
 738                     return 0;
 739                 }
 740 #endif /* RX_ENABLE_LOCKS */
 741             }
 742             if ((cp = rxi_AllocSendPacket(call, nbytes))) {
 743 #ifdef RX_TRACK_PACKETS
 744                 cp->flags |= RX_PKTFLAG_CP;
 745 #endif
 746                 call->currentPacket = cp;
 747                 call->nFree = cp->length;
 748                 call->curvec = 1;       /* 0th vec is always header */
 749                 /* begin at the beginning [ more or less ], continue
 750                  * on until the end, then stop. */
 751                 call->curpos =
 752                     (char *)cp->wirevec[1].iov_base +
 753                     call->conn->securityHeaderSize;
 754                 call->curlen =
 755                     cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
 756             }
 757             if (call->error) {
 758                 call->mode = RX_MODE_ERROR;
 759                 if (cp) {
 760 #ifdef RX_TRACK_PACKETS
 761                     cp->flags &= ~RX_PKTFLAG_CP;
 762 #endif
 763                     rxi_FreePacket(cp);
 764                     call->currentPacket = NULL;
 765                 }
 766                 MUTEX_EXIT(&call->lock);
 767                 return 0;
 768             }
 769             MUTEX_EXIT(&call->lock);
 770         }
 771
 772         if (cp && (int)call->nFree < nbytes) {
 773             /* Try to extend the current buffer */
 774             int len, mud;
 775             len = cp->length;
 776             mud = rx_MaxUserDataSize(call);
 777             if (mud > len) {
 778                 int want;
 779                 want = MIN(nbytes - (int)call->nFree, mud - len);
 780                 rxi_AllocDataBuf(cp, want, RX_PACKET_CLASS_SEND_CBUF);
 781                 if (cp->length > (unsigned)mud)
 782                     cp->length = mud;
 783                 call->nFree += (cp->length - len);
 784             }
 785         }
 786
 787         /* If the remaining bytes fit in the buffer, then store them
 788          * and return.  Don't ship a buffer that's full immediately to
 789          * the peer--we don't know if it's the last buffer yet */
 790
 791         if (!cp) {
 792             call->nFree = 0;
 793         }
 794
 795         while (nbytes && call->nFree) {
 796
 797             t = MIN((int)call->curlen, nbytes);
 798             t = MIN((int)call->nFree, t);
 799             memcpy(call->curpos, buf, t);
 800             buf += t;
 801             nbytes -= t;
 802             call->curpos += t;
 803             call->curlen -= (u_short)t;
 804             call->nFree -= (u_short)t;
 805
 806             if (!call->curlen) {
 807                 /* need to get another struct iov */
 808                 if (++call->curvec >= cp->niovecs) {
 809                     /* current packet is full, extend or send it */
 810                     call->nFree = 0;
 811                 } else {
 812                     call->curpos = (char *)cp->wirevec[call->curvec].iov_base;
 813                     call->curlen = cp->wirevec[call->curvec].iov_len;
 814                 }
 815             }
 816         }                       /* while bytes to send and room to send them */
 817
 818         /* might be out of space now */
 819         if (!nbytes) {
 820             return requestCount;
 821         } else;                 /* more data to send, so get another packet and keep going */
 822     } while (nbytes);
 823
 824     return requestCount - nbytes;
 825 }
 826
 827 int
 828 rx_WriteProc(struct rx_call *call, char *buf, int nbytes)
 829 {
 830     int bytes;
 831     int tcurlen;
 832     int tnFree;
 833     char *tcurpos;
 834     SPLVAR;
 835
 836     /* Free any packets from the last call to ReadvProc/WritevProc */
 837     if (queue_IsNotEmpty(&call->iovq)) {
 838 #ifdef RXDEBUG_PACKET
 839         call->iovqc -=
 840 #endif /* RXDEBUG_PACKET */
 841             rxi_FreePackets(0, &call->iovq);
 842     }
 843
 844     /*
 845      * Most common case: all of the data fits in the current iovec.
 846      * We are relying on nFree being zero unless the call is in send mode.
 847      */
 848     tcurlen = (int)call->curlen;
 849     tnFree = (int)call->nFree;
 850     if (!call->error && tcurlen >= nbytes && tnFree >= nbytes) {
 851         tcurpos = call->curpos;
 852
 853         memcpy(tcurpos, buf, nbytes);
 854         call->curpos = tcurpos + nbytes;
 855         call->curlen = (u_short)(tcurlen - nbytes);
 856         call->nFree = (u_short)(tnFree - nbytes);
 857         return nbytes;
 858     }
 859
 860     NETPRI;
 861     bytes = rxi_WriteProc(call, buf, nbytes);
 862     USERPRI;
 863     return bytes;
 864 }
 865
 866 /* Optimization for marshalling 32 bit arguments */
 867 int
 868 rx_WriteProc32(struct rx_call *call, afs_int32 * value)
 869 {
 870     int bytes;
 871     int tcurlen;
 872     int tnFree;
 873     char *tcurpos;
 874     SPLVAR;
 875
 876     if (queue_IsNotEmpty(&call->iovq)) {
 877 #ifdef RXDEBUG_PACKET
 878         call->iovqc -=
 879 #endif /* RXDEBUG_PACKET */
 880             rxi_FreePackets(0, &call->iovq);
 881     }
 882
 883     /*
 884      * Most common case: all of the data fits in the current iovec.
 885      * We are relying on nFree being zero unless the call is in send mode.
 886      */
 887     tcurlen = call->curlen;
 888     tnFree = call->nFree;
 889     if (!call->error && tcurlen >= sizeof(afs_int32)
 890         && tnFree >= sizeof(afs_int32)) {
 891         tcurpos = call->curpos;
 892
 893         if (!((size_t)tcurpos & (sizeof(afs_int32) - 1))) {
 894             *((afs_int32 *) (tcurpos)) = *value;
 895         } else {
 896             memcpy(tcurpos, (char *)value, sizeof(afs_int32));
 897         }
 898         call->curpos = tcurpos + sizeof(afs_int32);
 899         call->curlen = (u_short)(tcurlen - sizeof(afs_int32));
 900         call->nFree = (u_short)(tnFree - sizeof(afs_int32));
 901         return sizeof(afs_int32);
 902     }
 903
 904     NETPRI;
 905     bytes = rxi_WriteProc(call, (char *)value, sizeof(afs_int32));
 906     USERPRI;
 907     return bytes;
 908 }
 909
 910 /* rxi_WritevAlloc -- internal version.
 911  *
 912  * Fill in an iovec to point to data in packet buffers. The application
 913  * calls rxi_WritevProc when the buffers are full.
 914  *
 915  * LOCKS USED -- called at netpri.
 916  */
 917
 918 static int
 919 rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
 920                 int nbytes)
 921 {
 922     struct rx_connection *conn = call->conn;
 923     struct rx_packet *cp = call->currentPacket;
 924     int requestCount;
 925     int nextio;
 926     /* Temporary values, real work is done in rxi_WritevProc */
 927     int tnFree;
 928     unsigned int tcurvec;
 929     char *tcurpos;
 930     int tcurlen;
 931
 932     requestCount = nbytes;
 933     nextio = 0;
 934
 935     /* Free any packets from the last call to ReadvProc/WritevProc */
 936     if (queue_IsNotEmpty(&call->iovq)) {
 937 #ifdef RXDEBUG_PACKET
 938         call->iovqc -=
 939 #endif /* RXDEBUG_PACKET */
 940             rxi_FreePackets(0, &call->iovq);
 941     }
 942
 943     if (call->mode != RX_MODE_SENDING) {
 944         if ((conn->type == RX_SERVER_CONNECTION)
 945             && (call->mode == RX_MODE_RECEIVING)) {
 946             call->mode = RX_MODE_SENDING;
 947             if (cp) {
 948 #ifdef RX_TRACK_PACKETS
 949                 cp->flags &= ~RX_PKTFLAG_CP;
 950 #endif
 951                 rxi_FreePacket(cp);
 952                 cp = call->currentPacket = (struct rx_packet *)0;
 953                 call->nLeft = 0;
 954                 call->nFree = 0;
 955             }
 956         } else {
 957             return 0;
 958         }
 959     }
 960
 961     /* Set up the iovec to point to data in packet buffers. */
 962     tnFree = call->nFree;
 963     tcurvec = call->curvec;
 964     tcurpos = call->curpos;
 965     tcurlen = call->curlen;
 966     do {
 967         int t;
 968
 969         if (tnFree == 0) {
 970             /* current packet is full, allocate a new one */
 971             MUTEX_ENTER(&call->lock);
 972             cp = rxi_AllocSendPacket(call, nbytes);
 973             MUTEX_EXIT(&call->lock);
 974             if (cp == NULL) {
 975                 /* out of space, return what we have */
 976                 *nio = nextio;
 977                 return requestCount - nbytes;
 978             }
 979 #ifdef RX_TRACK_PACKETS
 980             cp->flags |= RX_PKTFLAG_IOVQ;
 981 #endif
 982             queue_Append(&call->iovq, cp);
 983 #ifdef RXDEBUG_PACKET
 984             call->iovqc++;
 985 #endif /* RXDEBUG_PACKET */
 986             tnFree = cp->length;
 987             tcurvec = 1;
 988             tcurpos =
 989                 (char *)cp->wirevec[1].iov_base +
 990                 call->conn->securityHeaderSize;
 991             tcurlen = cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
 992         }
 993
 994         if (tnFree < nbytes) {
 995             /* try to extend the current packet */
 996             int len, mud;
 997             len = cp->length;
 998             mud = rx_MaxUserDataSize(call);
 999             if (mud > len) {
1000                 int want;
1001                 want = MIN(nbytes - tnFree, mud - len);
1002                 rxi_AllocDataBuf(cp, want, RX_PACKET_CLASS_SEND_CBUF);
1003                 if (cp->length > (unsigned)mud)
1004                     cp->length = mud;
1005                 tnFree += (cp->length - len);
1006                 if (cp == call->currentPacket) {
1007                     call->nFree += (cp->length - len);
1008                 }
1009             }
1010         }
1011
1012         /* fill in the next entry in the iovec */
1013         t = MIN(tcurlen, nbytes);
1014         t = MIN(tnFree, t);
1015         iov[nextio].iov_base = tcurpos;
1016         iov[nextio].iov_len = t;
1017         nbytes -= t;
1018         tcurpos += t;
1019         tcurlen -= t;
1020         tnFree -= t;
1021         nextio++;
1022
1023         if (!tcurlen) {
1024             /* need to get another struct iov */
1025             if (++tcurvec >= cp->niovecs) {
1026                 /* current packet is full, extend it or move on to next packet */
1027                 tnFree = 0;
1028             } else {
1029                 tcurpos = (char *)cp->wirevec[tcurvec].iov_base;
1030                 tcurlen = cp->wirevec[tcurvec].iov_len;
1031             }
1032         }
1033     } while (nbytes && nextio < maxio);
1034     *nio = nextio;
1035     return requestCount - nbytes;
1036 }
1037
1038 int
1039 rx_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
1040                int nbytes)
1041 {
1042     int bytes;
1043     SPLVAR;
1044
1045     NETPRI;
1046     bytes = rxi_WritevAlloc(call, iov, nio, maxio, nbytes);
1047     USERPRI;
1048     return bytes;
1049 }
1050
1051 /* rxi_WritevProc -- internal version.
1052  *
1053  * Send buffers allocated in rxi_WritevAlloc.
1054  *
1055  * LOCKS USED -- called at netpri.
1056  */
1057 int
1058 rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
1059 {
1060     struct rx_packet *cp = NULL;
1061 #ifdef RX_TRACK_PACKETS
1062     struct rx_packet *p, *np;
1063 #endif
1064     int nextio;
1065     int requestCount;
1066     struct rx_queue tmpq;
1067 #ifdef RXDEBUG_PACKET
1068     u_short tmpqc;
1069 #endif
1070
1071     requestCount = nbytes;
1072     nextio = 0;
1073
1074     MUTEX_ENTER(&call->lock);
1075     if (call->error) {
1076         call->mode = RX_MODE_ERROR;
1077     } else if (call->mode != RX_MODE_SENDING) {
1078         call->error = RX_PROTOCOL_ERROR;
1079     }
1080 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
1081     rxi_WaitforTQBusy(call);
1082 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1083     cp = call->currentPacket;
1084
1085     if (call->error) {
1086         call->mode = RX_MODE_ERROR;
1087         MUTEX_EXIT(&call->lock);
1088         if (cp) {
1089 #ifdef RX_TRACK_PACKETS
1090             cp->flags &= ~RX_PKTFLAG_CP;
1091             cp->flags |= RX_PKTFLAG_IOVQ;
1092 #endif
1093             queue_Prepend(&call->iovq, cp);
1094 #ifdef RXDEBUG_PACKET
1095             call->iovqc++;
1096 #endif /* RXDEBUG_PACKET */
1097             call->currentPacket = (struct rx_packet *)0;
1098         }
1099 #ifdef RXDEBUG_PACKET
1100         call->iovqc -=
1101 #endif /* RXDEBUG_PACKET */
1102             rxi_FreePackets(0, &call->iovq);
1103         return 0;
1104     }
1105
1106     /* Loop through the I/O vector adjusting packet pointers.
1107      * Place full packets back onto the iovq once they are ready
1108      * to send. Set RX_PROTOCOL_ERROR if any problems are found in
1109      * the iovec. We put the loop condition at the end to ensure that
1110      * a zero length write will push a short packet. */
1111     nextio = 0;
1112     queue_Init(&tmpq);
1113 #ifdef RXDEBUG_PACKET
1114     tmpqc = 0;
1115 #endif /* RXDEBUG_PACKET */
1116     do {
1117         if (call->nFree == 0 && cp) {
1118             clock_NewTime();    /* Bogus:  need new time package */
1119             /* The 0, below, specifies that it is not the last packet:
1120              * there will be others. PrepareSendPacket may
1121              * alter the packet length by up to
1122              * conn->securityMaxTrailerSize */
1123             hadd32(call->bytesSent, cp->length);
1124             rxi_PrepareSendPacket(call, cp, 0);
1125 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1126             /* PrepareSendPacket drops the call lock */
1127             rxi_WaitforTQBusy(call);
1128 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1129             queue_Append(&tmpq, cp);
1130 #ifdef RXDEBUG_PACKET
1131             tmpqc++;
1132 #endif /* RXDEBUG_PACKET */
1133             cp = call->currentPacket = (struct rx_packet *)0;
1134
1135             /* The head of the iovq is now the current packet */
1136             if (nbytes) {
1137                 if (queue_IsEmpty(&call->iovq)) {
1138                     MUTEX_EXIT(&call->lock);
1139                     call->error = RX_PROTOCOL_ERROR;
1140 #ifdef RXDEBUG_PACKET
1141                     tmpqc -=
1142 #endif /* RXDEBUG_PACKET */
1143                         rxi_FreePackets(0, &tmpq);
1144                     return 0;
1145                 }
1146                 cp = queue_First(&call->iovq, rx_packet);
1147                 queue_Remove(cp);
1148 #ifdef RX_TRACK_PACKETS
1149                 cp->flags &= ~RX_PKTFLAG_IOVQ;
1150 #endif
1151 #ifdef RXDEBUG_PACKET
1152                 call->iovqc--;
1153 #endif /* RXDEBUG_PACKET */
1154 #ifdef RX_TRACK_PACKETS
1155                 cp->flags |= RX_PKTFLAG_CP;
1156 #endif
1157                 call->currentPacket = cp;
1158                 call->nFree = cp->length;
1159                 call->curvec = 1;
1160                 call->curpos =
1161                     (char *)cp->wirevec[1].iov_base +
1162                     call->conn->securityHeaderSize;
1163                 call->curlen =
1164                     cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
1165             }
1166         }
1167
1168         if (nbytes) {
1169             /* The next iovec should point to the current position */
1170             if (iov[nextio].iov_base != call->curpos
1171                 || iov[nextio].iov_len > (int)call->curlen) {
1172                 call->error = RX_PROTOCOL_ERROR;
1173                 MUTEX_EXIT(&call->lock);
1174                 if (cp) {
1175 #ifdef RX_TRACK_PACKETS
1176                     cp->flags &= ~RX_PKTFLAG_CP;
1177 #endif
1178                     queue_Prepend(&tmpq, cp);
1179 #ifdef RXDEBUG_PACKET
1180                     tmpqc++;
1181 #endif /* RXDEBUG_PACKET */
1182                     cp = call->currentPacket = (struct rx_packet *)0;
1183                 }
1184 #ifdef RXDEBUG_PACKET
1185                 tmpqc -=
1186 #endif /* RXDEBUG_PACKET */
1187                     rxi_FreePackets(0, &tmpq);
1188                 return 0;
1189             }
1190             nbytes -= iov[nextio].iov_len;
1191             call->curpos += iov[nextio].iov_len;
1192             call->curlen -= iov[nextio].iov_len;
1193             call->nFree -= iov[nextio].iov_len;
1194             nextio++;
1195             if (call->curlen == 0) {
1196                 if (++call->curvec > cp->niovecs) {
1197                     call->nFree = 0;
1198                 } else {
1199                     call->curpos = (char *)cp->wirevec[call->curvec].iov_base;
1200                     call->curlen = cp->wirevec[call->curvec].iov_len;
1201                 }
1202             }
1203         }
1204     } while (nbytes && nextio < nio);
1205
1206     /* Move the packets from the temporary queue onto the transmit queue.
1207      * We may end up with more than call->twind packets on the queue. */
1208
1209 #ifdef RX_TRACK_PACKETS
1210     for (queue_Scan(&tmpq, p, np, rx_packet))
1211     {
1212         p->flags |= RX_PKTFLAG_TQ;
1213     }
1214 #endif
1215
1216     if (call->error)
1217         call->mode = RX_MODE_ERROR;
1218
1219     queue_SpliceAppend(&call->tq, &tmpq);
1220
1221     /* If the call is in recovery, let it exhaust its current retransmit
1222      * queue before forcing it to send new packets
1223      */
1224     if (!(call->flags & RX_CALL_FAST_RECOVER)) {
1225         rxi_Start(call, 0);
1226     }
1227
1228     /* Wait for the length of the transmit queue to fall below call->twind */
1229     while (!call->error && call->tnext + 1 > call->tfirst + (2 * call->twind)) {
1230         clock_NewTime();
1231         call->startWait = clock_Sec();
1232 #ifdef  RX_ENABLE_LOCKS
1233         CV_WAIT(&call->cv_twind, &call->lock);
1234 #else
1235         call->flags |= RX_CALL_WAIT_WINDOW_ALLOC;
1236         osi_rxSleep(&call->twind);
1237 #endif
1238         call->startWait = 0;
1239     }
1240
1241     /* cp is no longer valid since we may have given up the lock */
1242     cp = call->currentPacket;
1243
1244     if (call->error) {
1245         call->mode = RX_MODE_ERROR;
1246         call->currentPacket = NULL;
1247         MUTEX_EXIT(&call->lock);
1248         if (cp) {
1249 #ifdef RX_TRACK_PACKETS
1250             cp->flags &= ~RX_PKTFLAG_CP;
1251 #endif
1252             rxi_FreePacket(cp);
1253         }
1254         return 0;
1255     }
1256     MUTEX_EXIT(&call->lock);
1257
1258     return requestCount - nbytes;
1259 }
1260
1261 int
1262 rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
1263 {
1264     int bytes;
1265     SPLVAR;
1266
1267     NETPRI;
1268     bytes = rxi_WritevProc(call, iov, nio, nbytes);
1269     USERPRI;
1270     return bytes;
1271 }
1272
1273 /* Flush any buffered data to the stream, switch to read mode
1274  * (clients) or to EOF mode (servers)
1275  *
1276  * LOCKS HELD: called at netpri.
1277  */
1278 void
1279 rxi_FlushWrite(struct rx_call *call)
1280 {
1281     struct rx_packet *cp = NULL;
1282
1283     /* Free any packets from the last call to ReadvProc/WritevProc */
1284     if (queue_IsNotEmpty(&call->iovq)) {
1285 #ifdef RXDEBUG_PACKET
1286         call->iovqc -=
1287 #endif /* RXDEBUG_PACKET */
1288             rxi_FreePackets(0, &call->iovq);
1289     }
1290
1291     if (call->mode == RX_MODE_SENDING) {
1292
1293         call->mode =
1294             (call->conn->type ==
1295              RX_CLIENT_CONNECTION ? RX_MODE_RECEIVING : RX_MODE_EOF);
1296
1297 #ifdef RX_KERNEL_TRACE
1298         {
1299             int glockOwner = ISAFS_GLOCK();
1300             if (!glockOwner)
1301                 AFS_GLOCK();
1302             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1303                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1304                        call);
1305             if (!glockOwner)
1306                 AFS_GUNLOCK();
1307         }
1308 #endif
1309
1310         MUTEX_ENTER(&call->lock);
1311         if (call->error)
1312             call->mode = RX_MODE_ERROR;
1313
1314         cp = call->currentPacket;
1315
1316         if (cp) {
1317             /* cp->length is only supposed to be the user's data */
1318             /* cp->length was already set to (then-current)
1319              * MaxUserDataSize or less. */
1320 #ifdef RX_TRACK_PACKETS
1321             cp->flags &= ~RX_PKTFLAG_CP;
1322 #endif
1323             cp->length -= call->nFree;
1324             call->currentPacket = (struct rx_packet *)0;
1325             call->nFree = 0;
1326         } else {
1327             cp = rxi_AllocSendPacket(call, 0);
1328             if (!cp) {
1329                 /* Mode can no longer be MODE_SENDING */
1330                 return;
1331             }
1332             cp->length = 0;
1333             cp->niovecs = 2;    /* header + space for rxkad stuff */
1334             call->nFree = 0;
1335         }
1336
1337         /* The 1 specifies that this is the last packet */
1338         hadd32(call->bytesSent, cp->length);
1339         rxi_PrepareSendPacket(call, cp, 1);
1340 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1341         /* PrepareSendPacket drops the call lock */
1342         rxi_WaitforTQBusy(call);
1343 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1344 #ifdef RX_TRACK_PACKETS
1345         cp->flags |= RX_PKTFLAG_TQ;
1346 #endif
1347         queue_Append(&call->tq, cp);
1348 #ifdef RXDEBUG_PACKET
1349         call->tqc++;
1350 #endif /* RXDEBUG_PACKET */
1351
1352         /* If the call is in recovery, let it exhaust its current retransmit
1353          * queue before forcing it to send new packets
1354          */
1355         if (!(call->flags & RX_CALL_FAST_RECOVER)) {
1356             rxi_Start(call, 0);
1357         }
1358         MUTEX_EXIT(&call->lock);
1359     }
1360 }
1361
1362 /* Flush any buffered data to the stream, switch to read mode
1363  * (clients) or to EOF mode (servers) */
1364 void
1365 rx_FlushWrite(struct rx_call *call)
1366 {
1367     SPLVAR;
1368     NETPRI;
1369     rxi_FlushWrite(call);
1370     USERPRI;
1371 }