[deliverable/linux.git] / fs / smbfs / dir.c

/*
 *  dir.c
 *
 *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
 *  Copyright (C) 1997 by Volker Lendecke
 *
 *  Please add a note about your changes to smbfs in the ChangeLog file.
 */

#include <linux/time.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/smp_lock.h>
#include <linux/ctype.h>
#include <linux/net.h>
#include <linux/sched.h>

#include <linux/smb_fs.h>
#include <linux/smb_mount.h>
#include <linux/smbno.h>

#include "smb_debug.h"
#include "proto.h"

static int smb_readdir(struct file *, void *, filldir_t);
static int smb_dir_open(struct inode *, struct file *);

static struct dentry *smb_lookup(struct inode *, struct dentry *, struct nameidata *);
static int smb_create(struct inode *, struct dentry *, int, struct nameidata *);
static int smb_mkdir(struct inode *, struct dentry *, int);
static int smb_rmdir(struct inode *, struct dentry *);
static int smb_unlink(struct inode *, struct dentry *);
static int smb_rename(struct inode *, struct dentry *,
		      struct inode *, struct dentry *);
static int smb_make_node(struct inode *,struct dentry *,int,dev_t);
static int smb_link(struct dentry *, struct inode *, struct dentry *);

const struct file_operations smb_dir_operations =
{
	.read		= generic_read_dir,
	.readdir	= smb_readdir,
	.ioctl		= smb_ioctl,
	.open		= smb_dir_open,
};

const struct inode_operations smb_dir_inode_operations =
{
	.create		= smb_create,
	.lookup		= smb_lookup,
	.unlink		= smb_unlink,
	.mkdir		= smb_mkdir,
	.rmdir		= smb_rmdir,
	.rename		= smb_rename,
	.getattr	= smb_getattr,
	.setattr	= smb_notify_change,
};

const struct inode_operations smb_dir_inode_operations_unix =
{
	.create		= smb_create,
	.lookup		= smb_lookup,
	.unlink		= smb_unlink,
	.mkdir		= smb_mkdir,
	.rmdir		= smb_rmdir,
	.rename		= smb_rename,
	.getattr	= smb_getattr,
	.setattr	= smb_notify_change,
	.symlink	= smb_symlink,
	.mknod		= smb_make_node,
	.link		= smb_link,
};

/*
 * Read a directory, using filldir to fill the dirent memory.
 * smb_proc_readdir does the actual reading from the smb server.
 *
 * The cache code is almost directly taken from ncpfs
 */
static int 
smb_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct dentry *dentry = filp->f_path.dentry;
	struct inode *dir = dentry->d_inode;
	struct smb_sb_info *server = server_from_dentry(dentry);
	union  smb_dir_cache *cache = NULL;
	struct smb_cache_control ctl;
	struct page *page = NULL;
	int result;

	ctl.page  = NULL;
	ctl.cache = NULL;

	VERBOSE("reading %s/%s, f_pos=%d\n",
		DENTRY_PATH(dentry),  (int) filp->f_pos);

	result = 0;

	lock_kernel();

	switch ((unsigned int) filp->f_pos) {
	case 0:
		if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
			goto out;
		filp->f_pos = 1;
		/* fallthrough */
	case 1:
		if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0)
			goto out;
		filp->f_pos = 2;
	}

	/*
	 * Make sure our inode is up-to-date.
	 */
	result = smb_revalidate_inode(dentry);
	if (result)
		goto out;


	page = grab_cache_page(&dir->i_data, 0);
	if (!page)
		goto read_really;

	ctl.cache = cache = kmap(page);
	ctl.head  = cache->head;

	if (!PageUptodate(page) || !ctl.head.eof) {
		VERBOSE("%s/%s, page uptodate=%d, eof=%d\n",
			 DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof);
		goto init_cache;
	}

	if (filp->f_pos == 2) {
		if (jiffies - ctl.head.time >= SMB_MAX_AGE(server))
			goto init_cache;

		/*
		 * N.B. ncpfs checks mtime of dentry too here, we don't.
		 *   1. common smb servers do not update mtime on dir changes
		 *   2. it requires an extra smb request
		 *      (revalidate has the same timeout as ctl.head.time)
		 *
		 * Instead smbfs invalidates its own cache on local changes
		 * and remote changes are not seen until timeout.
		 */
	}

	if (filp->f_pos > ctl.head.end)
		goto finished;

	ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2);
	ctl.ofs  = ctl.fpos / SMB_DIRCACHE_SIZE;
	ctl.idx  = ctl.fpos % SMB_DIRCACHE_SIZE;

	for (;;) {
		if (ctl.ofs != 0) {
			ctl.page = find_lock_page(&dir->i_data, ctl.ofs);
			if (!ctl.page)
				goto invalid_cache;
			ctl.cache = kmap(ctl.page);
			if (!PageUptodate(ctl.page))
				goto invalid_cache;
		}
		while (ctl.idx < SMB_DIRCACHE_SIZE) {
			struct dentry *dent;
			int res;

			dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx],
					     dentry, filp->f_pos);
			if (!dent)
				goto invalid_cache;

			res = filldir(dirent, dent->d_name.name,
				      dent->d_name.len, filp->f_pos,
				      dent->d_inode->i_ino, DT_UNKNOWN);
			dput(dent);
			if (res)
				goto finished;
			filp->f_pos += 1;
			ctl.idx += 1;
			if (filp->f_pos > ctl.head.end)
				goto finished;
		}
		if (ctl.page) {
			kunmap(ctl.page);
			SetPageUptodate(ctl.page);
			unlock_page(ctl.page);
			page_cache_release(ctl.page);
			ctl.page = NULL;
		}
		ctl.idx  = 0;
		ctl.ofs += 1;
	}
invalid_cache:
	if (ctl.page) {
		kunmap(ctl.page);
		unlock_page(ctl.page);
		page_cache_release(ctl.page);
		ctl.page = NULL;
	}
	ctl.cache = cache;
init_cache:
	smb_invalidate_dircache_entries(dentry);
	ctl.head.time = jiffies;
	ctl.head.eof = 0;
	ctl.fpos = 2;
	ctl.ofs = 0;
	ctl.idx = SMB_DIRCACHE_START;
	ctl.filled = 0;
	ctl.valid  = 1;
read_really:
	result = server->ops->readdir(filp, dirent, filldir, &ctl);
	if (result == -ERESTARTSYS && page)
		ClearPageUptodate(page);
	if (ctl.idx == -1)
		goto invalid_cache;	/* retry */
	ctl.head.end = ctl.fpos - 1;
	ctl.head.eof = ctl.valid;
finished:
	if (page) {
		cache->head = ctl.head;
		kunmap(page);
		if (result != -ERESTARTSYS)
			SetPageUptodate(page);
		unlock_page(page);
		page_cache_release(page);
	}
	if (ctl.page) {
		kunmap(ctl.page);
		SetPageUptodate(ctl.page);
		unlock_page(ctl.page);
		page_cache_release(ctl.page);
	}
out:
	unlock_kernel();
	return result;
}

static int
smb_dir_open(struct inode *dir, struct file *file)
{
	struct dentry *dentry = file->f_path.dentry;
	struct smb_sb_info *server;
	int error = 0;

	VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name);

	/*
	 * Directory timestamps in the core protocol aren't updated
	 * when a file is added, so we give them a very short TTL.
	 */
	lock_kernel();
	server = server_from_dentry(dentry);
	if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) {
		unsigned long age = jiffies - SMB_I(dir)->oldmtime;
		if (age > 2*HZ)
			smb_invalid_dir_cache(dir);
	}

	/*
	 * Note: in order to allow the smbmount process to open the
	 * mount point, we only revalidate if the connection is valid or
	 * if the process is trying to access something other than the root.
	 */
	if (server->state == CONN_VALID || !IS_ROOT(dentry))
		error = smb_revalidate_inode(dentry);
	unlock_kernel();
	return error;
}

/*
 * Dentry operations routines
 */
static int smb_lookup_validate(struct dentry *, struct nameidata *);
static int smb_hash_dentry(struct dentry *, struct qstr *);
static int smb_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
static int smb_delete_dentry(struct dentry *);

static struct dentry_operations smbfs_dentry_operations =
{
	.d_revalidate	= smb_lookup_validate,
	.d_hash		= smb_hash_dentry,
	.d_compare	= smb_compare_dentry,
	.d_delete	= smb_delete_dentry,
};

static struct dentry_operations smbfs_dentry_operations_case =
{
	.d_revalidate	= smb_lookup_validate,
	.d_delete	= smb_delete_dentry,
};


/*
 * This is the callback when the dcache has a lookup hit.
 */
static int
smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
{
	struct smb_sb_info *server = server_from_dentry(dentry);
	struct inode * inode = dentry->d_inode;
	unsigned long age = jiffies - dentry->d_time;
	int valid;

	/*
	 * The default validation is based on dentry age:
	 * we believe in dentries for a few seconds.  (But each
	 * successful server lookup renews the timestamp.)
	 */
	valid = (age <= SMB_MAX_AGE(server));
#ifdef SMBFS_DEBUG_VERBOSE
	if (!valid)
		VERBOSE("%s/%s not valid, age=%lu\n", 
			DENTRY_PATH(dentry), age);
#endif

	if (inode) {
		lock_kernel();
		if (is_bad_inode(inode)) {
			PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry));
			valid = 0;
		} else if (!valid)
			valid = (smb_revalidate_inode(dentry) == 0);
		unlock_kernel();
	} else {
		/*
		 * What should we do for negative dentries?
		 */
	}
	return valid;
}

static int 
smb_hash_dentry(struct dentry *dir, struct qstr *this)
{
	unsigned long hash;
	int i;

	hash = init_name_hash();
	for (i=0; i < this->len ; i++)
		hash = partial_name_hash(tolower(this->name[i]), hash);
	this->hash = end_name_hash(hash);
  
	return 0;
}

static int
smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b)
{
	int i, result = 1;

	if (a->len != b->len)
		goto out;
	for (i=0; i < a->len; i++) {
		if (tolower(a->name[i]) != tolower(b->name[i]))
			goto out;
	}
	result = 0;
out:
	return result;
}

/*
 * This is the callback from dput() when d_count is going to 0.
 * We use this to unhash dentries with bad inodes.
 */
static int
smb_delete_dentry(struct dentry * dentry)
{
	if (dentry->d_inode) {
		if (is_bad_inode(dentry->d_inode)) {
			PARANOIA("bad inode, unhashing %s/%s\n",
				 DENTRY_PATH(dentry));
			return 1;
		}
	} else {
		/* N.B. Unhash negative dentries? */
	}
	return 0;
}

/*
 * Initialize a new dentry
 */
void
smb_new_dentry(struct dentry *dentry)
{
	struct smb_sb_info *server = server_from_dentry(dentry);

	if (server->mnt->flags & SMB_MOUNT_CASE)
		dentry->d_op = &smbfs_dentry_operations_case;
	else
		dentry->d_op = &smbfs_dentry_operations;
	dentry->d_time = jiffies;
}


/*
 * Whenever a lookup succeeds, we know the parent directories
 * are all valid, so we want to update the dentry timestamps.
 * N.B. Move this to dcache?
 */
void
smb_renew_times(struct dentry * dentry)
{
	dget(dentry);
	spin_lock(&dentry->d_lock);
	for (;;) {
		struct dentry *parent;

		dentry->d_time = jiffies;
		if (IS_ROOT(dentry))
			break;
		parent = dentry->d_parent;
		dget(parent);
		spin_unlock(&dentry->d_lock);
		dput(dentry);
		dentry = parent;
		spin_lock(&dentry->d_lock);
	}
	spin_unlock(&dentry->d_lock);
	dput(dentry);
}

static struct dentry *
smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	struct smb_fattr finfo;
	struct inode *inode;
	int error;
	struct smb_sb_info *server;

	error = -ENAMETOOLONG;
	if (dentry->d_name.len > SMB_MAXNAMELEN)
		goto out;

	/* Do not allow lookup of names with backslashes in */
	error = -EINVAL;
	if (memchr(dentry->d_name.name, '\\', dentry->d_name.len))
		goto out;

	lock_kernel();
	error = smb_proc_getattr(dentry, &finfo);
#ifdef SMBFS_PARANOIA
	if (error && error != -ENOENT)
		PARANOIA("find %s/%s failed, error=%d\n",
			 DENTRY_PATH(dentry), error);
#endif

	inode = NULL;
	if (error == -ENOENT)
		goto add_entry;
	if (!error) {
		error = -EACCES;
		finfo.f_ino = iunique(dentry->d_sb, 2);
		inode = smb_iget(dir->i_sb, &finfo);
		if (inode) {
	add_entry:
			server = server_from_dentry(dentry);
			if (server->mnt->flags & SMB_MOUNT_CASE)
				dentry->d_op = &smbfs_dentry_operations_case;
			else
				dentry->d_op = &smbfs_dentry_operations;

			d_add(dentry, inode);
			smb_renew_times(dentry);
			error = 0;
		}
	}
	unlock_kernel();
out:
	return ERR_PTR(error);
}

/*
 * This code is common to all routines creating a new inode.
 */
static int
smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id)
{
	struct smb_sb_info *server = server_from_dentry(dentry);
	struct inode *inode;
	int error;
	struct smb_fattr fattr;

	VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid);

	error = smb_proc_getattr(dentry, &fattr);
	if (error)
		goto out_close;

	smb_renew_times(dentry);
	fattr.f_ino = iunique(dentry->d_sb, 2);
	inode = smb_iget(dentry->d_sb, &fattr);
	if (!inode)
		goto out_no_inode;

	if (have_id) {
		struct smb_inode_info *ei = SMB_I(inode);
		ei->fileid = fileid;
		ei->access = SMB_O_RDWR;
		ei->open = server->generation;
	}
	d_instantiate(dentry, inode);
out:
	return error;

out_no_inode:
	error = -EACCES;
out_close:
	if (have_id) {
		PARANOIA("%s/%s failed, error=%d, closing %u\n",
			 DENTRY_PATH(dentry), error, fileid);
		smb_close_fileid(dentry, fileid);
	}
	goto out;
}

/* N.B. How should the mode argument be used? */
static int
smb_create(struct inode *dir, struct dentry *dentry, int mode,
		struct nameidata *nd)
{
	struct smb_sb_info *server = server_from_dentry(dentry);
	__u16 fileid;
	int error;
	struct iattr attr;

	VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode);

	lock_kernel();
	smb_invalid_dir_cache(dir);
	error = smb_proc_create(dentry, 0, get_seconds(), &fileid);
	if (!error) {
		if (server->opt.capabilities & SMB_CAP_UNIX) {
			/* Set attributes for new file */
			attr.ia_valid = ATTR_MODE;
			attr.ia_mode = mode;
			error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
		}
		error = smb_instantiate(dentry, fileid, 1);
	} else {
		PARANOIA("%s/%s failed, error=%d\n",
			 DENTRY_PATH(dentry), error);
	}
	unlock_kernel();
	return error;
}

/* N.B. How should the mode argument be used? */
static int
smb_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	struct smb_sb_info *server = server_from_dentry(dentry);
	int error;
	struct iattr attr;

	lock_kernel();
	smb_invalid_dir_cache(dir);
	error = smb_proc_mkdir(dentry);
	if (!error) {
		if (server->opt.capabilities & SMB_CAP_UNIX) {
			/* Set attributes for new directory */
			attr.ia_valid = ATTR_MODE;
			attr.ia_mode = mode;
			error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
		}
		error = smb_instantiate(dentry, 0, 0);
	}
	unlock_kernel();
	return error;
}

static int
smb_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
	int error;

	/*
	 * Close the directory if it's open.
	 */
	lock_kernel();
	smb_close(inode);

	/*
	 * Check that nobody else is using the directory..
	 */
	error = -EBUSY;
	if (!d_unhashed(dentry))
		goto out;

	smb_invalid_dir_cache(dir);
	error = smb_proc_rmdir(dentry);

out:
	unlock_kernel();
	return error;
}

static int
smb_unlink(struct inode *dir, struct dentry *dentry)
{
	int error;

	/*
	 * Close the file if it's open.
	 */
	lock_kernel();
	smb_close(dentry->d_inode);

	smb_invalid_dir_cache(dir);
	error = smb_proc_unlink(dentry);
	if (!error)
		smb_renew_times(dentry);
	unlock_kernel();
	return error;
}

static int
smb_rename(struct inode *old_dir, struct dentry *old_dentry,
	   struct inode *new_dir, struct dentry *new_dentry)
{
	int error;

	/*
	 * Close any open files, and check whether to delete the
	 * target before attempting the rename.
	 */
	lock_kernel();
	if (old_dentry->d_inode)
		smb_close(old_dentry->d_inode);
	if (new_dentry->d_inode) {
		smb_close(new_dentry->d_inode);
		error = smb_proc_unlink(new_dentry);
		if (error) {
			VERBOSE("unlink %s/%s, error=%d\n",
				DENTRY_PATH(new_dentry), error);
			goto out;
		}
		/* FIXME */
		d_delete(new_dentry);
	}

	smb_invalid_dir_cache(old_dir);
	smb_invalid_dir_cache(new_dir);
	error = smb_proc_mv(old_dentry, new_dentry);
	if (!error) {
		smb_renew_times(old_dentry);
		smb_renew_times(new_dentry);
	}
out:
	unlock_kernel();
	return error;
}

/*
 * FIXME: samba servers won't let you create device nodes unless uid/gid
 * matches the connection credentials (and we don't know which those are ...)
 */
static int
smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
{
	int error;
	struct iattr attr;

	attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID;
	attr.ia_mode = mode;
	attr.ia_uid = current->euid;
	attr.ia_gid = current->egid;

	if (!new_valid_dev(dev))
		return -EINVAL;

	smb_invalid_dir_cache(dir);
	error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev));
	if (!error) {
		error = smb_instantiate(dentry, 0, 0);
	}
	return error;
}

/*
 * dentry = existing file
 * new_dentry = new file
 */
static int
smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry)
{
	int error;

	DEBUG1("smb_link old=%s/%s new=%s/%s\n",
	       DENTRY_PATH(dentry), DENTRY_PATH(new_dentry));
	smb_invalid_dir_cache(dir);
	error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry);
	if (!error) {
		smb_renew_times(dentry);
		error = smb_instantiate(new_dentry, 0, 0);
	}
	return error;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* dir.c
	3	*
	4	* Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
	5	* Copyright (C) 1997 by Volker Lendecke
	6	*
	7	* Please add a note about your changes to smbfs in the ChangeLog file.
	8	*/
	9
	10	#include <linux/time.h>
	11	#include <linux/errno.h>
	12	#include <linux/kernel.h>
	13	#include <linux/smp_lock.h>
	14	#include <linux/ctype.h>
	15	#include <linux/net.h>
e8edc6e0	16	#include <linux/sched.h>
1da177e4 LT	17
	18	#include <linux/smb_fs.h>
	19	#include <linux/smb_mount.h>
	20	#include <linux/smbno.h>
	21
	22	#include "smb_debug.h"
	23	#include "proto.h"
	24
	25	static int smb_readdir(struct file , void , filldir_t);
	26	static int smb_dir_open(struct inode , struct file );
	27
	28	static struct dentry smb_lookup(struct inode , struct dentry , struct nameidata );
	29	static int smb_create(struct inode , struct dentry , int, struct nameidata *);
	30	static int smb_mkdir(struct inode , struct dentry , int);
	31	static int smb_rmdir(struct inode , struct dentry );
	32	static int smb_unlink(struct inode , struct dentry );
	33	static int smb_rename(struct inode , struct dentry ,
	34	struct inode , struct dentry );
	35	static int smb_make_node(struct inode ,struct dentry ,int,dev_t);
	36	static int smb_link(struct dentry , struct inode , struct dentry *);
	37
4b6f5d20	38	const struct file_operations smb_dir_operations =
1da177e4 LT	39	{
	40	.read = generic_read_dir,
	41	.readdir = smb_readdir,
	42	.ioctl = smb_ioctl,
	43	.open = smb_dir_open,
	44	};
	45
c5ef1c42	46	const struct inode_operations smb_dir_inode_operations =
1da177e4 LT	47	{
	48	.create = smb_create,
	49	.lookup = smb_lookup,
	50	.unlink = smb_unlink,
	51	.mkdir = smb_mkdir,
	52	.rmdir = smb_rmdir,
	53	.rename = smb_rename,
	54	.getattr = smb_getattr,
	55	.setattr = smb_notify_change,
	56	};
	57
c5ef1c42	58	const struct inode_operations smb_dir_inode_operations_unix =
1da177e4 LT	59	{
	60	.create = smb_create,
	61	.lookup = smb_lookup,
	62	.unlink = smb_unlink,
	63	.mkdir = smb_mkdir,
	64	.rmdir = smb_rmdir,
	65	.rename = smb_rename,
	66	.getattr = smb_getattr,
	67	.setattr = smb_notify_change,
	68	.symlink = smb_symlink,
	69	.mknod = smb_make_node,
	70	.link = smb_link,
	71	};
	72
	73	/*
	74	* Read a directory, using filldir to fill the dirent memory.
	75	* smb_proc_readdir does the actual reading from the smb server.
	76	*
	77	* The cache code is almost directly taken from ncpfs
	78	*/
	79	static int
	80	smb_readdir(struct file filp, void dirent, filldir_t filldir)
	81	{
17b75e69	82	struct dentry *dentry = filp->f_path.dentry;
1da177e4 LT	83	struct inode *dir = dentry->d_inode;
	84	struct smb_sb_info *server = server_from_dentry(dentry);
	85	union smb_dir_cache *cache = NULL;
	86	struct smb_cache_control ctl;
	87	struct page *page = NULL;
	88	int result;
	89
	90	ctl.page = NULL;
	91	ctl.cache = NULL;
	92
	93	VERBOSE("reading %s/%s, f_pos=%d\n",
	94	DENTRY_PATH(dentry), (int) filp->f_pos);
	95
	96	result = 0;
	97
	98	lock_kernel();
	99
	100	switch ((unsigned int) filp->f_pos) {
	101	case 0:
	102	if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
	103	goto out;
	104	filp->f_pos = 1;
	105	/* fallthrough */
	106	case 1:
	107	if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0)
	108	goto out;
	109	filp->f_pos = 2;
	110	}
	111
	112	/*
	113	* Make sure our inode is up-to-date.
	114	*/
	115	result = smb_revalidate_inode(dentry);
	116	if (result)
	117	goto out;
	118
	119
	120	page = grab_cache_page(&dir->i_data, 0);
	121	if (!page)
	122	goto read_really;
	123
	124	ctl.cache = cache = kmap(page);
	125	ctl.head = cache->head;
	126
	127	if (!PageUptodate(page) \|\| !ctl.head.eof) {
	128	VERBOSE("%s/%s, page uptodate=%d, eof=%d\n",
	129	DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof);
	130	goto init_cache;
	131	}
	132
	133	if (filp->f_pos == 2) {
	134	if (jiffies - ctl.head.time >= SMB_MAX_AGE(server))
	135	goto init_cache;
	136
	137	/*
	138	* N.B. ncpfs checks mtime of dentry too here, we don't.
	139	* 1. common smb servers do not update mtime on dir changes
	140	* 2. it requires an extra smb request
	141	* (revalidate has the same timeout as ctl.head.time)
	142	*
	143	* Instead smbfs invalidates its own cache on local changes
	144	* and remote changes are not seen until timeout.
	145	*/
	146	}
147
148	if (filp->f_pos > ctl.head.end)
149	goto finished;
150
151	ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2);
152	ctl.ofs = ctl.fpos / SMB_DIRCACHE_SIZE;
153	ctl.idx = ctl.fpos % SMB_DIRCACHE_SIZE;
154
155	for (;;) {
156	if (ctl.ofs != 0) {
157	ctl.page = find_lock_page(&dir->i_data, ctl.ofs);
158	if (!ctl.page)
159	goto invalid_cache;
160	ctl.cache = kmap(ctl.page);
161	if (!PageUptodate(ctl.page))
162	goto invalid_cache;
163	}
164	while (ctl.idx < SMB_DIRCACHE_SIZE) {
165	struct dentry *dent;
166	int res;
167
168	dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx],
169	dentry, filp->f_pos);
170	if (!dent)
171	goto invalid_cache;
172
173	res = filldir(dirent, dent->d_name.name,
174	dent->d_name.len, filp->f_pos,
175	dent->d_inode->i_ino, DT_UNKNOWN);
176	dput(dent);
177	if (res)
178	goto finished;
179	filp->f_pos += 1;
180	ctl.idx += 1;
181	if (filp->f_pos > ctl.head.end)
182	goto finished;
183	}
184	if (ctl.page) {
185	kunmap(ctl.page);
186	SetPageUptodate(ctl.page);
187	unlock_page(ctl.page);
188	page_cache_release(ctl.page);
189	ctl.page = NULL;
190	}
191	ctl.idx = 0;
192	ctl.ofs += 1;
193	}
194	invalid_cache:
195	if (ctl.page) {
196	kunmap(ctl.page);
197	unlock_page(ctl.page);
198	page_cache_release(ctl.page);
199	ctl.page = NULL;
200	}
201	ctl.cache = cache;
202	init_cache:
203	smb_invalidate_dircache_entries(dentry);
204	ctl.head.time = jiffies;
205	ctl.head.eof = 0;
206	ctl.fpos = 2;
207	ctl.ofs = 0;
208	ctl.idx = SMB_DIRCACHE_START;
209	ctl.filled = 0;
210	ctl.valid = 1;
211	read_really:
212	result = server->ops->readdir(filp, dirent, filldir, &ctl);
caf73608 AM	213	if (result == -ERESTARTSYS && page)
caf73608 AM	214	ClearPageUptodate(page);
1da177e4 LT	215	if (ctl.idx == -1)
	216	goto invalid_cache; /* retry */
	217	ctl.head.end = ctl.fpos - 1;
	218	ctl.head.eof = ctl.valid;
	219	finished:
	220	if (page) {
	221	cache->head = ctl.head;
	222	kunmap(page);
caf73608 AM	223	if (result != -ERESTARTSYS)
caf73608 AM	224	SetPageUptodate(page);
1da177e4 LT	225	unlock_page(page);
	226	page_cache_release(page);
	227	}
	228	if (ctl.page) {
	229	kunmap(ctl.page);
	230	SetPageUptodate(ctl.page);
	231	unlock_page(ctl.page);
	232	page_cache_release(ctl.page);
	233	}
	234	out:
	235	unlock_kernel();
	236	return result;
	237	}
	238
	239	static int
	240	smb_dir_open(struct inode dir, struct file file)
	241	{
17b75e69	242	struct dentry *dentry = file->f_path.dentry;
1da177e4 LT	243	struct smb_sb_info *server;
	244	int error = 0;
	245
	246	VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
17b75e69	247	file->f_path.dentry->d_name.name);
1da177e4 LT	248
	249	/*
	250	* Directory timestamps in the core protocol aren't updated
	251	* when a file is added, so we give them a very short TTL.
	252	*/
	253	lock_kernel();
	254	server = server_from_dentry(dentry);
	255	if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) {
	256	unsigned long age = jiffies - SMB_I(dir)->oldmtime;
	257	if (age > 2*HZ)
	258	smb_invalid_dir_cache(dir);
	259	}
	260
	261	/*
	262	* Note: in order to allow the smbmount process to open the
	263	* mount point, we only revalidate if the connection is valid or
	264	* if the process is trying to access something other than the root.
	265	*/
	266	if (server->state == CONN_VALID \|\| !IS_ROOT(dentry))
	267	error = smb_revalidate_inode(dentry);
	268	unlock_kernel();
	269	return error;
	270	}
	271
	272	/*
	273	* Dentry operations routines
	274	*/
	275	static int smb_lookup_validate(struct dentry , struct nameidata );
	276	static int smb_hash_dentry(struct dentry , struct qstr );
	277	static int smb_compare_dentry(struct dentry , struct qstr , struct qstr *);
	278	static int smb_delete_dentry(struct dentry *);
	279
	280	static struct dentry_operations smbfs_dentry_operations =
	281	{
	282	.d_revalidate = smb_lookup_validate,
	283	.d_hash = smb_hash_dentry,
	284	.d_compare = smb_compare_dentry,
	285	.d_delete = smb_delete_dentry,
	286	};
	287
	288	static struct dentry_operations smbfs_dentry_operations_case =
	289	{
	290	.d_revalidate = smb_lookup_validate,
	291	.d_delete = smb_delete_dentry,
	292	};
	293
	294
	295	/*
	296	* This is the callback when the dcache has a lookup hit.
	297	*/
	298	static int
	299	smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
	300	{
	301	struct smb_sb_info *server = server_from_dentry(dentry);
	302	struct inode * inode = dentry->d_inode;
	303	unsigned long age = jiffies - dentry->d_time;
	304	int valid;
	305
	306	/*
	307	* The default validation is based on dentry age:
	308	* we believe in dentries for a few seconds. (But each
	309	* successful server lookup renews the timestamp.)
	310	*/
	311	valid = (age <= SMB_MAX_AGE(server));
312	#ifdef SMBFS_DEBUG_VERBOSE
313	if (!valid)
314	VERBOSE("%s/%s not valid, age=%lu\n",
315	DENTRY_PATH(dentry), age);
316	#endif
317
318	if (inode) {
319	lock_kernel();
320	if (is_bad_inode(inode)) {
321	PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry));
322	valid = 0;
323	} else if (!valid)
324	valid = (smb_revalidate_inode(dentry) == 0);
325	unlock_kernel();
326	} else {
327	/*
328	* What should we do for negative dentries?
329	*/
330	}
331	return valid;
332	}
333
334	static int
335	smb_hash_dentry(struct dentry dir, struct qstr this)
336	{
337	unsigned long hash;
338	int i;
339
340	hash = init_name_hash();
341	for (i=0; i < this->len ; i++)
342	hash = partial_name_hash(tolower(this->name[i]), hash);
343	this->hash = end_name_hash(hash);
344
345	return 0;
346	}
347
348	static int
349	smb_compare_dentry(struct dentry dir, struct qstr a, struct qstr *b)
350	{
351	int i, result = 1;
352
353	if (a->len != b->len)
354	goto out;
355	for (i=0; i < a->len; i++) {
356	if (tolower(a->name[i]) != tolower(b->name[i]))
357	goto out;
358	}
359	result = 0;
360	out:
361	return result;
362	}
363
364	/*
365	* This is the callback from dput() when d_count is going to 0.
366	* We use this to unhash dentries with bad inodes.
367	*/
368	static int
369	smb_delete_dentry(struct dentry * dentry)
370	{
371	if (dentry->d_inode) {
372	if (is_bad_inode(dentry->d_inode)) {
373	PARANOIA("bad inode, unhashing %s/%s\n",
374	DENTRY_PATH(dentry));
375	return 1;
376	}
377	} else {
378	/* N.B. Unhash negative dentries? */
379	}
380	return 0;
381	}
382
383	/*
384	* Initialize a new dentry
385	*/
386	void
387	smb_new_dentry(struct dentry *dentry)
388	{
389	struct smb_sb_info *server = server_from_dentry(dentry);
390
391	if (server->mnt->flags & SMB_MOUNT_CASE)
392	dentry->d_op = &smbfs_dentry_operations_case;
393	else
394	dentry->d_op = &smbfs_dentry_operations;
395	dentry->d_time = jiffies;
396	}
397
398
399	/*
400	* Whenever a lookup succeeds, we know the parent directories
401	* are all valid, so we want to update the dentry timestamps.
402	* N.B. Move this to dcache?
403	*/
404	void
405	smb_renew_times(struct dentry * dentry)
406	{
407	dget(dentry);
408	spin_lock(&dentry->d_lock);
409	for (;;) {
410	struct dentry *parent;
411
412	dentry->d_time = jiffies;
413	if (IS_ROOT(dentry))
414	break;
415	parent = dentry->d_parent;
416	dget(parent);
417	spin_unlock(&dentry->d_lock);
418	dput(dentry);
419	dentry = parent;
420	spin_lock(&dentry->d_lock);
421	}
422	spin_unlock(&dentry->d_lock);
423	dput(dentry);
424	}
425
426	static struct dentry *
427	smb_lookup(struct inode dir, struct dentry dentry, struct nameidata *nd)
428	{
429	struct smb_fattr finfo;
430	struct inode *inode;
431	int error;
432	struct smb_sb_info *server;
433
434	error = -ENAMETOOLONG;
435	if (dentry->d_name.len > SMB_MAXNAMELEN)
436	goto out;
437
3b7c8108 OK	438	/* Do not allow lookup of names with backslashes in */
	439	error = -EINVAL;
	440	if (memchr(dentry->d_name.name, '\\', dentry->d_name.len))
	441	goto out;
	442
1da177e4 LT	443	lock_kernel();
	444	error = smb_proc_getattr(dentry, &finfo);
	445	#ifdef SMBFS_PARANOIA
	446	if (error && error != -ENOENT)
	447	PARANOIA("find %s/%s failed, error=%d\n",
	448	DENTRY_PATH(dentry), error);
	449	#endif
	450
	451	inode = NULL;
	452	if (error == -ENOENT)
	453	goto add_entry;
	454	if (!error) {
	455	error = -EACCES;
	456	finfo.f_ino = iunique(dentry->d_sb, 2);
	457	inode = smb_iget(dir->i_sb, &finfo);
	458	if (inode) {
	459	add_entry:
	460	server = server_from_dentry(dentry);
	461	if (server->mnt->flags & SMB_MOUNT_CASE)
	462	dentry->d_op = &smbfs_dentry_operations_case;
	463	else
	464	dentry->d_op = &smbfs_dentry_operations;
	465
	466	d_add(dentry, inode);
	467	smb_renew_times(dentry);
	468	error = 0;
	469	}
	470	}
	471	unlock_kernel();
	472	out:
	473	return ERR_PTR(error);
	474	}
	475
	476	/*
	477	* This code is common to all routines creating a new inode.
	478	*/
	479	static int
	480	smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id)
	481	{
	482	struct smb_sb_info *server = server_from_dentry(dentry);
	483	struct inode *inode;
	484	int error;
	485	struct smb_fattr fattr;
	486
	487	VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid);
	488
	489	error = smb_proc_getattr(dentry, &fattr);
	490	if (error)
	491	goto out_close;
	492
	493	smb_renew_times(dentry);
	494	fattr.f_ino = iunique(dentry->d_sb, 2);
	495	inode = smb_iget(dentry->d_sb, &fattr);
	496	if (!inode)
	497	goto out_no_inode;
	498
	499	if (have_id) {
	500	struct smb_inode_info *ei = SMB_I(inode);
	501	ei->fileid = fileid;
	502	ei->access = SMB_O_RDWR;
	503	ei->open = server->generation;
	504	}
	505	d_instantiate(dentry, inode);
	506	out:
507	return error;
508
509	out_no_inode:
510	error = -EACCES;
511	out_close:
512	if (have_id) {
513	PARANOIA("%s/%s failed, error=%d, closing %u\n",
514	DENTRY_PATH(dentry), error, fileid);
515	smb_close_fileid(dentry, fileid);
516	}
517	goto out;
518	}
519
520	/* N.B. How should the mode argument be used? */
521	static int
522	smb_create(struct inode dir, struct dentry dentry, int mode,
523	struct nameidata *nd)
524	{
525	struct smb_sb_info *server = server_from_dentry(dentry);
526	__u16 fileid;
527	int error;
528	struct iattr attr;
529
530	VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode);
531
532	lock_kernel();
533	smb_invalid_dir_cache(dir);
534	error = smb_proc_create(dentry, 0, get_seconds(), &fileid);
535	if (!error) {
536	if (server->opt.capabilities & SMB_CAP_UNIX) {
537	/* Set attributes for new file */
538	attr.ia_valid = ATTR_MODE;
539	attr.ia_mode = mode;
540	error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
541	}
542	error = smb_instantiate(dentry, fileid, 1);
543	} else {
544	PARANOIA("%s/%s failed, error=%d\n",
545	DENTRY_PATH(dentry), error);
546	}
547	unlock_kernel();
548	return error;
549	}
550
551	/* N.B. How should the mode argument be used? */
552	static int
553	smb_mkdir(struct inode dir, struct dentry dentry, int mode)
554	{
555	struct smb_sb_info *server = server_from_dentry(dentry);
556	int error;
557	struct iattr attr;
558
559	lock_kernel();
560	smb_invalid_dir_cache(dir);
561	error = smb_proc_mkdir(dentry);
562	if (!error) {
563	if (server->opt.capabilities & SMB_CAP_UNIX) {
564	/* Set attributes for new directory */
565	attr.ia_valid = ATTR_MODE;
566	attr.ia_mode = mode;
567	error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
568	}
569	error = smb_instantiate(dentry, 0, 0);
570	}
571	unlock_kernel();
572	return error;
573	}
574
575	static int
576	smb_rmdir(struct inode dir, struct dentry dentry)
577	{
578	struct inode *inode = dentry->d_inode;
579	int error;
580
581	/*
582	* Close the directory if it's open.
583	*/
584	lock_kernel();
585	smb_close(inode);
586
587	/*
588	* Check that nobody else is using the directory..
589	*/
590	error = -EBUSY;
591	if (!d_unhashed(dentry))
592	goto out;
593
594	smb_invalid_dir_cache(dir);
595	error = smb_proc_rmdir(dentry);
596
597	out:
598	unlock_kernel();
599	return error;
600	}
601
602	static int
603	smb_unlink(struct inode dir, struct dentry dentry)
604	{
605	int error;
606
607	/*
608	* Close the file if it's open.
609	*/
610	lock_kernel();
611	smb_close(dentry->d_inode);
612
613	smb_invalid_dir_cache(dir);
614	error = smb_proc_unlink(dentry);
615	if (!error)
616	smb_renew_times(dentry);
617	unlock_kernel();
618	return error;
619	}
620
621	static int
622	smb_rename(struct inode old_dir, struct dentry old_dentry,
623	struct inode new_dir, struct dentry new_dentry)
624	{
625	int error;
626
627	/*
628	* Close any open files, and check whether to delete the
629	* target before attempting the rename.
630	*/
631	lock_kernel();
632	if (old_dentry->d_inode)
633	smb_close(old_dentry->d_inode);
634	if (new_dentry->d_inode) {
635	smb_close(new_dentry->d_inode);
636	error = smb_proc_unlink(new_dentry);
637	if (error) {
638	VERBOSE("unlink %s/%s, error=%d\n",
639	DENTRY_PATH(new_dentry), error);
640	goto out;
641	}
642	/* FIXME */
643	d_delete(new_dentry);
644	}
645
646	smb_invalid_dir_cache(old_dir);
647	smb_invalid_dir_cache(new_dir);
648	error = smb_proc_mv(old_dentry, new_dentry);
649	if (!error) {
650	smb_renew_times(old_dentry);
651	smb_renew_times(new_dentry);
652	}
653	out:
654	unlock_kernel();
655	return error;
656	}
657
658	/*
659	* FIXME: samba servers won't let you create device nodes unless uid/gid
660	* matches the connection credentials (and we don't know which those are ...)
661	*/
662	static int
663	smb_make_node(struct inode dir, struct dentry dentry, int mode, dev_t dev)
664	{
665	int error;
666	struct iattr attr;
667
668	attr.ia_valid = ATTR_MODE \| ATTR_UID \| ATTR_GID;
669	attr.ia_mode = mode;
670	attr.ia_uid = current->euid;
671	attr.ia_gid = current->egid;
672
673	if (!new_valid_dev(dev))
674	return -EINVAL;
675
676	smb_invalid_dir_cache(dir);
677	error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev));
678	if (!error) {
679	error = smb_instantiate(dentry, 0, 0);
680	}
681	return error;
682	}
683
684	/*
685	* dentry = existing file
686	* new_dentry = new file
687	*/
688	static int
689	smb_link(struct dentry dentry, struct inode dir, struct dentry *new_dentry)
690	{
691	int error;
692
693	DEBUG1("smb_link old=%s/%s new=%s/%s\n",
694	DENTRY_PATH(dentry), DENTRY_PATH(new_dentry));
695	smb_invalid_dir_cache(dir);
696	error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry);
697	if (!error) {
698	smb_renew_times(dentry);
699	error = smb_instantiate(new_dentry, 0, 0);
700	}
701	return error;
702	}