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