[net-next-2.6.git] / fs / 9p / vfs_dir.c

/*
 * linux/fs/9p/vfs_dir.c
 *
 * This file contains vfs directory ops for the 9P2000 protocol.
 *
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/smp_lock.h>
#include <linux/inet.h>
#include <linux/idr.h>

#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include "v9fs_vfs.h"
#include "fid.h"

/**
 * dt_type - return file type
 * @mistat: mistat structure
 *
 */

static inline int dt_type(struct v9fs_stat *mistat)
{
	unsigned long perm = mistat->mode;
	int rettype = DT_REG;

	if (perm & V9FS_DMDIR)
		rettype = DT_DIR;
	if (perm & V9FS_DMSYMLINK)
		rettype = DT_LNK;

	return rettype;
}

/**
 * v9fs_dir_readdir - read a directory
 * @filep: opened file structure
 * @dirent: directory structure ???
 * @filldir: function to populate directory structure ???
 *
 */

static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct v9fs_fcall *fcall = NULL;
	struct inode *inode = filp->f_dentry->d_inode;
	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
	struct v9fs_fid *file = filp->private_data;
	unsigned int i, n, s;
	int fid = -1;
	int ret = 0;
	struct v9fs_stat stat;
	int over = 0;

	dprintk(DEBUG_VFS, "name %s\n", filp->f_dentry->d_name.name);

	fid = file->fid;

	if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
		kfree(file->rdir_fcall);
		file->rdir_fcall = NULL;
	}

	if (file->rdir_fcall) {
		n = file->rdir_fcall->params.rread.count;
		i = file->rdir_fpos;
		while (i < n) {
			s = v9fs_deserialize_stat(
				file->rdir_fcall->params.rread.data + i,
				n - i, &stat, v9ses->extended);

			if (s == 0) {
				dprintk(DEBUG_ERROR,
					"error while deserializing stat\n");
				ret = -EIO;
				goto FreeStructs;
			}

			over = filldir(dirent, stat.name.str, stat.name.len,
				    filp->f_pos, v9fs_qid2ino(&stat.qid),
				    dt_type(&stat));

			if (over) {
				file->rdir_fpos = i;
				file->rdir_pos = filp->f_pos;
				break;
			}

			i += s;
			filp->f_pos += s;
		}

		if (!over) {
			kfree(file->rdir_fcall);
			file->rdir_fcall = NULL;
		}
	}

	while (!over) {
		ret = v9fs_t_read(v9ses, fid, filp->f_pos,
			v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
		if (ret < 0) {
			dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
				ret, fcall);
			goto FreeStructs;
		} else if (ret == 0)
			break;

		n = ret;
		i = 0;
		while (i < n) {
			s = v9fs_deserialize_stat(fcall->params.rread.data + i,
				n - i, &stat, v9ses->extended);

			if (s == 0) {
				dprintk(DEBUG_ERROR,
					"error while deserializing stat\n");
				return -EIO;
			}

			over = filldir(dirent, stat.name.str, stat.name.len,
				    filp->f_pos, v9fs_qid2ino(&stat.qid),
				    dt_type(&stat));

			if (over) {
				file->rdir_fcall = fcall;
				file->rdir_fpos = i;
				file->rdir_pos = filp->f_pos;
				fcall = NULL;
				break;
			}

			i += s;
			filp->f_pos += s;
		}

		kfree(fcall);
	}

      FreeStructs:
	kfree(fcall);
	return ret;
}

/**
 * v9fs_dir_release - close a directory
 * @inode: inode of the directory
 * @filp: file pointer to a directory
 *
 */

int v9fs_dir_release(struct inode *inode, struct file *filp)
{
	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
	struct v9fs_fid *fid = filp->private_data;
	int fidnum = -1;

	dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
		fid->fid);
	fidnum = fid->fid;

	filemap_write_and_wait(inode->i_mapping);

	if (fidnum >= 0) {
		dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
			fid->fid);

		if (v9fs_t_clunk(v9ses, fidnum))
			dprintk(DEBUG_ERROR, "clunk failed\n");

		kfree(fid->rdir_fcall);
		kfree(fid);

		filp->private_data = NULL;
	}

	d_drop(filp->f_dentry);
	return 0;
}

struct file_operations v9fs_dir_operations = {
	.read = generic_read_dir,
	.readdir = v9fs_dir_readdir,
	.open = v9fs_file_open,
	.release = v9fs_dir_release,
};
Commit	Line	Data
e69e7fe5 EVH	1	/*
	2	* linux/fs/9p/vfs_dir.c
	3	*
	4	* This file contains vfs directory ops for the 9P2000 protocol.
	5	*
	6	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
	7	* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to:
	21	* Free Software Foundation
	22	* 51 Franklin Street, Fifth Floor
	23	* Boston, MA 02111-1301 USA
	24	*
	25	*/
	26
	27	#include <linux/module.h>
	28	#include <linux/errno.h>
	29	#include <linux/fs.h>
	30	#include <linux/file.h>
	31	#include <linux/stat.h>
	32	#include <linux/string.h>
	33	#include <linux/smp_lock.h>
	34	#include <linux/inet.h>
	35	#include <linux/idr.h>
	36
	37	#include "debug.h"
	38	#include "v9fs.h"
	39	#include "9p.h"
e69e7fe5	40	#include "conv.h"
531b1094	41	#include "v9fs_vfs.h"
e69e7fe5 EVH	42	#include "fid.h"
	43
	44	/**
	45	* dt_type - return file type
	46	* @mistat: mistat structure
	47	*
	48	*/
	49
	50	static inline int dt_type(struct v9fs_stat *mistat)
	51	{
	52	unsigned long perm = mistat->mode;
	53	int rettype = DT_REG;
	54
	55	if (perm & V9FS_DMDIR)
	56	rettype = DT_DIR;
	57	if (perm & V9FS_DMSYMLINK)
	58	rettype = DT_LNK;
	59
	60	return rettype;
	61	}
	62
	63	/**
	64	* v9fs_dir_readdir - read a directory
	65	* @filep: opened file structure
	66	* @dirent: directory structure ???
	67	* @filldir: function to populate directory structure ???
	68	*
	69	*/
	70
	71	static int v9fs_dir_readdir(struct file filp, void dirent, filldir_t filldir)
	72	{
	73	struct v9fs_fcall *fcall = NULL;
	74	struct inode *inode = filp->f_dentry->d_inode;
	75	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
	76	struct v9fs_fid *file = filp->private_data;
3cf6429a	77	unsigned int i, n, s;
e69e7fe5 EVH	78	int fid = -1;
e69e7fe5 EVH	79	int ret = 0;
531b1094	80	struct v9fs_stat stat;
e69e7fe5 EVH	81	int over = 0;
	82
	83	dprintk(DEBUG_VFS, "name %s\n", filp->f_dentry->d_name.name);
	84
	85	fid = file->fid;
	86
e69e7fe5 EVH	87	if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
	88	kfree(file->rdir_fcall);
	89	file->rdir_fcall = NULL;
	90	}
	91
	92	if (file->rdir_fcall) {
	93	n = file->rdir_fcall->params.rread.count;
	94	i = file->rdir_fpos;
	95	while (i < n) {
3cf6429a LI	96	s = v9fs_deserialize_stat(
3cf6429a LI	97	file->rdir_fcall->params.rread.data + i,
531b1094	98	n - i, &stat, v9ses->extended);
e69e7fe5 EVH	99
	100	if (s == 0) {
	101	dprintk(DEBUG_ERROR,
531b1094	102	"error while deserializing stat\n");
e69e7fe5 EVH	103	ret = -EIO;
	104	goto FreeStructs;
	105	}
	106
531b1094 LI	107	over = filldir(dirent, stat.name.str, stat.name.len,
	108	filp->f_pos, v9fs_qid2ino(&stat.qid),
	109	dt_type(&stat));
e69e7fe5 EVH	110
	111	if (over) {
	112	file->rdir_fpos = i;
	113	file->rdir_pos = filp->f_pos;
	114	break;
	115	}
	116
	117	i += s;
	118	filp->f_pos += s;
	119	}
	120
	121	if (!over) {
	122	kfree(file->rdir_fcall);
	123	file->rdir_fcall = NULL;
	124	}
	125	}
	126
	127	while (!over) {
	128	ret = v9fs_t_read(v9ses, fid, filp->f_pos,
531b1094	129	v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
e69e7fe5 EVH	130	if (ret < 0) {
	131	dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
	132	ret, fcall);
	133	goto FreeStructs;
	134	} else if (ret == 0)
	135	break;
	136
	137	n = ret;
	138	i = 0;
	139	while (i < n) {
3cf6429a	140	s = v9fs_deserialize_stat(fcall->params.rread.data + i,
531b1094	141	n - i, &stat, v9ses->extended);
e69e7fe5 EVH	142
	143	if (s == 0) {
	144	dprintk(DEBUG_ERROR,
531b1094	145	"error while deserializing stat\n");
e69e7fe5 EVH	146	return -EIO;
	147	}
	148
531b1094 LI	149	over = filldir(dirent, stat.name.str, stat.name.len,
	150	filp->f_pos, v9fs_qid2ino(&stat.qid),
	151	dt_type(&stat));
e69e7fe5 EVH	152
	153	if (over) {
	154	file->rdir_fcall = fcall;
	155	file->rdir_fpos = i;
	156	file->rdir_pos = filp->f_pos;
	157	fcall = NULL;
	158	break;
	159	}
	160
	161	i += s;
	162	filp->f_pos += s;
	163	}
	164
	165	kfree(fcall);
	166	}
	167
	168	FreeStructs:
	169	kfree(fcall);
e69e7fe5 EVH	170	return ret;
	171	}
	172
	173	/**
	174	* v9fs_dir_release - close a directory
	175	* @inode: inode of the directory
	176	* @filp: file pointer to a directory
	177	*
	178	*/
	179
	180	int v9fs_dir_release(struct inode inode, struct file filp)
	181	{
	182	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
	183	struct v9fs_fid *fid = filp->private_data;
	184	int fidnum = -1;
	185
	186	dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
	187	fid->fid);
	188	fidnum = fid->fid;
	189
28fd1298	190	filemap_write_and_wait(inode->i_mapping);
e69e7fe5 EVH	191
e69e7fe5 EVH	192	if (fidnum >= 0) {
e69e7fe5 EVH	193	dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
	194	fid->fid);
	195
3cf6429a	196	if (v9fs_t_clunk(v9ses, fidnum))
0b8dd177	197	dprintk(DEBUG_ERROR, "clunk failed\n");
e69e7fe5	198
e69e7fe5	199	kfree(fid->rdir_fcall);
0b8dd177	200	kfree(fid);
e69e7fe5 EVH	201
e69e7fe5 EVH	202	filp->private_data = NULL;
e69e7fe5 EVH	203	}
	204
	205	d_drop(filp->f_dentry);
	206	return 0;
	207	}
	208
	209	struct file_operations v9fs_dir_operations = {
	210	.read = generic_read_dir,
	211	.readdir = v9fs_dir_readdir,
	212	.open = v9fs_file_open,
	213	.release = v9fs_dir_release,
	214	};