[SSI] openssi/kernel/cluster/ssi/cfs cfs_subr.c, 1.27, 1.28 dir.c, 1.28, 1.29 file.c, 1.24, 1.25 inode.c, 1.61, 1.62 proc.c, 1.21, 1.22 read.c, 1.21, 1.22 write.c, 1.38, 1.39

Update of /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs
In directory fdv4jf1.ch3.sourceforge.com:/tmp/cvs-serv4596/cluster/ssi/cfs

Modified Files:
      Tag: OPENSSI-FC
	cfs_subr.c dir.c file.c inode.c proc.c read.c write.c 
Log Message:
CFS:
- Split __cfs_lock() into do_getlk(), do_unlk(), and do_setlk().
- Flush data before unlocking. (#ifdef CFS_ZAP_CACHES)
- Fix VFS lock out of sync with server; take two. (#ifdef CFS_MIRROR_LOCK_WAIT)
- Fix VFS lock out of sync with server when interrupted. (#ifdef CFS_FLOCK)
- Comment out unused CXLOCK and related macros.
- Comment out unused in struct cnode.
- Data handlers to use GFP_NOFS flag.


Index: inode.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/inode.c,v
retrieving revision 1.61
retrieving revision 1.62
diff -u -d -r1.61 -r1.62
--- inode.c	27 Oct 2009 03:18:29 -0000	1.61
+++ inode.c	2 Nov 2009 03:44:37 -0000	1.62
@@ -1742,7 +1742,9 @@
 		init_waitqueue_head(&cp->c_i_wait);
 #endif
 		/* cp->c_hp = NULL; */
+#ifdef SSI_CFS_SKIP
 		INIT_CONDITION(&(cp->c_cxlock));
+#endif
 #ifdef CFSTOKHOLD_LINUX_LIST
 		for(idx = 0; idx < CFSTOK_NTOKS; idx++)
 			INIT_LIST_HEAD(&cp->c_hlist[idx]);

Index: file.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/file.c,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -d -r1.24 -r1.25
--- file.c	27 Oct 2009 03:18:29 -0000	1.24
+++ file.c	2 Nov 2009 03:44:37 -0000	1.25
@@ -39,6 +39,9 @@
 #include <cluster/ssi/cfs/cfs_fs.h>
 #include <cluster/ssi/cfs/cfs_mount.h>
 #include <cluster/ssi/cfs/cfstok.h>
+#ifdef CFS_EXPORT_OPS
+#include <cluster/ssi/cfs/cfsfh.h>
+#endif
 #include <cluster/ssi/ssidev.h>
 #include <cluster/ssi/ipc/shm.h>
 #include <linux/mm.h>
@@ -728,25 +731,180 @@
 #endif
 
 static int
-__cfs_lock(struct file *filp, int cmd, struct file_lock *fl)
+do_getlk(struct file *filp, int cmd, struct file_lock *fl,
+	struct cfslockargs *la)
+{
+	struct inode *inode;
+	cfs_mntinfo_t *mip;
+	struct cfsgetlockres res;
+	int status = 0;
+
+#ifdef KERNEL2616_53
+	if (IS_GETLK(cmd)) {
+		struct file_lock *cfl;
+
+		lock_kernel();
+
+		/* Try local locking first */
+		cfl = posix_test_lock(filp, fl);
+		if (cfl != NULL) {
+			locks_copy_lock(fl, cfl);
+			unlock_kernel();
+			goto out;
+		}
+		unlock_kernel();
+	}
+#endif
+
+	inode = filp->f_dentry->d_inode;
+	mip = itocmi(inode);
+
+	CFS_SB_FSOP_START(mip);
+sb_down_retry:
+	status = CFS_SB_CHECK(mip);
+	if (status)
+		goto sb_error_check;
+
+	if (CFS_AT_SERVER(inode)) {
+		cfsd_proc_getlock_0(la, &res);
+	} else {
+		status = rcfscall(mip, CFSD_PROC_GETLOCK,
+				(xdrproc_t )xdr_cfslockargs,
+				(caddr_t)la,
+				(xdrproc_t)xdr_cfsgetlockres,
+				(caddr_t)&res);
+		if (status != 0)
+			goto sb_error_check;
+	}
+
+	if (res.clro_status)
+		status = res.clro_status;
+	else {
+		locks_init_lock(fl);
+		fl->fl_lmops = &cfs_lockm_operations;
+		fl->fl_pid = res.clro_pid;
+		fl->fl_flags = res.clro_flags;
+		fl->fl_type = res.clro_type;
+		fl->fl_start = res.clro_start;
+		fl->fl_end = res.clro_end;
+	}
+
+sb_error_check:
+	if (CFS_SB_RETRY(mip, status))
+		goto sb_down_retry;
+	CFS_SB_FSOP_DONE(mip);
+
+#ifdef KERNEL2616_53
+out:
+#endif
+	return status;
+}
+
+static int
+do_unlk(struct file *filp, int cmd, struct file_lock *fl,
+	struct cfslockargs *la)
 {
 	struct inode * inode = filp->f_dentry->d_inode;
 	cfs_mntinfo_t *mip = itocmi(inode);
-	int	status = 0;
-	struct cfslockargs la;
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	sigset_t oldset;
+#endif
+	int status = 0;
 
-	if (!(IS_SETLK(cmd) || IS_SETLKW(cmd) || IS_GETLK(cmd))) {
-		printk("%s: Unknown command %d\n", __FUNCTION__, cmd);
-		return -EINVAL;
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	ssi_mask_signals(current, &oldset, 1);
+#endif
+#ifdef CFS_ZAP_CACHES
+	/*
+	 * Flush all pending writes before doing anything
+	 * with locks..
+	 */
+	if (!CFS_SB_HARD_MIP(mip)) {
+#ifdef KERNEL2616_53
+		cfs_sync_mapping(filp->f_mapping);
+#else
+		filemap_fdatawrite(filp->f_mapping);
+		down(&inode->i_sem);
+		cfs_wb_all(inode);
+		up(&inode->i_sem);
+		filemap_fdatawait(filp->f_mapping);
+#endif
+	}
+#endif /* CFS_ZAP_CACHES */
+
+	CFS_SB_FSOP_START(mip);
+sb_down_retry:
+	status = CFS_SB_CHECK(mip);
+	if (status)
+		goto sb_error_check;
+
+#ifdef CFS_MIRROR_LOCK_WAIT
+	lock_kernel(); /* serialize the mirror lock */
+#endif
+	if (CFS_AT_SERVER(inode)) {
+		cfsd_proc_setlock_0(la, &status);
+	} else {
+		int res;
+
+		status = rcfscall(mip, CFSD_PROC_SETLOCK,
+				(xdrproc_t )xdr_cfslockargs,
+				(caddr_t)la,
+				(xdrproc_t)xdr_arch_int,
+				(caddr_t)&res);
+		if (status == 0)
+			status = res;
 	}
 
+	/* Get the mirror lock ahead of the base under rebuild protection */
+	/* By being inside the CFS_SB_FSOP_START, rebuild can't proceed
+	 * and storing the mirror lock is safe vs rebuilding server.
+	 */
+#ifndef CFS_MIGRATE_ACTIVE_PFS
+	if (!CFS_AT_SERVER(inode))
+#endif
+#ifdef CFS_FLOCK
+	if (!status)
+		(void) do_vfs_lock(filp, fl);
+#else
+	if (!status && posix_lock_file_wait(filp, fl) < 0)
+		printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n",
+				__FUNCTION__);
+#endif /* !CFS_FLOCK */
+#ifdef CFS_MIRROR_LOCK_WAIT
+	unlock_kernel();
+#endif
+
+sb_error_check:
+	if (CFS_SB_RETRY(mip, status))
+		goto sb_down_retry;
+	CFS_SB_FSOP_DONE(mip);
+
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	ssi_unmask_signals(current, &oldset, 1);
+#endif
+	return status;
+}
+
+static int
+do_setlk(struct file *filp, int cmd, struct file_lock *fl,
+	struct cfslockargs *la)
+{
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	sigset_t oldset;
+#endif
+	struct inode * inode = filp->f_dentry->d_inode;
+	cfs_mntinfo_t *mip = itocmi(inode);
+	int status = 0;
+
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	ssi_mask_signals(current, &oldset, 1);
+#endif
 #ifdef CFS_ZAP_CACHES
 	/*
 	 * Flush all pending writes before doing anything
 	 * with locks..
 	 */
-	if (!CFS_SB_HARD_MIP(mip) &&
-	    fl->fl_type != F_UNLCK && (IS_SETLK(cmd) || IS_SETLKW(cmd))) {
+	if (!CFS_SB_HARD_MIP(mip)) {
 #ifdef KERNEL2616_53
 		status = cfs_sync_mapping(filp->f_mapping);
 		if (status != 0)
@@ -765,31 +923,6 @@
 #endif
 	}
 #endif /* CFS_ZAP_CACHES */
-#ifdef KERNEL2616_53
-	if (IS_GETLK(cmd)) {
-		struct file_lock *cfl;
-
-		lock_kernel();
-
-		/* Try local locking first */
-		cfl = posix_test_lock(filp, fl);
-		if (cfl != NULL) {
-			locks_copy_lock(fl, cfl);
-			unlock_kernel();
-			goto out;
-		}
-		unlock_kernel();
-	}
-#endif
-
-	la.cfrla_fh = *itocfh(inode);
-	la.cfrla_start = fl->fl_start;
-	la.cfrla_end = fl->fl_end;
-	la.cfrla_pid = fl->fl_pid;
-	la.cfrla_flags = fl->fl_flags;
-	la.cfrla_type = fl->fl_type;
-	la.cfrla_node = this_node;
-	la.cfrla_cmd = cmd;
 
 	CFS_SB_FSOP_START(mip);
 sb_down_retry:
@@ -797,85 +930,65 @@
 	if (status)
 		goto sb_error_check;
 
-#ifdef SSI_CFS_SKIP
-	/* Lock file against concurrent access */
-	CXLOCK(itoc(inode));
+#ifdef CFS_MIRROR_LOCK_WAIT
+	lock_kernel(); /* serialize the mirror lock */
 #endif
+	if (CFS_AT_SERVER(inode)) {
+		cfsd_proc_setlock_0(la, &status);
+	} else {
+		int res;
 
-	if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {
-		if (CFS_AT_SERVER(inode)) {
-			cfsd_proc_setlock_0(&la, &status);
-		} else {
-			int res;
+		status = rcfscall(mip, CFSD_PROC_SETLOCK,
+				(xdrproc_t )xdr_cfslockargs,
+				(caddr_t)la,
+				(xdrproc_t)xdr_arch_int,
+				(caddr_t)&res);
+		if (status == 0)
+			status = res;
+	}
 
-			status = rcfscall(mip, CFSD_PROC_SETLOCK,
-					(xdrproc_t )xdr_cfslockargs,
-					(caddr_t)&la,
-					(xdrproc_t)xdr_arch_int,
-					(caddr_t)&res);
-			if (status == 0)
-				status = res;
-		}
-		/* Get the mirror lock ahead of the base under rebuild protection */
-		/* By being inside the CFS_SB_FSOP_START, rebuild can't proceed
-		 * and storing the mirror lock is safe vs rebuilding server.
-		 */
+	/* Get the mirror lock ahead of the base under rebuild protection */
+	/* By being inside the CFS_SB_FSOP_START, rebuild can't proceed
+	 * and storing the mirror lock is safe vs rebuilding server.
+	 */
 #ifndef CFS_MIGRATE_ACTIVE_PFS
-		if (!CFS_AT_SERVER(inode))
+	if (!CFS_AT_SERVER(inode))
 #endif
 #ifdef CFS_MIRROR_LOCK_WAIT
 #ifdef CFS_FLOCK
-		if (!status) {
-			fl->fl_flags |= FL_SLEEP;
-			(void) do_vfs_lock(filp, fl);
-		}
+	if (!status ||
+	    status == -EINTR || status == -ERESTARTSYS) {
+		/* If we were signalled we still need to ensure that
+		 * we clean up any state on the server. We therefore
+		 * record the lock call as having succeeded in order to
+		 * ensure that locks_remove_posix() cleans it out when
+		 * the process exits.
+		 */
+		sigset_t old_blocked;
+
+		if (!status)
+			ssi_block_signals(current, &old_blocked);
+
+		(void) do_vfs_lock(filp, fl);
+		if (!status)
+			ssi_unblock_signals(current, &old_blocked);
+	}
 #else
-		if (!status && posix_lock_file_wait(filp, fl) < 0)
-			printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n",
-					__FUNCTION__);
+	if (!status && posix_lock_file_wait(filp, fl) < 0)
+		printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n",
+				__FUNCTION__);
 #endif /* !CFS_FLOCK */
+	unlock_kernel();
 #else
-#warn mirror locks could get out of sync with lock manager
-		if (!status) {
-			int err;
-			/* Can't fail if CFS server gaves us the lock */
-			fl->fl_flags &= ~FL_SLEEP;
-			err = posix_lock_file(filp, fl);
-			SSI_ASSERT(!err);
-		}
-#endif /* !CFS_MIRROR_LOCK_WAIT */
-	} else {
-		struct cfsgetlockres res;
-
-		if (CFS_AT_SERVER(inode)) {
-			cfsd_proc_getlock_0(&la, &res);
-		} else {
-			status = rcfscall(mip, CFSD_PROC_GETLOCK,
-					(xdrproc_t )xdr_cfslockargs,
-					(caddr_t)&la,
-					(xdrproc_t)xdr_cfsgetlockres,
-					(caddr_t)&res);
-			if (status != 0)
-				goto out_unlock;
-		}
-
-		if (res.clro_status)
-			status = res.clro_status;
-		else {
-			locks_init_lock(fl);
-			fl->fl_lmops = &cfs_lockm_operations;
-			fl->fl_pid = res.clro_pid;
-			fl->fl_flags = res.clro_flags;
-			fl->fl_type = res.clro_type;
-			fl->fl_start = res.clro_start;
-			fl->fl_end = res.clro_end;
-		}
+	if (!status) {
+		int err;
+		/* Can't fail if CFS server gaves us the lock */
+		fl->fl_flags &= ~FL_SLEEP;
+		err = posix_lock_file(filp, fl);
+		SSI_ASSERT(!err);
 	}
+#endif /* !CFS_MIRROR_LOCK_WAIT */
 
-out_unlock:
-#ifdef SSI_CFS_SKIP
-	CXUNLOCK(itoc(inode));
-#endif
 sb_error_check:
 	if (CFS_SB_RETRY(mip, status))
 		goto sb_down_retry;
@@ -886,9 +999,7 @@
 	 * Make sure we clear the cache whenever we try to get the lock.
 	 * This makes locking act as a cache coherency point.
 	 */
-	if (!status && !CFS_SB_HARD_MIP(mip) &&
-	    (fl->fl_type != F_UNLCK) &&
-	    (IS_SETLK(cmd) || IS_SETLKW(cmd))) {
+	if (!status && !CFS_SB_HARD_MIP(mip)) {
 #ifdef KERNEL2616_53
 		cfs_sync_mapping(filp->f_mapping);
 #else
@@ -904,9 +1015,44 @@
 #if defined(CFS_ZAP_CACHES) || defined(KERNEL2616_53)
 out:
 #endif
+#ifdef LINUX_SSI_INTERRUPTIBLE
+	ssi_unmask_signals(current, &oldset, 1);
+#endif
 	return status;
 }
 
+static int
+__cfs_lock(struct file *filp, int cmd, struct file_lock *fl)
+{
+	struct cfslockargs la;
+
+#ifdef CFS_PARANOIA
+	if (!(IS_SETLK(cmd) || IS_SETLKW(cmd) || IS_GETLK(cmd))) {
+		printk("%s: Unknown command %d\n", __FUNCTION__, cmd);
+		return -EINVAL;
+	}
+#endif
+
+#ifdef CFS_EXPORT_OPS
+	COPY_CFS_FH(&(la.cfrla_fh), itocfh(filp->f_dentry->d_inode));
+#else
+	la.cfrla_fh = *itocfh(inode);
+#endif
+	la.cfrla_start = fl->fl_start;
+	la.cfrla_end = fl->fl_end;
+	la.cfrla_pid = fl->fl_pid;
+	la.cfrla_flags = fl->fl_flags;
+	la.cfrla_type = fl->fl_type;
+	la.cfrla_node = this_node;
+	la.cfrla_cmd = cmd;
+
+	if (IS_GETLK(cmd))
+		return do_getlk(filp, cmd, fl, &la);
+	if (fl->fl_type == F_UNLCK)
+		return do_unlk(filp, cmd, fl, &la);
+	return do_setlk(filp, cmd, fl, &la);
+}
+
 /*
  * Lock a (portion of) a file
  */

Index: dir.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/dir.c,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -d -r1.28 -r1.29
--- dir.c	27 Oct 2009 03:18:29 -0000	1.28
+++ dir.c	2 Nov 2009 03:44:37 -0000	1.29
@@ -54,6 +54,9 @@
 #include <cluster/ssi/cfs/cfstok.h>
 #include <cluster/ssi/cfs/cfs_clnt.h>
 #include <cluster/ssi/cfs/cfsd.h>
+#ifdef CFS_EXPORT_OPS
+#include <cluster/ssi/cfs/cfsfh.h>
+#endif
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
 #include <linux/namei.h>
@@ -592,7 +595,11 @@
 		enum cfsstat status;
 		struct cfsdirsyncargs args;
 
+#ifdef CFS_EXPORT_OPS
+		COPY_CFS_FH(&(args.sa_fhandle), itocfh(inode));
+#else
 		args.sa_fhandle = *itocfh(inode);
+#endif
 		args.sa_datasync = datasync;	/* Not used yet */
 
 		th = nsc_hcreate(server, cluster_fs_svc, 0, 0);

Index: write.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/write.c,v
retrieving revision 1.38
retrieving revision 1.39
diff -u -d -r1.38 -r1.39
--- write.c	27 Oct 2009 03:18:29 -0000	1.38
+++ write.c	2 Nov 2009 03:44:37 -0000	1.39
@@ -704,7 +704,7 @@
 		next = req->wb_index + 1;
 		if (!CFS_WBACK_BUSY(req)) {
 #ifdef KERNEL2616_53
-#ifndef CFS_PAGEVEC
+#ifndef CFS_ASYNC_QUEUE
 			if (CFS_REQ_DOWN(req))
 				continue;
 #endif
@@ -930,7 +930,7 @@
 		}
 	}
 
-#ifndef CFS_PAGEVEC
+#ifndef CFS_ASYNC_QUEUE
 	/* If request is on the down list indicate that caller needs to wait
 	 * for remount.
 	 */
@@ -1160,18 +1160,19 @@
 			SSI_ASSERT(data->flags & RPC_TASK_ASYNC);
 			printk(KERN_WARNING "CFS: %d write handler delayed data 0x%p\n",
 				current->pid, data);
-			//idelay(HZ);
 			return -EAGAIN;
 		}
 
 		printk(KERN_WARNING "CFS: write handler down off %llo len %d\n",
 			data->offset, data->count);
 
+#ifndef CFS_ASYNC_QUEUE
+#error not supported
+#endif
 		while (!list_empty(&data->pages)) {
 			req = cfs_list_entry(data->pages.next);
 			cfs_list_remove_request(req);
 			cfs_list_add_request(req, &CFS_SERVER(data->inode)->dirty_down);
-			/* cfs_set_down(req); */
 		}
 
 		UNLOCK_COND_LOCK(&mip->mi_cond_lock);
@@ -1694,28 +1695,19 @@
 			SSI_ASSERT(data->flags & RPC_TASK_ASYNC);
 			printk(KERN_WARNING "CFS: %d commit handler delayed data 0x%p\n",
 				current->pid, data);
-			//idelay(HZ);
 			return -EAGAIN;
 		}
 
 		printk(KERN_WARNING "CFS: commit handler down off %llo len %d\n",
 			data->offset, data->count);
 
+#ifndef CFS_COMMIT_DOWN
+#error not supported
+#endif
 		while (!list_empty(&data->pages)) {
 			req = cfs_list_entry(data->pages.next);
 			cfs_list_remove_request(req);
-#ifdef CFS_COMMIT_DOWN
 			cfs_list_add_request(req, &CFS_SERVER(data->inode)->commit_down);
-			/* cfs_set_down(req); */
-#else
-			cfs_mark_request_commit(req);
-			/* cfs_set_down(req); */
-#ifdef KERNEL2616_53
-			cfs_clear_page_writeback(req);
-#else
-			cfs_unlock_request(req);
-#endif
-#endif /* !CFS_COMMIT_DOWN */
 		}
 
 		UNLOCK_COND_LOCK(&mip->mi_cond_lock);
@@ -2270,14 +2262,12 @@
 #ifdef CFS_ASYNC_QUEUE
 	int err = 0;
 
-#ifdef CFS_COMMIT_DOWN
+#ifndef CFS_COMMIT_DOWN
+#error not supported
+#endif
 	/* Flush downed commit pages to disk */
 	if (!list_empty(&server->commit_down))
 		err = cfs_commit_list(&server->commit_down, 0);
-#else
-	/* Flush commit pages to disk */
-	process_cnodes(server->mi_sb, commit_list, NULL);
-#endif /* !CFS_COMMIT_DOWN */
 
 	/*
 	 * Flush downed dirty pages to disk

Index: proc.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/proc.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- proc.c	27 Oct 2009 03:18:29 -0000	1.21
+++ proc.c	2 Nov 2009 03:44:37 -0000	1.22
@@ -61,10 +61,10 @@
 	int i, len = (_data)->count; \
  \
 	(_vlen) = (_vlen) ? : \
-			((_data)->pgbase + (_data)->count + PAGE_CACHE_SIZE - 1) \
+			((_data)->pgbase + (_data)->count + PAGE_SIZE - 1) \
 			>> PAGE_SHIFT; \
  \
-	(_vec) = kmalloc_nofail((_vlen) * sizeof(struct kvec)); \
+	(_vec) = kmalloc((_vlen) * sizeof(struct kvec), GFP_NOFS|__GFP_NOFAIL); \
  \
 	if (PageHighMem((_data)->pagevec[0])) \
 		down(&map_cfs_pagevec_sem); \
@@ -98,7 +98,7 @@
 
 #ifndef ICS_OOL_STRUCT_PAGES
 #define CFS_PAGEVEC_MAP_BUFFER(_data, _buf, _vlen) do {			\
-	_vlen = _vlen ? : (_data->pgbase + _data->count + PAGE_CACHE_SIZE - 1) \
+	_vlen = _vlen ? : (_data->pgbase + _data->count + PAGE_SIZE - 1) \
 			>> PAGE_SHIFT; \
 									\
 	if (_vlen == 1) {						\

Index: read.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/read.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- read.c	27 Oct 2009 03:18:29 -0000	1.21
+++ read.c	2 Nov 2009 03:44:37 -0000	1.22
@@ -444,19 +444,19 @@
 			SSI_ASSERT(data->flags & RPC_TASK_ASYNC);
 			printk(KERN_WARNING "CFS: %d read handler delayed data 0x%p\n",
 				current->pid, data);
-			//idelay(HZ);
 			return -EAGAIN;
 		}
 
 		printk(KERN_WARNING "CFS: read handler down off %llo len %u\n",
 			data->offset, data->count);
 
+#ifndef CFS_ASYNC_QUEUE
+#error not supported
+#endif
 		while (!list_empty(&(data->pages))) {
 			req = cfs_list_entry(data->pages.next);
 			cfs_list_remove_request(req);
 			cfs_list_add_request(req, &CFS_SERVER(data->inode)->read_down);
-			SetPageError(req->wb_page);
-			flush_dcache_page(req->wb_page);
 		}
 
 		UNLOCK_COND_LOCK(&mip->mi_cond_lock);

Index: cfs_subr.c
===================================================================
RCS file: /cvsroot/ssic-linux/openssi/kernel/cluster/ssi/cfs/cfs_subr.c,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- cfs_subr.c	27 Oct 2009 03:18:29 -0000	1.27
+++ cfs_subr.c	2 Nov 2009 03:44:37 -0000	1.28
@@ -1387,7 +1387,11 @@
 
 	/* SSI_XXX: When/if CHIDDEN is implemented, then how do we clean-up */
 
+#ifdef CFS_EXPORT_OPS
+	COPY_CFS_FH(&(clargs.cla_fhandle), ctofh(cp));
+#else
 	clargs.cla_fhandle = *ctofh(cp);
+#endif
 	clargs.cla_fromnode = this_node;
 
 	lock_kernel();


------------------------------------------------------------------------------
Come build with us! The BlackBerry(R) Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay 
ahead of the curve. Join us from November 9 - 12, 2009. Register now!
http://p.sf.net/sfu/devconference