1 files changed, 164 insertions, 803 deletions

diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
index 0f356fc4690c..56820b39a993 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -18,6 +18,7 @@
 #include <linux/mm.h>
 #include <linux/smp_lock.h>
 #include <linux/gfs2_ioctl.h>
+#include <linux/fs.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
@@ -27,7 +28,6 @@
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
-#include "jdata.h"
 #include "lm.h"
 #include "log.h"
 #include "meta_io.h"
@@ -67,10 +67,37 @@ struct filldir_reg {
 	void *fdr_opaque;
 };
 
-typedef ssize_t(*do_rw_t) (struct file *file,
-		   char __user *buf,
-		   size_t size, loff_t *offset,
-		   unsigned int num_gh, struct gfs2_holder *ghs);
+static int gfs2_read_actor(read_descriptor_t *desc, struct page *page,
+			   unsigned long offset, unsigned long size)
+{
+	char *kaddr;
+	unsigned long count = desc->count;
+
+	if (size > count)
+		size = count;
+
+	kaddr = kmap(page);
+	memcpy(desc->arg.buf, kaddr + offset, size);
+        kunmap(page);
+
+        desc->count = count - size;
+        desc->written += size;
+        desc->arg.buf += size;
+        return size;
+}
+
+int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
+		       char *buf, loff_t *pos, unsigned size)
+{
+	struct inode *inode = ip->i_vnode;
+	read_descriptor_t desc;
+	desc.written = 0;
+	desc.arg.buf = buf;
+	desc.count = size;
+	desc.error = 0;
+	do_generic_mapping_read(inode->i_mapping, ra_state, NULL, pos, &desc, gfs2_read_actor);
+	return desc.written ? desc.written : desc.error;
+}
 
 /**
  * gfs2_llseek - seek to a location in a file
@@ -105,247 +132,114 @@ static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
 	return error;
 }
 
-static inline unsigned int vma2state(struct vm_area_struct *vma)
-{
-	if ((vma->vm_flags & (VM_MAYWRITE | VM_MAYSHARE)) ==
-	    (VM_MAYWRITE | VM_MAYSHARE))
-		return LM_ST_EXCLUSIVE;
-	return LM_ST_SHARED;
-}
 
-static ssize_t walk_vm_hard(struct file *file, const char __user *buf, size_t size,
-		    loff_t *offset, do_rw_t operation)
+static ssize_t gfs2_direct_IO_read(struct kiocb *iocb, const struct iovec *iov,
+				   loff_t offset, unsigned long nr_segs)
 {
-	struct gfs2_holder *ghs;
-	unsigned int num_gh = 0;
-	ssize_t count;
-	struct super_block *sb = file->f_dentry->d_inode->i_sb;
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long start = (unsigned long)buf;
-	unsigned long end = start + size;
-	int dumping = (current->flags & PF_DUMPCORE);
-	unsigned int x = 0;
-
-	for (vma = find_vma(mm, start); vma; vma = vma->vm_next) {
-		if (end <= vma->vm_start)
-			break;
-		if (vma->vm_file &&
-		    vma->vm_file->f_dentry->d_inode->i_sb == sb) {
-			num_gh++;
-		}
-	}
-
-	ghs = kcalloc((num_gh + 1), sizeof(struct gfs2_holder), GFP_KERNEL);
-	if (!ghs) {
-		if (!dumping)
-			up_read(&mm->mmap_sem);
-		return -ENOMEM;
-	}
+	struct file *file = iocb->ki_filp;
+	struct address_space *mapping = file->f_mapping;
+	ssize_t retval;
 
-	for (vma = find_vma(mm, start); vma; vma = vma->vm_next) {
-		if (end <= vma->vm_start)
-			break;
-		if (vma->vm_file) {
-			struct inode *inode = vma->vm_file->f_dentry->d_inode;
-			if (inode->i_sb == sb)
-				gfs2_holder_init(get_v2ip(inode)->i_gl,
-						 vma2state(vma), 0, &ghs[x++]);
-		}
+	retval = filemap_write_and_wait(mapping);
+	if (retval == 0) {
+		retval = mapping->a_ops->direct_IO(READ, iocb, iov, offset,
+						   nr_segs);
 	}
-
-	if (!dumping)
-		up_read(&mm->mmap_sem);
-
-	gfs2_assert(get_v2sdp(sb), x == num_gh);
-
-	count = operation(file, buf, size, offset, num_gh, ghs);
-
-	while (num_gh--)
-		gfs2_holder_uninit(&ghs[num_gh]);
-	kfree(ghs);
-
-	return count;
+	return retval;
 }
 
 /**
- * walk_vm - Walk the vmas associated with a buffer for read or write.
- *    If any of them are gfs2, pass the gfs2 inode down to the read/write
- *    worker function so that locks can be acquired in the correct order.
- * @file: The file to read/write from/to
- * @buf: The buffer to copy to/from
- * @size: The amount of data requested
- * @offset: The current file offset
- * @operation: The read or write worker function
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
+ * __gfs2_file_aio_read - The main GFS2 read function
+ * 
+ * N.B. This is almost, but not quite the same as __generic_file_aio_read()
+ * the important subtle different being that inode->i_size isn't valid
+ * unless we are holding a lock, and we do this _only_ on the O_DIRECT
+ * path since otherwise locking is done entirely at the page cache
+ * layer.
  */
-
-static ssize_t walk_vm(struct file *file, const char __user *buf, size_t size,
-	       loff_t *offset, do_rw_t operation)
+static ssize_t __gfs2_file_aio_read(struct kiocb *iocb,
+				    const struct iovec *iov,
+				    unsigned long nr_segs, loff_t *ppos)
 {
+	struct file *filp = iocb->ki_filp;
+	struct gfs2_inode *ip = get_v2ip(filp->f_mapping->host);
 	struct gfs2_holder gh;
-
-	if (current->mm) {
-		struct super_block *sb = file->f_dentry->d_inode->i_sb;
-		struct mm_struct *mm = current->mm;
-		struct vm_area_struct *vma;
-		unsigned long start = (unsigned long)buf;
-		unsigned long end = start + size;
-		int dumping = (current->flags & PF_DUMPCORE);
-
-		if (!dumping)
-			down_read(&mm->mmap_sem);
-
-		for (vma = find_vma(mm, start); vma; vma = vma->vm_next) {
-			if (end <= vma->vm_start)
-				break;
-			if (vma->vm_file &&
-			    vma->vm_file->f_dentry->d_inode->i_sb == sb)
-				goto do_locks;
-		}
-
-		if (!dumping)
-			up_read(&mm->mmap_sem);
-	}
-
-	return operation(file, buf, size, offset, 0, &gh);
-
-do_locks:
-	return walk_vm_hard(file, buf, size, offset, operation);
-}
-
-static ssize_t do_jdata_read(struct file *file, char __user *buf, size_t size,
-			     loff_t *offset)
-{
-	struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
-	ssize_t count = 0;
-
-	if (*offset < 0)
+	ssize_t retval;
+	unsigned long seg;
+	size_t count;
+
+	count = 0;
+	for (seg = 0; seg < nr_segs; seg++) {
+		const struct iovec *iv = &iov[seg];
+
+		/*
+		 * If any segment has a negative length, or the cumulative
+		 * length ever wraps negative then return -EINVAL.
+		 */
+	count += iv->iov_len;
+	if (unlikely((ssize_t)(count|iv->iov_len) < 0))
 		return -EINVAL;
-	if (!access_ok(VERIFY_WRITE, buf, size))
+	if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
+		continue;
+	if (seg == 0)
 		return -EFAULT;
+	nr_segs = seg;
+	count -= iv->iov_len;   /* This segment is no good */
+	break;
+	}
+
+	/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
+	if (filp->f_flags & O_DIRECT) {
+		loff_t pos = *ppos, size;
+		struct address_space *mapping;
+		struct inode *inode;
+
+		mapping = filp->f_mapping;
+		inode = mapping->host;
+		retval = 0;
+		if (!count)
+			goto out; /* skip atime */
+
+		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
+		retval = gfs2_glock_nq_m_atime(1, &gh);
+		if (retval)
+			goto out;
 
-	if (!(file->f_flags & O_LARGEFILE)) {
-		if (*offset >= MAX_NON_LFS)
-			return -EFBIG;
-		if (*offset + size > MAX_NON_LFS)
-			size = MAX_NON_LFS - *offset;
-	}
-
-	count = gfs2_jdata_read(ip, buf, *offset, size, gfs2_copy2user);
-
-	if (count > 0)
-		*offset += count;
-
-	return count;
-}
-
-/**
- * do_read_direct - Read bytes from a file
- * @file: The file to read from
- * @buf: The buffer to copy into
- * @size: The amount of data requested
- * @offset: The current file offset
- * @num_gh: The number of other locks we need to do the read
- * @ghs: the locks we need plus one for our lock
- *
- * Outputs: Offset - updated according to number of bytes read
- *
- * Returns: The number of bytes read, errno on failure
- */
-
-static ssize_t do_read_direct(struct file *file, char __user *buf, size_t size,
-			      loff_t *offset, unsigned int num_gh,
-			      struct gfs2_holder *ghs)
-{
-	struct inode *inode = file->f_mapping->host;
-	struct gfs2_inode *ip = get_v2ip(inode);
-	unsigned int state = LM_ST_DEFERRED;
-	int flags = 0;
-	unsigned int x;
-	ssize_t count = 0;
-	int error;
-
-	for (x = 0; x < num_gh; x++)
-		if (ghs[x].gh_gl == ip->i_gl) {
-			state = LM_ST_SHARED;
-			flags |= GL_LOCAL_EXCL;
-			break;
+		size = i_size_read(inode);
+		if (pos < size) {
+			 retval = gfs2_direct_IO_read(iocb, iov, pos, nr_segs);
+			if (retval > 0 && !is_sync_kiocb(iocb))
+				retval = -EIOCBQUEUED;
+			if (retval > 0)
+				*ppos = pos + retval;
 		}
-
-	gfs2_holder_init(ip->i_gl, state, flags, &ghs[num_gh]);
-
-	error = gfs2_glock_nq_m(num_gh + 1, ghs);
-	if (error)
+		file_accessed(filp);
+		gfs2_glock_dq_m(1, &gh);
+		gfs2_holder_uninit(&gh);
 		goto out;
+	}
 
-	error = -EINVAL;
-	if (gfs2_is_jdata(ip))
-		goto out_gunlock;
-
-	if (gfs2_is_stuffed(ip)) {
-		size_t mask = bdev_hardsect_size(inode->i_sb->s_bdev) - 1;
-
-		if (((*offset) & mask) || (((unsigned long)buf) & mask))
-			goto out_gunlock;
-
-		count = do_jdata_read(file, buf, size & ~mask, offset);
-	} else
-		count = generic_file_read(file, buf, size, offset);
-
-	error = 0;
-
- out_gunlock:
-	gfs2_glock_dq_m(num_gh + 1, ghs);
-
- out:
-	gfs2_holder_uninit(&ghs[num_gh]);
-
-	return (count) ? count : error;
-}
-
-/**
- * do_read_buf - Read bytes from a file
- * @file: The file to read from
- * @buf: The buffer to copy into
- * @size: The amount of data requested
- * @offset: The current file offset
- * @num_gh: The number of other locks we need to do the read
- * @ghs: the locks we need plus one for our lock
- *
- * Outputs: Offset - updated according to number of bytes read
- *
- * Returns: The number of bytes read, errno on failure
- */
-
-static ssize_t do_read_buf(struct file *file, char __user *buf, size_t size,
-			   loff_t *offset, unsigned int num_gh,
-			   struct gfs2_holder *ghs)
-{
-	struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
-	ssize_t count = 0;
-	int error;
-
-	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &ghs[num_gh]);
-
-	error = gfs2_glock_nq_m_atime(num_gh + 1, ghs);
-	if (error)
-		goto out;
-
-	if (gfs2_is_jdata(ip))
-		count = do_jdata_read(file, buf, size, offset);
-	else
-		count = generic_file_read(file, buf, size, offset);
-
-	gfs2_glock_dq_m(num_gh + 1, ghs);
-
- out:
-	gfs2_holder_uninit(&ghs[num_gh]);
-
-	return (count) ? count : error;
+	retval = 0;
+	if (count) {
+		for (seg = 0; seg < nr_segs; seg++) {
+			read_descriptor_t desc;
+
+			desc.written = 0;
+			desc.arg.buf = iov[seg].iov_base;
+			desc.count = iov[seg].iov_len;
+			if (desc.count == 0)
+				continue;
+			desc.error = 0;
+			do_generic_file_read(filp,ppos,&desc,file_read_actor);
+			retval += desc.written;
+			if (desc.error) {
+				retval = retval ?: desc.error;
+				 break;
+			}
+		}
+	}
+out:
+	return retval;
 }
 
 /**
@@ -360,550 +254,49 @@ static ssize_t do_read_buf(struct file *file, char __user *buf, size_t size,
  * Returns: The number of bytes read, errno on failure
  */
 
-static ssize_t gfs2_read(struct file *file, char __user *buf, size_t size,
+static ssize_t gfs2_read(struct file *filp, char __user *buf, size_t size,
 			 loff_t *offset)
 {
-	atomic_inc(&get_v2sdp(file->f_mapping->host->i_sb)->sd_ops_file);
-
-	if (file->f_flags & O_DIRECT)
-		return walk_vm(file, buf, size, offset, do_read_direct);
-	else
-		return walk_vm(file, buf, size, offset, do_read_buf);
-}
-
-/**
- * grope_mapping - feel up a mapping that needs to be written
- * @buf: the start of the memory to be written
- * @size: the size of the memory to be written
- *
- * We do this after acquiring the locks on the mapping,
- * but before starting the write transaction.  We need to make
- * sure that we don't cause recursive transactions if blocks
- * need to be allocated to the file backing the mapping.
- *
- * Returns: errno
- */
-
-static int grope_mapping(const char __user *buf, size_t size)
-{
-	const char __user *stop = buf + size;
-	char c;
-
-	while (buf < stop) {
-		if (copy_from_user(&c, buf, 1))
-			return -EFAULT;
-		buf += PAGE_CACHE_SIZE;
-		buf = (const char __user *)PAGE_ALIGN((unsigned long)buf);
-	}
-
-	return 0;
-}
-
-/**
- * do_write_direct_alloc - Write bytes to a file
- * @file: The file to write to
- * @buf: The buffer to copy from
- * @size: The amount of data requested
- * @offset: The current file offset
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
- */
-
-static ssize_t do_write_direct_alloc(struct file *file, const char __user *buf, size_t size,
-				     loff_t *offset)
-{
-	struct inode *inode = file->f_mapping->host;
-	struct gfs2_inode *ip = get_v2ip(inode);
-	struct gfs2_sbd *sdp = ip->i_sbd;
-	struct gfs2_alloc *al = NULL;
 	struct iovec local_iov = { .iov_base = buf, .iov_len = size };
-	struct buffer_head *dibh;
-	unsigned int data_blocks, ind_blocks;
-	ssize_t count;
-	int error;
-
-	gfs2_write_calc_reserv(ip, size, &data_blocks, &ind_blocks);
-
-	al = gfs2_alloc_get(ip);
-
-	error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
-	if (error)
-		goto fail;
-
-	error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
-	if (error)
-		goto fail_gunlock_q;
-
-	al->al_requested = data_blocks + ind_blocks;
-
-	error = gfs2_inplace_reserve(ip);
-	if (error)
-		goto fail_gunlock_q;
-
-	error = gfs2_trans_begin(sdp,
-				 al->al_rgd->rd_ri.ri_length + ind_blocks +
-				 RES_DINODE + RES_STATFS + RES_QUOTA, 0);
-	if (error)
-		goto fail_ipres;
-
-	if ((ip->i_di.di_mode & (S_ISUID | S_ISGID)) && !capable(CAP_FSETID)) {
-		error = gfs2_meta_inode_buffer(ip, &dibh);
-		if (error)
-			goto fail_end_trans;
-
-		ip->i_di.di_mode &= (ip->i_di.di_mode & S_IXGRP) ?
-			(~(S_ISUID | S_ISGID)) : (~S_ISUID);
-
-		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-		gfs2_dinode_out(&ip->i_di, dibh->b_data);
-		brelse(dibh);
-	}
-
-	if (gfs2_is_stuffed(ip)) {
-		error = gfs2_unstuff_dinode(ip, gfs2_unstuffer_sync, NULL);
-		if (error)
-			goto fail_end_trans;
-	}
-
-	count = generic_file_write_nolock(file, &local_iov, 1, offset);
-	if (count < 0) {
-		error = count;
-		goto fail_end_trans;
-	}
-
-	error = gfs2_meta_inode_buffer(ip, &dibh);
-	if (error)
-		goto fail_end_trans;
-
-	if (ip->i_di.di_size < inode->i_size)
-		ip->i_di.di_size = inode->i_size;
-	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
-
-	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-	gfs2_dinode_out(&ip->i_di, dibh->b_data);
-	brelse(dibh);
-
-	gfs2_trans_end(sdp);
+	struct kiocb kiocb;
+	ssize_t ret;
 
-	if (file->f_flags & O_SYNC)
-		gfs2_log_flush_glock(ip->i_gl);
-
-	gfs2_inplace_release(ip);
-	gfs2_quota_unlock(ip);
-	gfs2_alloc_put(ip);
-
-	if (file->f_mapping->nrpages) {
-		error = filemap_fdatawrite(file->f_mapping);
-		if (!error)
-			error = filemap_fdatawait(file->f_mapping);
-	}
-	if (error)
-		return error;
-
-	return count;
-
- fail_end_trans:
-	gfs2_trans_end(sdp);
-
- fail_ipres:
-	gfs2_inplace_release(ip);
-
- fail_gunlock_q:
-	gfs2_quota_unlock(ip);
-
- fail:
-	gfs2_alloc_put(ip);
+	atomic_inc(&get_v2sdp(filp->f_mapping->host->i_sb)->sd_ops_file);
 
-	return error;
-}
-
-/**
- * do_write_direct - Write bytes to a file
- * @file: The file to write to
- * @buf: The buffer to copy from
- * @size: The amount of data requested
- * @offset: The current file offset
- * @num_gh: The number of other locks we need to do the read
- * @gh: the locks we need plus one for our lock
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
- */
-
-static ssize_t do_write_direct(struct file *file, const char __user *buf, size_t size,
-			       loff_t *offset, unsigned int num_gh,
-			       struct gfs2_holder *ghs)
-{
-	struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
-	struct gfs2_sbd *sdp = ip->i_sbd;
-	struct gfs2_file *fp = get_v2fp(file);
-	unsigned int state = LM_ST_DEFERRED;
-	int alloc_required;
-	unsigned int x;
-	size_t s;
-	ssize_t count = 0;
-	int error;
-
-	if (test_bit(GFF_DID_DIRECT_ALLOC, &fp->f_flags))
-		state = LM_ST_EXCLUSIVE;
-	else
-		for (x = 0; x < num_gh; x++)
-			if (ghs[x].gh_gl == ip->i_gl) {
-				state = LM_ST_EXCLUSIVE;
-				break;
-			}
-
- restart:
-	gfs2_holder_init(ip->i_gl, state, 0, &ghs[num_gh]);
-
-	error = gfs2_glock_nq_m(num_gh + 1, ghs);
-	if (error)
-		goto out;
-
-	error = -EINVAL;
-	if (gfs2_is_jdata(ip))
-		goto out_gunlock;
-
-	if (num_gh) {
-		error = grope_mapping(buf, size);
-		if (error)
-			goto out_gunlock;
-	}
-
-	if (file->f_flags & O_APPEND)
-		*offset = ip->i_di.di_size;
-
-	if (!(file->f_flags & O_LARGEFILE)) {
-		error = -EFBIG;
-		if (*offset >= MAX_NON_LFS)
-			goto out_gunlock;
-		if (*offset + size > MAX_NON_LFS)
-			size = MAX_NON_LFS - *offset;
-	}
-
-	if (gfs2_is_stuffed(ip) ||
-	    *offset + size > ip->i_di.di_size ||
-	    ((ip->i_di.di_mode & (S_ISUID | S_ISGID)) && !capable(CAP_FSETID)))
-		alloc_required = 1;
-	else {
-		error = gfs2_write_alloc_required(ip, *offset, size,
-						 &alloc_required);
-		if (error)
-			goto out_gunlock;
-	}
-
-	if (alloc_required && state != LM_ST_EXCLUSIVE) {
-		gfs2_glock_dq_m(num_gh + 1, ghs);
-		gfs2_holder_uninit(&ghs[num_gh]);
-		state = LM_ST_EXCLUSIVE;
-		goto restart;
-	}
-
-	if (alloc_required) {
-		set_bit(GFF_DID_DIRECT_ALLOC, &fp->f_flags);
-
-		/* split large writes into smaller atomic transactions */
-		while (size) {
-			s = gfs2_tune_get(sdp, gt_max_atomic_write);
-			if (s > size)
-				s = size;
-
-			error = do_write_direct_alloc(file, buf, s, offset);
-			if (error < 0)
-				goto out_gunlock;
-
-			buf += error;
-			size -= error;
-			count += error;
-		}
-	} else {
-		struct iovec local_iov = { .iov_base = buf, .iov_len = size };
-		struct gfs2_holder t_gh;
-
-		clear_bit(GFF_DID_DIRECT_ALLOC, &fp->f_flags);
-
-		error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
-					   GL_NEVER_RECURSE, &t_gh);
-		if (error)
-			goto out_gunlock;
-
-		count = generic_file_write_nolock(file, &local_iov, 1, offset);
-
-		gfs2_glock_dq_uninit(&t_gh);
-	}
-
-	error = 0;
-
- out_gunlock:
-	gfs2_glock_dq_m(num_gh + 1, ghs);
-
- out:
-	gfs2_holder_uninit(&ghs[num_gh]);
-
-	return (count) ? count : error;
+	init_sync_kiocb(&kiocb, filp);
+	ret = __gfs2_file_aio_read(&kiocb, &local_iov, 1, offset);
+	if (-EIOCBQUEUED == ret)
+		ret = wait_on_sync_kiocb(&kiocb);
+	return ret;
 }
 
-/**
- * do_do_write_buf - Write bytes to a file
- * @file: The file to write to
- * @buf: The buffer to copy from
- * @size: The amount of data requested
- * @offset: The current file offset
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
- */
-
-static ssize_t do_do_write_buf(struct file *file, const char __user *buf, size_t size,
-			       loff_t *offset)
+static ssize_t gfs2_file_readv(struct file *filp, const struct iovec *iov,
+			       unsigned long nr_segs, loff_t *ppos)
 {
-	struct inode *inode = file->f_mapping->host;
-	struct gfs2_inode *ip = get_v2ip(inode);
-	struct gfs2_sbd *sdp = ip->i_sbd;
-	struct gfs2_alloc *al = NULL;
-	struct buffer_head *dibh;
-	unsigned int data_blocks, ind_blocks;
-	int alloc_required, journaled;
-	ssize_t count;
-	int error;
-
-	journaled = gfs2_is_jdata(ip);
-
-	gfs2_write_calc_reserv(ip, size, &data_blocks, &ind_blocks);
-
-	error = gfs2_write_alloc_required(ip, *offset, size, &alloc_required);
-	if (error)
-		return error;
-
-	if (alloc_required) {
-		al = gfs2_alloc_get(ip);
-
-		error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
-		if (error)
-			goto fail;
-
-		error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
-		if (error)
-			goto fail_gunlock_q;
-
-		al->al_requested = data_blocks + ind_blocks;
-
-		error = gfs2_inplace_reserve(ip);
-		if (error)
-			goto fail_gunlock_q;
-
-		error = gfs2_trans_begin(sdp,
-					 al->al_rgd->rd_ri.ri_length +
-					 ind_blocks +
-					 ((journaled) ? data_blocks : 0) +
-					 RES_DINODE + RES_STATFS + RES_QUOTA,
-					 0);
-		if (error)
-			goto fail_ipres;
-	} else {
-		error = gfs2_trans_begin(sdp,
-					((journaled) ? data_blocks : 0) +
-					RES_DINODE,
-					0);
-		if (error)
-			goto fail_ipres;
-	}
-
-	if ((ip->i_di.di_mode & (S_ISUID | S_ISGID)) && !capable(CAP_FSETID)) {
-		error = gfs2_meta_inode_buffer(ip, &dibh);
-		if (error)
-			goto fail_end_trans;
-
-		ip->i_di.di_mode &= (ip->i_di.di_mode & S_IXGRP) ?
-					  (~(S_ISUID | S_ISGID)) : (~S_ISUID);
-
-		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-		gfs2_dinode_out(&ip->i_di, dibh->b_data);
-		brelse(dibh);
-	}
+	struct kiocb kiocb;
+	ssize_t ret;
 
-	if (journaled) {
-		count = gfs2_jdata_write(ip, buf, *offset, size,
-					 gfs2_copy_from_user);
-		if (count < 0) {
-			error = count;
-			goto fail_end_trans;
-		}
-
-		*offset += count;
-	} else {
-		struct iovec local_iov = { .iov_base = buf, .iov_len = size };
-
-		count = generic_file_write_nolock(file, &local_iov, 1, offset);
-		if (count < 0) {
-			error = count;
-			goto fail_end_trans;
-		}
-
-		error = gfs2_meta_inode_buffer(ip, &dibh);
-		if (error)
-			goto fail_end_trans;
-
-		if (ip->i_di.di_size < inode->i_size)
-			ip->i_di.di_size = inode->i_size;
-		ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
-
-		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-		gfs2_dinode_out(&ip->i_di, dibh->b_data);
-		brelse(dibh);
-	}
-
-	gfs2_trans_end(sdp);
-
-	if (file->f_flags & O_SYNC || IS_SYNC(inode)) {
-		gfs2_log_flush_glock(ip->i_gl);
-		error = filemap_fdatawrite(file->f_mapping);
-		if (error == 0)
-			error = filemap_fdatawait(file->f_mapping);
-		if (error)
-			goto fail_ipres;
-	}
-
-	if (alloc_required) {
-		gfs2_assert_warn(sdp, count != size ||
-				 al->al_alloced);
-		gfs2_inplace_release(ip);
-		gfs2_quota_unlock(ip);
-		gfs2_alloc_put(ip);
-	}
-
-	return count;
-
- fail_end_trans:
-	gfs2_trans_end(sdp);
-
- fail_ipres:
-	if (alloc_required)
-		gfs2_inplace_release(ip);
-
- fail_gunlock_q:
-	if (alloc_required)
-		gfs2_quota_unlock(ip);
+	atomic_inc(&get_v2sdp(filp->f_mapping->host->i_sb)->sd_ops_file);
 
- fail:
-	if (alloc_required)
-		gfs2_alloc_put(ip);
-
-	return error;
+	init_sync_kiocb(&kiocb, filp);
+	ret = __gfs2_file_aio_read(&kiocb, iov, nr_segs, ppos);
+	if (-EIOCBQUEUED == ret)
+		ret = wait_on_sync_kiocb(&kiocb);
+	return ret;
 }
 
-/**
- * do_write_buf - Write bytes to a file
- * @file: The file to write to
- * @buf: The buffer to copy from
- * @size: The amount of data requested
- * @offset: The current file offset
- * @num_gh: The number of other locks we need to do the read
- * @gh: the locks we need plus one for our lock
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
- */
-
-static ssize_t do_write_buf(struct file *file, const char __user *buf, size_t size,
-			    loff_t *offset, unsigned int num_gh,
-			    struct gfs2_holder *ghs)
+static ssize_t gfs2_file_aio_read(struct kiocb *iocb, char __user *buf,
+				  size_t count, loff_t pos)
 {
-	struct gfs2_inode *ip = get_v2ip(file->f_mapping->host);
-	struct gfs2_sbd *sdp = ip->i_sbd;
-	size_t s;
-	ssize_t count = 0;
-	int error;
-
-	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ghs[num_gh]);
-
-	error = gfs2_glock_nq_m(num_gh + 1, ghs);
-	if (error)
-		goto out;
-
-	if (num_gh) {
-		error = grope_mapping(buf, size);
-		if (error)
-			goto out_gunlock;
-	}
-
-	if (file->f_flags & O_APPEND)
-		*offset = ip->i_di.di_size;
-
-	if (!(file->f_flags & O_LARGEFILE)) {
-		error = -EFBIG;
-		if (*offset >= MAX_NON_LFS)
-			goto out_gunlock;
-		if (*offset + size > MAX_NON_LFS)
-			size = MAX_NON_LFS - *offset;
-	}
-
-	/* split large writes into smaller atomic transactions */
-	while (size) {
-		s = gfs2_tune_get(sdp, gt_max_atomic_write);
-		if (s > size)
-			s = size;
-
-		error = do_do_write_buf(file, buf, s, offset);
-		if (error < 0)
-			goto out_gunlock;
-
-		buf += error;
-		size -= error;
-		count += error;
-	}
-
-	error = 0;
+	struct file *filp = iocb->ki_filp;
+        struct iovec local_iov = { .iov_base = buf, .iov_len = count };
 
- out_gunlock:
-	gfs2_glock_dq_m(num_gh + 1, ghs);
+	atomic_inc(&get_v2sdp(filp->f_mapping->host->i_sb)->sd_ops_file);
 
- out:
-	gfs2_holder_uninit(&ghs[num_gh]);
-
-	return (count) ? count : error;
+        BUG_ON(iocb->ki_pos != pos);
+        return __gfs2_file_aio_read(iocb, &local_iov, 1, &iocb->ki_pos);
 }
 
-/**
- * gfs2_write - Write bytes to a file
- * @file: The file to write to
- * @buf: The buffer to copy from
- * @size: The amount of data requested
- * @offset: The current file offset
- *
- * Outputs: Offset - updated according to number of bytes written
- *
- * Returns: The number of bytes written, errno on failure
- */
-
-static ssize_t gfs2_write(struct file *file, const char __user *buf,
-			  size_t size, loff_t *offset)
-{
-	struct inode *inode = file->f_mapping->host;
-	ssize_t count;
-
-	atomic_inc(&get_v2sdp(inode->i_sb)->sd_ops_file);
-
-	if (*offset < 0)
-		return -EINVAL;
-	if (!access_ok(VERIFY_READ, buf, size))
-		return -EFAULT;
-
-	mutex_lock(&inode->i_mutex);
-	if (file->f_flags & O_DIRECT)
-		count = walk_vm(file, buf, size, offset,
-				do_write_direct);
-	else
-		count = walk_vm(file, buf, size, offset, do_write_buf);
-	mutex_unlock(&inode->i_mutex);
-
-	return count;
-}
 
 /**
  * filldir_reg_func - Report a directory entry to the caller of gfs2_dir_read()
@@ -1158,9 +551,6 @@ static int gfs2_ioctl_flags(struct gfs2_inode *ip, unsigned int cmd, unsigned lo
 		if (flags & (GFS2_DIF_JDATA|GFS2_DIF_DIRECTIO)) {
 			if (!S_ISREG(ip->i_di.di_mode))
 				goto out;
-			/* FIXME: Would be nice not to require the following test */
-			if ((flags & GFS2_DIF_JDATA) && ip->i_di.di_size)
-				goto out;
 		}
 		if (flags & (GFS2_DIF_INHERIT_JDATA|GFS2_DIF_INHERIT_DIRECTIO)) {
 			if (!S_ISDIR(ip->i_di.di_mode))
@@ -1246,21 +636,14 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 		return error;
 	}
 
-	if (gfs2_is_jdata(ip)) {
-		if (vma->vm_flags & VM_MAYSHARE)
-			error = -EOPNOTSUPP;
-		else
-			vma->vm_ops = &gfs2_vm_ops_private;
-	} else {
-		/* This is VM_MAYWRITE instead of VM_WRITE because a call
-		   to mprotect() can turn on VM_WRITE later. */
-
-		if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
-		    (VM_MAYSHARE | VM_MAYWRITE))
-			vma->vm_ops = &gfs2_vm_ops_sharewrite;
-		else
-			vma->vm_ops = &gfs2_vm_ops_private;
-	}
+	/* This is VM_MAYWRITE instead of VM_WRITE because a call
+	   to mprotect() can turn on VM_WRITE later. */
+
+	if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
+	    (VM_MAYSHARE | VM_MAYWRITE))
+		vma->vm_ops = &gfs2_vm_ops_sharewrite;
+	else
+		vma->vm_ops = &gfs2_vm_ops_private;
 
 	gfs2_glock_dq_uninit(&i_gh);
 
@@ -1313,13 +696,6 @@ static int gfs2_open(struct inode *inode, struct file *file)
 		if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
 			file->f_flags |= O_DIRECT;
 
-		/* Don't let the user open O_DIRECT on a jdata file */
-
-		if ((file->f_flags & O_DIRECT) && gfs2_is_jdata(ip)) {
-			error = -EINVAL;
-			goto fail_gunlock;
-		}
-
 		gfs2_glock_dq_uninit(&i_gh);
 	}
 
@@ -1446,29 +822,10 @@ static ssize_t gfs2_sendfile(struct file *in_file, loff_t *offset, size_t count,
 			     read_actor_t actor, void *target)
 {
 	struct gfs2_inode *ip = get_v2ip(in_file->f_mapping->host);
-	struct gfs2_holder gh;
-	ssize_t retval;
 
 	atomic_inc(&ip->i_sbd->sd_ops_file);
 
-	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
-
-	retval = gfs2_glock_nq_atime(&gh);
-	if (retval)
-		goto out;
-
-	if (gfs2_is_jdata(ip))
-		retval = -EOPNOTSUPP;
-	else
-		retval = generic_file_sendfile(in_file, offset, count, actor,
-					       target);
-
-	gfs2_glock_dq(&gh);
-
- out:
-	gfs2_holder_uninit(&gh);
-
-	return retval;
+	return generic_file_sendfile(in_file, offset, count, actor, target);
 }
 
 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
@@ -1567,7 +924,11 @@ static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
 struct file_operations gfs2_file_fops = {
 	.llseek = gfs2_llseek,
 	.read = gfs2_read,
-	.write = gfs2_write,
+	.readv = gfs2_file_readv,
+	.aio_read = gfs2_file_aio_read,
+	.write = generic_file_write,
+	.writev = generic_file_writev,
+	.aio_write = generic_file_aio_write,
 	.ioctl = gfs2_ioctl,
 	.mmap = gfs2_mmap,
 	.open = gfs2_open,