Tidy up uio_t meaning
[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
22 #include "afs/sysincludes.h"    /* Standard vendor system headers */
23 #include "afsincludes.h"        /* Afs-based standard headers */
24 #include "afs/afs_stats.h"      /* statistics */
25 #include "afs/afs_cbqueue.h"
26 #include "afs/nfsclient.h"
27 #include "afs/afs_osidnlc.h"
28 #include "afs/afs_osi.h"
29
30
31 extern char afs_zeros[AFS_ZEROS];
32
33 /* Imported variables */
34 extern afs_rwlock_t afs_xdcache;
35 extern unsigned char *afs_indexFlags;
36 extern afs_hyper_t *afs_indexTimes;     /* Dcache entry Access times */
37 extern afs_hyper_t afs_indexCounter;    /* Fake time for marking index */
38
39
40 /* Forward declarations */
41 void afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
42                        afs_ucred_t *acred, struct vrequest *areq);
43
44 int
45 afs_read(struct vcache *avc, struct uio *auio, afs_ucred_t *acred,
46          int noLock)
47 {
48     afs_size_t totalLength;
49     afs_size_t transferLength;
50     afs_size_t filePos;
51     afs_size_t offset, len, tlen;
52     afs_int32 trimlen;
53     struct dcache *tdc = 0;
54     afs_int32 error, trybusy = 1;
55 #ifdef AFS_DARWIN80_ENV
56     uio_t tuiop = NULL;
57 #else
58     struct uio tuio;
59     struct uio *tuiop = &tuio;
60     struct iovec *tvec = NULL;
61 #endif
62     afs_int32 code;
63     struct vrequest treq;
64
65     AFS_STATCNT(afs_read);
66
67     if (avc->vc_error)
68         return EIO;
69
70     AFS_DISCON_LOCK();
71
72     /* check that we have the latest status info in the vnode cache */
73     if ((code = afs_InitReq(&treq, acred)))
74         goto out;
75
76     if (!noLock) {
77         if (!avc)
78             osi_Panic("null avc in afs_GenericRead");
79
80         code = afs_VerifyVCache(avc, &treq);
81         if (code) {
82             code = afs_CheckCode(code, &treq, 8);       /* failed to get it */
83             goto out;
84         }
85     }
86 #ifndef AFS_VM_RDWR_ENV
87     if (AFS_NFSXLATORREQ(acred)) {
88         if (!afs_AccessOK
89             (avc, PRSFS_READ, &treq,
90              CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
91             code = afs_CheckCode(EACCES, &treq, 9);
92             goto out;
93         }
94     }
95 #endif
96
97 #ifndef AFS_DARWIN80_ENV
98     tvec = 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->f.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->f.m.DataVersion);
113     }
114 #endif
115
116     /*
117      * Locks held:
118      * avc->lock(R)
119      */
120     if (filePos >= avc->f.m.Length) {
121         if (len > AFS_ZEROS)
122             len = sizeof(afs_zeros);    /* and in 0 buffer */
123         len = 0;
124 #ifdef AFS_DARWIN80_ENV
125         trimlen = len;
126         tuiop = afsio_darwin_partialcopy(auio, trimlen);
127 #else
128         afsio_copy(auio, &tuio, tvec);
129         trimlen = len;
130         afsio_trim(&tuio, trimlen);
131 #endif
132         AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
133     }
134
135     while (avc->f.m.Length > 0 && totalLength > 0) {
136         /* read all of the cached info */
137         if (filePos >= avc->f.m.Length)
138             break;              /* all done */
139         if (noLock) {
140             if (tdc) {
141                 ReleaseReadLock(&tdc->lock);
142                 afs_PutDCache(tdc);
143             }
144             tdc = afs_FindDCache(avc, filePos);
145             if (tdc) {
146                 ObtainReadLock(&tdc->lock);
147                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
148                 len = tdc->validPos - filePos;
149             }
150         } else {
151             /* a tricky question: does the presence of the DFFetching flag
152              * mean that we're fetching the latest version of the file?  No.
153              * The server could update the file as soon as the fetch responsible
154              * for the setting of the DFFetching flag completes.
155              * 
156              * However, the presence of the DFFetching flag (visible under
157              * a dcache read lock since it is set and cleared only under a
158              * dcache write lock) means that we're fetching as good a version
159              * as was known to this client at the time of the last call to
160              * afs_VerifyVCache, since the latter updates the stat cache's
161              * m.DataVersion field under a vcache write lock, and from the
162              * time that the DFFetching flag goes on in afs_GetDCache (before
163              * the fetch starts), to the time it goes off (after the fetch
164              * completes), afs_GetDCache keeps at least a read lock on the
165              * vcache entry.
166              * 
167              * This means that if the DFFetching flag is set, we can use that
168              * data for any reads that must come from the current version of
169              * the file (current == m.DataVersion).
170              * 
171              * Another way of looking at this same point is this: if we're
172              * fetching some data and then try do an afs_VerifyVCache, the
173              * VerifyVCache operation will not complete until after the
174              * DFFetching flag is turned off and the dcache entry's f.versionNo
175              * field is updated.
176              * 
177              * Note, by the way, that if DFFetching is set,
178              * m.DataVersion > f.versionNo (the latter is not updated until
179              * after the fetch completes).
180              */
181             if (tdc) {
182                 ReleaseReadLock(&tdc->lock);
183                 afs_PutDCache(tdc);     /* before reusing tdc */
184             }
185             tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 2);
186             if (!tdc) {
187                 error = ENETDOWN;
188                 break;
189             }
190
191             ObtainReadLock(&tdc->lock);
192             /* now, first try to start transfer, if we'll need the data.  If
193              * data already coming, we don't need to do this, obviously.  Type
194              * 2 requests never return a null dcache entry, btw.
195              */
196             if (!(tdc->dflags & DFFetching)
197                 && !hsame(avc->f.m.DataVersion, tdc->f.versionNo)) {
198                 /* have cache entry, it is not coming in now,
199                  * and we'll need new data */
200               tagain:
201                 if (trybusy && !afs_BBusy()) {
202                     struct brequest *bp;
203                     /* daemon is not busy */
204                     ObtainSharedLock(&tdc->mflock, 665);
205                     if (!(tdc->mflags & DFFetchReq)) {
206                         /* start the daemon (may already be running, however) */
207                         UpgradeSToWLock(&tdc->mflock, 666);
208                         tdc->mflags |= DFFetchReq;
209                         bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
210                                         (afs_size_t) filePos, (afs_size_t) 0,
211                                         tdc, NULL, NULL);
212                         if (!bp) {
213                             /* Bkg table full; retry deadlocks */
214                             tdc->mflags &= ~DFFetchReq;
215                             trybusy = 0;        /* Avoid bkg daemon since they're too busy */
216                             ReleaseWriteLock(&tdc->mflock);
217                             goto tagain;
218                         }
219                         ConvertWToSLock(&tdc->mflock);
220                         /* don't use bp pointer! */
221                     }
222                     code = 0;
223                     ConvertSToRLock(&tdc->mflock);
224                     while (!code && tdc->mflags & DFFetchReq) {
225                         afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT,
226                                    ICL_TYPE_STRING, __FILE__, ICL_TYPE_INT32,
227                                    __LINE__, ICL_TYPE_POINTER, tdc,
228                                    ICL_TYPE_INT32, tdc->dflags);
229                         /* don't need waiting flag on this one */
230                         ReleaseReadLock(&tdc->mflock);
231                         ReleaseReadLock(&tdc->lock);
232                         ReleaseReadLock(&avc->lock);
233                         code = afs_osi_SleepSig(&tdc->validPos);
234                         ObtainReadLock(&avc->lock);
235                         ObtainReadLock(&tdc->lock);
236                         ObtainReadLock(&tdc->mflock);
237                     }
238                     ReleaseReadLock(&tdc->mflock);
239                     if (code) {
240                         error = code;
241                         break;
242                     }
243                 }
244             }
245             /* now data may have started flowing in (if DFFetching is on).  If
246              * data is now streaming in, then wait for some interesting stuff.
247              */
248             code = 0;
249             while (!code && (tdc->dflags & DFFetching)
250                    && tdc->validPos <= filePos) {
251                 /* too early: wait for DFFetching flag to vanish,
252                  * or data to appear */
253                 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT, ICL_TYPE_STRING,
254                            __FILE__, ICL_TYPE_INT32, __LINE__,
255                            ICL_TYPE_POINTER, tdc, ICL_TYPE_INT32,
256                            tdc->dflags);
257                 ReleaseReadLock(&tdc->lock);
258                 ReleaseReadLock(&avc->lock);
259                 code = afs_osi_SleepSig(&tdc->validPos);
260                 ObtainReadLock(&avc->lock);
261                 ObtainReadLock(&tdc->lock);
262             }
263             if (code) {
264                 error = code;
265                 break;
266             }
267             /* fetching flag gone, data is here, or we never tried 
268              * (BBusy for instance) */
269             if (tdc->dflags & DFFetching) {
270                 /* still fetching, some new data is here: 
271                  * compute length and offset */
272                 offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
273                 len = tdc->validPos - filePos;
274             } else {
275                 /* no longer fetching, verify data version 
276                  * (avoid new GetDCache call) */
277                 if (hsame(avc->f.m.DataVersion, tdc->f.versionNo)
278                     && ((len = tdc->validPos - filePos) > 0)) {
279                     offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
280                 } else {
281                     /* don't have current data, so get it below */
282                     afs_Trace3(afs_iclSetp, CM_TRACE_VERSIONNO,
283                                ICL_TYPE_INT64, ICL_HANDLE_OFFSET(filePos),
284                                ICL_TYPE_HYPER, &avc->f.m.DataVersion,
285                                ICL_TYPE_HYPER, &tdc->f.versionNo);
286                     ReleaseReadLock(&tdc->lock);
287                     afs_PutDCache(tdc);
288                     tdc = NULL;
289                 }
290             }
291
292             if (!tdc) {
293                 /* If we get, it was not possible to start the
294                  * background daemon. With flag == 1 afs_GetDCache
295                  * does the FetchData rpc synchronously.
296                  */
297                 ReleaseReadLock(&avc->lock);
298                 tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 1);
299                 ObtainReadLock(&avc->lock);
300                 if (tdc)
301                     ObtainReadLock(&tdc->lock);
302             }
303         }
304
305         afs_Trace3(afs_iclSetp, CM_TRACE_VNODEREAD, ICL_TYPE_POINTER, tdc,
306                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(offset),
307                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(len));
308         if (!tdc) {
309             error = EIO;
310             break;
311         }
312
313         /*
314          * Locks held:
315          * avc->lock(R)
316          * tdc->lock(R)
317          */
318
319         if (len > totalLength)
320             len = totalLength;  /* will read len bytes */
321         if (len <= 0) {         /* shouldn't get here if DFFetching is on */
322             /* read past the end of a chunk, may not be at next chunk yet, and yet
323              * also not at eof, so may have to supply fake zeros */
324             len = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;       /* bytes left in chunk addr space */
325             if (len > totalLength)
326                 len = totalLength;      /* and still within xfr request */
327             tlen = avc->f.m.Length - offset;    /* and still within file */
328             if (len > tlen)
329                 len = tlen;
330             if (len > AFS_ZEROS)
331                 len = sizeof(afs_zeros);        /* and in 0 buffer */
332 #ifdef AFS_DARWIN80_ENV
333             trimlen = len;
334             tuiop = afsio_darwin_partialcopy(auio, trimlen);
335 #else
336             afsio_copy(auio, &tuio, tvec);
337             trimlen = len;
338             afsio_trim(&tuio, trimlen);
339 #endif
340             AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);
341             if (code) {
342                 error = code;
343                 break;
344             }
345         } else {
346             /* get the data from the cache */
347
348             /* mung uio structure to be right for this transfer */
349 #ifdef AFS_DARWIN80_ENV
350             trimlen = len;
351             tuiop = afsio_darwin_partialcopy(auio, trimlen);
352             uio_setoffset(tuiop, offset);
353 #else
354             afsio_copy(auio, &tuio, tvec);
355             trimlen = len;
356             afsio_trim(&tuio, trimlen);
357             tuio.afsio_offset = offset;
358 #endif
359
360             code = (*(afs_cacheType->vreadUIO))(&tdc->f.inode, tuiop);
361
362             if (code) {
363                 error = code;
364                 break;
365             }
366         }
367         /* otherwise we've read some, fixup length, etc and continue with next seg */
368         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
369         trimlen = len;
370         afsio_skip(auio, trimlen);      /* update input uio structure */
371         totalLength -= len;
372         transferLength += len;
373         filePos += len;
374
375         if (len <= 0)
376             break;              /* surprise eof */
377 #ifdef AFS_DARWIN80_ENV
378         if (tuiop) {
379             uio_free(tuiop);
380             tuiop = 0;
381         }
382 #endif
383     }                           /* the whole while loop */
384
385     /*
386      * Locks held:
387      * avc->lock(R)
388      * tdc->lock(R) if tdc
389      */
390
391     /* if we make it here with tdc non-zero, then it is the last chunk we
392      * dealt with, and we have to release it when we're done.  We hold on
393      * to it in case we need to do a prefetch.
394      */
395     if (tdc) {
396         ReleaseReadLock(&tdc->lock);
397 #if !defined(AFS_VM_RDWR_ENV)
398         /* try to queue prefetch, if needed */
399         if (!noLock) {
400             if (!(tdc->mflags &DFNextStarted))
401                 afs_PrefetchChunk(avc, tdc, acred, &treq);
402         }
403 #endif
404         afs_PutDCache(tdc);
405     }
406     if (!noLock)
407         ReleaseReadLock(&avc->lock);
408
409     code = afs_CheckCode(error, &treq, 10);
410
411 #ifdef AFS_DARWIN80_ENV
412     if (tuiop)
413        uio_free(tuiop);
414 #else
415     osi_FreeSmallSpace(tvec);
416 #endif
417
418 out:
419     AFS_DISCON_UNLOCK();
420     return code;
421 }
422
423 /* called with the dcache entry triggering the fetch, the vcache entry involved,
424  * and a vrequest for the read call.  Marks the dcache entry as having already
425  * triggered a prefetch, starts the prefetch going and sets the DFFetchReq
426  * flag in the prefetched block, so that the next call to read knows to wait
427  * for the daemon to start doing things.
428  *
429  * This function must be called with the vnode at least read-locked, and
430  * no locks on the dcache, because it plays around with dcache entries.
431  */
432 void
433 afs_PrefetchChunk(struct vcache *avc, struct dcache *adc,
434                   afs_ucred_t *acred, struct vrequest *areq)
435 {
436     struct dcache *tdc;
437     afs_size_t offset;
438     afs_size_t j1, j2;          /* junk vbls for GetDCache to trash */
439
440     offset = adc->f.chunk + 1;  /* next chunk we'll need */
441     offset = AFS_CHUNKTOBASE(offset);   /* base of next chunk */
442     ObtainReadLock(&adc->lock);
443     ObtainSharedLock(&adc->mflock, 662);
444     if (offset < avc->f.m.Length && !(adc->mflags & DFNextStarted)
445         && !afs_BBusy()) {
446         struct brequest *bp;
447
448         UpgradeSToWLock(&adc->mflock, 663);
449         adc->mflags |= DFNextStarted;   /* we've tried to prefetch for this guy */
450         ReleaseWriteLock(&adc->mflock);
451         ReleaseReadLock(&adc->lock);
452
453         tdc = afs_GetDCache(avc, offset, areq, &j1, &j2, 2);    /* type 2 never returns 0 */
454         /*
455          * In disconnected mode, type 2 can return 0 because it doesn't
456          * make any sense to allocate a dcache we can never fill
457          */
458          if (tdc == NULL)
459              return;
460
461         ObtainSharedLock(&tdc->mflock, 651);
462         if (!(tdc->mflags & DFFetchReq)) {
463             /* ask the daemon to do the work */
464             UpgradeSToWLock(&tdc->mflock, 652);
465             tdc->mflags |= DFFetchReq;  /* guaranteed to be cleared by BKG or GetDCache */
466             /* last parm (1) tells bkg daemon to do an afs_PutDCache when it is done,
467              * since we don't want to wait for it to finish before doing so ourselves.
468              */
469             bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
470                             (afs_size_t) offset, (afs_size_t) 1, tdc,
471                             (void *)0, (void *)0);
472             if (!bp) {
473                 /* Bkg table full; just abort non-important prefetching to avoid deadlocks */
474                 tdc->mflags &= ~DFFetchReq;
475                 ReleaseWriteLock(&tdc->mflock);
476                 afs_PutDCache(tdc);
477
478                 /*
479                  * DCLOCKXXX: This is a little sketchy, since someone else
480                  * could have already started a prefetch..  In practice,
481                  * this probably doesn't matter; at most it would cause an
482                  * extra slot in the BKG table to be used up when someone
483                  * prefetches this for the second time.
484                  */
485                 ObtainReadLock(&adc->lock);
486                 ObtainWriteLock(&adc->mflock, 664);
487                 adc->mflags &= ~DFNextStarted;
488                 ReleaseWriteLock(&adc->mflock);
489                 ReleaseReadLock(&adc->lock);
490             } else {
491                 ReleaseWriteLock(&tdc->mflock);
492             }
493         } else {
494             ReleaseSharedLock(&tdc->mflock);
495             afs_PutDCache(tdc);
496         }
497     } else {
498         ReleaseSharedLock(&adc->mflock);
499         ReleaseReadLock(&adc->lock);
500     }
501 }
502
503 int
504 afs_UFSReadUIO(afs_dcache_id_t *cacheId, struct uio *tuiop)
505 {
506     int code;
507     struct osi_file *tfile;
508
509     tfile = (struct osi_file *) osi_UFSOpen(cacheId);
510
511 #if defined(AFS_AIX41_ENV)
512     AFS_GUNLOCK();
513     code =
514         VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, tuiop, NULL, NULL,
515                   NULL, afs_osi_credp);
516     AFS_GLOCK();
517 #elif defined(AFS_AIX32_ENV)
518     code =
519         VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, tuiop, NULL, NULL);
520     /* Flush all JFS pages now for big performance gain in big file cases
521      * If we do something like this, must check to be sure that AFS file
522      * isn't mmapped... see afs_gn_map() for why.
523      */
524     /*
525    if (tfile->vnode->v_gnode && tfile->vnode->v_gnode->gn_seg) {
526    any different ways to do similar things:
527    so far, the best performing one is #2, but #1 might match it if we
528    straighten out the confusion regarding which pages to flush.  It 
529    really does matter.
530    1.       vm_flushp(tfile->vnode->v_gnode->gn_seg, 0, len/PAGESIZE - 1);
531    2.       vm_releasep(tfile->vnode->v_gnode->gn_seg, offset/PAGESIZE, 
532                         (len + PAGESIZE-1)/PAGESIZE);
533    3.       vms_inactive(tfile->vnode->v_gnode->gn_seg) Doesn't work correctly
534    4.       vms_delete(tfile->vnode->v_gnode->gn_seg) probably also fails
535             tfile->vnode->v_gnode->gn_seg = NULL;
536    5.       deletep
537    6.       ipgrlse
538    7.       ifreeseg
539           Unfortunately, this seems to cause frequent "cache corruption" episodes.
540             vm_releasep(tfile->vnode->v_gnode->gn_seg, offset/PAGESIZE, 
541                         (len + PAGESIZE-1)/PAGESIZE);
542           }     
543 */
544 #elif defined(AFS_AIX_ENV)
545     code =
546         VNOP_RDWR(tfile->vnode, UIO_READ, FREAD, (off_t) & offset,
547                   tuiop, NULL, NULL, -1);
548 #elif defined(AFS_SUN5_ENV)
549     AFS_GUNLOCK();
550 #ifdef AFS_SUN510_ENV
551     {
552         caller_context_t ct;
553         VOP_RWLOCK(tfile->vnode, 0, &ct);
554         code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp, &ct);
555         VOP_RWUNLOCK(tfile->vnode, 0, &ct);
556     }
557 #else
558     VOP_RWLOCK(tfile->vnode, 0);
559     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
560     VOP_RWUNLOCK(tfile->vnode, 0);
561 #endif
562     AFS_GLOCK();
563 #elif defined(AFS_SGI_ENV)
564     AFS_GUNLOCK();
565     AFS_VOP_RWLOCK(tfile->vnode, VRWLOCK_READ);
566     AFS_VOP_READ(tfile->vnode, tuiop, IO_ISLOCKED, afs_osi_credp,
567                  code);
568     AFS_VOP_RWUNLOCK(tfile->vnode, VRWLOCK_READ);
569     AFS_GLOCK();
570 #elif defined(AFS_HPUX100_ENV)
571     AFS_GUNLOCK();
572     code = VOP_RDWR(tfile->vnode, tuiop, UIO_READ, 0, afs_osi_credp);
573     AFS_GLOCK();
574 #elif defined(AFS_LINUX20_ENV)
575     AFS_GUNLOCK();
576     code = osi_rdwr(tfile, tuiop, UIO_READ);
577     AFS_GLOCK();
578 #elif defined(AFS_DARWIN80_ENV)
579     AFS_GUNLOCK();
580     code = VNOP_READ(tfile->vnode, tuiop, 0, afs_osi_ctxtp);
581     AFS_GLOCK();
582 #elif defined(AFS_DARWIN_ENV)
583     AFS_GUNLOCK();
584     VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
585     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
586     VOP_UNLOCK(tfile->vnode, 0, current_proc());
587     AFS_GLOCK();
588 #elif defined(AFS_FBSD80_ENV)
589     AFS_GUNLOCK();
590     VOP_LOCK(tfile->vnode, LK_EXCLUSIVE);
591     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
592     VOP_UNLOCK(tfile->vnode, 0);
593     AFS_GLOCK();
594 #elif defined(AFS_FBSD_ENV)
595     AFS_GUNLOCK();
596     VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
597     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
598     VOP_UNLOCK(tfile->vnode, 0, curthread);
599     AFS_GLOCK();
600 #elif defined(AFS_NBSD_ENV)
601     tuiop->uio_rw = UIO_READ;
602     AFS_GUNLOCK();
603     VOP_LOCK(tfile->vnode, LK_EXCLUSIVE);
604     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
605 # if defined(AFS_NBSD60_ENV)
606     VOP_UNLOCK(tfile->vnode);
607 # else
608     VOP_UNLOCK(tfile->vnode, 0);
609 # endif
610     AFS_GLOCK();
611 #elif defined(AFS_XBSD_ENV)
612     AFS_GUNLOCK();
613     VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
614     code = VOP_READ(tfile->vnode, tuiop, 0, afs_osi_credp);
615     VOP_UNLOCK(tfile->vnode, 0, curproc);
616     AFS_GLOCK();
617 #else
618     code = VOP_RDWR(tfile->vnode, tuiop, UIO_READ, 0, afs_osi_credp);
619 #endif
620     osi_UFSClose(tfile);
621
622     return code;
623 }