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