Bug Summary

File:afs/VNOPS/afs_vnop_readdir.c
Location:line 674, column 5
Description:Value stored to 'len' is never read

Annotated Source Code

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 DIRPAD3 7
35#elif defined(AFS_NBSD40_ENV)
36#define DIRPAD3 7
37#else
38#define DIRPAD3 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*/
58int
59BlobScan(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)((afs_cmstats.callInfo.C_BlobScan)++);
69 /* advance ablob over free and header blobs */
70 while (1) {
71 pageBlob = ablob & ~(EPP64 - 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 < DHE12 + 1)
82 relativeBlob = DHE12 + 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 < EPP64; 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 != EPP64)
96 return i + pageBlob;
97 ablob = pageBlob + EPP64; /* 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. */
117struct 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. */
124struct 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
138struct 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_ENV1)
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)
173struct 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 - (MAXNAMLEN255+1)) + (((len)+1 + DIRPAD3) &~ DIRPAD3))
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_STASH50 AFSCBMAX50
192struct AFSFid afs_readdir_stash[READDIR_STASH50];
193int 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)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) \
208 ((sizeof (struct __dirent) - (_MAXNAMLEN+1)) + (((len)+1 + DIRPAD3) &~ DIRPAD3))
209#else
210#if defined(AFS_SUN5_ENV)
211#define DIRSIZ_LEN(len)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) ((18 + (len) + 1 + 7) & ~7 )
212#else
213#ifdef AFS_NBSD40_ENV
214#define DIRSIZ_LEN(len)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) \
215 ((sizeof (struct dirent) - (MAXNAMLEN255+1)) + (((len)+1 + 7) & ~7))
216#else
217#ifdef AFS_DIRENT
218#define DIRSIZ_LEN(len)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) \
219 ((sizeof (struct dirent) - (MAXNAMLEN255+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)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) DIRENTSIZE(len)
225#endif
226#else /* AFS_SGI_ENV */
227#define DIRSIZ_LEN(len)((sizeof (struct dirent) - (255 +1)) + (((len)+1 + 3) &~ 3
)) \
228 ((sizeof (struct directdirent) - (MAXNAMLEN255+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_ENV1)
236int
237afs_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)(__builtin_constant_p(ade->fid.vnode) ? ((((__uint32_t)(ade
->fid.vnode)) >> 24) | ((((__uint32_t)(ade->fid.vnode
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ade
->fid.vnode)) & (0xff << 8)) << 8) | (((__uint32_t
)(ade->fid.vnode)) << 24)) : __bswap32_var(ade->fid
.vnode));
245 tfid.Fid.Unique = ntohl(ade->fid.vunique)(__builtin_constant_p(ade->fid.vunique) ? ((((__uint32_t)(
ade->fid.vunique)) >> 24) | ((((__uint32_t)(ade->
fid.vunique)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(ade->fid.vunique)) & (0xff << 8)) << 8) |
(((__uint32_t)(ade->fid.vunique)) << 24)) : __bswap32_var
(ade->fid.vunique));
246 if ((avc->f.states & CForeign0x00002000) == 0 && (ntohl(ade->fid.vnode)(__builtin_constant_p(ade->fid.vnode) ? ((((__uint32_t)(ade
->fid.vnode)) >> 24) | ((((__uint32_t)(ade->fid.vnode
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ade
->fid.vnode)) & (0xff << 8)) << 8) | (((__uint32_t
)(ade->fid.vnode)) << 24)) : __bswap32_var(ade->fid
.vnode)) & 1)) {
247 return DT_DIR4;
248 }
249 ObtainReadLock(&afs_xvcache)do { ; if (!((&afs_xvcache)->excl_locked & 2)) ((&
afs_xvcache)->readers_reading)++; else Afs_Lock_Obtain(&
afs_xvcache, 1); (&afs_xvcache)->pid_last_reader = (((
__curthread())->td_proc)->p_pid ); } while (0);
250 if ((tvc = afs_FindVCache(&tfid, 0, 0))) {
251 ReleaseReadLock(&afs_xvcache)do { ; if (!(--((&afs_xvcache)->readers_reading)) &&
(&afs_xvcache)->wait_states) Afs_Lock_ReleaseW(&afs_xvcache
) ; if ( (&afs_xvcache)->pid_last_reader == (((__curthread
())->td_proc)->p_pid ) ) (&afs_xvcache)->pid_last_reader
=0; } while (0);
252 if (tvc->mvstat) {
253 afs_PutVCache(tvc);
254 return DT_DIR4;
255 } else if (((tvc->f.states) & (CStatd0x00000001 | CTruth0x00000400))) {
256 /* CTruth will be set if the object has
257 *ever* been statd */
258 vtype = vType(tvc)((tvc)->v)->v_type;
259 afs_PutVCache(tvc);
260 if (vtype == VDIR)
261 return DT_DIR4;
262 else if (vtype == VREG)
263 return DT_REG8;
264 /* Don't do this until we're sure it can't be a mtpt */
265 /* if we're CStatd and CTruth and mvstat==0, it's a link */
266 else if (vtype == VLNK)
267 return DT_LNK10;
268 /* what other types does AFS support? */
269 } else
270 afs_PutVCache(tvc);
271 } else
272 ReleaseReadLock(&afs_xvcache)do { ; if (!(--((&afs_xvcache)->readers_reading)) &&
(&afs_xvcache)->wait_states) Afs_Lock_ReleaseW(&afs_xvcache
) ; if ( (&afs_xvcache)->pid_last_reader == (((__curthread
())->td_proc)->p_pid ) ) (&afs_xvcache)->pid_last_reader
=0; } while (0);
273 return DT_UNKNOWN0;
274}
275#endif
276
277#ifdef AFS_AIX41_ENV
278#define AFS_MOVE_LOCK() AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 278); (void)0; } while (0)
279#define AFS_MOVE_UNLOCK() AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 279
); } while (0)
280#else
281#define AFS_MOVE_LOCK()
282#define AFS_MOVE_UNLOCK()
283#endif
284char bufofzeros[64]; /* gotta fill with something */
285
286#ifdef AFS_SGI65_ENV
287int
288afs_readdir_move(struct DirEntry *de, struct vcache *vc, struct uio *auio,
289 int slen, ssize_t rlen, afs_size_t off)
290#else
291int
292afs_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)((afs_cmstats.callInfo.C_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)((&afs_rootFid)->Fid.Unique != (&vc->f.fid)->
Fid.Unique || (&afs_rootFid)->Fid.Vnode != (&vc->
f.fid)->Fid.Vnode || (&afs_rootFid)->Fid.Volume != (
&vc->f.fid)->Fid.Volume || (&afs_rootFid)->Cell
!= (&vc->f.fid)->Cell)) {
320 Volume = 0;
321 Vnode = 2;
322 } else if (vc->mvstat == 2) {
323 tvp = afs_GetVolume(&vc->f.fid, 0, READ_LOCK1);
324 if (tvp) {
325 Volume = tvp->mtpoint.Fid.Volume;
326 Vnode = tvp->mtpoint.Fid.Vnode;
327 afs_PutVolume(tvp, READ_LOCK)((tvp)->refCount--);
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)((&afs_rootFid)->Fid.Unique != (&vc->f.fid)->
Fid.Unique || (&afs_rootFid)->Fid.Vnode != (&vc->
f.fid)->Fid.Vnode || (&afs_rootFid)->Fid.Volume != (
&vc->f.fid)->Fid.Volume || (&afs_rootFid)->Cell
!= (&vc->f.fid)->Cell)) {
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 == 2) {
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) {
344 if (!FidCmp(&afs_rootFid, vc->mvid)((&afs_rootFid)->Fid.Unique != (vc->mvid)->Fid.Unique
|| (&afs_rootFid)->Fid.Vnode != (vc->mvid)->Fid
.Vnode || (&afs_rootFid)->Fid.Volume != (vc->mvid)->
Fid.Volume || (&afs_rootFid)->Cell != (vc->mvid)->
Cell)) {
345 /* Parent directory is the root of the AFS root */
346 Volume = 0;
347 Vnode = 2;
348 } else if (vc->mvid->Fid.Vnode == 1
349 && vc->mvid->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, 0, READ_LOCK1);
353 if (tvp) {
354 Volume = tvp->mtpoint.Fid.Volume;
355 Vnode = tvp->mtpoint.Fid.Vnode;
356 afs_PutVolume(tvp, READ_LOCK)((tvp)->refCount--);
357 }
358 } else {
359 /* Parent directory is not a volume root */
360 Volume = vc->mvid->Fid.Volume;
361 Vnode = vc->mvid->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_LOCK1);
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)((tvp)->refCount--);
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)(__builtin_constant_p(Vnode) ? ((((__uint32_t)(Vnode)) >>
24) | ((((__uint32_t)(Vnode)) & (0xff << 16)) >>
8) | ((((__uint32_t)(Vnode)) & (0xff << 8)) <<
8) | (((__uint32_t)(Vnode)) << 24)) : __bswap32_var(Vnode
)));
411 sdirEntry.d_reclen = rlen;
412 sdirEntry.d_off = (off_t) off;
413 AFS_UIOMOVE(&sdirEntry, AFS_DIRENT64BASESIZE, UIO_READ, auio,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 414); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((&sdirEntry),(AFS_DIRENT64BASESIZE),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 414
); (void)0; } while (0); } while(0)
414 code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 414); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((&sdirEntry),(AFS_DIRENT64BASESIZE),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 414
); (void)0; } while (0); } while(0);
415 if (code == 0)
416 AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 416); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((de->name),(slen - 1),(auio)); if (haveGlock) do { (void)
0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 416); (void)0; } while (0); } while(0);
417 if (code == 0)
418 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(DIRENTSIZE(slen) - (AFS_DIRENT64BASESIZE + slen
- 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags(
((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); (void)0; } while (0); } while(0)
419 DIRENTSIZE(slen) - (AFS_DIRENT64BASESIZE + slen -do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(DIRENTSIZE(slen) - (AFS_DIRENT64BASESIZE + slen
- 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags(
((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); (void)0; } while (0); } while(0)
420 1), UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(DIRENTSIZE(slen) - (AFS_DIRENT64BASESIZE + slen
- 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags(
((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 420); (void)0; } while (0); } while(0);
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)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 426); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 426); (void)0; } while (0); } while(0);
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)(__builtin_constant_p(Vnode) ? ((((__uint32_t)(Vnode)) >>
24) | ((((__uint32_t)(Vnode)) & (0xff << 16)) >>
8) | ((((__uint32_t)(Vnode)) & (0xff << 8)) <<
8) | (((__uint32_t)(Vnode)) << 24)) : __bswap32_var(Vnode
)));
434 sdirEntry.d_reclen = rlen;
435 sdirEntry.d_off = (afs_int32) off;
436 AFS_UIOMOVE(&sdirEntry, AFS_DIRENT32BASESIZE, UIO_READ, auio,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 437); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((&sdirEntry),(AFS_DIRENT32BASESIZE),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 437
); (void)0; } while (0); } while(0)
437 code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 437); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((&sdirEntry),(AFS_DIRENT32BASESIZE),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 437
); (void)0; } while (0); } while(0);
438 if (code == 0)
439 AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 439); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((de->name),(slen - 1),(auio)); if (haveGlock) do { (void)
0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 439); (void)0; } while (0); } while(0);
440 if (code == 0)
441 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE
+ slen - 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); (void)0; } while (0); } while(0)
442 IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE +do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE
+ slen - 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); (void)0; } while (0); } while(0)
443 slen - 1), UIO_READ,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE
+ slen - 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); (void)0; } while (0); } while(0)
444 auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(IRIX5_DIRENTSIZE(slen) - (AFS_DIRENT32BASESIZE
+ slen - 1)),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 444); (void)0; } while (0); } while(0);
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)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 450); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 450); (void)0; } while (0); } while(0);
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#if defined(AFS_SUN5_ENV)
459 direntp = (struct dirent64 *)osi_AllocLargeSpace(AFS_LRALLOCSIZ4096);
460#else
461 direntp = (struct dirent *)osi_AllocLargeSpace(AFS_LRALLOCSIZ4096);
462#endif
463 direntp->d_ino = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode)(__builtin_constant_p(Vnode) ? ((((__uint32_t)(Vnode)) >>
24) | ((((__uint32_t)(Vnode)) & (0xff << 16)) >>
8) | ((((__uint32_t)(Vnode)) & (0xff << 8)) <<
8) | (((__uint32_t)(Vnode)) << 24)) : __bswap32_var(Vnode
)));
464#if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
465 direntp->d_offset = off;
466 direntp->d_namlen = slen;
467#else
468 direntp->d_off = off;
469#endif
470 direntp->d_reclen = rlen;
471 strcpy(direntp->d_name, de->name);
472 AFS_UIOMOVE((caddr_t) direntp, rlen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 472); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((caddr_t) direntp),(rlen),(auio)); if (haveGlock) do { (void
)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 472); (void)0; } while (0); } while(0);
473 osi_FreeLargeSpace((char *)direntp);
474#else /* AFS_SUN5_ENV */
475 /* Note the odd mechanism for building the inode number */
476 sdirEntry.d_fileno = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode)(__builtin_constant_p(Vnode) ? ((((__uint32_t)(Vnode)) >>
24) | ((((__uint32_t)(Vnode)) & (0xff << 16)) >>
8) | ((((__uint32_t)(Vnode)) & (0xff << 8)) <<
8) | (((__uint32_t)(Vnode)) << 24)) : __bswap32_var(Vnode
)));
477 sdirEntry.d_reclen = rlen;
478#if !defined(AFS_SGI_ENV)
479 sdirEntry.d_namlen = slen;
480#endif
481#if defined(AFS_AIX32_ENV) || defined(AFS_SGI_ENV)
482 sdirEntry.d_off = off;
483#endif
484#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
485 sdirEntry.d_type = afs_readdir_type(vc, de);
486#endif
487
488#if defined(AFS_SGI_ENV)
489 AFS_UIOMOVE(&sdirEntry, DIRENTBASESIZE, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 489); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((&sdirEntry),(DIRENTBASESIZE),(auio)); if (haveGlock) do
{ (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 489); (void)0; } while (0); } while(0);
490 if (code == 0)
491 AFS_UIOMOVE(de->name, slen - 1, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 491); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((de->name),(slen - 1),(auio)); if (haveGlock) do { (void)
0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 491); (void)0; } while (0); } while(0);
492 if (code == 0)
493 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((sizeof (struct dirent) - (255 +1)) + (((slen
)+1 + 3) &~ 3)) - (DIRENTBASESIZE + slen - 1)),(auio)); if
(haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); (void)0; } while (0); } while(0)
494 DIRSIZ_LEN(slen) - (DIRENTBASESIZE + slen - 1), UIO_READ,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((sizeof (struct dirent) - (255 +1)) + (((slen
)+1 + 3) &~ 3)) - (DIRENTBASESIZE + slen - 1)),(auio)); if
(haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); (void)0; } while (0); } while(0)
495 auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((sizeof (struct dirent) - (255 +1)) + (((slen
)+1 + 3) &~ 3)) - (DIRENTBASESIZE + slen - 1)),(auio)); if
(haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 495); (void)0; } while (0); } while(0);
496#else /* AFS_SGI_ENV */
497 AFS_MOVE_UNLOCK();
498#if defined(AFS_NBSD40_ENV)
499 {
500 struct dirent *dp;
501 dp = osi_AllocLargeSpace(sizeof(struct dirent));
502 memset(dp, 0, sizeof(struct dirent));
503 dp->d_ino = afs_calc_inum(vc->f.fid.Cell, Volume, ntohl(Vnode)(__builtin_constant_p(Vnode) ? ((((__uint32_t)(Vnode)) >>
24) | ((((__uint32_t)(Vnode)) & (0xff << 16)) >>
8) | ((((__uint32_t)(Vnode)) & (0xff << 8)) <<
8) | (((__uint32_t)(Vnode)) << 24)) : __bswap32_var(Vnode
)));
504 dp->d_namlen = slen;
505 dp->d_type = afs_readdir_type(vc, de);
506 strcpy(dp->d_name, de->name);
507 dp->d_reclen = _DIRENT_SIZE(dp) /* rlen */;
508 if ((afs_debug & AFSDEB_VNLAYER8) != 0) {
509 afs_warn("%s: %s type %d slen %d rlen %d act. rlen %zu\n", __func__,
510 dp->d_name, dp->d_type, slen, rlen, _DIRENT_SIZE(dp));
511 }
512 AFS_UIOMOVE(dp, dp->d_reclen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 512); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((dp),(dp->d_reclen),(auio)); if (haveGlock) do { (void)0;
_mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 512); (void)0; } while (0); } while(0);
513 osi_FreeLargeSpace((char *)dp);
514 }
515#else
516 AFS_UIOMOVE((char *) &sdirEntry, sizeof(sdirEntry), UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 516); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *) &sdirEntry),(sizeof(sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 516
); (void)0; } while (0); } while(0);
517 if (code == 0) {
518 AFS_UIOMOVE(de->name, slen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 518); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((de->name),(slen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 518); (void)0; } while (0); } while(0);
519 }
520 /* pad out the remaining characters with zeros */
521 if (code == 0) {
522 AFS_UIOMOVE(bufofzeros, ((slen + 1 + DIRPAD) & ~DIRPAD) - slen,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 523); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((slen + 1 + 3) & ~3) - slen),(auio)); if (
haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 523); (void)0; } while (0); } while(0)
523 UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 523); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((slen + 1 + 3) & ~3) - slen),(auio)); if (
haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 523); (void)0; } while (0); } while(0);
524 }
525#endif
526 AFS_MOVE_LOCK();
527#endif /* AFS_SGI_ENV */
528#if !defined(AFS_NBSD_ENV)
529 /* pad out the difference between rlen and slen... */
530 if (DIRSIZ_LEN(slen)((sizeof (struct dirent) - (255 +1)) + (((slen)+1 + 3) &~
3)) < rlen) {
531 AFS_MOVE_UNLOCK();
532 while (DIRSIZ_LEN(slen)((sizeof (struct dirent) - (255 +1)) + (((slen)+1 + 3) &~
3)) < rlen) {
533 int minLen = rlen - DIRSIZ_LEN(slen)((sizeof (struct dirent) - (255 +1)) + (((slen)+1 + 3) &~
3));
534 if (minLen > sizeof(bufofzeros))
535 minLen = sizeof(bufofzeros);
536 AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 536); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 536); (void)0; } while (0); } while(0);
537 rlen -= minLen;
538 }
539 AFS_MOVE_LOCK();
540 }
541#endif
542#endif /* AFS_SUN5_ENV */
543#endif /* AFS_SGI53_ENV */
544 return (code);
545}
546
547
548/*
549 *------------------------------------------------------------------------------
550 *
551 * Read directory entries.
552 * There are some weird things to look out for here. The uio_offset
553 * field is either 0 or it is the offset returned from a previous
554 * readdir. It is an opaque value used by the server to find the
555 * correct directory block to read. The byte count must be at least
556 * vtoblksz(vp) bytes. The count field is the number of blocks to
557 * read on the server. This is advisory only, the server may return
558 * only one block's worth of entries. Entries may be compressed on
559 * the server.
560 *
561 * This routine encodes knowledge of Vice dirs.
562 */
563
564void
565afs_bulkstat_send(struct vcache *avc, struct vrequest *req)
566{
567 afs_rd_stash_i = 0;
568}
569
570/*
571 * Here is the bad, bad, really bad news.
572 * It has to do with 'offset' (seek locations).
573*/
574
575int
576#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
577afs_readdir(OSI_VC_DECL(avc)struct vcache *avc, struct uio *auio, afs_ucred_t *acred,
578 int *eofp)
579#else
580#if defined(AFS_HPUX100_ENV)
581afs_readdir2(OSI_VC_DECL(avc)struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
582#else
583afs_readdir(OSI_VC_DECL(avc)struct vcache *avc, struct uio *auio, afs_ucred_t *acred)
584#endif
585#endif
586{
587 struct vrequest treq;
588 struct dcache *tdc;
589 afs_size_t origOffset, tlen;
590 afs_int32 len;
591 int code = 0;
592 struct DirBuffer oldEntry, nextEntry;
593 struct DirEntry *ode = 0, *nde = 0;
594 int o_slen = 0, n_slen = 0;
595 afs_uint32 us;
596 struct afs_fakestat_state fakestate;
597#if defined(AFS_SGI53_ENV)
598 afs_int32 use64BitDirent, dirsiz;
599#endif /* defined(AFS_SGI53_ENV) */
600#ifndef AFS_HPUX_ENV
601 OSI_VC_CONVERT(avc);
602#else
603 /*
604 * XXX All the hacks for alloced sdirEntry and inlining of afs_readdir_move instead of calling
605 * it is necessary for hpux due to stack problems that seem to occur when coming thru the nfs
606 * translator side XXX
607 */
608 struct min_direct *sdirEntry =
609 (struct min_direct *)osi_AllocSmallSpace(sizeof(struct min_direct));
610 afs_int32 rlen;
611#endif
612
613 /* opaque value is pointer into a vice dir; use bit map to decide
614 * if the entries are in use. Always assumed to be valid. 0 is
615 * special, means start of a new dir. Int32 inode, followed by
616 * short reclen and short namelen. Namelen does not include
617 * the null byte. Followed by null-terminated string.
618 */
619 AFS_STATCNT(afs_readdir)((afs_cmstats.callInfo.C_afs_readdir)++);
620
621 memset(&oldEntry, 0, sizeof(struct DirBuffer));
622 memset(&nextEntry, 0, sizeof(struct DirBuffer));
623
624#if defined(AFS_SGI53_ENV)
625#ifdef AFS_SGI61_ENV
626#ifdef AFS_SGI62_ENV
627 use64BitDirent =
628 ABI_IS(ABI_IRIX5_64, GETDENTS_ABI(OSI_GET_CURRENT_ABI(), auio));
629#else
630 use64BitDirent =
631 (auio->uio_segflg !=
632 UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64 | ABI_IRIX5_N32,
633 u.u_procp->p_abi));
634#endif /* AFS_SGI62_ENV */
635#else /* AFS_SGI61_ENV */
636 use64BitDirent =
637 (auio->uio_segflg !=
638 UIO_USERSPACE) ? ABI_IRIX5_64 : (ABI_IS(ABI_IRIX5_64,
639 u.u_procp->p_abi));
640#endif /* AFS_SGI61_ENV */
641#endif /* defined(AFS_SGI53_ENV) */
642
643#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
644 /* Not really used by the callee so we ignore it for now */
645 if (eofp)
646 *eofp = 0;
647#endif
648#ifndef AFS_64BIT_CLIENT1
649 if (AfsLargeFileUio(auio)0 /* file is large than 2 GB */
650 ||AfsLargeFileSize(AFS_UIO_OFFSET(auio), AFS_UIO_RESID(auio))0)
651 return EFBIG27;
652#endif
653
654 if ((code = afs_InitReq(&treq, acred))) {
655#ifdef AFS_HPUX_ENV
656 osi_FreeSmallSpace((char *)sdirEntry);
657#endif
658 return code;
659 }
660 /* update the cache entry */
661 afs_InitFakeStat(&fakestate);
662
663 AFS_DISCON_LOCK()do { ; if (!((&afs_discon_lock)->excl_locked & 2))
((&afs_discon_lock)->readers_reading)++; else Afs_Lock_Obtain
(&afs_discon_lock, 1); (&afs_discon_lock)->pid_last_reader
= (((__curthread())->td_proc)->p_pid ); } while (0);
664
665 code = afs_EvalFakeStat(&avc, &fakestate, &treq);
666 if (code)
667 goto done;
668 tagain:
669 code = afs_VerifyVCache(avc, &treq)(((avc)->f.states & 0x00000001) ? 0 : afs_VerifyVCache2
((avc),&treq));
670 if (code)
671 goto done;
672 /* get a reference to the entire directory */
673 tdc = afs_GetDCache(avc, (afs_size_t) 0, &treq, &origOffset, &tlen, 1);
674 len = tlen;
Value stored to 'len' is never read
675 if (!tdc) {
676 code = ENOENT2;
677 goto done;
678 }
679 ObtainReadLock(&avc->lock)do { ; if (!((&avc->lock)->excl_locked & 2)) ((
&avc->lock)->readers_reading)++; else Afs_Lock_Obtain
(&avc->lock, 1); (&avc->lock)->pid_last_reader
= (((__curthread())->td_proc)->p_pid ); } while (0);
680 ObtainReadLock(&tdc->lock)do { ; if (!((&tdc->lock)->excl_locked & 2)) ((
&tdc->lock)->readers_reading)++; else Afs_Lock_Obtain
(&tdc->lock, 1); (&tdc->lock)->pid_last_reader
= (((__curthread())->td_proc)->p_pid ); } while (0);
681
682 /*
683 * Make sure that the data in the cache is current. There are two
684 * cases we need to worry about:
685 * 1. The cache data is being fetched by another process.
686 * 2. The cache data is no longer valid
687 */
688 while ((avc->f.states & CStatd0x00000001)
689 && (tdc->dflags & DFFetching0x04)
690 && hsame(avc->f.m.DataVersion, tdc->f.versionNo)((avc->f.m.DataVersion).low == (tdc->f.versionNo).low &&
(avc->f.m.DataVersion).high == (tdc->f.versionNo).high
)) {
691 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAIT, ICL_TYPE_STRING,(((afs_iclSetp) && (afs_iclSetp->states & 2)) ?
afs_icl_Event4(afs_iclSetp, (701087887L), (1<<24)+((4)
<<18)+((7)<<12)+((2)<<6)+(7), (long)("/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
), (long)(692), (long)(tdc), (long)(tdc->dflags)) : 0)
692 __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER, tdc,(((afs_iclSetp) && (afs_iclSetp->states & 2)) ?
afs_icl_Event4(afs_iclSetp, (701087887L), (1<<24)+((4)
<<18)+((7)<<12)+((2)<<6)+(7), (long)("/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
), (long)(692), (long)(tdc), (long)(tdc->dflags)) : 0)
693 ICL_TYPE_INT32, tdc->dflags)(((afs_iclSetp) && (afs_iclSetp->states & 2)) ?
afs_icl_Event4(afs_iclSetp, (701087887L), (1<<24)+((4)
<<18)+((7)<<12)+((2)<<6)+(7), (long)("/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
), (long)(692), (long)(tdc), (long)(tdc->dflags)) : 0);
694 ReleaseReadLock(&tdc->lock)do { ; if (!(--((&tdc->lock)->readers_reading)) &&
(&tdc->lock)->wait_states) Afs_Lock_ReleaseW(&
tdc->lock) ; if ( (&tdc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&tdc->lock
)->pid_last_reader =0; } while (0);
695 ReleaseReadLock(&avc->lock)do { ; if (!(--((&avc->lock)->readers_reading)) &&
(&avc->lock)->wait_states) Afs_Lock_ReleaseW(&
avc->lock) ; if ( (&avc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&avc->lock
)->pid_last_reader =0; } while (0);
696 afs_osi_Sleep(&tdc->validPos);
697 ObtainReadLock(&avc->lock)do { ; if (!((&avc->lock)->excl_locked & 2)) ((
&avc->lock)->readers_reading)++; else Afs_Lock_Obtain
(&avc->lock, 1); (&avc->lock)->pid_last_reader
= (((__curthread())->td_proc)->p_pid ); } while (0);
698 ObtainReadLock(&tdc->lock)do { ; if (!((&tdc->lock)->excl_locked & 2)) ((
&tdc->lock)->readers_reading)++; else Afs_Lock_Obtain
(&tdc->lock, 1); (&tdc->lock)->pid_last_reader
= (((__curthread())->td_proc)->p_pid ); } while (0);
699 }
700 if (!(avc->f.states & CStatd0x00000001)
701 || !hsame(avc->f.m.DataVersion, tdc->f.versionNo)((avc->f.m.DataVersion).low == (tdc->f.versionNo).low &&
(avc->f.m.DataVersion).high == (tdc->f.versionNo).high
)) {
702 ReleaseReadLock(&tdc->lock)do { ; if (!(--((&tdc->lock)->readers_reading)) &&
(&tdc->lock)->wait_states) Afs_Lock_ReleaseW(&
tdc->lock) ; if ( (&tdc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&tdc->lock
)->pid_last_reader =0; } while (0);
703 ReleaseReadLock(&avc->lock)do { ; if (!(--((&avc->lock)->readers_reading)) &&
(&avc->lock)->wait_states) Afs_Lock_ReleaseW(&
avc->lock) ; if ( (&avc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&avc->lock
)->pid_last_reader =0; } while (0);
704 afs_PutDCache(tdc);
705 goto tagain;
706 }
707
708 /*
709 * iterator for the directory reads. Takes the AFS DirEntry
710 * structure and slams them into UFS direct structures.
711 * uses afs_readdir_move to get the struct to the user space.
712 *
713 * The routine works by looking ahead one AFS directory entry.
714 * That's because the AFS entry we are currenly working with
715 * may not fit into the buffer the user has provided. If it
716 * doesn't we have to change the size of the LAST AFS directory
717 * entry, so that it will FIT perfectly into the block the
718 * user has provided.
719 *
720 * The 'forward looking' of the code makes it a bit tough to read.
721 * Remember we need to get an entry, see if it it fits, then
722 * set it up as the LAST entry, and find the next one.
723 *
724 * Tough to take: We give out an EINVAL if we don't have enough
725 * space in the buffer, and at the same time, don't have an entry
726 * to put into the buffer. This CAN happen if the first AFS entry
727 * we get can't fit into the 512 character buffer provided. Seems
728 * it ought not happen...
729 *
730 * Assumption: don't need to use anything but one dc entry:
731 * this means the directory ought not be greater than 64k.
732 */
733 len = 0;
734#ifdef AFS_HPUX_ENV
735 auio->uio_fpflags = 0;
736#endif
737 while (code == 0) {
738 origOffset = AFS_UIO_OFFSET(auio)(auio)->uio_offset;
739 /* scan for the next interesting entry scan for in-use blob otherwise up point at
740 * this blob note that ode, if non-zero, also represents a held dir page */
741 if (!(us = BlobScan(tdc, (origOffset >> 5)))
742 || (afs_dir_GetBlob(tdc, us, &nextEntry) != 0)) {
743 /* failed to setup nde, return what we've got, and release ode */
744 if (len) {
745 /* something to hand over. */
746#ifdef AFS_HPUX_ENV
747 sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
748 avc->f.fid.Fid.Volume,
749 ntohl(ode->fid.vnode)(__builtin_constant_p(ode->fid.vnode) ? ((((__uint32_t)(ode
->fid.vnode)) >> 24) | ((((__uint32_t)(ode->fid.vnode
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ode
->fid.vnode)) & (0xff << 8)) << 8) | (((__uint32_t
)(ode->fid.vnode)) << 24)) : __bswap32_var(ode->fid
.vnode)));
750 sdirEntry->d_reclen = rlen = AFS_UIO_RESID(auio)(auio)->uio_resid;
751 sdirEntry->d_namlen = o_slen;
752#if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
753 sdirEntry->d_off = origOffset;
754#endif
755 AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 756); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 756
); (void)0; } while (0); } while(0)
756 auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 756); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 756
); (void)0; } while (0); } while(0);
757 if (code == 0)
758 AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 758); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((ode->name),(o_slen),(auio)); if (haveGlock) do { (void)0
; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 758); (void)0; } while (0); } while(0);
759 /* pad out the remaining characters with zeros */
760 if (code == 0) {
761 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); (void)0; } while (0); } while(0)
762 ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); (void)0; } while (0); } while(0)
763 UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 763); (void)0; } while (0); } while(0);
764 }
765 /* pad out the difference between rlen and slen... */
766 if (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
767 while (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
768 int minLen = rlen - DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3));
769 if (minLen > sizeof(bufofzeros))
770 minLen = sizeof(bufofzeros);
771 AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 771); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 771); (void)0; } while (0); } while(0);
772 rlen -= minLen;
773 }
774 }
775#else
776 code = afs_readdir_move(ode, avc, auio, o_slen,
777#if defined(AFS_SUN5_ENV) || defined(AFS_NBSD_ENV)
778 len, origOffset);
779#else
780 AFS_UIO_RESID(auio)(auio)->uio_resid, origOffset);
781#endif
782#endif /* AFS_HPUX_ENV */
783#if !defined(AFS_SUN5_ENV) && !defined(AFS_NBSD_ENV)
784 AFS_UIO_SETRESID(auio, 0)(auio)->uio_resid = 0;
785#endif
786 } else {
787 /* nothin to hand over */
788 }
789#if defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
790 if (eofp)
791 *eofp = 1; /* Set it properly */
792#endif
793 DRelease(&oldEntry, 0);
794 goto dirend;
795 }
796 nde = (struct DirEntry *)nextEntry.data;
797
798 /* Do we have enough user space to carry out our mission? */
799#if defined(AFS_SGI_ENV)
800 n_slen = strlen(nde->name) + 1; /* NULL terminate */
801#else
802 n_slen = strlen(nde->name);
803#endif
804#ifdef AFS_SGI53_ENV
805 dirsiz =
806 use64BitDirent ? DIRENTSIZE(n_slen) : IRIX5_DIRENTSIZE(n_slen);
807 if (dirsiz >= (AFS_UIO_RESID(auio)(auio)->uio_resid - len)) {
808#else
809 if (DIRSIZ_LEN(n_slen)((sizeof (struct dirent) - (255 +1)) + (((n_slen)+1 + 3) &
~ 3)) >= (AFS_UIO_RESID(auio)(auio)->uio_resid - len)) {
810#endif /* AFS_SGI53_ENV */
811 /* No can do no more now; ya know... at this time */
812 DRelease(&nextEntry, 0); /* can't use this one. */
813 if (len) {
814#ifdef AFS_HPUX_ENV
815 sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
816 avc->f.fid.Fid.Volume,
817 ntohl(ode->fid.vnode)(__builtin_constant_p(ode->fid.vnode) ? ((((__uint32_t)(ode
->fid.vnode)) >> 24) | ((((__uint32_t)(ode->fid.vnode
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ode
->fid.vnode)) & (0xff << 8)) << 8) | (((__uint32_t
)(ode->fid.vnode)) << 24)) : __bswap32_var(ode->fid
.vnode)));
818 sdirEntry->d_reclen = rlen = AFS_UIO_RESID(auio)(auio)->uio_resid;
819 sdirEntry->d_namlen = o_slen;
820#if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
821 sdirEntry->d_off = origOffset;
822#endif
823 AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 824); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 824
); (void)0; } while (0); } while(0)
824 auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 824); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 824
); (void)0; } while (0); } while(0);
825 if (code == 0)
826 AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 826); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((ode->name),(o_slen),(auio)); if (haveGlock) do { (void)0
; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 826); (void)0; } while (0); } while(0);
827 /* pad out the remaining characters with zeros */
828 if (code == 0) {
829 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); (void)0; } while (0); } while(0)
830 ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); (void)0; } while (0); } while(0)
831 UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 831); (void)0; } while (0); } while(0);
832 }
833 /* pad out the difference between rlen and slen... */
834 if (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
835 while (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
836 int minLen = rlen - DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3));
837 if (minLen > sizeof(bufofzeros))
838 minLen = sizeof(bufofzeros);
839 AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 839); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 839); (void)0; } while (0); } while(0);
840 rlen -= minLen;
841 }
842 }
843#else /* AFS_HPUX_ENV */
844 code =
845 afs_readdir_move(ode, avc, auio, o_slen,
846 AFS_UIO_RESID(auio)(auio)->uio_resid, origOffset);
847#endif /* AFS_HPUX_ENV */
848 /* this next line used to be AFSVFS40 or AIX 3.1, but is
849 * really generic */
850 AFS_UIO_SETOFFSET(auio, origOffset)(auio)->uio_offset = origOffset;
851#if !defined(AFS_NBSD_ENV)
852 AFS_UIO_SETRESID(auio, 0)(auio)->uio_resid = 0;
853#endif
854 } else { /* trouble, can't give anything to the user! */
855 /* even though he has given us a buffer,
856 * even though we have something to give us,
857 * Looks like we lost something somewhere.
858 */
859 code = EINVAL22;
860 }
861 DRelease(&oldEntry, 0);
862 goto dirend;
863 }
864
865 /*
866 * In any event, we move out the LAST de entry, getting ready
867 * to set up for the next one.
868 */
869 if (len) {
870#ifdef AFS_HPUX_ENV
871 sdirEntry->d_fileno = afs_calc_inum(avc->f.fid.Cell,
872 avc->f.fid.Fid.Volume,
873 ntohl(ode->fid.vnode)(__builtin_constant_p(ode->fid.vnode) ? ((((__uint32_t)(ode
->fid.vnode)) >> 24) | ((((__uint32_t)(ode->fid.vnode
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(ode
->fid.vnode)) & (0xff << 8)) << 8) | (((__uint32_t
)(ode->fid.vnode)) << 24)) : __bswap32_var(ode->fid
.vnode)));
874 sdirEntry->d_reclen = rlen = len;
875 sdirEntry->d_namlen = o_slen;
876#if defined(AFS_SUN5_ENV) || defined(AFS_AIX32_ENV) || defined(AFS_HPUX100_ENV)
877 sdirEntry->d_off = origOffset;
878#endif
879 AFS_UIOMOVE((char *)sdirEntry, sizeof(*sdirEntry), UIO_READ, auio,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 880); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 880
); (void)0; } while (0); } while(0)
880 code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 880); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
(((char *)sdirEntry),(sizeof(*sdirEntry)),(auio)); if (haveGlock
) do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c", 880
); (void)0; } while (0); } while(0);
881 if (code == 0)
882 AFS_UIOMOVE(ode->name, o_slen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 882); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((ode->name),(o_slen),(auio)); if (haveGlock) do { (void)0
; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 882); (void)0; } while (0); } while(0);
883 /* pad out the remaining characters with zeros */
884 if (code == 0) {
885 AFS_UIOMOVE(bufofzeros,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); (void)0; } while (0); } while(0)
886 ((o_slen + 1 + DIRPAD) & ~DIRPAD) - o_slen,do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); (void)0; } while (0); } while(0)
887 UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(((o_slen + 1 + 3) & ~3) - o_slen),(auio));
if (haveGlock) do { (void)0; _mtx_lock_flags(((&afs_global_mtx
)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 887); (void)0; } while (0); } while(0);
888 }
889 /* pad out the difference between rlen and slen... */
890 if (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
891 while (DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3)) < rlen) {
892 int minLen = rlen - DIRSIZ_LEN(o_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen)+1 + 3) &
~ 3));
893 if (minLen > sizeof(bufofzeros))
894 minLen = sizeof(bufofzeros);
895 AFS_UIOMOVE(bufofzeros, minLen, UIO_READ, auio, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 895); } while (0); (auio)->uio_rw = (UIO_READ); code = uiomove
((bufofzeros),(minLen),(auio)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/VNOPS/afs_vnop_readdir.c"
, 895); (void)0; } while (0); } while(0);
896 rlen -= minLen;
897 }
898 }
899#else /* AFS_HPUX_ENV */
900 code = afs_readdir_move(ode, avc, auio, o_slen, len, origOffset);
901#endif /* AFS_HPUX_ENV */
902 }
903#ifdef AFS_SGI53_ENV
904 len = use64BitDirent ? DIRENTSIZE(o_slen =
905 n_slen) : IRIX5_DIRENTSIZE(o_slen =
906 n_slen);
907#else
908 len = DIRSIZ_LEN(o_slen = n_slen)((sizeof (struct dirent) - (255 +1)) + (((o_slen = n_slen)+1 +
3) &~ 3));
909#endif /* AFS_SGI53_ENV */
910
911 DRelease(&oldEntry, 0);
912 ode = nde;
913 AFS_UIO_SETOFFSET(auio, (afs_int32) ((us + afs_dir_NameBlobs(nde->name)) << 5))(auio)->uio_offset = (afs_int32) ((us + afs_dir_NameBlobs(
nde->name)) << 5);
914 }
915
916 DRelease(&oldEntry, 0);
917
918 dirend:
919 ReleaseReadLock(&tdc->lock)do { ; if (!(--((&tdc->lock)->readers_reading)) &&
(&tdc->lock)->wait_states) Afs_Lock_ReleaseW(&
tdc->lock) ; if ( (&tdc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&tdc->lock
)->pid_last_reader =0; } while (0);
920 afs_PutDCache(tdc);
921 ReleaseReadLock(&avc->lock)do { ; if (!(--((&avc->lock)->readers_reading)) &&
(&avc->lock)->wait_states) Afs_Lock_ReleaseW(&
avc->lock) ; if ( (&avc->lock)->pid_last_reader ==
(((__curthread())->td_proc)->p_pid ) ) (&avc->lock
)->pid_last_reader =0; } while (0);
922
923 done:
924#ifdef AFS_HPUX_ENV
925 osi_FreeSmallSpace((char *)sdirEntry);
926#endif
927 AFS_DISCON_UNLOCK()do { ; if (!(--((&afs_discon_lock)->readers_reading)) &&
(&afs_discon_lock)->wait_states) Afs_Lock_ReleaseW(&
afs_discon_lock) ; if ( (&afs_discon_lock)->pid_last_reader
== (((__curthread())->td_proc)->p_pid ) ) (&afs_discon_lock
)->pid_last_reader =0; } while (0);
928 afs_PutFakeStat(&fakestate);
929 code = afs_CheckCode(code, &treq, 28);
930 return code;
931}
932
933#endif /* !AFS_LINUX20_ENV */