afs: Clarify vcache->mvid accesses
[openafs.git] / src / afs / VNOPS / afs_vnop_readdir.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  * afs_vnop_readdir.c - afs_readdir and bulk stat
12  *
13  * Implements:
14  * BlobScan
15  * afs_readdir_move
16  * afs_bulkstat_send
17  * afs_readdir/afs_readdir2(HP)
18  * afs_readdir1 - HP NFS version
19  * 
20  */
21
22 #include <afsconfig.h>
23 #include "afs/param.h"
24
25
26 #include "afs/sysincludes.h"    /* Standard vendor system headers */
27 #include "afsincludes.h"        /* Afs-based standard headers */
28 #include "afs/afs_stats.h"      /* statistics */
29 #include "afs/afs_cbqueue.h"
30 #include "afs/nfsclient.h"
31 #include "afs/afs_osidnlc.h"
32
33 #if defined(AFS_HPUX1122_ENV)
34 #define DIRPAD 7
35 #elif defined(AFS_NBSD40_ENV)
36 #define DIRPAD 7
37 #else
38 #define DIRPAD 3
39 #endif
40
41 /*
42  * AFS readdir vnodeop and bulk stat support.
43  */
44
45 /* BlobScan is supposed to ensure that the blob reference refers to a valid
46     directory entry.  It consults the allocation map in the page header
47     to determine whether a blob is actually in use or not.
48
49     More formally, BlobScan is supposed to return a new blob number which is just like
50     the input parameter, only it is advanced over header or free blobs.
51     
52     Note that BlobScan switches pages if necessary.  BlobScan may return
53     either 0 or an out-of-range blob number for end of file.
54
55     BlobScan is used by the Linux port in a separate file, so it should not
56     become static.
57 */
58 int
59 BlobScan(struct dcache * afile, afs_int32 ablob)
60 {
61     afs_int32 relativeBlob;
62     afs_int32 pageBlob;
63     struct PageHeader *tpe;
64     struct DirBuffer headerbuf;
65     afs_int32 i;
66     int code;
67
68     AFS_STATCNT(BlobScan);
69     /* advance ablob over free and header blobs */
70     while (1) {
71         pageBlob = ablob & ~(EPP - 1);  /* base blob in same page */
72         code = afs_dir_GetBlob(afile, pageBlob, &headerbuf);
73         if (code)
74             return 0;
75         tpe = (struct PageHeader *)headerbuf.data;
76
77         relativeBlob = ablob - pageBlob;        /* relative to page's first blob */
78         /* first watch for headers */
79         if (pageBlob == 0) {    /* first dir page has extra-big header */
80             /* first page */
81             if (relativeBlob < DHE + 1)
82                 relativeBlob = DHE + 1;
83         } else {                /* others have one header blob */
84             if (relativeBlob == 0)
85                 relativeBlob = 1;
86         }
87         /* make sure blob is allocated */
88         for (i = relativeBlob; i < EPP; i++) {
89             if (tpe->freebitmap[i >> 3] & (1 << (i & 7)))
90                 break;
91         }
92         /* now relativeBlob is the page-relative first allocated blob,
93          * or EPP (if there are none in this page). */
94         DRelease(&headerbuf, 0);
95         if (i != EPP)
96             return i + pageBlob;
97         ablob = pageBlob + EPP; /* go around again */
98     }
99     /* never get here */
100 }
101
102
103 #if !defined(AFS_LINUX20_ENV)
104 /* Changes to afs_readdir which affect dcache or vcache handling or use of
105  * bulk stat data should also be reflected in the Linux specific verison of
106  * the readdir routine.
107  */
108
109 /*
110  * The kernel don't like it so much to have large stuff on the stack.
111  * Here we use a watered down version of the direct struct, since
112  * its not too bright to double copy the strings anyway.
113 */
114 #if !defined(UKERNEL)
115 #if defined(AFS_SGI_ENV)
116 /* Long form for 64 bit apps and kernel requests. */
117 struct min_dirent {             /* miniature dirent structure */
118     /* If struct dirent changes, this must too */
119     ino_t d_fileno;             /* This is 32 bits for 3.5, 64 for 6.2+ */
120     off64_t d_off;
121     u_short d_reclen;
122 };
123 /* Short form for 32 bit apps. */
124 struct irix5_min_dirent {       /* miniature dirent structure */
125     /* If struct dirent changes, this must too */
126     afs_uint32 d_fileno;
127     afs_int32 d_off;
128     u_short d_reclen;
129 };
130 #ifdef AFS_SGI62_ENV
131 #define AFS_DIRENT32BASESIZE IRIX5_DIRENTBASESIZE
132 #define AFS_DIRENT64BASESIZE DIRENT64BASESIZE
133 #else
134 #define AFS_DIRENT32BASESIZE IRIX5_DIRENTBASESIZE
135 #define AFS_DIRENT64BASESIZE DIRENTBASESIZE
136 #endif /* AFS_SGI62_ENV */
137 #else
138 struct min_direct {             /* miniature direct structure */
139     /* If struct direct changes, this must too */
140 #if defined(AFS_DARWIN80_ENV)
141     ino_t d_fileno;
142     u_short d_reclen;
143     u_char d_type;
144     u_char d_namlen;
145 #elif defined(AFS_NBSD40_ENV)
146     ino_t d_fileno;             /* file number of entry */
147     uint16_t d_reclen;          /* length of this record */
148     uint16_t d_namlen;          /* length of string in d_name */
149     uint8_t  d_type;            /* file type, see below */
150 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
151     afs_uint32 d_fileno;
152     u_short d_reclen;
153     u_char d_type;
154     u_char d_namlen;
155 #elif defined(AFS_SUN5_ENV)
156     afs_uint32 d_fileno;
157     afs_int32 d_off;
158     u_short d_reclen;
159 #else
160 #if defined(AFS_AIX32_ENV)
161     afs_int32 d_off;
162 #elif defined(AFS_HPUX100_ENV)
163     unsigned long long d_off;
164 #endif
165     afs_uint32 d_fileno;
166     u_short d_reclen;
167     u_short d_namlen;
168 #endif
169 };
170 #endif /* AFS_SGI_ENV */
171
172 #if     defined(AFS_HPUX_ENV)
173 struct minnfs_direct {
174     afs_int32 d_off;            /* XXX */
175     afs_uint32 d_fileno;
176     u_short d_reclen;
177     u_short d_namlen;
178 };
179 #define NDIRSIZ_LEN(len)   ((sizeof (struct dirent)+4 - (MAXNAMLEN+1)) + (((len)+1 + DIRPAD) &~ DIRPAD))
180 #endif
181 #endif /* !defined(UKERNEL) */
182
183
184 /*
185  *------------------------------------------------------------------------------
186  *
187  * Keep a stack of about 256 fids for the bulk stat call.
188  * Fill it during the readdir_move.  Later empty it...
189  */
190
191 #define READDIR_STASH   AFSCBMAX
192 struct AFSFid afs_readdir_stash[READDIR_STASH];
193 int afs_rd_stash_i = 0;
194
195 /*
196  *------------------------------------------------------------------------------
197  *
198  * afs_readdir_move.
199  *      mainly a kind of macro... makes getting the struct direct
200  *      out to the user space easy... could take more parameters,
201  *      but now just takes what it needs.
202  *
203  *
204 */
205
206 #if     defined(AFS_HPUX100_ENV)
207 #define DIRSIZ_LEN(len) \
208     ((sizeof (struct __dirent) - (_MAXNAMLEN+1)) + (((len)+1 + DIRPAD) &~ DIRPAD))
209 #else
210 #if     defined(AFS_SUN5_ENV)
211 #define DIRSIZ_LEN(len) ((18 + (len) + 1 + 7) & ~7 )
212 #else
213 #ifdef  AFS_NBSD40_ENV
214 #define DIRSIZ_LEN(len) \
215     ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((len)+1 + 7) & ~7))
216 #else
217 #ifdef  AFS_DIRENT
218 #define DIRSIZ_LEN(len) \
219     ((sizeof (struct dirent) - (MAXNAMLEN+1)) + (((len)+1 + 3) &~ 3))
220 #else
221 #if defined(AFS_SGI_ENV)
222 #ifndef AFS_SGI53_ENV
223 /* SGI 5.3 and later use 32/64 bit versions of directory size. */
224 #define DIRSIZ_LEN(len)         DIRENTSIZE(len)
225 #endif
226 #else /* AFS_SGI_ENV */
227 #define DIRSIZ_LEN(len) \
228     ((sizeof (struct direct) - (MAXNAMLEN+1)) + (((len)+1 + 3) &~ 3))
229 #endif /* AFS_SGI_ENV */
230 #endif /* AFS_DIRENT */
231 #endif /* AFS_NBSD40_ENV */
232 #endif /* AFS_SUN5_ENV */
233 #endif /* AFS_HPUX100_ENV */
234
235 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
236 int
237 afs_readdir_type(struct vcache *avc, struct DirEntry *ade)
238 {
239     struct VenusFid tfid;
240     struct vcache *tvc;
241     int vtype;
242     tfid.Cell = avc->f.fid.Cell;
243     tfid.Fid.Volume = avc->f.fid.Fid.Volume;
244     tfid.Fid.Vnode = ntohl(ade->fid.vnode);
245     tfid.Fid.Unique = ntohl(ade->fid.vunique);
246     if ((avc->f.states & CForeign) == 0 && (ntohl(ade->fid.vnode) & 1)) {
247         return DT_DIR;
248     }
249     ObtainReadLock(&afs_xvcache);
250     if ((tvc = afs_FindVCache(&tfid, 0, 0))) {
251         ReleaseReadLock(&afs_xvcache);
252         if (tvc->mvstat != AFS_MVSTAT_FILE) {
253             afs_PutVCache(tvc);
254             return DT_DIR;
255         } else if (((tvc->f.states) & (CStatd | CTruth))) {
256             /* CTruth will be set if the object has
257              *ever* been statd */
258             vtype = vType(tvc);
259             afs_PutVCache(tvc);
260             if (vtype == VDIR)
261                 return DT_DIR;
262             else if (vtype == VREG)
263                 return DT_REG;
264             /* Don't do this until we're sure it can't be a mtpt */
265             /* if we're CStatd and CTruth and mvstat==AFS_MVSTAT_FILE, it's a link */
266             else if (vtype == VLNK)
267                 return DT_LNK;
268             /* what other types does AFS support? */
269         } else
270             afs_PutVCache(tvc);
271     } else
272         ReleaseReadLock(&afs_xvcache);
273     return DT_UNKNOWN;
274 }
275 #endif
276
277 #ifdef AFS_AIX41_ENV
278 #define AFS_MOVE_LOCK()   AFS_GLOCK()
279 #define AFS_MOVE_UNLOCK() AFS_GUNLOCK()
280 #else
281 #define AFS_MOVE_LOCK()
282 #define AFS_MOVE_UNLOCK()
283 #endif
284 char bufofzeros[64];            /* gotta fill with something */
285
286 #ifdef AFS_SGI65_ENV
287 int
288 afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio, 
289                  int slen, ssize_t rlen, afs_size_t off)
290 #else
291 int
292 afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio, 
293                  int slen, int rlen, afs_size_t off)
294 #endif
295 {
296     int code = 0;
297     struct volume *tvp;
298     afs_uint32 Volume = vc->f.fid.Fid.Volume;
299     afs_uint32 Vnode  = de->fid.vnode;
300 #if     defined(AFS_SUN5_ENV)
301     struct dirent64 *direntp;
302 #else
303 #if  (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
304     struct dirent *direntp;
305 #endif
306 #endif /* AFS_SUN5_ENV */
307 #ifndef AFS_SGI53_ENV
308     struct min_direct sdirEntry;
309 #endif /* AFS_SGI53_ENV */
310
311     AFS_STATCNT(afs_readdir_move);
312
313 #define READDIR_CORRECT_INUMS
314 #ifdef READDIR_CORRECT_INUMS
315     if (de->name[0] == '.' && !de->name[1]) {
316         /* This is the '.' entry; if we are a volume root, we need to
317          * ignore the directory and use the inum for the mount point.
318          */
319         if (!FidCmp(&afs_rootFid, &vc->f.fid)) {
320             Volume = 0;
321             Vnode  = 2;
322         } else if (vc->mvstat == AFS_MVSTAT_ROOT) {
323             tvp = afs_GetVolume(&vc->f.fid, 0, READ_LOCK);
324             if (tvp) {
325                 Volume = tvp->mtpoint.Fid.Volume;
326                 Vnode  = tvp->mtpoint.Fid.Vnode;
327                 afs_PutVolume(tvp, READ_LOCK);
328             }
329         }
330     }
331     else if (de->name[0] == '.' && de->name[1] == '.' && !de->name[2]) {
332         /* This is the '..' entry.  Getting this right is very tricky,
333          * because we might be a volume root (so our parent is in a
334          * different volume), or our parent might be a volume root
335          * (so we actually want the mount point) or BOTH! */
336         if (!FidCmp(&afs_rootFid, &vc->f.fid)) {
337             /* We are the root of the AFS root, and thus our own parent */
338             Volume = 0;
339             Vnode  = 2;
340         } else if (vc->mvstat == AFS_MVSTAT_ROOT) {
341             /* We are a volume root, which means our parent is in another
342              * volume.  Luckily, we should have his fid cached... */
343             if (vc->mvid.parent) {
344                 if (!FidCmp(&afs_rootFid, vc->mvid.parent)) {
345                     /* Parent directory is the root of the AFS root */
346                     Volume = 0;
347                     Vnode  = 2;
348                 } else if (vc->mvid.parent->Fid.Vnode == 1
349                            && vc->mvid.parent->Fid.Unique == 1) {
350                     /* XXX The above test is evil and probably breaks DFS */
351                     /* Parent directory is the target of a mount point */
352                     tvp = afs_GetVolume(vc->mvid.parent, 0, READ_LOCK);
353                     if (tvp) {
354                         Volume = tvp->mtpoint.Fid.Volume;
355                         Vnode  = tvp->mtpoint.Fid.Vnode;
356                         afs_PutVolume(tvp, READ_LOCK);
357                     }
358                 } else {
359                     /* Parent directory is not a volume root */
360                     Volume = vc->mvid.parent->Fid.Volume;
361                     Vnode  = vc->mvid.parent->Fid.Vnode;
362                 }
363             }
364         } else if (de->fid.vnode == 1 && de->fid.vunique == 1) {
365             /* XXX The above test is evil and probably breaks DFS */
366             /* Parent directory is a volume root; use the right inum */
367             tvp = afs_GetVolume(&vc->f.fid, 0, READ_LOCK);
368             if (tvp) {
369                 if (tvp->cell == afs_rootFid.Cell
370                     && tvp->volume == afs_rootFid.Fid.Volume) {
371                     /* Parent directory is the root of the AFS root */
372                     Volume = 0;
373                     Vnode  = 2;
374                 } else {
375                     /* Parent directory is the target of a mount point */
376                     Volume = tvp->mtpoint.Fid.Volume;
377                     Vnode  = tvp->mtpoint.Fid.Vnode;
378                 }
379                 afs_PutVolume(tvp, READ_LOCK);
380             }
381         }
382     }
383 #endif
384
385 #ifdef  AFS_SGI53_ENV
386     {
387         afs_int32 use64BitDirent;
388
389 #ifdef AFS_SGI61_ENV
390 #ifdef AFS_SGI62_ENV
391         use64BitDirent =
392             ABI_IS(ABI_IRIX5_64, GETDENTS_ABI(OSI_GET_CURRENT_ABI(), auio));
393 #else
394         use64BitDirent =
395             (auio->uio_segflg !=
396              UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64 |
397                                                      ABI_IRIX5_N32,
398                                                      u.u_procp->p_abi));
399 #endif
400 #else /* AFS_SGI61_ENV */
401         use64BitDirent =
402             (auio->uio_segflg !=
403              UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64,
404                                                      u.u_procp->p_abi));
405 #endif /* AFS_SGI61_ENV */
406
407         if (use64BitDirent) {
408             struct min_dirent sdirEntry;
409             sdirEntry.d_fileno = afs_calc_inum(vc->f.fid.Cell,
410                                                Volume, ntohl(Vnode));
411             sdirEntry.d_reclen = rlen;
412             sdirEntry.d_off = (off_t) off;
413             AFS_UIOMOVE(&sdirEntry, AFS_DIRENT64BASESIZE, UIO_READ, auio,
414                         code);
415             if (code == 0)
416                 AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code);
417             if (code == 0)
418                 AFS_UIOMOVE(bufofzeros,
419                             DIRENTSIZE(slen) - (AFS_DIRENT64BASESIZE + slen -
420                                                 1), UIO_READ, auio, code);
421             if (DIRENTSIZE(slen) < rlen) {
422                 while (DIRENTSIZE(slen) < rlen) {
423                     int minLen = rlen - DIRENTSIZE(slen);
424                     if (minLen > sizeof(bufofzeros))
425                         minLen = sizeof(bufofzeros);
426                     AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
427                     rlen -= minLen;
428                 }
429             }
430         } else {
431             struct irix5_min_dirent sdirEntry;
432             sdirEntry.d_fileno = afs_calc_inum(vc->f.fid.Cell,
433                                                Volume, ntohl(Vnode));
434             sdirEntry.d_reclen = rlen;
435             sdirEntry.d_off = (afs_int32) off;
436             AFS_UIOMOVE(&sdirEntry, AFS_DIRENT32BASESIZE, UIO_READ, auio,
437                         code);
438             if (code == 0)
439                 AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code);
440             if (code == 0)
441                 AFS_UIOMOVE(bufofzeros,
442                             IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE +
443                                                       slen - 1), UIO_READ,
444                             auio, code);
445             if (IRIX5_DIRENTSIZE(slen) < rlen) {
446                 while (IRIX5_DIRENTSIZE(slen) < rlen) {
447                     int minLen = rlen - IRIX5_DIRENTSIZE(slen);
448                     if (minLen > sizeof(bufofzeros))
449                         minLen = sizeof(bufofzeros);
450                     AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
451                     rlen -= minLen;
452                 }
453             }
454         }
455     }
456 #else /* AFS_SGI53_ENV */
457 #if  defined(AFS_SUN5_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
458     direntp = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
459     direntp->d_ino = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode));
460 #if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
461     direntp->d_offset = off;
462     direntp->d_namlen = slen;
463 #else
464     direntp->d_off = off;
465 #endif
466     direntp->d_reclen = rlen;
467     strcpy(direntp->d_name, de->name);
468     AFS_UIOMOVE((caddr_t) direntp, rlen, UIO_READ, auio, code);
469     osi_FreeLargeSpace((char *)direntp);
470 #else /* AFS_SUN5_ENV */
471     /* Note the odd mechanism for building the inode number */
472     sdirEntry.d_fileno = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode));
473     sdirEntry.d_reclen = rlen;
474 #if !defined(AFS_SGI_ENV)
475     sdirEntry.d_namlen = slen;
476 #endif
477 #if defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
478     sdirEntry.d_off = off;
479 #endif
480 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
481     sdirEntry.d_type = afs_readdir_type(vc, de);
482 #endif
483
484 #if defined(AFS_SGI_ENV)
485     AFS_UIOMOVE(&sdirEntry, DIRENTBASESIZE, UIO_READ, auio, code);
486     if (code == 0)
487         AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code);
488     if (code == 0)
489         AFS_UIOMOVE(bufofzeros,
490                     DIRSIZ_LEN(slen) - (DIRENTBASESIZE + slen - 1), UIO_READ,
491                     auio, code);
492 #else /* AFS_SGI_ENV */
493     AFS_MOVE_UNLOCK();
494 #if defined(AFS_NBSD40_ENV)
495     {
496         struct dirent *dp;
497         dp = osi_AllocLargeSpace(sizeof(struct dirent));
498         memset(dp, 0, sizeof(struct dirent));
499         dp->d_ino = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode));
500         dp->d_namlen = slen;
501         dp->d_type = afs_readdir_type(vc, de);
502         strcpy(dp->d_name, de->name);
503         dp->d_reclen = _DIRENT_SIZE(dp) /* rlen */;
504         if ((afs_debug & AFSDEB_VNLAYER) != 0) {
505             afs_warn("%s: %s type %d slen %d rlen %d act. rlen %zu\n", __func__,
506                 dp->d_name, dp->d_type, slen, rlen, _DIRENT_SIZE(dp));
507         }
508         AFS_UIOMOVE(dp, dp->d_reclen, UIO_READ, auio, code);
509         osi_FreeLargeSpace((char *)dp);
510     }
511 #else
512     AFS_UIOMOVE((char *) &sdirEntry, sizeof(sdirEntry), UIO_READ, auio, code);
513     if (code == 0) {
514         AFS_UIOMOVE(de->name, slen, UIO_READ, auio, code);
515     }
516     /* pad out the remaining characters with zeros */
517     if (code == 0) {
518         AFS_UIOMOVE(bufofzeros, ((slen + 1 + DIRPAD) & ~DIRPAD) - slen,
519                     UIO_READ, auio, code);
520     }
521 #endif
522     AFS_MOVE_LOCK();
523 #endif /* AFS_SGI_ENV */
524 #if !defined(AFS_NBSD_ENV)
525     /* pad out the difference between rlen and slen... */
526     if (DIRSIZ_LEN(slen) < rlen) {
527         AFS_MOVE_UNLOCK();
528         while (DIRSIZ_LEN(slen) < rlen) {
529             int minLen = rlen - DIRSIZ_LEN(slen);
530             if (minLen > sizeof(bufofzeros))
531                 minLen = sizeof(bufofzeros);
532             AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
533             rlen -= minLen;
534         }
535         AFS_MOVE_LOCK();
536     }
537 #endif
538 #endif /* AFS_SUN5_ENV */
539 #endif /* AFS_SGI53_ENV */
540     return (code);
541 }
542
543
544 /*
545  *------------------------------------------------------------------------------
546  *
547  * Read directory entries.
548  * There are some weird things to look out for here.  The uio_offset
549  * field is either 0 or it is the offset returned from a previous
550  * readdir.  It is an opaque value used by the server to find the
551  * correct directory block to read.  The byte count must be at least
552  * vtoblksz(vp) bytes.  The count field is the number of blocks to
553  * read on the server.  This is advisory only, the server may return
554  * only one block's worth of entries.  Entries may be compressed on
555  * the server.
556  *
557  * This routine encodes knowledge of Vice dirs.
558  */
559
560 void
561 afs_bulkstat_send(struct vcache *avc, struct vrequest *req)
562 {
563     afs_rd_stash_i = 0;
564 }
565
566 /*
567  * Here is the bad, bad, really bad news.
568  * It has to do with 'offset' (seek locations).
569 */
570
571 int
572 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
573 afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred, 
574             int *eofp)
575 #else
576 #if defined(AFS_HPUX100_ENV)
577 afs_readdir2(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
578 #else
579 afs_readdir(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
580 #endif
581 #endif
582 {
583     struct vrequest *treq = NULL;
584     struct dcache *tdc;
585     afs_size_t origOffset, tlen;
586     afs_int32 len;
587     int code = 0;
588     struct DirBuffer oldEntry, nextEntry;
589     struct DirEntry *ode = 0, *nde = 0;
590     int o_slen = 0, n_slen = 0;
591     afs_uint32 us;
592     struct afs_fakestat_state fakestate;
593 #if defined(AFS_SGI53_ENV)
594     afs_int32 use64BitDirent, dirsiz;
595 #endif /* defined(AFS_SGI53_ENV) */
596 #ifndef AFS_HPUX_ENV
597     OSI_VC_CONVERT(avc);
598 #else
599     /*
600      * XXX All the hacks for alloced sdirEntry and inlining of afs_readdir_move instead of calling
601      * it is necessary for hpux due to stack problems that seem to occur when coming thru the nfs
602      * translator side XXX
603      */
604     struct min_direct *sdirEntry = osi_AllocSmallSpace(sizeof(struct min_direct));
605     afs_int32 rlen;
606 #endif
607
608     /* opaque value is pointer into a vice dir; use bit map to decide
609      * if the entries are in use.  Always assumed to be valid.  0 is
610      * special, means start of a new dir.  Int32 inode, followed by
611      * short reclen and short namelen.  Namelen does not include
612      * the null byte.  Followed by null-terminated string.
613      */
614     AFS_STATCNT(afs_readdir);
615
616     memset(&oldEntry, 0, sizeof(struct DirBuffer));
617     memset(&nextEntry, 0, sizeof(struct DirBuffer));
618
619 #if defined(AFS_SGI53_ENV)
620 #ifdef AFS_SGI61_ENV
621 #ifdef AFS_SGI62_ENV
622     use64BitDirent =
623         ABI_IS(ABI_IRIX5_64, GETDENTS_ABI(OSI_GET_CURRENT_ABI(), auio));
624 #else
625     use64BitDirent =
626         (auio->uio_segflg !=
627          UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64 | ABI_IRIX5_N32,
628                                                  u.u_procp->p_abi));
629 #endif /* AFS_SGI62_ENV */
630 #else /* AFS_SGI61_ENV */
631     use64BitDirent =
632         (auio->uio_segflg !=
633          UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64,
634                                                  u.u_procp->p_abi));
635 #endif /* AFS_SGI61_ENV */
636 #endif /* defined(AFS_SGI53_ENV) */
637
638 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
639     /* Not really used by the callee so we ignore it for now */
640     if (eofp)
641         *eofp = 0;
642 #endif
643 #ifndef AFS_64BIT_CLIENT
644     if (AfsLargeFileUio(auio)   /* file is large than 2 GB */
645         ||AfsLargeFileSize(AFS_UIO_OFFSET(auio), AFS_UIO_RESID(auio)))
646         return EFBIG;
647 #endif
648
649     if ((code = afs_CreateReq(&treq, acred))) {
650 #ifdef  AFS_HPUX_ENV
651         osi_FreeSmallSpace((char *)sdirEntry);
652 #endif
653         return code;
654     }
655     /* update the cache entry */
656     afs_InitFakeStat(&fakestate);
657
658     AFS_DISCON_LOCK();
659
660     code = afs_EvalFakeStat(&avc, &fakestate, treq);
661     if (code)
662         goto done;
663   tagain:
664     code = afs_VerifyVCache(avc, treq);
665     if (code)
666         goto done;
667     /* get a reference to the entire directory */
668     tdc = afs_GetDCache(avc, (afs_size_t) 0, treq, &origOffset, &tlen, 1);
669     if (!tdc) {
670         code = ENOENT;
671         goto done;
672     }
673     ObtainReadLock(&avc->lock);
674     ObtainReadLock(&tdc->lock);
675
676     /*
677      * Make sure that the data in the cache is current. There are two
678      * cases we need to worry about:
679      * 1. The cache data is being fetched by another process.
680      * 2. The cache data is no longer valid
681      */
682     while ((avc->f.states & CStatd)
683            && (tdc->dflags & DFFetching)
684            && hsame(avc->f.m.DataVersion, tdc->f.versionNo)) {
685         afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT, ICL_TYPE_STRING,
686                    __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER, tdc,
687                    ICL_TYPE_INT32, tdc->dflags);
688         ReleaseReadLock(&tdc->lock);
689         ReleaseReadLock(&avc->lock);
690         afs_osi_Sleep(&tdc->validPos);
691         ObtainReadLock(&avc->lock);
692         ObtainReadLock(&tdc->lock);
693     }
694     if (!(avc->f.states & CStatd)
695         || !hsame(avc->f.m.DataVersion, tdc->f.versionNo)) {
696         ReleaseReadLock(&tdc->lock);
697         ReleaseReadLock(&avc->lock);
698         afs_PutDCache(tdc);
699         goto tagain;
700     }
701
702     /*
703      *  iterator for the directory reads.  Takes the AFS DirEntry
704      *  structure and slams them into UFS direct structures.
705      *  uses afs_readdir_move to get the struct to the user space.
706      *
707      *  The routine works by looking ahead one AFS directory entry.
708      *  That's because the AFS entry we are currenly working with
709      *  may not fit into the buffer the user has provided.  If it
710      *  doesn't we have to change the size of the LAST AFS directory
711      *  entry, so that it will FIT perfectly into the block the
712      *  user has provided.
713      *  
714      *  The 'forward looking' of the code makes it a bit tough to read.
715      *  Remember we need to get an entry, see if it it fits, then
716      *  set it up as the LAST entry, and find the next one.
717      *
718      *  Tough to take: We give out an EINVAL if we don't have enough
719      *  space in the buffer, and at the same time, don't have an entry
720      *  to put into the buffer. This CAN happen if the first AFS entry
721      *  we get can't fit into the 512 character buffer provided.  Seems
722      *  it ought not happen... 
723      *
724      *  Assumption: don't need to use anything but one dc entry:
725      *  this means the directory ought not be greater than 64k.
726      */
727     len = 0;
728 #ifdef AFS_HPUX_ENV
729     auio->uio_fpflags = 0;
730 #endif
731     while (code == 0) {
732         origOffset = AFS_UIO_OFFSET(auio);
733         /* scan for the next interesting entry scan for in-use blob otherwise up point at
734          * this blob note that ode, if non-zero, also represents a held dir page */
735         us = BlobScan(tdc, (origOffset >> 5));
736
737         if (us)
738            code = afs_dir_GetVerifiedBlob(tdc, us, &nextEntry);
739
740         if (us == 0 || code != 0) {
741             code = 0; /* Reset code - keep old failure behaviour */
742             /* failed to setup nde, return what we've got, and release ode */
743             if (len) {
744                 /* something to hand over. */
745 #ifdef  AFS_HPUX_ENV
746                 sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
747                                                     avc->f.fid.Fid.Volume,
748                                                     ntohl(ode->fid.vnode));
749                 sdirEntry->d_reclen = rlen = AFS_UIO_RESID(auio);
750                 sdirEntry->d_namlen = o_slen;
751 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
752                 sdirEntry->d_off = origOffset;
753 #endif
754                 AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ,
755                             auio, code);
756                 if (code == 0)
757                     AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code);
758                 /* pad out the remaining characters with zeros */
759                 if (code == 0) {
760                     AFS_UIOMOVE(bufofzeros,
761                                 ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,
762                                 UIO_READ, auio, code);
763                 }
764                 /* pad out the difference between rlen and slen... */
765                 if (DIRSIZ_LEN(o_slen) < rlen) {
766                     while (DIRSIZ_LEN(o_slen) < rlen) {
767                         int minLen = rlen - DIRSIZ_LEN(o_slen);
768                         if (minLen > sizeof(bufofzeros))
769                             minLen = sizeof(bufofzeros);
770                         AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
771                         rlen -= minLen;
772                     }
773                 }
774 #else
775                 code = afs_readdir_move(ode, avc, auio, o_slen,
776 #if defined(AFS_SUN5_ENV) || defined(AFS_NBSD_ENV)
777                                         len, origOffset);
778 #else
779                                         AFS_UIO_RESID(auio), origOffset);
780 #endif
781 #endif /* AFS_HPUX_ENV */
782 #if !defined(AFS_SUN5_ENV) && !defined(AFS_NBSD_ENV)
783                 AFS_UIO_SETRESID(auio, 0);
784 #endif
785             } else {
786                 /* nothin to hand over */
787             }
788 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
789             if (eofp)
790                 *eofp = 1;      /* Set it properly */
791 #endif
792             DRelease(&oldEntry, 0);
793             goto dirend;
794         }
795         nde = (struct DirEntry *)nextEntry.data;
796         
797         /* Do we have enough user space to carry out our mission? */
798 #if defined(AFS_SGI_ENV)
799         n_slen = strlen(nde->name) + 1; /* NULL terminate */
800 #else
801         n_slen = strlen(nde->name);
802 #endif
803 #ifdef  AFS_SGI53_ENV
804         dirsiz =
805             use64BitDirent ? DIRENTSIZE(n_slen) : IRIX5_DIRENTSIZE(n_slen);
806         if (dirsiz >= (AFS_UIO_RESID(auio) - len)) {
807 #else
808         if (DIRSIZ_LEN(n_slen) >= (AFS_UIO_RESID(auio) - len)) {
809 #endif /* AFS_SGI53_ENV */
810             /* No can do no more now; ya know... at this time */
811             DRelease(&nextEntry, 0);    /* can't use this one. */
812             if (len) {
813 #ifdef  AFS_HPUX_ENV
814                 sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
815                                                     avc->f.fid.Fid.Volume,
816                                                     ntohl(ode->fid.vnode));
817                 sdirEntry->d_reclen = rlen = AFS_UIO_RESID(auio);
818                 sdirEntry->d_namlen = o_slen;
819 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
820                 sdirEntry->d_off = origOffset;
821 #endif
822                 AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ,
823                             auio, code);
824                 if (code == 0)
825                     AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code);
826                 /* pad out the remaining characters with zeros */
827                 if (code == 0) {
828                     AFS_UIOMOVE(bufofzeros,
829                                 ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,
830                                 UIO_READ, auio, code);
831                 }
832                 /* pad out the difference between rlen and slen... */
833                 if (DIRSIZ_LEN(o_slen) < rlen) {
834                     while (DIRSIZ_LEN(o_slen) < rlen) {
835                         int minLen = rlen - DIRSIZ_LEN(o_slen);
836                         if (minLen > sizeof(bufofzeros))
837                             minLen = sizeof(bufofzeros);
838                         AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
839                         rlen -= minLen;
840                     }
841                 }
842 #else /* AFS_HPUX_ENV */
843                 code =
844                     afs_readdir_move(ode, avc, auio, o_slen,
845                                      AFS_UIO_RESID(auio), origOffset);
846 #endif /* AFS_HPUX_ENV */
847                 /* this next line used to be AFSVFS40 or AIX 3.1, but is
848                  * really generic */
849                 AFS_UIO_SETOFFSET(auio, origOffset);
850 #if !defined(AFS_NBSD_ENV)
851                 AFS_UIO_SETRESID(auio, 0);
852 #endif
853             } else {            /* trouble, can't give anything to the user! */
854                 /* even though he has given us a buffer, 
855                  * even though we have something to give us,
856                  * Looks like we lost something somewhere.
857                  */
858                 code = EINVAL;
859             }
860             DRelease(&oldEntry, 0);
861             goto dirend;
862         }
863
864         /*
865          * In any event, we move out the LAST de entry, getting ready
866          * to set up for the next one.
867          */
868         if (len) {
869 #ifdef  AFS_HPUX_ENV
870             sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
871                                                 avc->f.fid.Fid.Volume,
872                                                 ntohl(ode->fid.vnode));
873             sdirEntry->d_reclen = rlen = len;
874             sdirEntry->d_namlen = o_slen;
875 #if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
876             sdirEntry->d_off = origOffset;
877 #endif
878             AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ, auio,
879                         code);
880             if (code == 0)
881                 AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code);
882             /* pad out the remaining characters with zeros */
883             if (code == 0) {
884                 AFS_UIOMOVE(bufofzeros,
885                             ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,
886                             UIO_READ, auio, code);
887             }
888             /* pad out the difference between rlen and slen... */
889             if (DIRSIZ_LEN(o_slen) < rlen) {
890                 while (DIRSIZ_LEN(o_slen) < rlen) {
891                     int minLen = rlen - DIRSIZ_LEN(o_slen);
892                     if (minLen > sizeof(bufofzeros))
893                         minLen = sizeof(bufofzeros);
894                     AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code);
895                     rlen -= minLen;
896                 }
897             }
898 #else /* AFS_HPUX_ENV */
899             code = afs_readdir_move(ode, avc, auio, o_slen, len, origOffset);
900 #endif /* AFS_HPUX_ENV */
901         }
902 #ifdef  AFS_SGI53_ENV
903         len = use64BitDirent ? DIRENTSIZE(o_slen =
904                                           n_slen) : IRIX5_DIRENTSIZE(o_slen =
905                                                                      n_slen);
906 #else
907         len = DIRSIZ_LEN(o_slen = n_slen);
908 #endif /* AFS_SGI53_ENV */
909         
910         DRelease(&oldEntry, 0);
911         oldEntry = nextEntry;
912         ode = nde;
913         AFS_UIO_SETOFFSET(auio, (afs_int32) ((us + afs_dir_NameBlobs(nde->name)) << 5));
914     }
915     
916     DRelease(&oldEntry, 0);
917
918   dirend:
919     ReleaseReadLock(&tdc->lock);
920     afs_PutDCache(tdc);
921     ReleaseReadLock(&avc->lock);
922
923   done:
924 #ifdef  AFS_HPUX_ENV
925     osi_FreeSmallSpace((char *)sdirEntry);
926 #endif
927     AFS_DISCON_UNLOCK();
928     afs_PutFakeStat(&fakestate);
929     code = afs_CheckCode(code, treq, 28);
930     afs_DestroyReq(treq);
931     return code;
932 }
933
934 #endif /* !AFS_LINUX20_ENV */