static DIR *
__opendir_common(int fd, const char *name, int flags)
{
DIR *dirp = NULL;
int serrno;
struct stat sb;
#if !defined(__minix)
struct statvfs sfb;
#endif /* !defined(__minix) */
int error;
if (fstat(fd, &sb) || !S_ISDIR(sb.st_mode)) {
errno = ENOTDIR;
goto error;
}
if ((dirp = malloc(sizeof(*dirp))) == NULL)
goto error;
dirp->dd_buf = NULL;
dirp->dd_internal = NULL;
#ifdef _REENTRANT
if (__isthreaded) {
if ((dirp->dd_lock = malloc(sizeof(mutex_t))) == NULL)
goto error;
mutex_init((mutex_t *)dirp->dd_lock, NULL);
}
#endif
/*
* Tweak flags for the underlying filesystem.
*/
#if defined(__minix)
/* MOUNT_UNION and MOUNT_NFS not supported */
flags &= ~DTF_NODUP;
#else
if (fstatvfs1(fd, &sfb, ST_NOWAIT) < 0)
goto error;
if ((flags & DTF_NODUP) != 0) {
if (!strncmp(sfb.f_fstypename, MOUNT_UNION,
sizeof(sfb.f_fstypename)) ||
(sfb.f_flag & MNT_UNION) != 0) {
flags |= __DTF_READALL;
} else {
flags &= ~DTF_NODUP;
}
}
if (!strncmp(sfb.f_fstypename, MOUNT_NFS, sizeof(sfb.f_fstypename))) {
flags |= __DTF_READALL | __DTF_RETRY_ON_BADCOOKIE;
}
#endif /* !defined(__minix) */
dirp->dd_flags = flags;
error = _initdir(dirp, fd, name);
if (error) {
errno = error;
goto error;
}
return (dirp);
error:
serrno = errno;
if (dirp != NULL) {
#ifdef _REENTRANT
if (__isthreaded) {
mutex_destroy((mutex_t *)dirp->dd_lock);
free(dirp->dd_lock);
}
#endif
free(dirp->dd_buf);
}
free(dirp);
if (fd != -1)
(void)close(fd);
errno = serrno;
return NULL;
}
int
fstatvfs(int f, struct statvfs *st)
{
return fstatvfs1(f, st, ST_WAIT);
}
static DIR *
__opendir_common(int fd, const char *name, int flags)
{
DIR *dirp = NULL;
int serrno;
struct stat sb;
int pagesz;
int incr;
int unionstack, nfsdir;
struct statvfs sfb;
_DIAGASSERT(name != NULL);
if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
goto error;
if (fstat(fd, &sb) || !S_ISDIR(sb.st_mode)) {
errno = ENOTDIR;
goto error;
}
if ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL)
goto error;
dirp->dd_buf = NULL;
/*
* If the machine's page size is an exact multiple of DIRBLKSIZ,
* use a buffer that is cluster boundary aligned.
* Hopefully this can be a big win someday by allowing page trades
* to user space to be done by getdirentries()
*/
if (((pagesz = getpagesize()) % DIRBLKSIZ) == 0)
incr = pagesz;
else
incr = DIRBLKSIZ;
/*
* Determine whether this directory is the top of a union stack.
*/
if (fstatvfs1(fd, &sfb, ST_NOWAIT) < 0)
goto error;
if (flags & DTF_NODUP)
unionstack = !(strncmp(sfb.f_fstypename, MOUNT_UNION,
sizeof(sfb.f_fstypename))) || (sfb.f_flag & MNT_UNION);
else
unionstack = 0;
nfsdir = !(strncmp(sfb.f_fstypename, MOUNT_NFS, sizeof(sfb.f_fstypename)));
if (unionstack || nfsdir) {
size_t len;
size_t space;
char *buf, *nbuf;
char *ddptr;
char *ddeptr;
int n;
struct dirent **dpv;
int i;
/*
* The strategy here for directories on top of a union stack
* is to read all the directory entries into a buffer, sort
* the buffer, and remove duplicate entries by setting the
* inode number to zero.
*
* For directories on an NFS mounted filesystem, we try
* to get a consistent snapshot by trying until we have
* successfully read all of the directory without errors
* (i.e. 'bad cookie' errors from the server because
* the directory was modified). These errors should not
* happen often, but need to be dealt with.
*/
i = 0;
retry:
len = 0;
space = 0;
buf = 0;
ddptr = 0;
do {
/*
* Always make at least DIRBLKSIZ bytes
* available to getdirentries
*/
if (space < DIRBLKSIZ) {
space += incr;
len += incr;
nbuf = realloc(buf, len);
if (nbuf == NULL) {
dirp->dd_buf = buf;
goto error;
}
buf = nbuf;
ddptr = buf + (len - space);
}
dirp->dd_seek = lseek(fd, (off_t)0, SEEK_CUR);
n = getdents(fd, ddptr, space);
/*
* For NFS: EINVAL means a bad cookie error
* from the server. Keep trying to get a
* consistent view, in this case this means
* starting all over again.
*/
if (n == -1 && errno == EINVAL && nfsdir) {
free(buf);
lseek(fd, (off_t)0, SEEK_SET);
if (++i > MAXITERATIONS)
goto error;
goto retry;
}
if (n > 0) {
ddptr += n;
space -= n;
}
} while (n > 0);
ddeptr = ddptr;
flags |= __DTF_READALL;
/*
* Re-open the directory.
* This has the effect of rewinding back to the
* top of the union stack and is needed by
* programs which plan to fchdir to a descriptor
* which has also been read -- see fts.c.
*/
if (flags & DTF_REWIND) {
(void) close(fd);
if ((fd = open(name, O_RDONLY)) == -1 ||
fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
dirp->dd_buf = buf;
goto error;
}
}
/*
* There is now a buffer full of (possibly) duplicate
* names.
*/
dirp->dd_buf = buf;
/*
* Go round this loop twice...
*
* Scan through the buffer, counting entries.
* On the second pass, save pointers to each one.
* Then sort the pointers and remove duplicate names.
*/
if (!nfsdir) {
for (dpv = 0;;) {
for (n = 0, ddptr = buf; ddptr < ddeptr;) {
struct dirent *dp;
dp = (struct dirent *)(void *)ddptr;
if ((long)dp & _DIRENT_ALIGN(dp))
break;
/*
* d_reclen is unsigned,
* so no need to compare <= 0
*/
if (dp->d_reclen > (ddeptr + 1 - ddptr))
break;
ddptr += dp->d_reclen;
if (dp->d_fileno) {
if (dpv)
dpv[n] = dp;
n++;
}
}
if (dpv) {
struct dirent *xp;
/*
* This sort must be stable.
*/
mergesort(dpv, (size_t)n, sizeof(*dpv),
alphasort);
dpv[n] = NULL;
xp = NULL;
/*
* Scan through the buffer in sort
* order, zapping the inode number
* of any duplicate names.
*/
for (n = 0; dpv[n]; n++) {
struct dirent *dp = dpv[n];
if ((xp == NULL) ||
strcmp(dp->d_name,
xp->d_name))
xp = dp;
else
dp->d_fileno = 0;
if (dp->d_type == DT_WHT &&
(flags & DTF_HIDEW))
dp->d_fileno = 0;
}
free(dpv);
break;
} else {
dpv = malloc((n + 1) *
sizeof(struct dirent *));
if (dpv == NULL)
break;
}
}
}
dirp->dd_len = len;
dirp->dd_size = ddptr - dirp->dd_buf;
} else {
dirp->dd_len = incr;
dirp->dd_buf = malloc((size_t)dirp->dd_len);
if (dirp->dd_buf == NULL)
goto error;
dirp->dd_seek = 0;
flags &= ~DTF_REWIND;
}
dirp->dd_loc = 0;
dirp->dd_fd = fd;
dirp->dd_flags = flags;
/*
* Set up seek point for rewinddir.
*/
#ifdef _REENTRANT
if (__isthreaded) {
if ((dirp->dd_lock = malloc(sizeof(mutex_t))) == NULL)
goto error;
mutex_init((mutex_t *)dirp->dd_lock, NULL);
}
#endif
dirp->dd_internal = NULL;
(void)_telldir_unlocked(dirp);
return (dirp);
error:
serrno = errno;
if (dirp && dirp->dd_buf)
free(dirp->dd_buf);
if (dirp)
free(dirp);
if (fd != -1)
(void)close(fd);
errno = serrno;
return NULL;
}
