/*
* Vnode op for reading directories.
*
* Convert the on-disk entries to <sys/dirent.h> entries.
* the problem is that the conversion will blow up some entries by four bytes,
* so it can't be done in place. This is too bad. Right now the conversion is
* done entry by entry, the converted entry is sent via uiomove.
*
* XXX allocate a buffer, convert as many entries as possible, then send
* the whole buffer to uiomove
*/
int
ext2fs_readdir(void *v)
{
struct vop_readdir_args /* {
struct vnode *a_vp;
struct uio *a_uio;
kauth_cred_t a_cred;
int **a_eofflag;
off_t **a_cookies;
int ncookies;
} */ *ap = v;
struct uio *uio = ap->a_uio;
int error;
size_t e2fs_count, readcnt;
struct vnode *vp = ap->a_vp;
struct m_ext2fs *fs = VTOI(vp)->i_e2fs;
struct ext2fs_direct *dp;
struct dirent *dstd;
struct uio auio;
struct iovec aiov;
void *dirbuf;
off_t off = uio->uio_offset;
off_t *cookies = NULL;
int nc = 0, ncookies = 0;
int e2d_reclen;
if (vp->v_type != VDIR)
return (ENOTDIR);
e2fs_count = uio->uio_resid;
/* Make sure we don't return partial entries. */
e2fs_count -= (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize -1);
if (e2fs_count <= 0)
return (EINVAL);
auio = *uio;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
aiov.iov_len = e2fs_count;
auio.uio_resid = e2fs_count;
UIO_SETUP_SYSSPACE(&auio);
dirbuf = kmem_alloc(e2fs_count, KM_SLEEP);
dstd = kmem_zalloc(sizeof(struct dirent), KM_SLEEP);
if (ap->a_ncookies) {
nc = e2fs_count / _DIRENT_MINSIZE((struct dirent *)0);
ncookies = nc;
cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
*ap->a_cookies = cookies;
}
aiov.iov_base = dirbuf;
error = UFS_BUFRD(ap->a_vp, &auio, 0, ap->a_cred);
if (error == 0) {
readcnt = e2fs_count - auio.uio_resid;
for (dp = (struct ext2fs_direct *)dirbuf;
(char *)dp < (char *)dirbuf + readcnt; ) {
e2d_reclen = fs2h16(dp->e2d_reclen);
if (e2d_reclen == 0) {
error = EIO;
break;
}
ext2fs_dirconv2ffs(dp, dstd);
if(dstd->d_reclen > uio->uio_resid) {
break;
}
error = uiomove(dstd, dstd->d_reclen, uio);
if (error != 0) {
break;
}
off = off + e2d_reclen;
if (cookies != NULL) {
*cookies++ = off;
if (--ncookies <= 0){
break; /* out of cookies */
}
}
/* advance dp */
dp = (struct ext2fs_direct *) ((char *)dp + e2d_reclen);
}
/* we need to correct uio_offset */
uio->uio_offset = off;
}
kmem_free(dirbuf, e2fs_count);
kmem_free(dstd, sizeof(*dstd));
*ap->a_eofflag = ext2fs_size(VTOI(ap->a_vp)) <= uio->uio_offset;
if (ap->a_ncookies) {
if (error) {
free(*ap->a_cookies, M_TEMP);
*ap->a_ncookies = 0;
*ap->a_cookies = NULL;
} else
*ap->a_ncookies = nc - ncookies;
}
return (error);
}
/*
* Vnode op for reading directories.
*
* Convert the on-disk entries to <sys/dirent.h> entries.
* the problem is that the conversion will blow up some entries by four bytes,
* so it can't be done in place. This is too bad. Right now the conversion is
* done entry by entry, the converted entry is sent via uiomove.
*
* XXX allocate a buffer, convert as many entries as possible, then send
* the whole buffer to uiomove
*/
int
ext2fs_readdir(void *v)
{
struct vop_readdir_args *ap = v;
struct uio *uio = ap->a_uio;
int error;
size_t e2fs_count, readcnt, entries;
struct vnode *vp = ap->a_vp;
struct m_ext2fs *fs = VTOI(vp)->i_e2fs;
struct ext2fs_direct *dp;
struct dirent dstd;
struct uio auio;
struct iovec aiov;
caddr_t dirbuf;
off_t off = uio->uio_offset;
u_long *cookies = NULL;
int nc = 0, ncookies = 0;
int e2d_reclen;
if (vp->v_type != VDIR)
return (ENOTDIR);
e2fs_count = uio->uio_resid;
entries = (uio->uio_offset + e2fs_count) & (fs->e2fs_bsize - 1);
/* Make sure we don't return partial entries. */
if (e2fs_count <= entries)
return (EINVAL);
e2fs_count -= entries;
auio = *uio;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_segflg = UIO_SYSSPACE;
aiov.iov_len = e2fs_count;
auio.uio_resid = e2fs_count;
dirbuf = malloc(e2fs_count, M_TEMP, M_WAITOK | M_ZERO);
if (ap->a_ncookies) {
nc = ncookies = e2fs_count / 16;
cookies = malloc(sizeof(*cookies) * ncookies, M_TEMP, M_WAITOK);
*ap->a_cookies = cookies;
}
aiov.iov_base = dirbuf;
error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred);
if (error == 0) {
readcnt = e2fs_count - auio.uio_resid;
for (dp = (struct ext2fs_direct *)dirbuf;
(char *)dp < (char *)dirbuf + readcnt; ) {
e2d_reclen = fs2h16(dp->e2d_reclen);
if (e2d_reclen == 0) {
error = EIO;
break;
}
ext2fs_dirconv2ffs(dp, &dstd);
if(dstd.d_reclen > uio->uio_resid) {
break;
}
if ((error = uiomove((caddr_t)&dstd, dstd.d_reclen, uio)) != 0) {
break;
}
off = off + e2d_reclen;
if (cookies != NULL) {
*cookies++ = off;
if (--ncookies <= 0){
break; /* out of cookies */
}
}
/* advance dp */
dp = (struct ext2fs_direct *) ((char *)dp + e2d_reclen);
}
/* we need to correct uio_offset */
uio->uio_offset = off;
}
free(dirbuf, M_TEMP);
*ap->a_eofflag = ext2fs_size(VTOI(ap->a_vp)) <= uio->uio_offset;
if (ap->a_ncookies) {
if (error) {
free(*ap->a_cookies, M_TEMP);
*ap->a_ncookies = 0;
*ap->a_cookies = NULL;
} else
*ap->a_ncookies = nc - ncookies;
}
return (error);
}