src/afs/VNOPS/afs_vnop_read.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 /*
  11  * Implements:
  12  * afs_MemRead
  13  * afs_PrefetchChunk
  14  * afs_UFSRead
  15  *
  16  */
  17
  18 #include <afsconfig.h>
  19 #include "afs/param.h"
  20
  21 RCSID
  22     ("$Header$");
  23
  24 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  25 #include "afsincludes.h"        /* Afs-based standard headers */
  26 #include "afs/afs_stats.h"      /* statistics */
  27 #include "afs/afs_cbqueue.h"
  28 #include "afs/nfsclient.h"
  29 #include "afs/afs_osidnlc.h"
  30 #include "afs/afs_osi.h"
  31
  32
  33 extern char afs_zeros[AFS_ZEROS];
  34
  35 afs_int32 maxIHint;
  36 afs_int32 nihints;              /* # of above actually in-use */
  37 afs_int32 usedihint;
  38
  39
  40 /* Imported variables */
  41 extern afs_rwlock_t afs_xdcache;
  42 extern unsigned char *afs_indexFlags;
  43 extern afs_hyper_t *afs_indexTimes;     /* Dcache entry Access times */
  44 extern afs_hyper_t afs_indexCounter;    /* Fake time for marking index */
  45
  46
  47 /* Forward declarations */
  48 void afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
  49                        struct AFS_UCRED *acred, struct vrequest *areq);
  50
  51 int
  52 afs_MemRead(register struct vcache *avc, struct uio *auio,
  53             struct AFS_UCRED *acred, daddr_t albn, struct buf **abpp,
  54             int noLock)
  55 {
  56     afs_size_t totalLength;
  57     afs_size_t transferLength;
  58     afs_size_t filePos;
  59     afs_size_t offset, len, tlen;
  60     afs_int32 trimlen;
  61     struct dcache *tdc = 0;
  62     afs_int32 error, trybusy = 1;
  63 #ifdef AFS_DARWIN80_ENV
  64     uio_t tuiop;
  65 #else
  66     struct uio tuio;
  67     struct uio *tuiop = &tuio;
  68     struct iovec *tvec;
  69 #endif
  70     afs_int32 code;
  71     struct vrequest treq;
  72
  73     AFS_STATCNT(afs_MemRead);
  74     if (avc->vc_error)
  75         return EIO;
  76
  77     /* check that we have the latest status info in the vnode cache */
  78     if ((code = afs_InitReq(&treq, acred)))
  79         return code;
  80     if (!noLock) {
  81         code = afs_VerifyVCache(avc, &treq);
  82         if (code) {
  83             code = afs_CheckCode(code, &treq, 8);       /* failed to get it */
  84             return code;
  85         }
  86     }
  87 #ifndef AFS_VM_RDWR_ENV
  88     if (AFS_NFSXLATORREQ(acred)) {
  89         if (!afs_AccessOK
  90             (avc, PRSFS_READ, &treq,
  91              CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
  92             return afs_CheckCode(EACCES, &treq, 9);
  93         }
  94     }
  95 #endif
  96
  97 #ifndef AFS_DARWIN80_ENV
  98     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
  99 #endif
 100     totalLength = AFS_UIO_RESID(auio);
 101     filePos = AFS_UIO_OFFSET(auio);
 102     afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
 103                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
 104                totalLength, ICL_TYPE_OFFSET,
 105                ICL_HANDLE_OFFSET(avc->m.Length));
 106     error = 0;
 107     transferLength = 0;
 108     if (!noLock)
 109         ObtainReadLock(&avc->lock);
 110 #if     defined(AFS_TEXT_ENV) && !defined(AFS_VM_RDWR_ENV)
 111     if (avc->flushDV.high == AFS_MAXDV && avc->flushDV.low == AFS_MAXDV) {
 112         hset(avc->flushDV, avc->m.DataVersion);
 113     }
 114 #endif
 115
 116     /*
 117      * Locks held:
 118      * avc->lock(R)
 119      */
 120     while (totalLength > 0) {
 121         /* read all of the cached info */
 122         if (filePos >= avc->m.Length)
 123             break;              /* all done */
 124         if (noLock) {
 125             if (tdc) {
 126                 ReleaseReadLock(&tdc->lock);
 127                 afs_PutDCache(tdc);
 128             }
 129             tdc = afs_FindDCache(avc, filePos);
 130             if (tdc) {
 131                 ObtainReadLock(&tdc->lock);
 132                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 133                 len = tdc->f.chunkBytes - offset;
 134             }
 135         } else {
 136             /* a tricky question: does the presence of the DFFetching flag
 137              * mean that we're fetching the latest version of the file?  No.
 138              * The server could update the file as soon as the fetch responsible
 139              * for the setting of the DFFetching flag completes.
 140              *
 141              * However, the presence of the DFFetching flag (visible under
 142              * a dcache read lock since it is set and cleared only under a
 143              * dcache write lock) means that we're fetching as good a version
 144              * as was known to this client at the time of the last call to
 145              * afs_VerifyVCache, since the latter updates the stat cache's
 146              * m.DataVersion field under a vcache write lock, and from the
 147              * time that the DFFetching flag goes on in afs_GetDCache (before
 148              * the fetch starts), to the time it goes off (after the fetch
 149              * completes), afs_GetDCache keeps at least a read lock on the
 150              * vcache entry.
 151              *
 152              * This means that if the DFFetching flag is set, we can use that
 153              * data for any reads that must come from the current version of
 154              * the file (current == m.DataVersion).
 155              *
 156              * Another way of looking at this same point is this: if we're
 157              * fetching some data and then try do an afs_VerifyVCache, the
 158              * VerifyVCache operation will not complete until after the
 159              * DFFetching flag is turned off and the dcache entry's f.versionNo
 160              * field is updated.
 161              *
 162              * Note, by the way, that if DFFetching is set,
 163              * m.DataVersion > f.versionNo (the latter is not updated until
 164              * after the fetch completes).
 165              */
 166             if (tdc) {
 167                 ReleaseReadLock(&tdc->lock);
 168                 afs_PutDCache(tdc);     /* before reusing tdc */
 169             }
 170             tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 2);
 171             ObtainReadLock(&tdc->lock);
 172             /* now, first try to start transfer, if we'll need the data.  If
 173              * data already coming, we don't need to do this, obviously.  Type
 174              * 2 requests never return a null dcache entry, btw.
 175              */
 176             if (!(tdc->dflags & DFFetching)
 177                 && !hsame(avc->m.DataVersion, tdc->f.versionNo)) {
 178                 /* have cache entry, it is not coming in now,
 179                  * and we'll need new data */
 180               tagain:
 181                 if (trybusy && !afs_BBusy()) {
 182                     struct brequest *bp;
 183                     /* daemon is not busy */
 184                     ObtainSharedLock(&tdc->mflock, 665);
 185                     if (!(tdc->mflags & DFFetchReq)) {
 186                         /* start the daemon (may already be running, however) */
 187                         UpgradeSToWLock(&tdc->mflock, 666);
 188                         tdc->mflags |= DFFetchReq;
 189                         bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
 190                                         (afs_size_t) filePos, (afs_size_t) 0,
 191                                         tdc);
 192                         if (!bp) {
 193                             tdc->mflags &= ~DFFetchReq;
 194                             trybusy = 0;        /* Avoid bkg daemon since they're too busy */
 195                             ReleaseWriteLock(&tdc->mflock);
 196                             goto tagain;
 197                         }
 198                         ConvertWToSLock(&tdc->mflock);
 199                         /* don't use bp pointer! */
 200                     }
 201                     code = 0;
 202                     ConvertSToRLock(&tdc->mflock);
 203                     while (!code && tdc->mflags & DFFetchReq) {
 204                         afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT,
 205                                    ICL_TYPE_STRING, __FILE__, ICL_TYPE_INT32,
 206                                    __LINE__, ICL_TYPE_POINTER, tdc,
 207                                    ICL_TYPE_INT32, tdc->dflags);
 208                         /* don't need waiting flag on this one */
 209                         ReleaseReadLock(&tdc->mflock);
 210                         ReleaseReadLock(&tdc->lock);
 211                         ReleaseReadLock(&avc->lock);
 212                         code = afs_osi_SleepSig(&tdc->validPos);
 213                         ObtainReadLock(&avc->lock);
 214                         ObtainReadLock(&tdc->lock);
 215                         ObtainReadLock(&tdc->mflock);
 216                     }
 217                     ReleaseReadLock(&tdc->mflock);
 218                     if (code) {
 219                         error = code;
 220                         break;
 221                     }
 222                 }
 223             }
 224             /* now data may have started flowing in (if DFFetching is on).  If
 225              * data is now streaming in, then wait for some interesting stuff.
 226              */
 227             code = 0;
 228             while (!code && (tdc->dflags & DFFetching)
 229                    && tdc->validPos <= filePos) {
 230                 /* too early: wait for DFFetching flag to vanish,
 231                  * or data to appear */
 232                 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT, ICL_TYPE_STRING,
 233                            __FILE__, ICL_TYPE_INT32, __LINE__,
 234                            ICL_TYPE_POINTER, tdc, ICL_TYPE_INT32,
 235                            tdc->dflags);
 236                 ReleaseReadLock(&tdc->lock);
 237                 ReleaseReadLock(&avc->lock);
 238                 code = afs_osi_SleepSig(&tdc->validPos);
 239                 ObtainReadLock(&avc->lock);
 240                 ObtainReadLock(&tdc->lock);
 241             }
 242             if (code) {
 243                 error = code;
 244                 break;
 245             }
 246             /* fetching flag gone, data is here, or we never tried
 247              * (BBusy for instance) */
 248             if (tdc->dflags & DFFetching) {
 249                 /* still fetching, some new data is here:
 250                  * compute length and offset */
 251                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 252                 len = tdc->validPos - filePos;
 253             } else {
 254                 /* no longer fetching, verify data version
 255                  * (avoid new GetDCache call) */
 256                 if (hsame(avc->m.DataVersion, tdc->f.versionNo)
 257                     && ((len = tdc->validPos - filePos) > 0)) {
 258                     offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 259                 } else {
 260                     /* don't have current data, so get it below */
 261                     afs_Trace3(afs_iclSetp, CM_TRACE_VERSIONNO,
 262                                ICL_TYPE_INT64, ICL_HANDLE_OFFSET(filePos),
 263                                ICL_TYPE_HYPER, &avc->m.DataVersion,
 264                                ICL_TYPE_HYPER, &tdc->f.versionNo);
 265                     ReleaseReadLock(&tdc->lock);
 266                     afs_PutDCache(tdc);
 267                     tdc = NULL;
 268                 }
 269             }
 270
 271             if (!tdc) {
 272                 /* If we get, it was not possible to start the
 273                  * background daemon. With flag == 1 afs_GetDCache
 274                  * does the FetchData rpc synchronously.
 275                  */
 276                 ReleaseReadLock(&avc->lock);
 277                 tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 1);
 278                 ObtainReadLock(&avc->lock);
 279                 if (tdc)
 280                     ObtainReadLock(&tdc->lock);
 281             }
 282         }
 283
 284         afs_Trace3(afs_iclSetp, CM_TRACE_VNODEREAD, ICL_TYPE_POINTER, tdc,
 285                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(offset),
 286                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(len));
 287         if (!tdc) {
 288             error = EIO;
 289             break;
 290         }
 291
 292         /*
 293          * Locks held:
 294          * avc->lock(R)
 295          * tdc->lock(R)
 296          */
 297
 298         if (len > totalLength)
 299             len = totalLength;  /* will read len bytes */
 300         if (len <= 0) {         /* shouldn't get here if DFFetching is on */
 301             /* read past the end of a chunk, may not be at next chunk yet, and yet
 302              * also not at eof, so may have to supply fake zeros */
 303             len = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;       /* bytes left in chunk addr space */
 304             if (len > totalLength)
 305                 len = totalLength;      /* and still within xfr request */
 306             tlen = avc->m.Length - offset;      /* and still within file */
 307             if (len > tlen)
 308                 len = tlen;
 309             if (len > AFS_ZEROS)
 310                 len = sizeof(afs_zeros);        /* and in 0 buffer */
 311 #ifdef AFS_DARWIN80_ENV
 312             trimlen = len;
 313             tuiop = afsio_darwin_partialcopy(auio, trimlen);
 314 #else
 315             afsio_copy(auio, &tuio, tvec);
 316             trimlen = len;
 317             afsio_trim(&tuio, trimlen);
 318 #endif
 319             AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
 320             if (code) {
 321                 error = code;
 322                 break;
 323             }
 324         } else {
 325             /* get the data from the mem cache */
 326
 327             /* mung uio structure to be right for this transfer */
 328 #ifdef AFS_DARWIN80_ENV
 329             trimlen = len;
 330             tuiop = afsio_darwin_partialcopy(auio, trimlen);
 331             uio_setoffset(tuiop, offset);
 332 #else
 333             afsio_copy(auio, &tuio, tvec);
 334             trimlen = len;
 335             afsio_trim(&tuio, trimlen);
 336             tuio.afsio_offset = offset;
 337 #endif
 338
 339             code = afs_MemReadUIO(tdc->f.inode, tuiop);
 340
 341             if (code) {
 342                 error = code;
 343                 break;
 344             }
 345         }
 346         /* otherwise we've read some, fixup length, etc and continue with next seg */
 347         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
 348         trimlen = len;
 349         afsio_skip(auio, trimlen);      /* update input uio structure */
 350         totalLength -= len;
 351         transferLength += len;
 352         filePos += len;
 353
 354         if (len <= 0)
 355             break;              /* surprise eof */
 356     }                           /* the whole while loop */
 357
 358     /*
 359      * Locks held:
 360      * avc->lock(R)
 361      * tdc->lock(R) if tdc
 362      */
 363
 364     /* if we make it here with tdc non-zero, then it is the last chunk we
 365      * dealt with, and we have to release it when we're done.  We hold on
 366      * to it in case we need to do a prefetch.
 367      */
 368     if (tdc) {
 369         ReleaseReadLock(&tdc->lock);
 370 #if !defined(AFS_VM_RDWR_ENV)
 371         /* try to queue prefetch, if needed */
 372         if (!noLock) {
 373             afs_PrefetchChunk(avc, tdc, acred, &treq);
 374         }
 375 #endif
 376         afs_PutDCache(tdc);
 377     }
 378     if (!noLock)
 379         ReleaseReadLock(&avc->lock);
 380 #ifdef AFS_DARWIN80_ENV
 381     uio_free(tuiop);
 382 #else
 383     osi_FreeSmallSpace(tvec);
 384 #endif
 385     error = afs_CheckCode(error, &treq, 10);
 386     return error;
 387 }
 388
 389 /* called with the dcache entry triggering the fetch, the vcache entry involved,
 390  * and a vrequest for the read call.  Marks the dcache entry as having already
 391  * triggered a prefetch, starts the prefetch going and sets the DFFetchReq
 392  * flag in the prefetched block, so that the next call to read knows to wait
 393  * for the daemon to start doing things.
 394  *
 395  * This function must be called with the vnode at least read-locked, and
 396  * no locks on the dcache, because it plays around with dcache entries.
 397  */
 398 void
 399 afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
 400                   struct AFS_UCRED *acred, struct vrequest *areq)
 401 {
 402     register struct dcache *tdc;
 403     afs_size_t offset;
 404     afs_size_t j1, j2;          /* junk vbls for GetDCache to trash */
 405
 406     offset = adc->f.chunk + 1;  /* next chunk we'll need */
 407     offset = AFS_CHUNKTOBASE(offset);   /* base of next chunk */
 408     ObtainReadLock(&adc->lock);
 409     ObtainSharedLock(&adc->mflock, 662);
 410     if (offset < avc->m.Length && !(adc->mflags & DFNextStarted)
 411         && !afs_BBusy()) {
 412         struct brequest *bp;
 413
 414         UpgradeSToWLock(&adc->mflock, 663);
 415         adc->mflags |= DFNextStarted;   /* we've tried to prefetch for this guy */
 416         ReleaseWriteLock(&adc->mflock);
 417         ReleaseReadLock(&adc->lock);
 418
 419         tdc = afs_GetDCache(avc, offset, areq, &j1, &j2, 2);    /* type 2 never returns 0 */
 420         ObtainSharedLock(&tdc->mflock, 651);
 421         if (!(tdc->mflags & DFFetchReq)) {
 422             /* ask the daemon to do the work */
 423             UpgradeSToWLock(&tdc->mflock, 652);
 424             tdc->mflags |= DFFetchReq;  /* guaranteed to be cleared by BKG or GetDCache */
 425             /* last parm (1) tells bkg daemon to do an afs_PutDCache when it is done,
 426              * since we don't want to wait for it to finish before doing so ourselves.
 427              */
 428             bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
 429                             (afs_size_t) offset, (afs_size_t) 1, tdc);
 430             if (!bp) {
 431                 /* Bkg table full; just abort non-important prefetching to avoid deadlocks */
 432                 tdc->mflags &= ~DFFetchReq;
 433                 ReleaseWriteLock(&tdc->mflock);
 434                 afs_PutDCache(tdc);
 435
 436                 /*
 437                  * DCLOCKXXX: This is a little sketchy, since someone else
 438                  * could have already started a prefetch..  In practice,
 439                  * this probably doesn't matter; at most it would cause an
 440                  * extra slot in the BKG table to be used up when someone
 441                  * prefetches this for the second time.
 442                  */
 443                 ObtainReadLock(&adc->lock);
 444                 ObtainWriteLock(&adc->mflock, 664);
 445                 adc->mflags &= ~DFNextStarted;
 446                 ReleaseWriteLock(&adc->mflock);
 447                 ReleaseReadLock(&adc->lock);
 448             } else {
 449                 ReleaseWriteLock(&tdc->mflock);
 450             }
 451         } else {
 452             ReleaseSharedLock(&tdc->mflock);
 453             afs_PutDCache(tdc);
 454         }
 455     } else {
 456         ReleaseSharedLock(&adc->mflock);
 457         ReleaseReadLock(&adc->lock);
 458     }
 459 }
 460
 461 int
 462 afs_UFSRead(register struct vcache *avc, struct uio *auio,
 463             struct AFS_UCRED *acred, daddr_t albn, struct buf **abpp,
 464             int noLock)
 465 {
 466     afs_size_t totalLength;
 467     afs_size_t transferLength;
 468     afs_size_t filePos;
 469     afs_size_t offset, len, tlen;
 470     afs_int32 trimlen;
 471     struct dcache *tdc = 0;
 472     afs_int32 error;
 473 #ifdef AFS_DARWIN80_ENV
 474     uio_t tuiop;
 475 #else
 476     struct uio tuio;
 477     struct uio *tuiop = &tuio;
 478     struct iovec *tvec;
 479 #endif
 480     struct osi_file *tfile;
 481     afs_int32 code;
 482     int trybusy = 1;
 483     struct vrequest treq;
 484
 485     AFS_STATCNT(afs_UFSRead);
 486     if (avc && avc->vc_error)
 487         return EIO;
 488
 489     /* check that we have the latest status info in the vnode cache */
 490     if ((code = afs_InitReq(&treq, acred)))
 491         return code;
 492     if (!noLock) {
 493         if (!avc)
 494             osi_Panic("null avc in afs_UFSRead");
 495         else {
 496             code = afs_VerifyVCache(avc, &treq);
 497             if (code) {
 498                 code = afs_CheckCode(code, &treq, 11);  /* failed to get it */
 499                 return code;
 500             }
 501         }
 502     }
 503 #ifndef AFS_VM_RDWR_ENV
 504     if (AFS_NFSXLATORREQ(acred)) {
 505         if (!afs_AccessOK
 506             (avc, PRSFS_READ, &treq,
 507              CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
 508             return afs_CheckCode(EACCES, &treq, 12);
 509         }
 510     }
 511 #endif
 512
 513 #ifndef AFS_DARWIN80_ENV
 514     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
 515 #endif
 516     totalLength = AFS_UIO_RESID(auio);
 517     filePos = AFS_UIO_OFFSET(auio);
 518     afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,
 519                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,
 520                totalLength, ICL_TYPE_OFFSET,
 521                ICL_HANDLE_OFFSET(avc->m.Length));
 522     error = 0;
 523     transferLength = 0;
 524     if (!noLock)
 525         ObtainReadLock(&avc->lock);
 526 #if     defined(AFS_TEXT_ENV) && !defined(AFS_VM_RDWR_ENV)
 527     if (avc->flushDV.high == AFS_MAXDV && avc->flushDV.low == AFS_MAXDV) {
 528         hset(avc->flushDV, avc->m.DataVersion);
 529     }
 530 #endif
 531
 532     while (totalLength > 0) {
 533         /* read all of the cached info */
 534         if (filePos >= avc->m.Length)
 535             break;              /* all done */
 536         if (noLock) {
 537             if (tdc) {
 538                 ReleaseReadLock(&tdc->lock);
 539                 afs_PutDCache(tdc);
 540             }
 541             tdc = afs_FindDCache(avc, filePos);
 542             if (tdc) {
 543                 ObtainReadLock(&tdc->lock);
 544                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 545                 len = tdc->validPos - filePos;
 546             }
 547         } else {
 548             /* a tricky question: does the presence of the DFFetching flag
 549              * mean that we're fetching the latest version of the file?  No.
 550              * The server could update the file as soon as the fetch responsible
 551              * for the setting of the DFFetching flag completes.
 552              *
 553              * However, the presence of the DFFetching flag (visible under
 554              * a dcache read lock since it is set and cleared only under a
 555              * dcache write lock) means that we're fetching as good a version
 556              * as was known to this client at the time of the last call to
 557              * afs_VerifyVCache, since the latter updates the stat cache's
 558              * m.DataVersion field under a vcache write lock, and from the
 559              * time that the DFFetching flag goes on in afs_GetDCache (before
 560              * the fetch starts), to the time it goes off (after the fetch
 561              * completes), afs_GetDCache keeps at least a read lock on the
 562              * vcache entry.
 563              *
 564              * This means that if the DFFetching flag is set, we can use that
 565              * data for any reads that must come from the current version of
 566              * the file (current == m.DataVersion).
 567              *
 568              * Another way of looking at this same point is this: if we're
 569              * fetching some data and then try do an afs_VerifyVCache, the
 570              * VerifyVCache operation will not complete until after the
 571              * DFFetching flag is turned off and the dcache entry's f.versionNo
 572              * field is updated.
 573              *
 574              * Note, by the way, that if DFFetching is set,
 575              * m.DataVersion > f.versionNo (the latter is not updated until
 576              * after the fetch completes).
 577              */
 578             if (tdc) {
 579                 ReleaseReadLock(&tdc->lock);
 580                 afs_PutDCache(tdc);     /* before reusing tdc */
 581             }
 582             tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 2);
 583             ObtainReadLock(&tdc->lock);
 584             /* now, first try to start transfer, if we'll need the data.  If
 585              * data already coming, we don't need to do this, obviously.  Type
 586              * 2 requests never return a null dcache entry, btw. */
 587             if (!(tdc->dflags & DFFetching)
 588                 && !hsame(avc->m.DataVersion, tdc->f.versionNo)) {
 589                 /* have cache entry, it is not coming in now, and we'll need new data */
 590               tagain:
 591                 if (trybusy && !afs_BBusy()) {
 592                     struct brequest *bp;
 593                     /* daemon is not busy */
 594                     ObtainSharedLock(&tdc->mflock, 667);
 595                     if (!(tdc->mflags & DFFetchReq)) {
 596                         UpgradeSToWLock(&tdc->mflock, 668);
 597                         tdc->mflags |= DFFetchReq;
 598                         bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
 599                                         (afs_size_t) filePos, (afs_size_t) 0,
 600                                         tdc);
 601                         if (!bp) {
 602                             /* Bkg table full; retry deadlocks */
 603                             tdc->mflags &= ~DFFetchReq;
 604                             trybusy = 0;        /* Avoid bkg daemon since they're too busy */
 605                             ReleaseWriteLock(&tdc->mflock);
 606                             goto tagain;
 607                         }
 608                         ConvertWToSLock(&tdc->mflock);
 609                     }
 610                     code = 0;
 611                     ConvertSToRLock(&tdc->mflock);
 612                     while (!code && tdc->mflags & DFFetchReq) {
 613                         afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT,
 614                                    ICL_TYPE_STRING, __FILE__, ICL_TYPE_INT32,
 615                                    __LINE__, ICL_TYPE_POINTER, tdc,
 616                                    ICL_TYPE_INT32, tdc->dflags);
 617                         /* don't need waiting flag on this one */
 618                         ReleaseReadLock(&tdc->mflock);
 619                         ReleaseReadLock(&tdc->lock);
 620                         ReleaseReadLock(&avc->lock);
 621                         code = afs_osi_SleepSig(&tdc->validPos);
 622                         ObtainReadLock(&avc->lock);
 623                         ObtainReadLock(&tdc->lock);
 624                         ObtainReadLock(&tdc->mflock);
 625                     }
 626                     ReleaseReadLock(&tdc->mflock);
 627                     if (code) {
 628                         error = code;
 629                         break;
 630                     }
 631                 }
 632             }
 633             /* now data may have started flowing in (if DFFetching is on).  If
 634              * data is now streaming in, then wait for some interesting stuff.
 635              */
 636             code = 0;
 637             while (!code && (tdc->dflags & DFFetching)
 638                    && tdc->validPos <= filePos) {
 639                 /* too early: wait for DFFetching flag to vanish,
 640                  * or data to appear */
 641                 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT, ICL_TYPE_STRING,
 642                            __FILE__, ICL_TYPE_INT32, __LINE__,
 643                            ICL_TYPE_POINTER, tdc, ICL_TYPE_INT32,
 644                            tdc->dflags);
 645                 ReleaseReadLock(&tdc->lock);
 646                 ReleaseReadLock(&avc->lock);
 647                 code = afs_osi_SleepSig(&tdc->validPos);
 648                 ObtainReadLock(&avc->lock);
 649                 ObtainReadLock(&tdc->lock);
 650             }
 651             if (code) {
 652                 error = code;
 653                 break;
 654             }
 655             /* fetching flag gone, data is here, or we never tried
 656              * (BBusy for instance) */
 657             if (tdc->dflags & DFFetching) {
 658                 /* still fetching, some new data is here:
 659                  * compute length and offset */
 660                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 661                 len = tdc->validPos - filePos;
 662             } else {
 663                 /* no longer fetching, verify data version (avoid new
 664                  * GetDCache call) */
 665                 if (hsame(avc->m.DataVersion, tdc->f.versionNo)
 666                     && ((len = tdc->validPos - filePos) > 0)) {
 667                     offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 668                 } else {
 669                     /* don't have current data, so get it below */
 670                     afs_Trace3(afs_iclSetp, CM_TRACE_VERSIONNO,
 671                                ICL_TYPE_INT64, ICL_HANDLE_OFFSET(filePos),
 672                                ICL_TYPE_HYPER, &avc->m.DataVersion,
 673                                ICL_TYPE_HYPER, &tdc->f.versionNo);
 674                     ReleaseReadLock(&tdc->lock);
 675                     afs_PutDCache(tdc);
 676                     tdc = NULL;
 677                 }
 678             }
 679
 680             if (!tdc) {
 681                 /* If we get, it was not possible to start the
 682                  * background daemon. With flag == 1 afs_GetDCache
 683                  * does the FetchData rpc synchronously.
 684                  */
 685                 ReleaseReadLock(&avc->lock);
 686                 tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 1);
 687                 ObtainReadLock(&avc->lock);
 688                 if (tdc)
 689                     ObtainReadLock(&tdc->lock);
 690             }
 691         }
 692
 693         if (!tdc) {
 694             error = EIO;
 695             break;
 696         }
 697         len = tdc->validPos - filePos;
 698         afs_Trace3(afs_iclSetp, CM_TRACE_VNODEREAD, ICL_TYPE_POINTER, tdc,
 699                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(offset),
 700                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(len));
 701         if (len > totalLength)
 702             len = totalLength;  /* will read len bytes */
 703         if (len <= 0) {         /* shouldn't get here if DFFetching is on */
 704             afs_Trace4(afs_iclSetp, CM_TRACE_VNODEREAD2, ICL_TYPE_POINTER,
 705                        tdc, ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(tdc->validPos),
 706                        ICL_TYPE_INT32, tdc->f.chunkBytes, ICL_TYPE_INT32,
 707                        tdc->dflags);
 708             /* read past the end of a chunk, may not be at next chunk yet, and yet
 709              * also not at eof, so may have to supply fake zeros */
 710             len = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;       /* bytes left in chunk addr space */
 711             if (len > totalLength)
 712                 len = totalLength;      /* and still within xfr request */
 713             tlen = avc->m.Length - offset;      /* and still within file */
 714             if (len > tlen)
 715                 len = tlen;
 716             if (len > AFS_ZEROS)
 717                 len = sizeof(afs_zeros);        /* and in 0 buffer */
 718 #ifdef AFS_DARWIN80_ENV
 719             trimlen = len;
 720             tuiop = afsio_darwin_partialcopy(auio, trimlen);
 721 #else
 722             afsio_copy(auio, &tuio, tvec);
 723             trimlen = len;
 724             afsio_trim(&tuio, trimlen);
 725 #endif
 726             AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
 727             if (code) {
 728                 error = code;
 729                 break;
 730             }
 731         } else {
 732             /* get the data from the file */
 733 #ifdef IHINT
 734             if (tfile = tdc->ihint) {
 735                 if (tdc->f.inode != tfile->inum) {
 736                     afs_warn("afs_UFSRead: %x hint mismatch tdc %d inum %d\n",
 737                              tdc, tdc->f.inode, tfile->inum);
 738                     osi_UFSClose(tfile);
 739                     tdc->ihint = tfile = 0;
 740                     nihints--;
 741                 }
 742             }
 743             if (tfile != 0) {
 744                 usedihint++;
 745             } else
 746 #endif /* IHINT */
 747
 748                 tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
 749 #ifdef AFS_DARWIN80_ENV
 750             trimlen = len;
 751             tuiop = afsio_darwin_partialcopy(auio, trimlen);
 752             uio_setoffset(tuiop, offset);
 753 #else
 754             /* mung uio structure to be right for this transfer */
 755             afsio_copy(auio, &tuio, tvec);
 756             trimlen = len;
 757             afsio_trim(&tuio, trimlen);
 758             tuio.afsio_offset = offset;
 759 #endif
 760
 761 #if defined(AFS_AIX41_ENV)
 762             AFS_GUNLOCK();
 763             code =
 764                 VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, &tuio, NULL, NULL,
 765                           NULL, afs_osi_credp);
 766             AFS_GLOCK();
 767 #elif defined(AFS_AIX32_ENV)
 768             code =
 769                 VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, &tuio, NULL, NULL);
 770             /* Flush all JFS pages now for big performance gain in big file cases
 771              * If we do something like this, must check to be sure that AFS file
 772              * isn't mmapped... see afs_gn_map() for why.
 773              */
 774 /*
 775           if (tfile->vnode->v_gnode && tfile->vnode->v_gnode->gn_seg) {
 776  many different ways to do similar things:
 777    so far, the best performing one is #2, but #1 might match it if we
 778    straighten out the confusion regarding which pages to flush.  It
 779    really does matter.
 780    1.       vm_flushp(tfile->vnode->v_gnode->gn_seg, 0, len/PAGESIZE - 1);
 781    2.       vm_releasep(tfile->vnode->v_gnode->gn_seg, offset/PAGESIZE,
 782                         (len + PAGESIZE-1)/PAGESIZE);
 783    3.       vms_inactive(tfile->vnode->v_gnode->gn_seg) Doesn't work correctly
 784    4.       vms_delete(tfile->vnode->v_gnode->gn_seg) probably also fails
 785             tfile->vnode->v_gnode->gn_seg = NULL;
 786    5.       deletep
 787    6.       ipgrlse
 788    7.       ifreeseg
 789           Unfortunately, this seems to cause frequent "cache corruption" episodes.
 790             vm_releasep(tfile->vnode->v_gnode->gn_seg, offset/PAGESIZE,
 791                         (len + PAGESIZE-1)/PAGESIZE);
 792           }
 793 */
 794 #elif defined(AFS_AIX_ENV)
 795             code =
 796                 VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, (off_t) & offset,
 797                           &tuio, NULL, NULL, -1);
 798 #elif defined(AFS_SUN5_ENV)
 799             AFS_GUNLOCK();
 800 #ifdef AFS_SUN510_ENV
 801             {
 802                 caller_context_t ct;
 803
 804                 VOP_RWLOCK(tfile->vnode, 0, &ct);
 805                 code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp, &ct);
 806                 VOP_RWUNLOCK(tfile->vnode, 0, &ct);
 807             }
 808 #else
 809             VOP_RWLOCK(tfile->vnode, 0);
 810             code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
 811             VOP_RWUNLOCK(tfile->vnode, 0);
 812 #endif
 813             AFS_GLOCK();
 814 #elif defined(AFS_SGI_ENV)
 815             AFS_GUNLOCK();
 816             AFS_VOP_RWLOCK(tfile->vnode, VRWLOCK_READ);
 817             AFS_VOP_READ(tfile->vnode, &tuio, IO_ISLOCKED, afs_osi_credp,
 818                          code);
 819             AFS_VOP_RWUNLOCK(tfile->vnode, VRWLOCK_READ);
 820             AFS_GLOCK();
 821 #elif defined(AFS_OSF_ENV)
 822             tuio.uio_rw = UIO_READ;
 823             AFS_GUNLOCK();
 824             VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp, code);
 825             AFS_GLOCK();
 826 #elif defined(AFS_HPUX100_ENV)
 827             AFS_GUNLOCK();
 828             code = VOP_RDWR(tfile->vnode, &tuio, UIO_READ, 0, afs_osi_credp);
 829             AFS_GLOCK();
 830 #elif defined(AFS_LINUX20_ENV)
 831             AFS_GUNLOCK();
 832             code = osi_rdwr(tfile, &tuio, UIO_READ);
 833             AFS_GLOCK();
 834 #elif defined(AFS_DARWIN_ENV)
 835             AFS_GUNLOCK();
 836             VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
 837             code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
 838             VOP_UNLOCK(tfile->vnode, 0, current_proc());
 839             AFS_GLOCK();
 840 #elif defined(AFS_DARWIN80_ENV)
 841             AFS_GUNLOCK();
 842             code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_ctxp);
 843             AFS_GLOCK();
 844 #elif defined(AFS_DARWIN_ENV)
 845             AFS_GUNLOCK();
 846             VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
 847             code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
 848             VOP_UNLOCK(tfile->vnode, 0, current_proc());
 849             AFS_GLOCK();
 850 #elif defined(AFS_FBSD50_ENV)
 851             AFS_GUNLOCK();
 852             VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
 853             code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
 854             VOP_UNLOCK(tfile->vnode, 0, curthread);
 855             AFS_GLOCK();
 856 #elif defined(AFS_XBSD_ENV)
 857             AFS_GUNLOCK();
 858             VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
 859             code = VOP_READ(tfile->vnode, &tuio, 0, afs_osi_credp);
 860             VOP_UNLOCK(tfile->vnode, 0, curproc);
 861             AFS_GLOCK();
 862 #else
 863             code = VOP_RDWR(tfile->vnode, &tuio, UIO_READ, 0, afs_osi_credp);
 864 #endif
 865
 866 #ifdef IHINT
 867             if (!tdc->ihint && nihints < maxIHint) {
 868                 tdc->ihint = tfile;
 869                 nihints++;
 870             } else
 871 #endif /* IHINT */
 872                 osi_UFSClose(tfile);
 873
 874             if (code) {
 875                 error = code;
 876                 break;
 877             }
 878         }
 879         /* otherwise we've read some, fixup length, etc and continue with next seg */
 880         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
 881         trimlen = len;
 882         afsio_skip(auio, trimlen);      /* update input uio structure */
 883         totalLength -= len;
 884         transferLength += len;
 885         filePos += len;
 886         if (len <= 0)
 887             break;              /* surprise eof */
 888     }
 889
 890     /* if we make it here with tdc non-zero, then it is the last chunk we
 891      * dealt with, and we have to release it when we're done.  We hold on
 892      * to it in case we need to do a prefetch, obviously.
 893      */
 894     if (tdc) {
 895         ReleaseReadLock(&tdc->lock);
 896 #if !defined(AFS_VM_RDWR_ENV)
 897         /* try to queue prefetch, if needed */
 898         if (!noLock) {
 899             if (!(tdc->mflags & DFNextStarted))
 900                 afs_PrefetchChunk(avc, tdc, acred, &treq);
 901         }
 902 #endif
 903         afs_PutDCache(tdc);
 904     }
 905     if (!noLock)
 906         ReleaseReadLock(&avc->lock);
 907
 908 #ifdef AFS_DARWIN80_ENV
 909     uio_free(tuiop);
 910 #else
 911     osi_FreeSmallSpace(tvec);
 912 #endif
 913     error = afs_CheckCode(error, &treq, 13);
 914     return error;
 915 }