[XFS] use filldir internally (051e7cd4) · Commits · 戴 / test

fs/xfs/linux-2.6/xfs_file.c

+23 −67

Original line number	Original line	Diff line number	Diff line
	@@ -233,74 +233,30 @@ xfs_file_readdir(
	void *dirent,		void *dirent,
	filldir_t filldir)		filldir_t filldir)
	{		{
	int error = 0;		struct inode *inode = filp->f_path.dentry->d_inode;
	bhv_vnode_t *vp = vn_from_inode(filp->f_path.dentry->d_inode);		bhv_vnode_t *vp = vn_from_inode(inode);
	uio_t uio;		int error;
	iovec_t iov;		size_t bufsize;
	int eof = 0;
	caddr_t read_buf;
	int namelen, size = 0;
	size_t rlen = PAGE_CACHE_SIZE;
	xfs_off_t start_offset, curr_offset;
	xfs_dirent_t *dbp = NULL;

	/* Try fairly hard to get memory */
	do {
	if ((read_buf = kmalloc(rlen, GFP_KERNEL)))
	break;
	rlen >>= 1;
	} while (rlen >= 1024);

	if (read_buf == NULL)
	return -ENOMEM;

	uio.uio_iov = &iov;
	uio.uio_segflg = UIO_SYSSPACE;
	curr_offset = filp->f_pos;
	if (filp->f_pos != 0x7fffffff)
	uio.uio_offset = filp->f_pos;
	else
	uio.uio_offset = 0xffffffff;

	while (!eof) {
	uio.uio_resid = iov.iov_len = rlen;
	iov.iov_base = read_buf;
	uio.uio_iovcnt = 1;

	start_offset = uio.uio_offset;

	error = bhv_vop_readdir(vp, &uio, NULL, &eof);
	if ((uio.uio_offset == start_offset) \|\| error) {
	size = 0;
	break;
	}

	size = rlen - uio.uio_resid;
	dbp = (xfs_dirent_t *)read_buf;
	while (size > 0) {
	namelen = strlen(dbp->d_name);

	if (filldir(dirent, dbp->d_name, namelen,		/*
	(loff_t) curr_offset & 0x7fffffff,		* The Linux API doesn't pass down the total size of the buffer
	(ino_t) dbp->d_ino,		* we read into down to the filesystem. With the filldir concept
	DT_UNKNOWN)) {		* it's not needed for correct information, but the XFS dir2 leaf
	goto done;		* code wants an estimate of the buffer size to calculate it's
	}		* readahead window and size the buffers used for mapping to
	size -= dbp->d_reclen;		* physical blocks.
	curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;		*
	dbp = (xfs_dirent_t )((char )dbp + dbp->d_reclen);		* Try to give it an estimate that's good enough, maybe at some
	}		* point we can change the ->readdir prototype to include the
	}		* buffer size.
	done:		*/
	if (!error) {		bufsize = (size_t)min_t(loff_t, PAGE_SIZE, inode->i_size);
	if (size == 0)
	filp->f_pos = uio.uio_offset & 0x7fffffff;
	else if (dbp)
	filp->f_pos = curr_offset;
	}

	kfree(read_buf);		error = bhv_vop_readdir(vp, dirent, bufsize,
			(xfs_off_t *)&filp->f_pos, filldir);
			if (error)
	return -error;		return -error;
			return 0;
	}		}

	STATIC int		STATIC int

fs/xfs/linux-2.6/xfs_vnode.h

+4 −4

fs/xfs/xfs_dir2.c

+18 −103

Original line number	Original line	Diff line number	Diff line
	@@ -43,8 +43,6 @@
	#include "xfs_dir2_trace.h"		#include "xfs_dir2_trace.h"
	#include "xfs_error.h"		#include "xfs_error.h"

	static int xfs_dir2_put_dirent64_direct(xfs_dir2_put_args_t *pa);
	static int xfs_dir2_put_dirent64_uio(xfs_dir2_put_args_t *pa);

	void		void
	xfs_dir_mount(		xfs_dir_mount(
	@@ -293,47 +291,35 @@ xfs_dir_removename(
	* Read a directory.		* Read a directory.
	*/		*/
	int		int
	xfs_dir_getdents(		xfs_readdir(
	xfs_trans_t *tp,		bhv_desc_t *dir_bdp,
	xfs_inode_t *dp,		void *dirent,
	uio_t uio, / caller's buffer control */		size_t bufsize,
	int eofp) / out: eof reached */		xfs_off_t *offset,
			filldir_t filldir)
	{		{
	int alignment; /* alignment required for ABI */		xfs_inode_t *dp = XFS_BHVTOI(dir_bdp);
	xfs_dirent_t dbp; / malloc'ed buffer */
	xfs_dir2_put_t put; /* entry formatting routine */
	int rval; /* return value */		int rval; /* return value */
	int v; /* type-checking value */		int v; /* type-checking value */

			vn_trace_entry(BHV_TO_VNODE(dir_bdp), __FUNCTION__,
			(inst_t *)__return_address);

			if (XFS_FORCED_SHUTDOWN(dp->i_mount))
			return XFS_ERROR(EIO);

	ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);		ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
	XFS_STATS_INC(xs_dir_getdents);		XFS_STATS_INC(xs_dir_getdents);
	/*
	* If our caller has given us a single contiguous aligned memory buffer,
	* just work directly within that buffer. If it's in user memory,
	* lock it down first.
	*/
	alignment = sizeof(xfs_off_t) - 1;
	if ((uio->uio_iovcnt == 1) &&
	(((__psint_t)uio->uio_iov[0].iov_base & alignment) == 0) &&
	((uio->uio_iov[0].iov_len & alignment) == 0)) {
	dbp = NULL;
	put = xfs_dir2_put_dirent64_direct;
	} else {
	dbp = kmem_alloc(sizeof(*dbp) + MAXNAMELEN, KM_SLEEP);
	put = xfs_dir2_put_dirent64_uio;
	}

	*eofp = 0;
	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)		if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
	rval = xfs_dir2_sf_getdents(dp, uio, eofp, dbp, put);		rval = xfs_dir2_sf_getdents(dp, dirent, offset, filldir);
	else if ((rval = xfs_dir2_isblock(tp, dp, &v)))		else if ((rval = xfs_dir2_isblock(NULL, dp, &v)))
	;		;
	else if (v)		else if (v)
	rval = xfs_dir2_block_getdents(tp, dp, uio, eofp, dbp, put);		rval = xfs_dir2_block_getdents(dp, dirent, offset, filldir);
	else		else
	rval = xfs_dir2_leaf_getdents(tp, dp, uio, eofp, dbp, put);		rval = xfs_dir2_leaf_getdents(dp, dirent, bufsize, offset,
	if (dbp != NULL)		filldir);
	kmem_free(dbp, sizeof(*dbp) + MAXNAMELEN);
	return rval;		return rval;
	}		}

	@@ -612,77 +598,6 @@ xfs_dir2_isleaf(
	return 0;		return 0;
	}		}

	/*
	* Getdents put routine for 64-bit ABI, direct form.
	*/
	static int
	xfs_dir2_put_dirent64_direct(
	xfs_dir2_put_args_t *pa)
	{
	xfs_dirent_t idbp; / dirent pointer */
	iovec_t iovp; / io vector */
	int namelen; /* entry name length */
	int reclen; /* entry total length */
	uio_t uio; / I/O control */

	namelen = pa->namelen;
	reclen = DIRENTSIZE(namelen);
	uio = pa->uio;
	/*
	* Won't fit in the remaining space.
	*/
	if (reclen > uio->uio_resid) {
	pa->done = 0;
	return 0;
	}
	iovp = uio->uio_iov;
	idbp = (xfs_dirent_t *)iovp->iov_base;
	iovp->iov_base = (char *)idbp + reclen;
	iovp->iov_len -= reclen;
	uio->uio_resid -= reclen;
	idbp->d_reclen = reclen;
	idbp->d_ino = pa->ino;
	idbp->d_off = pa->cook;
	idbp->d_name[namelen] = '\0';
	pa->done = 1;
	memcpy(idbp->d_name, pa->name, namelen);
	return 0;
	}

	/*
	* Getdents put routine for 64-bit ABI, uio form.
	*/
	static int
	xfs_dir2_put_dirent64_uio(
	xfs_dir2_put_args_t *pa)
	{
	xfs_dirent_t idbp; / dirent pointer */
	int namelen; /* entry name length */
	int reclen; /* entry total length */
	int rval; /* return value */
	uio_t uio; / I/O control */

	namelen = pa->namelen;
	reclen = DIRENTSIZE(namelen);
	uio = pa->uio;
	/*
	* Won't fit in the remaining space.
	*/
	if (reclen > uio->uio_resid) {
	pa->done = 0;
	return 0;
	}
	idbp = pa->dbp;
	idbp->d_reclen = reclen;
	idbp->d_ino = pa->ino;
	idbp->d_off = pa->cook;
	idbp->d_name[namelen] = '\0';
	memcpy(idbp->d_name, pa->name, namelen);
	rval = xfs_uio_read((caddr_t)idbp, reclen, uio);
	pa->done = (rval == 0);
	return rval;
	}

	/*		/*
	* Remove the given block from the directory.		* Remove the given block from the directory.
	* This routine is used for data and free blocks, leaf/node are done		* This routine is used for data and free blocks, leaf/node are done

fs/xfs/xfs_dir2.h

+2 −17

Original line number	Original line	Diff line number	Diff line
	@@ -59,21 +59,6 @@ typedef __uint32_t xfs_dir2_db_t;
	*/		*/
	typedef xfs_off_t xfs_dir2_off_t;		typedef xfs_off_t xfs_dir2_off_t;

	/*
	* For getdents, argument struct for put routines.
	*/
	typedef int (xfs_dir2_put_t)(struct xfs_dir2_put_args pa);
	typedef struct xfs_dir2_put_args {
	xfs_off_t cook; /* cookie of (next) entry */
	xfs_intino_t ino; /* inode number */
	xfs_dirent_t dbp; / buffer pointer */
	char name; / directory entry name */
	int namelen; /* length of name */
	int done; /* output: set if value was stored */
	xfs_dir2_put_t put; /* put function ptr (i/o) */
	struct uio uio; / uio control structure */
	} xfs_dir2_put_args_t;

	/*		/*
	* Generic directory interface routines		* Generic directory interface routines
	*/		*/
	@@ -92,8 +77,6 @@ extern int xfs_dir_removename(struct xfs_trans tp, struct xfs_inode dp,
	char *name, int namelen, xfs_ino_t ino,		char *name, int namelen, xfs_ino_t ino,
	xfs_fsblock_t *first,		xfs_fsblock_t *first,
	struct xfs_bmap_free *flist, xfs_extlen_t tot);		struct xfs_bmap_free *flist, xfs_extlen_t tot);
	extern int xfs_dir_getdents(struct xfs_trans tp, struct xfs_inode dp,
	uio_t uio, int eofp);
	extern int xfs_dir_replace(struct xfs_trans tp, struct xfs_inode dp,		extern int xfs_dir_replace(struct xfs_trans tp, struct xfs_inode dp,
	char *name, int namelen, xfs_ino_t inum,		char *name, int namelen, xfs_ino_t inum,
	xfs_fsblock_t *first,		xfs_fsblock_t *first,
	@@ -101,6 +84,8 @@ extern int xfs_dir_replace(struct xfs_trans tp, struct xfs_inode dp,
	extern int xfs_dir_canenter(struct xfs_trans tp, struct xfs_inode dp,		extern int xfs_dir_canenter(struct xfs_trans tp, struct xfs_inode dp,
	char *name, int namelen);		char *name, int namelen);
	extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);		extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
			extern int xfs_readdir(bhv_desc_t dir_bdp, void dirent, size_t bufsize,
			xfs_off_t *offset, filldir_t filldir);

	/*		/*
	* Utility routines for v2 directories.		* Utility routines for v2 directories.

fs/xfs/xfs_dir2_block.c

+23 −40

Original line number	Original line	Diff line number	Diff line
	@@ -432,12 +432,10 @@ xfs_dir2_block_addname(
	*/		*/
	int /* error */		int /* error */
	xfs_dir2_block_getdents(		xfs_dir2_block_getdents(
	xfs_trans_t tp, / transaction (NULL) */
	xfs_inode_t dp, / incore inode */		xfs_inode_t dp, / incore inode */
	uio_t uio, / caller's buffer control */		void *dirent,
	int eofp, / eof reached? (out) */		xfs_off_t *offset,
	xfs_dirent_t dbp, / caller's buffer */		filldir_t filldir)
	xfs_dir2_put_t put) /* abi's formatting function */
	{		{
	xfs_dir2_block_t block; / directory block structure */		xfs_dir2_block_t block; / directory block structure */
	xfs_dabuf_t bp; / buffer for block */		xfs_dabuf_t bp; / buffer for block */
	@@ -447,31 +445,32 @@ xfs_dir2_block_getdents(
	char endptr; / end of the data entries */		char endptr; / end of the data entries */
	int error; /* error return value */		int error; /* error return value */
	xfs_mount_t mp; / filesystem mount point */		xfs_mount_t mp; / filesystem mount point */
	xfs_dir2_put_args_t p; /* arg package for put rtn */
	char ptr; / current data entry */		char ptr; / current data entry */
	int wantoff; /* starting block offset */		int wantoff; /* starting block offset */
			xfs_ino_t ino;
			xfs_off_t cook;

	mp = dp->i_mount;		mp = dp->i_mount;
	/*		/*
	* If the block number in the offset is out of range, we're done.		* If the block number in the offset is out of range, we're done.
	*/		*/
	if (xfs_dir2_dataptr_to_db(mp, uio->uio_offset) > mp->m_dirdatablk) {		if (xfs_dir2_dataptr_to_db(mp, *offset) > mp->m_dirdatablk) {
	*eofp = 1;
	return 0;		return 0;
	}		}
	/*		/*
	* Can't read the block, give up, else get dabuf in bp.		* Can't read the block, give up, else get dabuf in bp.
	*/		*/
	if ((error =		error = xfs_da_read_buf(NULL, dp, mp->m_dirdatablk, -1,
	xfs_da_read_buf(tp, dp, mp->m_dirdatablk, -1, &bp, XFS_DATA_FORK))) {		&bp, XFS_DATA_FORK);
			if (error)
	return error;		return error;
	}
	ASSERT(bp != NULL);		ASSERT(bp != NULL);
	/*		/*
	* Extract the byte offset we start at from the seek pointer.		* Extract the byte offset we start at from the seek pointer.
	* We'll skip entries before this.		* We'll skip entries before this.
	*/		*/
	wantoff = xfs_dir2_dataptr_to_off(mp, uio->uio_offset);		wantoff = xfs_dir2_dataptr_to_off(mp, *offset);
	block = bp->data;		block = bp->data;
	xfs_dir2_data_check(dp, bp);		xfs_dir2_data_check(dp, bp);
	/*		/*
	@@ -480,9 +479,7 @@ xfs_dir2_block_getdents(
	btp = xfs_dir2_block_tail_p(mp, block);		btp = xfs_dir2_block_tail_p(mp, block);
	ptr = (char *)block->u;		ptr = (char *)block->u;
	endptr = (char *)xfs_dir2_block_leaf_p(btp);		endptr = (char *)xfs_dir2_block_leaf_p(btp);
	p.dbp = dbp;
	p.put = put;
	p.uio = uio;
	/*		/*
	* Loop over the data portion of the block.		* Loop over the data portion of the block.
	* Each object is a real entry (dep) or an unused one (dup).		* Each object is a real entry (dep) or an unused one (dup).
	@@ -508,33 +505,24 @@ xfs_dir2_block_getdents(
	*/		*/
	if ((char )dep - (char )block < wantoff)		if ((char )dep - (char )block < wantoff)
	continue;		continue;
	/*
	* Set up argument structure for put routine.
	*/
	p.namelen = dep->namelen;

	p.cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,		cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
	ptr - (char *)block);		ptr - (char *)block);
	p.ino = be64_to_cpu(dep->inumber);		ino = be64_to_cpu(dep->inumber);
	#if XFS_BIG_INUMS		#if XFS_BIG_INUMS
	p.ino += mp->m_inoadd;		ino += mp->m_inoadd;
	#endif		#endif
	p.name = (char *)dep->name;

	/*
	* Put the entry in the caller's buffer.
	*/
	error = p.put(&p);

	/*		/*
	* If it didn't fit, set the final offset to here & return.		* If it didn't fit, set the final offset to here & return.
	*/		*/
	if (!p.done) {		if (filldir(dirent, dep->name, dep->namelen, cook,
	uio->uio_offset =		ino, DT_UNKNOWN)) {
	xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,		*offset = xfs_dir2_db_off_to_dataptr(mp,
			mp->m_dirdatablk,
	(char )dep - (char )block);		(char )dep - (char )block);
	xfs_da_brelse(tp, bp);		xfs_da_brelse(NULL, bp);
	return error;		return 0;
	}		}
	}		}

	@@ -542,13 +530,8 @@ xfs_dir2_block_getdents(
	* Reached the end of the block.		* Reached the end of the block.
	* Set the offset to a non-existent block 1 and return.		* Set the offset to a non-existent block 1 and return.
	*/		*/
	*eofp = 1;		*offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0);
			xfs_da_brelse(NULL, bp);
	uio->uio_offset =
	xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0);

	xfs_da_brelse(tp, bp);

	return 0;		return 0;
	}		}

Original line number	Original line	Diff line number	Diff line
	@@ -161,8 +161,8 @@ typedef int (vop_rename_t)(bhv_desc_t , bhv_vname_t , bhv_vnode_t ,
	typedef int (vop_mkdir_t)(bhv_desc_t , bhv_vname_t , struct bhv_vattr ,		typedef int (vop_mkdir_t)(bhv_desc_t , bhv_vname_t , struct bhv_vattr ,
	bhv_vnode_t *, struct cred );		bhv_vnode_t *, struct cred );
	typedef int (vop_rmdir_t)(bhv_desc_t , bhv_vname_t , struct cred );		typedef int (vop_rmdir_t)(bhv_desc_t , bhv_vname_t , struct cred );
	typedef int (vop_readdir_t)(bhv_desc_t , struct uio , struct cred ,		typedef int (vop_readdir_t)(bhv_desc_t , void *dirent, size_t bufsize,
	int *);		xfs_off_t *offset, filldir_t filldir);
	typedef int (vop_symlink_t)(bhv_desc_t , bhv_vname_t , struct bhv_vattr,		typedef int (vop_symlink_t)(bhv_desc_t , bhv_vname_t , struct bhv_vattr,
	char , bhv_vnode_t , struct cred );		char , bhv_vnode_t , struct cred );
	typedef int (vop_readlink_t)(bhv_desc_t , struct uio *, int,		typedef int (vop_readlink_t)(bhv_desc_t , struct uio *, int,
	@@ -267,8 +267,8 @@ typedef struct bhv_vnodeops {
	#define bhv_vop_mkdir(dp,d,vap,vpp,cr) \		#define bhv_vop_mkdir(dp,d,vap,vpp,cr) \
	VOP(vop_mkdir, dp)(VNHEAD(dp),d,vap,vpp,cr)		VOP(vop_mkdir, dp)(VNHEAD(dp),d,vap,vpp,cr)
	#define bhv_vop_rmdir(dp,d,cr) VOP(vop_rmdir, dp)(VNHEAD(dp),d,cr)		#define bhv_vop_rmdir(dp,d,cr) VOP(vop_rmdir, dp)(VNHEAD(dp),d,cr)
	#define bhv_vop_readdir(vp,uiop,cr,eofp) \		#define bhv_vop_readdir(vp,dirent,bufsize,offset,filldir) \
	VOP(vop_readdir, vp)(VNHEAD(vp),uiop,cr,eofp)		VOP(vop_readdir, vp)(VNHEAD(vp),dirent,bufsize,offset,filldir)
	#define bhv_vop_symlink(dvp,d,vap,tnm,vpp,cr) \		#define bhv_vop_symlink(dvp,d,vap,tnm,vpp,cr) \
	VOP(vop_symlink, dvp)(VNHEAD(dvp),d,vap,tnm,vpp,cr)		VOP(vop_symlink, dvp)(VNHEAD(dvp),d,vap,tnm,vpp,cr)
	#define bhv_vop_readlink(vp,uiop,fl,cr) \		#define bhv_vop_readlink(vp,uiop,fl,cr) \

Admin message