Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f7cc02b8 authored by Yoshihisa Abe's avatar Yoshihisa Abe Committed by Linus Torvalds
Browse files

Coda: push BKL regions into coda_upcall() 



Now that shared inode state is locked using the cii->c_lock, the BKL is
only used to protect the upcall queues used to communicate with the
userspace cache manager. The remaining state is all local and we can
push the lock further down into coda_upcall().

Signed-off-by: default avatarYoshihisa Abe <yoshiabe@cs.cmu.edu>
Signed-off-by: default avatarJan Harkes <jaharkes@cs.cmu.edu>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent b5ce1d83

fs/coda/dir.c

+42 −107
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#include <linux/stat.h>

#include <linux/errno.h>

#include <linux/string.h>

#include <linux/smp_lock.h>

#include <linux/spinlock.h>



#include <asm/uaccess.h>
@@ -117,15 +116,11 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struc 
		goto exit;

	}



	lock_kernel();



	error = venus_lookup(dir->i_sb, coda_i2f(dir), name, length,

			     &type, &resfid);

	if (!error)

		error = coda_cnode_make(&inode, &resfid, dir->i_sb);



	unlock_kernel();



	if (error && error != -ENOENT)

		return ERR_PTR(error);
@@ -141,7 +136,7 @@ static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struc 


int coda_permission(struct inode *inode, int mask)

{

        int error = 0;

	int error;



	mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
@@ -151,18 +146,14 @@ int coda_permission(struct inode *inode, int mask) 
	if ((mask & MAY_EXEC) && !execute_ok(inode))

		return -EACCES;



	lock_kernel();



	if (coda_cache_check(inode, mask))

		goto out; 

		return 0;



	error = venus_access(inode->i_sb, coda_i2f(inode), mask);

    

	if (!error)

		coda_cache_enter(inode, mask);



 out:

	unlock_kernel();

	return error;

}
@@ -201,41 +192,34 @@ static inline void coda_dir_drop_nlink(struct inode *dir) 
/* creation routines: create, mknod, mkdir, link, symlink */

static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd)

{

        int error=0;

	int error;

	const char *name=de->d_name.name;

	int length=de->d_name.len;

	struct inode *inode;

	struct CodaFid newfid;

	struct coda_vattr attrs;



	lock_kernel();



	if (coda_isroot(dir) && coda_iscontrol(name, length)) {

		unlock_kernel();

	if (coda_isroot(dir) && coda_iscontrol(name, length))

		return -EPERM;

	}



	error = venus_create(dir->i_sb, coda_i2f(dir), name, length, 

				0, mode, &newfid, &attrs);



        if ( error ) {

		unlock_kernel();

		d_drop(de);

		return error;

	}

	if (error)

		goto err_out;



	inode = coda_iget(dir->i_sb, &newfid, &attrs);

	if (IS_ERR(inode)) {

		unlock_kernel();

		d_drop(de);

		return PTR_ERR(inode);

		error = PTR_ERR(inode);

		goto err_out;

	}



	/* invalidate the directory cnode's attributes */

	coda_dir_update_mtime(dir);

	unlock_kernel();

	d_instantiate(de, inode);

	return 0;

err_out:

	d_drop(de);

	return error;

}



static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
@@ -247,36 +231,29 @@ static int coda_mkdir(struct inode *dir, struct dentry *de, int mode) 
	int error;

	struct CodaFid newfid;



	lock_kernel();



	if (coda_isroot(dir) && coda_iscontrol(name, len)) {

		unlock_kernel();

	if (coda_isroot(dir) && coda_iscontrol(name, len))

		return -EPERM;

	}



	attrs.va_mode = mode;

	error = venus_mkdir(dir->i_sb, coda_i2f(dir), 

			       name, len, &newfid, &attrs);

        

        if ( error ) {

		unlock_kernel();

		d_drop(de);

		return error;

        }

	if (error)

		goto err_out;

         

	inode = coda_iget(dir->i_sb, &newfid, &attrs);

	if (IS_ERR(inode)) {

		unlock_kernel();

		d_drop(de);

		return PTR_ERR(inode);

		error = PTR_ERR(inode);

		goto err_out;

	}



	/* invalidate the directory cnode's attributes */

	coda_dir_inc_nlink(dir);

	coda_dir_update_mtime(dir);

	unlock_kernel();

	d_instantiate(de, inode);

	return 0;

err_out:

	d_drop(de);

	return error;

}



/* try to make de an entry in dir_inodde linked to source_de */
@@ -288,29 +265,21 @@ static int coda_link(struct dentry *source_de, struct inode *dir_inode, 
	int len = de->d_name.len;

	int error;



	lock_kernel();



	if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) {

		unlock_kernel();

	if (coda_isroot(dir_inode) && coda_iscontrol(name, len))

		return -EPERM;

	}



	error = venus_link(dir_inode->i_sb, coda_i2f(inode),

			   coda_i2f(dir_inode), (const char *)name, len);



	if (error) {

		d_drop(de);

		goto out;

		return error;

	}



	coda_dir_update_mtime(dir_inode);

	atomic_inc(&inode->i_count);

	d_instantiate(de, inode);

	inc_nlink(inode);



out:

	unlock_kernel();

	return(error);

	return 0;

}
@@ -320,20 +289,14 @@ static int coda_symlink(struct inode *dir_inode, struct dentry *de, 
	const char *name = de->d_name.name;

	int len = de->d_name.len;

	int symlen;

	int error = 0;



	lock_kernel();

	int error;



	if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) {

		unlock_kernel();

	if (coda_isroot(dir_inode) && coda_iscontrol(name, len))

		return -EPERM;

	}



	symlen = strlen(symname);

	if ( symlen > CODA_MAXPATHLEN ) {

		unlock_kernel();

	if (symlen > CODA_MAXPATHLEN)

		return -ENAMETOOLONG;

	}



	/*

	 * This entry is now negative. Since we do not create
@@ -347,7 +310,6 @@ static int coda_symlink(struct inode *dir_inode, struct dentry *de, 
	if (!error)

		coda_dir_update_mtime(dir_inode);



	unlock_kernel();

	return error;

}
@@ -358,17 +320,12 @@ static int coda_unlink(struct inode *dir, struct dentry *de) 
	const char *name = de->d_name.name;

	int len = de->d_name.len;



	lock_kernel();



	error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);

	if ( error ) {

		unlock_kernel();

	if (error)

		return error;

	}



	coda_dir_update_mtime(dir);

	drop_nlink(de->d_inode);

	unlock_kernel();

	return 0;

}
@@ -378,8 +335,6 @@ static int coda_rmdir(struct inode *dir, struct dentry *de) 
	int len = de->d_name.len;

	int error;



	lock_kernel();



	error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);

	if (!error) {

		/* VFS may delete the child */
@@ -390,7 +345,6 @@ static int coda_rmdir(struct inode *dir, struct dentry *de) 
		coda_dir_drop_nlink(dir);

		coda_dir_update_mtime(dir);

	}

	unlock_kernel();

	return error;

}
@@ -404,12 +358,9 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry, 
	int new_length = new_dentry->d_name.len;

	int error;



	lock_kernel();



	error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),

			     coda_i2f(new_dir), old_length, new_length,

			     (const char *) old_name, (const char *)new_name);



	if (!error) {

		if (new_dentry->d_inode) {

			if (S_ISDIR(new_dentry->d_inode->i_mode)) {
@@ -424,8 +375,6 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry, 
			coda_flag_inode(new_dir, C_VATTR);

		}

	}

	unlock_kernel();



	return error;

}
@@ -595,10 +544,7 @@ static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd) 
	struct inode *inode = de->d_inode;

	struct coda_inode_info *cii;



	if (!inode)

		return 1;

	lock_kernel();

	if (coda_isroot(inode))

	if (!inode || coda_isroot(inode))

		goto out;

	if (is_bad_inode(inode))

		goto bad;
@@ -621,12 +567,9 @@ static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd) 
	spin_lock(&cii->c_lock);

	cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);

	spin_unlock(&cii->c_lock);



bad:

	unlock_kernel();

	return 0;

out:

	unlock_kernel();

	return 1;

}
@@ -659,20 +602,19 @@ static int coda_dentry_delete(struct dentry * dentry) 
int coda_revalidate_inode(struct dentry *dentry)

{

	struct coda_vattr attr;

	int error = 0;

	int error;

	int old_mode;

	ino_t old_ino;

	struct inode *inode = dentry->d_inode;

	struct coda_inode_info *cii = ITOC(inode);



	lock_kernel();

	if (!cii->c_flags)

		goto ok;

		return 0;



	if (cii->c_flags & (C_VATTR | C_PURGE | C_FLUSH)) {

		error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr);

		if (error)

			goto return_bad;

			return -EIO;



		/* this inode may be lost if:

		   - it's ino changed
@@ -691,7 +633,7 @@ int coda_revalidate_inode(struct dentry *dentry) 
		/* the following can happen when a local fid is replaced 

		   with a global one, here we lose and declare the inode bad */

		if (inode->i_ino != old_ino)

			goto return_bad;

			return -EIO;

		

		coda_flag_inode_children(inode, C_FLUSH);
@@ -699,12 +641,5 @@ int coda_revalidate_inode(struct dentry *dentry) 
		cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);

		spin_unlock(&cii->c_lock);

	}



ok:

	unlock_kernel();

	return 0;



return_bad:

	unlock_kernel();

	return -EIO;

}

fs/coda/file.c

+3 −16
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ 
#include <linux/stat.h>

#include <linux/cred.h>

#include <linux/errno.h>

#include <linux/smp_lock.h>

#include <linux/spinlock.h>

#include <linux/string.h>

#include <linux/slab.h>
@@ -144,8 +143,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file) 
	if (!cfi)

		return -ENOMEM;



	lock_kernel();



	error = venus_open(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,

			   &host_file);

	if (!host_file)
@@ -153,7 +150,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file) 


	if (error) {

		kfree(cfi);

		unlock_kernel();

		return error;

	}
@@ -165,8 +161,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file) 


	BUG_ON(coda_file->private_data != NULL);

	coda_file->private_data = cfi;



	unlock_kernel();

	return 0;

}
@@ -177,9 +171,7 @@ int coda_release(struct inode *coda_inode, struct file *coda_file) 
	struct coda_file_info *cfi;

	struct coda_inode_info *cii;

	struct inode *host_inode;

	int err = 0;



	lock_kernel();

	int err;



	cfi = CODA_FTOC(coda_file);

	BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
@@ -203,8 +195,6 @@ int coda_release(struct inode *coda_inode, struct file *coda_file) 
	kfree(coda_file->private_data);

	coda_file->private_data = NULL;



	unlock_kernel();



	/* VFS fput ignores the return value from file_operations->release, so

	 * there is no use returning an error here */

	return 0;
@@ -215,7 +205,7 @@ int coda_fsync(struct file *coda_file, int datasync) 
	struct file *host_file;

	struct inode *coda_inode = coda_file->f_path.dentry->d_inode;

	struct coda_file_info *cfi;

	int err = 0;

	int err;



	if (!(S_ISREG(coda_inode->i_mode) || S_ISDIR(coda_inode->i_mode) ||

	      S_ISLNK(coda_inode->i_mode)))
@@ -226,11 +216,8 @@ int coda_fsync(struct file *coda_file, int datasync) 
	host_file = cfi->cfi_container;



	err = vfs_fsync(host_file, datasync);

	if ( !err && !datasync ) {

		lock_kernel();

	if (!err && !datasync)

		err = venus_fsync(coda_inode->i_sb, coda_i2f(coda_inode));

		unlock_kernel();

	}



	return err;

}

fs/coda/inode.c

+20 −26
Original line number Diff line number Diff line
@@ -150,8 +150,6 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent) 
	int error;

	int idx;



	lock_kernel();



	idx = get_device_index((struct coda_mount_data *) data);



	/* Ignore errors in data, for backward compatibility */
@@ -161,23 +159,26 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent) 
	printk(KERN_INFO "coda_read_super: device index: %i\n", idx);



	vc = &coda_comms[idx];

	lock_kernel();



	if (!vc->vc_inuse) {

		printk("coda_read_super: No pseudo device\n");

		unlock_kernel();

		return -EINVAL;

		error = -EINVAL;

		goto unlock_out;

	}



	if (vc->vc_sb) {

		printk("coda_read_super: Device already mounted\n");

		unlock_kernel();

		return -EBUSY;

		error = -EBUSY;

		goto unlock_out;

	}



	error = bdi_setup_and_register(&vc->bdi, "coda", BDI_CAP_MAP_COPY);

	if (error)

		goto bdi_err;

		goto unlock_out;



	vc->vc_sb = sb;

	unlock_kernel();



	sb->s_fs_info = vc;

	sb->s_flags |= MS_NOATIME;
@@ -206,21 +207,23 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent) 
	printk("coda_read_super: rootinode is %ld dev %s\n", 

	       root->i_ino, root->i_sb->s_id);

	sb->s_root = d_alloc_root(root);

	if (!sb->s_root)

	if (!sb->s_root) {

		error = -EINVAL;

		goto error;

	unlock_kernel();

	}

	return 0;



error:

	bdi_destroy(&vc->bdi);

 bdi_err:

	if (root)

		iput(root);

	if (vc)

		vc->vc_sb = NULL;



	lock_kernel();

	bdi_destroy(&vc->bdi);

	vc->vc_sb = NULL;

	sb->s_fs_info = NULL;

unlock_out:

	unlock_kernel();

	return -EINVAL;

	return error;

}



static void coda_put_super(struct super_block *sb)
@@ -253,8 +256,6 @@ int coda_setattr(struct dentry *de, struct iattr *iattr) 
	struct coda_vattr vattr;

	int error;



	lock_kernel();

	

	memset(&vattr, 0, sizeof(vattr)); 



	inode->i_ctime = CURRENT_TIME_SEC;
@@ -268,9 +269,6 @@ int coda_setattr(struct dentry *de, struct iattr *iattr) 
	        coda_vattr_to_iattr(inode, &vattr); 

		coda_cache_clear_inode(inode);

	}



	unlock_kernel();



	return error;

}
@@ -284,12 +282,8 @@ static int coda_statfs(struct dentry *dentry, struct kstatfs *buf) 
{

	int error;

	

	lock_kernel();



	error = venus_statfs(dentry, buf);



	unlock_kernel();



	if (error) {

		/* fake something like AFS does */

		buf->f_blocks = 9000000;

fs/coda/pioctl.c

+6 −16
Original line number Diff line number Diff line
@@ -23,8 +23,6 @@ 
#include <linux/coda_fs_i.h>

#include <linux/coda_psdev.h>



#include <linux/smp_lock.h>



/* pioctl ops */

static int coda_ioctl_permission(struct inode *inode, int mask);

static long coda_pioctl(struct file *filp, unsigned int cmd,
@@ -58,13 +56,9 @@ static long coda_pioctl(struct file *filp, unsigned int cmd, 
	struct inode *target_inode = NULL;

	struct coda_inode_info *cnp;



	lock_kernel();



	/* get the Pioctl data arguments from user space */

	if (copy_from_user(&data, (void __user *)user_data, sizeof(data))) {

		error = -EINVAL;

		goto out;

	}

	if (copy_from_user(&data, (void __user *)user_data, sizeof(data)))

		return -EINVAL;



	/*

	 * Look up the pathname. Note that the pathname is in
@@ -76,13 +70,12 @@ static long coda_pioctl(struct file *filp, unsigned int cmd, 
		error = user_lpath(data.path, &path);



	if (error)

		goto out;

	else

		return error;



	target_inode = path.dentry->d_inode;



	/* return if it is not a Coda inode */

	if (target_inode->i_sb != inode->i_sb) {

		path_put(&path);

		error = -EINVAL;

		goto out;

	}
@@ -91,10 +84,7 @@ static long coda_pioctl(struct file *filp, unsigned int cmd, 
	cnp = ITOC(target_inode);



	error = venus_pioctl(inode->i_sb, &(cnp->c_fid), cmd, &data);



	path_put(&path);



out:

	unlock_kernel();

	path_put(&path);

	return error;

}

fs/coda/psdev.c

+2 −11
Original line number Diff line number Diff line
@@ -108,16 +108,9 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf, 
	        return -EFAULT;



        if (DOWNCALL(hdr.opcode)) {

		struct super_block *sb = NULL;

		union outputArgs *dcbuf;

		int size = sizeof(*dcbuf);



		sb = vcp->vc_sb;

		if ( !sb ) {

                        count = nbytes;

                        goto out;

		}



		if  ( nbytes < sizeof(struct coda_out_hdr) ) {

		        printk("coda_downcall opc %d uniq %d, not enough!\n",

			       hdr.opcode, hdr.unique);
@@ -137,9 +130,7 @@ static ssize_t coda_psdev_write(struct file *file, const char __user *buf, 
		}



		/* what downcall errors does Venus handle ? */

		lock_kernel();

		error = coda_downcall(hdr.opcode, dcbuf, sb);

		unlock_kernel();

		error = coda_downcall(vcp, hdr.opcode, dcbuf);



		CODA_FREE(dcbuf, nbytes);

		if (error) {