Message-ID: <20070620120947.GA3973@infradead.org>
Date:	Wed, 20 Jun 2007 13:09:47 +0100
From:	Christoph Hellwig <hch@...radead.org>
To:	Bharata B Rao <bharata@...ux.vnet.ibm.com>
Cc:	linux-fsdevel@...r.kernel.org, linux-kernel@...r.kernel.org,
	Jan Blunck <j.blunck@...harburg.de>
Subject: Re: [RFC PATCH 4/4] Directory listing support for union mounted directories.

On Wed, Jun 20, 2007 at 11:24:18AM +0530, Bharata B Rao wrote:
> From: Bharata B Rao <bharata@...ux.vnet.ibm.com>
> Subject: Directory listing support for union mounted directories.
> 
> Modifies readdir()/getdents() to support union mounted directories.
> 
> This patch adds support to readdir()/getdents() to read directory entries
> from all the directories of the union stack, and present a merged view to
> the userspace. This is achieved by maintaining a cache of read entries.
> 
> TODO: Breaks lseek on union mounted directories, Fix this.

Btw, to avoid dealing with file structs representing multiple objects
->readdir should be changed to an inode_operation and not take a struct
file * but rather struct inode + loff_t *ppos.  This sounds like a nice
preparatory patch for any kind of union mount implementation and is
acceptable standing on it's own.

> 
> Signed-off-by: Bharata B Rao <bharata@...ux.vnet.ibm.com>
> ---
>  fs/file_table.c    |    1 
>  fs/readdir.c       |  242 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
>  include/linux/fs.h |   12 ++
>  3 files changed, 254 insertions(+), 1 deletion(-)
> 
> --- a/fs/file_table.c
> +++ b/fs/file_table.c
> @@ -174,6 +174,7 @@ void fastcall __fput(struct file *file)
>  	if (file->f_mode & FMODE_WRITE)
>  		put_write_access(inode);
>  	put_pid(file->f_owner.pid);
> +	put_rdstate(file->f_rdstate);
>  	file_kill(file);
>  	file->f_path.dentry = NULL;
>  	file->f_path.mnt = NULL;
> --- a/fs/readdir.c
> +++ b/fs/readdir.c
> @@ -19,6 +19,8 @@
>  
>  #include <asm/uaccess.h>
>  
> +int readdir_union(struct file *file, void *buf, filldir_t filler);
> +
>  int vfs_readdir(struct file *file, filldir_t filler, void *buf)
>  {
>  	struct inode *inode = file->f_path.dentry->d_inode;
> @@ -33,7 +35,10 @@ int vfs_readdir(struct file *file, filld
>  	mutex_lock(&inode->i_mutex);
>  	res = -ENOENT;
>  	if (!IS_DEADDIR(inode)) {
> -		res = file->f_op->readdir(file, buf, filler);
> +		if (IS_MNT_UNION(file->f_path.mnt))
> +			res = readdir_union(file, buf, filler);
> +		else
> +			res = file->f_op->readdir(file, buf, filler);
>  		file_accessed(file);
>  	}
>  	mutex_unlock(&inode->i_mutex);
> @@ -303,3 +308,238 @@ out_putf:
>  out:
>  	return error;
>  }
> +
> +/*
> + * NOTE: Some of the code below which maintains a list of dirents as a cache
> + * is from Jan Blunck's original union mount readdir patch.
> + */
> +
> +/* The readdir cache object */
> +struct rdcache_entry {
> +	struct list_head list;
> +	struct qstr name;
> +};
> +
> +struct rdcache_callback {
> +	void *buf;			/* original callback buffer */
> +	filldir_t filldir;		/* the filldir() we should call */
> +	int error;			/* stores filldir error */
> +	struct rdstate *rdstate;	/* readdir state */
> +};
> +
> +static int rdcache_add_entry(struct list_head *list,
> +				 const char *name, int namelen)
> +{
> +	struct rdcache_entry *this;
> +	char *tmp_name;
> +
> +	this = kmalloc(sizeof(*this), GFP_KERNEL);
> +	if (!this) {
> +		printk(KERN_CRIT "rdcache_add_entry(): out of kernel memory\n");
> +		return -ENOMEM;
> +	}
> +
> +	tmp_name = kmalloc(namelen + 1, GFP_KERNEL);
> +	if (!tmp_name) {
> +		printk(KERN_CRIT "rdcache_add_entry(): out of kernel memory\n");
> +		kfree(this);
> +		return -ENOMEM;
> +	}
> +
> +	this->name.name = tmp_name;
> +	this->name.len = namelen;
> +	this->name.hash = 0;
> +	memcpy(tmp_name, name, namelen);
> +	tmp_name[namelen] = 0;
> +	INIT_LIST_HEAD(&this->list);
> +	list_add(&this->list, list);
> +	return 0;
> +}
> +
> +static void rdcache_free(struct list_head *list)
> +{
> +	struct list_head *p;
> +	struct list_head *ptmp;
> +	int count = 0;
> +
> +	list_for_each_safe(p, ptmp, list) {
> +		struct rdcache_entry *this;
> +
> +		this = list_entry(p, struct rdcache_entry, list);
> +		list_del_init(&this->list);
> +		kfree(this->name.name);
> +		kfree(this);
> +		count++;
> +	}
> +	return;
> +}
> +
> +static int rdcache_find_entry(struct list_head *uc_list,
> +				  const char *name, int namelen)
> +{
> +	struct rdcache_entry *p;
> +	int ret = 0;
> +
> +	list_for_each_entry(p, uc_list, list) {
> +		if (p->name.len != namelen)
> +			continue;
> +		if (strncmp(p->name.name, name, namelen) == 0) {
> +			ret = 1;
> +			break;
> +		}
> +	}
> +	return ret;
> +}
> +
> +/*
> + * filldir routine for union mounted directories.
> + * Handles duplicate elimination by building a readdir cache.
> + * TODO: readdir cache is a linked list. Check if this can be designed
> + * more efficiently.
> + */
> +static int filldir_union(void *buf, const char *name, int namlen,
> +			   loff_t offset, u64 ino, unsigned int d_type)
> +{
> +	struct rdcache_callback *cb = buf;
> +	int err;
> +
> +	if (rdcache_find_entry(&cb->rdstate->dirent_cache, name, namlen))
> +		return 0;
> +
> +	err =  cb->filldir(cb->buf, name, namlen, offset, ino, d_type);
> +	if (err >= 0)
> +		rdcache_add_entry(&cb->rdstate->dirent_cache, name, namlen);
> +	cb->error = err;
> +	return err;
> +}
> +
> +/* Called from last fput() */
> +void put_rdstate(struct rdstate *rdstate)
> +{
> +	if (!rdstate)
> +		return;
> +
> +	mntput(rdstate->mnt);
> +	dput(rdstate->dentry);
> +	rdcache_free(&rdstate->dirent_cache);
> +	kfree(rdstate);
> +}
> +
> +static struct rdstate *get_rdstate(struct file *file)
> +{
> +	if (file->f_rdstate)
> +		return file->f_rdstate;
> +
> +	/*
> +	 * We have read the dirents from this earlier but now don't have a
> +	 * corresponding rdstate. This shouldn't happen.
> +	 */
> +	if (file->f_pos)
> +		return ERR_PTR(-EINVAL);
> +
> +	file->f_rdstate = kmalloc(sizeof(struct rdstate), GFP_KERNEL);
> +	if (!file->f_rdstate)
> +		return ERR_PTR(-ENOMEM);
> +
> +	file->f_rdstate->off = 0;
> +	file->f_rdstate->mnt = mntget(file->f_path.mnt);
> +	file->f_rdstate->dentry = dget(file->f_path.dentry);
> +	INIT_LIST_HEAD(&file->f_rdstate->dirent_cache);
> +	return file->f_rdstate;
> +}
> +
> +int readdir_union(struct file *file, void *buf, filldir_t filler)
> +{
> +	struct dentry *topmost = file->f_path.dentry;
> +	struct rdstate *rdstate;
> +	struct nameidata nd;
> +	loff_t offset = 0;
> +	struct rdcache_callback cb;
> +	int err = 0;
> +
> +	/*
> +	 * If this is not a union mount point or not a unioned directory
> +	 * within the union mount point, do readdir in the normal way.
> +	 */
> +	nd.mnt = file->f_path.mnt;
> +	nd.dentry = file->f_path.dentry;
> +	if (!next_union_mount_exists(nd.mnt, nd.dentry))
> +		return file->f_op->readdir(file, buf, filler);
> +
> +	rdstate = get_rdstate(file);
> +	if (IS_ERR(rdstate)) {
> +		err = PTR_ERR(rdstate);
> +		return err;
> +	}
> +
> +	cb.buf = buf;
> +	cb.filldir = filler;
> +	cb.rdstate = rdstate;
> +
> +	offset = rdstate->off;
> +
> +	/* Read from the topmost directory */
> +	if (rdstate->dentry == topmost) {
> +		file->f_pos = offset;
> +		err = file->f_op->readdir(file, &cb, filldir_union);
> +		rdstate->off = file->f_pos;
> +		if (err < 0 || cb.error < 0)
> +			goto out;
> +
> +		/*
> +		 * Reading from topmost dir complete, start reading the lower
> +		 * dir from the beginning.
> +		 */
> +		offset = 0;
> +	} else {
> +		nd.mnt = rdstate->mnt;
> +		nd.dentry = rdstate->dentry;
> +		goto read_lower;
> +	}
> +
> +	if (!next_union_mount(&nd))
> +		return err;
> +
> +read_lower:
> +	do {
> +		struct vfsmount *mnt_tmp = mntget(nd.mnt);
> +		struct dentry *dentry_tmp = dget(nd.dentry);
> +		struct file *ftmp = dentry_open(nd.dentry, nd.mnt,
> +						file->f_flags);
> +		if (IS_ERR(ftmp)) {
> +			mntput(mnt_tmp);
> +			dput(dentry_tmp);
> +			err = PTR_ERR(ftmp);
> +			goto out;
> +		}
> +
> +		mutex_lock(&nd.dentry->d_inode->i_mutex);
> +		ftmp->f_pos = offset;
> +
> +		err = ftmp->f_op->readdir(ftmp, &cb, filldir_union);
> +		file_accessed(ftmp);
> +		rdstate->off = ftmp->f_pos;
> +		mutex_unlock(&nd.dentry->d_inode->i_mutex);
> +		if (nd.mnt != rdstate->mnt) {
> +			mntput(rdstate->mnt);
> +			rdstate->mnt = mntget(nd.mnt);
> +		}
> +		if (nd.dentry != rdstate->dentry) {
> +			dput(rdstate->dentry);
> +			rdstate->dentry = dget(nd.dentry);
> +		}
> +		fput(ftmp);
> +		if (err < 0 || cb.error < 0)
> +			goto out;
> +
> +		/*
> +		 * Reading from a lower dir complete, start reading the
> +		 * next lower dir from the beginning.
> +		 */
> +		offset = 0;
> +	} while (next_union_mount(&nd));
> +
> +	return 0;
> +out:
> +	return err;
> +}
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -841,6 +841,14 @@ static inline void ra_set_size(struct fi
>  unsigned long ra_submit(struct file_ra_state *ra,
>  		       struct address_space *mapping, struct file *filp);
>  
> +/* Direct cache for readdir, used for union mounted directories. */
> +struct rdstate {
> +	struct vfsmount *mnt;
> +	struct dentry *dentry;
> +	loff_t off;
> +	struct list_head dirent_cache;
> +};
> +
>  struct file {
>  	/*
>  	 * fu_list becomes invalid after file_free is called and queued via
> @@ -875,6 +883,7 @@ struct file {
>  	spinlock_t		f_ep_lock;
>  #endif /* #ifdef CONFIG_EPOLL */
>  	struct address_space	*f_mapping;
> +	struct rdstate		*f_rdstate;
>  };
>  extern spinlock_t files_lock;
>  #define file_list_lock() spin_lock(&files_lock);
> @@ -2119,5 +2128,8 @@ static inline void free_secdata(void *se
>  { }
>  #endif	/* CONFIG_SECURITY */
>  
> +/* fs/readdir.c */
> +void put_rdstate(struct rdstate *rdstate);
> +
>  #endif /* __KERNEL__ */
>  #endif /* _LINUX_FS_H */
> -
> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
> the body of a message to majordomo@...r.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
---end quoted text---
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Powered by blists - more mailing lists