From: adilger <adilger>
Date: Tue, 4 Jan 2000 18:01:46 +0000 (+0000)
Subject: Updated for new obdo methods.
X-Git-Tag: 0.4.2~758
X-Git-Url: https://git.whamcloud.com/?a=commitdiff_plain;h=6080efcd90128c21ff7cb8d9111f9423c7da97ac;p=fs%2Flustre-release.git

Updated for new obdo methods.
---

diff --git a/lustre/include/linux/obd_class.h b/lustre/include/linux/obd_class.h
index 6ea3e80..cd85152 100644
--- a/lustre/include/linux/obd_class.h
+++ b/lustre/include/linux/obd_class.h
@@ -211,6 +211,42 @@ static __inline__ struct obdo *obdo_fromid(struct obd_conn *conn, obd_id id)
 	return res;
 }
 
+static inline void obdo_from_iattr(struct obdo *oa, struct iattr *attr)
+{
+	unsigned int ia_valid = attr->ia_valid;
+
+	if (ia_valid & ATTR_ATIME) {
+		oa->o_atime = attr->ia_atime;
+		oa->o_valid |= OBD_MD_FLATIME;
+	}
+	if (ia_valid & ATTR_MTIME) {
+		oa->o_mtime = attr->ia_mtime;
+		oa->o_valid |= OBD_MD_FLMTIME;
+	}
+	if (ia_valid & ATTR_CTIME) {
+		oa->o_ctime = attr->ia_ctime;
+		oa->o_valid |= OBD_MD_FLCTIME;
+	}
+	if (ia_valid & ATTR_SIZE) {
+		oa->o_size = attr->ia_size;
+		oa->o_valid |= OBD_MD_FLSIZE;
+	}
+	if (ia_valid & ATTR_MODE) {
+		oa->o_mode = attr->ia_mode;
+		oa->o_valid |= OBD_MD_FLMODE;
+		if (!in_group_p(oa->o_gid) && !capable(CAP_FSETID))
+			oa->o_mode &= ~S_ISGID;
+	}
+	if (ia_valid & ATTR_UID)
+	{
+		oa->o_uid = attr->ia_uid;
+		oa->o_valid |= OBD_MD_FLUID;
+	}
+	if (ia_valid & ATTR_GID) {
+		oa->o_gid = attr->ia_gid;
+		oa->o_valid |= OBD_MD_FLGID;
+	}
+}
 
 
 static __inline__ void obdo_cpy_md(struct obdo *dst, struct obdo *src)
diff --git a/lustre/include/linux/obdfs.h b/lustre/include/linux/obdfs.h
index 3cc202c..6800db6 100644
--- a/lustre/include/linux/obdfs.h
+++ b/lustre/include/linux/obdfs.h
@@ -22,6 +22,7 @@ int flushd_init(void);
 
 
 /* rw.c */
+int obdfs_do_writepage(struct inode *, struct page *, int sync);
 int obdfs_init_wreqcache(void);
 int obdfs_readpage(struct dentry *dentry, struct page *page);
 int obdfs_writepage(struct dentry *dentry, struct page *page);
diff --git a/lustre/obdfs/Makefile b/lustre/obdfs/Makefile
index 173d49c..f0a7390 100644
--- a/lustre/obdfs/Makefile
+++ b/lustre/obdfs/Makefile
@@ -5,6 +5,6 @@
 include ../config.mk
 
 MODULE = obdfs.o
-CFILES=file.c dir.c sysctl.c super.c rw.c namei.c symlink.c # flushd.c 
+CFILES=  file.c dir.c sysctl.c super.c rw.c namei.c symlink.c #flushd.c
 
 include ../make.rules
diff --git a/lustre/obdfs/namei.c b/lustre/obdfs/namei.c
index 86065bd..dfb3c00 100644
--- a/lustre/obdfs/namei.c
+++ b/lustre/obdfs/namei.c
@@ -199,6 +199,9 @@ struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
 
  * returns a locked and held page upon success 
  */
+
+/* XXX I believe these pages should in fact NOT be locked */
+
 static struct page *obdfs_add_entry (struct inode * dir,
 				     const char * name, int namelen,
 				     struct ext2_dir_entry_2 ** res_dir,
@@ -440,6 +443,44 @@ static void show_dentry(struct list_head * dlist, int subdirs)
 #endif
 
 
+struct inode *obdfs_new_inode(struct inode *dir)
+{
+	struct obdo *obdo;
+	struct inode *inode;
+	int err;
+
+	obdo = obdo_alloc();
+	if (!obdo) {
+		EXIT;
+		return ERR_PTR(-ENOMEM);
+	}
+
+	err = IOPS(dir, create)(IID(dir), obdo);
+	if ( err ) 
+		return ERR_PTR(err);
+
+	inode = iget(dir->i_sb, (unsigned long)obdo->o_id);
+	if (!inode) {
+		obdo_free(obdo);
+		EXIT;
+		return ERR_PTR(-EIO);
+	}
+
+	if (!list_empty(&inode->i_dentry)) {
+		CDEBUG(D_INODE, "New inode (%ld) has aliases!\n", 
+		       inode->i_ino);
+		iput(inode);
+		EXIT;
+		return ERR_PTR(-EIO);
+	}
+
+
+	obdo_free(obdo);
+	EXIT;
+	return inode;
+}
+
+
 /*
  * By the time this is called, we already have created
  * the directory cache entry for the new file, but it
@@ -454,60 +495,37 @@ int obdfs_create (struct inode * dir, struct dentry * dentry, int mode)
 	struct page *page;
 	struct ext2_dir_entry_2 * de;
 	int err = -EIO;
-	struct obdo *oa;
 
         ENTRY;
 
-	oa = obdo_alloc(oa);
-	if (!oa) {
-		EXIT;
-		return -ENOMEM;
-	}
-
-	err = IOPS(dir, create)(IID(dir), 0, oa);
-
-	if ( err ) 
-		return err;
-	obdo_to_inode(inode, oa);
-	inode = iget(dir->i_sb, inode->i_ino);
-	if (!inode || !list_empty(&inode->i_dentry)) {
-		CDEBUG(D_INODE, "No inode, ino %ld\n", inode->i_ino);
-		obdo_free(oa);
+	inode = obdfs_new_inode(dir);
+	if ( IS_ERR(inode) ) {
 		EXIT;
-		return -EIO;
+		return PTR_ERR(inode);
 	}
 
 	inode->i_op = &obdfs_file_inode_operations;
 	inode->i_mode = mode;
 	mark_inode_dirty(inode);
-	page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len,
-				&de, &err);
+	page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 	if (!page) {
 		inode->i_nlink--;
 		mark_inode_dirty(inode);
 		iput (inode);
-		obdo_free(oa);
 		EXIT;
 		return err;
 	}
 	de->inode = cpu_to_le32(inode->i_ino);
 	ext2_set_de_type(dir->i_sb, de, S_IFREG);
 	dir->i_version = ++event;
-	oa->o_id = dir->i_ino; /* Note: this is a different OA than above */
-	err = IOPS(dir, brw)(WRITE, IID(dir), oa, (char *)page_address(page),
-			     PAGE_SIZE, (page->index) << PAGE_SHIFT, 0);
-	obdo_free(oa);
+
+	err = obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
+
 	page_cache_release(page);
 	d_instantiate(dentry, inode);
 	EXIT;
-	return 0;
+	return err;
 }
 
 int obdfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
@@ -515,49 +533,29 @@ int obdfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
 	struct inode * inode;
 	struct page *page;
 	struct ext2_dir_entry_2 * de;
-	struct obdo *oa;
 	int err;
 
         ENTRY;
 
-	oa = obdo_alloc();
-	if (!oa) {
+	inode = obdfs_new_inode(dir);
+	if ( IS_ERR(inode) ) {
 		EXIT;
-		return -ENOMEM;
-	}
-	err = IOPS(dir, create)(IID(dir), 0, oa);
-	if ( err ) 
-		return err;
-	obdo_to_inode(inode, oa);
-	inode = iget(dir->i_sb, inode->i_ino);
-	if (!inode) {
-		obdo_free(oa);
-		EXIT;
-		return -EIO;
+		return PTR_ERR(inode);
 	}
 
 	inode->i_uid = current->fsuid;
 	init_special_inode(inode, mode, rdev);
-	page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len,
-				&de, &err);
+	page = obdfs_add_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, &err);
 	if (!page)
 		goto out_no_entry;
 	de->inode = cpu_to_le32(inode->i_ino);
 	dir->i_version = ++event;
 	ext2_set_de_type(dir->i_sb, de, inode->i_mode);
 	mark_inode_dirty(inode);
-	oa->o_id = dir->i_ino; /* Note: this is a different OA than above */
-	err = IOPS(dir, brw)(WRITE, IID(dir), oa, (char *)page_address(page),
-			       PAGE_SIZE, (page->index) << PAGE_SHIFT, 0);
+
+	err = obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
-	obdo_free(oa);
 
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
 	d_instantiate(dentry, inode);
 	page_cache_release(page);
 	err = 0;
@@ -576,7 +574,6 @@ int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 	struct inode * inode;
 	struct page *page, *inode_page;
 	struct ext2_dir_entry_2 * de;
-	struct obdo *ioa, *doa;
 	int err;
 
 	ENTRY;
@@ -585,29 +582,10 @@ int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 	if (dir->i_nlink >= EXT2_LINK_MAX)
 		goto out;
 
-	ioa = obdo_alloc();
-	if (!ioa) {
-		EXIT;
-		return -ENOMEM;
-	}
-	doa = obdo_alloc();
-	if (!ioa) {
+	inode = obdfs_new_inode(dir);
+	if ( IS_ERR(inode) ) {
 		EXIT;
-		return -ENOMEM;
-	}
-
-	err = IOPS(dir, create)(IID(dir), 0, ioa);
-	if ( err ) {
-		obdo_free(oa);
-		EXIT;
-		return err;
-	}
-	obdo_to_inode(inode, ioa);
-	inode = iget(dir->i_sb, inode->i_ino);
-	if (!inode) {
-		obdo_free(oa);
-		EXIT;
-		return -EIO;
+		return PTR_ERR(inode);
 	}
 
 	inode->i_op = &obdfs_dir_inode_operations;
@@ -617,7 +595,6 @@ int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 		inode->i_nlink--; /* is this nlink == 0? */
 		mark_inode_dirty(inode);
 		iput (inode);
-		obdo_free(oa);
 		return err;
 	}
 
@@ -636,17 +613,12 @@ int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 	strcpy (de->name, "..");
 	ext2_set_de_type(dir->i_sb, de, S_IFDIR);
 	
-	oa->o_id = dir->i_ino;
-	err = IOPS(dir, brw)(WRITE, IID(dir), oa, (char *)page_address(inode_page),
-			     PAGE_SIZE, (inode_page->index) << PAGE_SHIFT, 1);
-
-	obdo_to_inode(dir, doa); /* copy o_blocks to i_blocks */
-	obdo_free(doa);
-
+	err = obdfs_do_writepage(inode, inode_page, IS_SYNC(inode));
 	inode->i_blocks = PAGE_SIZE/inode->i_sb->s_blocksize;
 	inode->i_size = PAGE_SIZE;
 	UnlockPage(inode_page);
 	page_cache_release(inode_page);
+	/* XXX handle err */
 
 	inode->i_nlink = 2;
 	inode->i_mode = S_IFDIR | mode;
@@ -664,17 +636,13 @@ int obdfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 	ext2_set_de_type(dir->i_sb, de, S_IFDIR);
 	dir->i_version = ++event;
 
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
 	dir->i_nlink++;
 	dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 	mark_inode_dirty(dir);
-	iops(dir)->o_brw(WRITE, iid(dir), dir, page, 1);
+	err = obdfs_do_writepage(dir, page, IS_SYNC(dir));
+
 	UnlockPage(page);
+
 	page_cache_release(page);
 	d_instantiate(dentry, inode);
 	err = 0;
@@ -764,6 +732,7 @@ int obdfs_rmdir (struct inode * dir, struct dentry *dentry)
 	struct inode * inode;
 	struct page *page;
 	struct ext2_dir_entry_2 * de;
+	int err;
 
 	ENTRY;
 
@@ -787,14 +756,9 @@ int obdfs_rmdir (struct inode * dir, struct dentry *dentry)
 	dir->i_version = ++event;
 	if (retval)
 		goto end_rmdir;
-	iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
+	err = obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
+
 	if (inode->i_nlink != 2)
 		ext2_warning (inode->i_sb, "ext2_rmdir",
 			      "empty directory has nlink!=2 (%d)",
@@ -822,6 +786,7 @@ int obdfs_unlink(struct inode * dir, struct dentry *dentry)
 	struct inode * inode;
 	struct page *page;
 	struct ext2_dir_entry_2 * de;
+	int err;
 
         ENTRY;
 
@@ -847,14 +812,9 @@ int obdfs_unlink(struct inode * dir, struct dentry *dentry)
 	if (retval)
 		goto end_unlink;
 	dir->i_version = ++event;
-	iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
+	err = obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
+
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
 	mark_inode_dirty(dir);
@@ -879,22 +839,14 @@ int obdfs_symlink (struct inode * dir, struct dentry *dentry, const char * symna
 	char * link;
 	int i, l, err = -EIO;
 	char c;
-	obd_id id;
 
         ENTRY;
-	/*
-	 * N.B. Several error exits in ext2_new_inode don't set err.
-	 */
-	err = iops(dir)->o_create(iid(dir), 0, &id);
-	if ( err )  {
-		EXIT;
-		return err;
-	}
-	inode =  iget(dir->i_sb, (ino_t)id);
-	if (!inode) {
+	inode = obdfs_new_inode(dir);
+	if ( IS_ERR(inode) ) {
 		EXIT;
-		return err;
+		return PTR_ERR(inode);
 	}
+
 	inode->i_mode = S_IFLNK | S_IRWXUGO;
 	inode->i_op = &obdfs_symlink_inode_operations;
 	for (l = 0; l < inode->i_sb->s_blocksize - 1 &&
@@ -924,7 +876,7 @@ int obdfs_symlink (struct inode * dir, struct dentry *dentry, const char * symna
 		link[i++] = c;
 	link[i] = 0;
 	if (name_page) {
-		iops(inode)->o_brw(WRITE, iid(inode), inode, name_page, 1);
+		obdfs_do_writepage(inode, name_page, IS_SYNC(inode));
 		PDEBUG(name_page, "symlink");
 		UnlockPage(name_page);
 		page_cache_release(name_page);
@@ -938,14 +890,9 @@ int obdfs_symlink (struct inode * dir, struct dentry *dentry, const char * symna
 	de->inode = cpu_to_le32(inode->i_ino);
 	ext2_set_de_type(dir->i_sb, de, S_IFLNK);
 	dir->i_version = ++event;
-	iops(dir)->o_brw(WRITE, iid(dir), dir, page, 1);
+	obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
+
 	d_instantiate(dentry, inode);
 	err = 0;
 out:
@@ -982,15 +929,10 @@ int obdfs_link (struct dentry * old_dentry,
 	de->inode = cpu_to_le32(inode->i_ino);
 	ext2_set_de_type(dir->i_sb, de, inode->i_mode);
 	dir->i_version = ++event;
-	iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
+
+	obdfs_do_writepage(dir, page, IS_SYNC(dir));
 	UnlockPage(page);
 
-#if 0
-	if (IS_SYNC(dir)) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-#endif
 	page_cache_release(page);
 	inode->i_nlink++;
 	inode->i_ctime = CURRENT_TIME;
@@ -1100,7 +1042,7 @@ int obdfs_rename (struct inode * old_dir, struct dentry *old_dentry,
 	mark_inode_dirty(old_dir);
 	if (dir_page) {
 		PARENT_INO(page_address(dir_page)) = le32_to_cpu(new_dir->i_ino);
-		iops(old_inode)->o_brw(WRITE, iid(old_inode), old_inode, dir_page, 0);
+		obdfs_do_writepage(old_inode, dir_page, IS_SYNC(old_inode));
 		old_dir->i_nlink--;
 		mark_inode_dirty(old_dir);
 		if (new_inode) {
@@ -1119,21 +1061,10 @@ int obdfs_rename (struct inode * old_dir, struct dentry *old_dentry,
 		page_cache_release(old_page);
 		old_page = obdfs_getpage(old_dir, index >> PAGE_SHIFT, 0, LOCKED);
 		CDEBUG(D_INODE, "old_page at %p\n", old_page);
-		iops(old_dir)->o_brw(WRITE, iid(old_dir), old_dir, old_page,0);
-	}
-#if 0
-	if (IS_SYNC(old_dir)) {
-		ll_rw_block (WRITE, 1, &old_bh);
-		wait_on_buffer (old_bh);
+		obdfs_do_writepage(old_dir, old_page, IS_SYNC(old_dir));
 	}
-#endif
-	iops(new_dir)->o_brw(WRITE, iid(new_dir), new_dir, new_page, 0);
-#if 0
-	if (IS_SYNC(new_dir)) {
-		ll_rw_block (WRITE, 1, &new_bh);
-		wait_on_buffer (new_bh);
-	}
-#endif
+
+	obdfs_do_writepage(new_dir, new_page, IS_SYNC(new_dir));
 
 	retval = 0;
 
diff --git a/lustre/obdfs/rw.c b/lustre/obdfs/rw.c
index aa18c72..465b5de 100644
--- a/lustre/obdfs/rw.c
+++ b/lustre/obdfs/rw.c
@@ -1,6 +1,7 @@
 /*
  * OBDFS Super operations
  *
+ * Copyright (C) 1996, 1997, Olaf Kirch <okir@monad.swb.de>
  * Copryright (C) 1999 Stelias Computing Inc, 
  *                (author Peter J. Braam <braam@stelias.com>)
  * Copryright (C) 1999 Seagate Technology Inc.
@@ -34,46 +35,50 @@
 
 int console_loglevel;
 
-/* VFS super_block ops */
-
-#if 0
-int obdfs_brw(struct inode *dir, int rw, struct page *page, int create)
+/* SYNCHRONOUS I/O for an inode */
+int obdfs_brw(int rw, struct inode *inode, struct page *page, int create)
 {
-	return IOPS(dir, brw)(rw, IID(dir), dir, page, create);
+	struct obdo *obdo;
+	int res;
+
+	obdo = obdo_alloc();
+	if ( ! obdo ) {
+		EXIT;
+		return -ENOMEM;
+	}
+
+	obdo->o_id = inode->i_ino;
+
+	res = IOPS(inode, brw)(rw, IID(inode), obdo, 
+			       (char *)page_address(page), 
+			       PAGE_SIZE,
+			       (page->index) >> PAGE_SHIFT,
+			       create);
+
+	obdo_to_inode(inode, obdo); /* copy o_blocks to i_blocks */
+	obdo_free(obdo);
+	
+	if ( res == PAGE_SIZE )
+		res = 0;
+	return res;
 }
-#endif
 
 /* returns the page unlocked, but with a reference */
 int obdfs_readpage(struct dentry *dentry, struct page *page)
 {
 	struct inode *inode = dentry->d_inode;
-	struct obdo *oa;
-	int err;
+	int rc;
 
         ENTRY;
 	PDEBUG(page, "READ");
-	oa = obdo_alloc();
-	if (!oa) {
-		printk("obdfs_readpage: obdo_alloc failure\n");
-		EXIT;
-		return -ENOMEM;
-	}
-
-	oa->o_id = inode->i_ino;
-	err = IOPS(inode, brw)(READ, IID(inode), oa, (char *)page_address(page),
-			       PAGE_SIZE, (page->index) << PAGE_SHIFT, 0);
-	obdo_to_inode(inode, oa); /* copy o_blocks to i_blocks */
-	obdo_free(oa);
-
-	if (err == PAGE_SIZE ) {
+	rc =  obdfs_brw(READ, inode, page, 0);
+	if (!rc) {
 		SetPageUptodate(page);
 		UnlockPage(page);
 	} 
 	PDEBUG(page, "READ");
-	if ( err == PAGE_SIZE ) 
-		err = 0;
 	EXIT;
-	return err;
+	return rc;
 }
 
 static kmem_cache_t *obdfs_wreq_cachep;
@@ -134,22 +139,12 @@ obdfs_remove_from_page_cache(struct obdfs_wreq *wreq)
 {
 	struct inode *inode = wreq->wb_inode;
 	struct page *page = wreq->wb_page;
-	struct obdo *oa;
-	int err;
+	int rc;
 
 	ENTRY;
 	CDEBUG(D_INODE, "removing inode %ld page %p, wreq: %p\n",
 	       inode->i_ino, page, wreq);
-	oa = obdo_alloc();
-	if (!oa) {
-		printk("obdfs_remove_from_page_cache: obdo_alloc failure\n");
-		EXIT;
-		return -ENOMEM;
-	}
-	oa->o_id = inode->i_ino;
-	err = IOPS(inode, brw)(WRITE, IID(inode), oa,(char *)page_address(page),
-			       PAGE_SIZE, (page->index) << PAGE_SHIFT, 1);
-	obdo_to_inode(inode, oa); /* copy o_blocks to i_blocks */
+	rc = obdfs_brw(WRITE, inode, page, 1);
 	/* XXX probably should handle error here somehow.  I think that
 	 *     ext2 also does the same thing - discard write even if error?
 	 */
@@ -158,7 +153,7 @@ obdfs_remove_from_page_cache(struct obdfs_wreq *wreq)
 	kmem_cache_free(obdfs_wreq_cachep, wreq);
 
 	EXIT;
-	return err;
+	return rc;
 }
 
 /*
@@ -199,21 +194,29 @@ obdfs_add_to_page_cache(struct inode *inode, struct page *page)
 }
 
 
-/* returns the page unlocked, but with a reference */
-int obdfs_writepage(struct dentry *dentry, struct page *page)
+int obdfs_do_writepage(struct inode *inode, struct page *page, int sync)
 {
-        struct inode *inode = dentry->d_inode;
-	int err;
+	int rc;
 
         ENTRY;
 	PDEBUG(page, "WRITEPAGE");
-	/* XXX flush stuff */
-	err = obdfs_add_to_page_cache(inode, page);
-
-	if (!err)
+	if ( sync ) {
+		rc = obdfs_brw(WRITE, inode, page, 1);
+	} else {
+		/* XXX flush stuff */
+		rc = obdfs_add_to_page_cache(inode, page);
+	}
+		
+	if (!rc)
 		SetPageUptodate(page);
 	PDEBUG(page,"WRITEPAGE");
-	return err;
+	return rc;
+}
+
+/* returns the page unlocked, but with a reference */
+int obdfs_writepage(struct dentry *dentry, struct page *page)
+{
+	return obdfs_do_writepage(dentry->d_inode, page, 0);
 }
 
 /*
@@ -225,29 +228,15 @@ int obdfs_writepage(struct dentry *dentry, struct page *page)
  * If the writer ends up delaying the write, the writer needs to
  * increment the page use counts until he is done with the page.
  */
-int obdfs_write_one_page(struct file *file, struct page *page,
-			 unsigned long offset, unsigned long bytes,
-			 const char * buf)
+int obdfs_write_one_page(struct file *file, struct page *page, unsigned long offset, unsigned long bytes, const char * buf)
 {
 	long status;
         struct inode *inode = file->f_dentry->d_inode;
 
 	ENTRY;
 	if ( !Page_Uptodate(page) ) {
-		struct obdo *oa;
-		oa = obdo_alloc();
-		if (!oa) {
-			printk("obdfs_write_one_page: obdo_alloc failure\n");
-			EXIT;
-			return -ENOMEM;
-		}
-		oa->o_id = inode->i_ino;
-		status = IOPS(inode, brw)(READ, IID(inode), oa,
-					  (char *)page_address(page), PAGE_SIZE,					  (page->index) << PAGE_SHIFT, 1);
-		obdo_to_inode(inode, oa); /* copy o_blocks to i_blocks */
-		obdo_free(oa);
-
-		if (status == PAGE_SIZE ) {
+		status =  obdfs_brw(READ, inode, page, 1);
+		if (!status) {
 			SetPageUptodate(page);
 		} else { 
 			return status;
@@ -268,18 +257,6 @@ int obdfs_write_one_page(struct file *file, struct page *page,
 		return bytes;
 }
 
-
-
-
-
-void report_inode(struct page * page) {
-	struct inode *inode = (struct inode *)0;
-	int offset = (int)&inode->i_data;
-	inode = (struct inode *)( (char *)page->mapping - offset);
-	if ( inode->i_sb->s_magic == 0x4711 )
-		printk("----> ino %ld , dev %d\n", inode->i_ino, inode->i_dev);
-}
-
 /* 
    return an up to date page:
     - if locked is true then is returned locked
@@ -288,14 +265,12 @@ void report_inode(struct page * page) {
 
    modeled on NFS code.
 */
-struct page *obdfs_getpage(struct inode *inode, unsigned long offset,
-			   int create, int locked)
+struct page *obdfs_getpage(struct inode *inode, unsigned long offset, int create, int locked)
 {
 	struct page *page_cache;
 	struct page ** hash;
 	struct page * page;
-	struct obdo *oa;
-	int err;
+	int rc;
 
         ENTRY;
 
@@ -311,7 +286,13 @@ struct page *obdfs_getpage(struct inode *inode, unsigned long offset,
 	hash = page_hash(&inode->i_data, offset);
 	page = grab_cache_page(&inode->i_data, offset);
 
-	PDEBUG(page, "obdfs_getpage: got page - before reading\n");
+	/* Yuck, no page */
+	if (! page) {
+	    printk("grab_cache_page says no dice ...\n");
+	    return 0;
+	}
+
+	PDEBUG(page, "GETPAGE: got page - before reading\n");
 	/* now check if the data in the page is up to date */
 	if ( Page_Uptodate(page)) { 
 		if (!locked)
@@ -320,26 +301,9 @@ struct page *obdfs_getpage(struct inode *inode, unsigned long offset,
 		return page;
 	} 
 
-	/* it's not: read it */
-	if (! page) {
-		printk("obdfs_getpage: says no dice ...\n");
-		return NULL;
-	}
-
-	oa = obdo_alloc();
-	if (!oa) {
-		printk("obdfs_getpage: obdo_alloc failure\n");
-		EXIT;
-		return NULL;
-	}
-	oa->o_id = inode->i_ino;
-	err = IOPS(inode, brw)(READ, IID(inode), oa, (char *)page_address(page),
-			       PAGE_SIZE, (page->index) << PAGE_SHIFT, create);
-
-	obdo_to_inode(inode, oa); /* XXX to copy o_blocks */
-	obdo_free(oa);
+	rc = obdfs_brw(READ, inode, page, create);
 
-	if ( err != PAGE_SIZE ) {
+	if ( rc != PAGE_SIZE ) {
 		SetPageError(page);
 		UnlockPage(page);
 		return page;
diff --git a/lustre/obdfs/super.c b/lustre/obdfs/super.c
index 5c663ea..c48a9e3 100644
--- a/lustre/obdfs/super.c
+++ b/lustre/obdfs/super.c
@@ -130,6 +130,7 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         struct inode *root = 0; 
 	struct obdfs_sb_info *sbi = (struct obdfs_sb_info *)(&sb->u.generic_sbp);
 	struct obd_device *obddev;
+        int error = 0;
 	char *device = NULL;
 	char *version = NULL;
 	int devno;
@@ -138,6 +139,7 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
 	unsigned long blocksize_bits;
 	unsigned long root_ino;
 	int scratch;
+	
 
 	ENTRY;
         MOD_INC_USE_COUNT; 
@@ -153,7 +155,7 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
 	}
 
 	if ( (err = obdfs_getdev(device, &devno)) ) {
-		printk("Cannot get devno of %s, err %d\n", device, err);
+		printk("Cannot get devno of %s, error %d\n", device, err);
 		MOD_DEC_USE_COUNT;
 		EXIT;
 		return NULL;
@@ -188,41 +190,44 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
 	sbi->osi_ops = sbi->osi_obd->obd_type->typ_ops;
 	
 	sbi->osi_conn.oc_dev = obddev;
-        err  = sbi->osi_ops->o_connect(&sbi->osi_conn);
-	if ( err ) {
+        error  = sbi->osi_ops->o_connect(&sbi->osi_conn);
+	if ( error ) {
 		printk("OBDFS: cannot connect to %s\n", device);
-		goto ERR;
+		goto error;
 	}
 
 	INIT_LIST_HEAD(&sbi->osi_list);
 
 	sbi->osi_super = sb;
 
-	err = sbi->osi_ops->o_get_info(&sbi->osi_conn,
+	error = sbi->osi_ops->o_get_info(&sbi->osi_conn,
 					 strlen("blocksize"), 
 					 "blocksize", 
 					 &scratch, (void *)&blocksize);
-	if ( err ) {
+	if ( error ) {
 		printk("Getinfo call to drive failed (blocksize)\n");
-		goto ERR;
+		goto error;
 	}
 
-	err = sbi->osi_ops->o_get_info(&sbi->osi_conn, strlen("blocksize_bits"),
-				       "blocksize_bits", &scratch,
-				       (void *)&blocksize_bits);
-	if ( err ) {
+	error = sbi->osi_ops->o_get_info(&sbi->osi_conn,
+					 strlen("blocksize_bits"), 
+					 "blocksize_bits", 
+					 &scratch, (void *)&blocksize_bits);
+	if ( error ) {
 		printk("Getinfo call to drive failed (blocksize_bits)\n");
-		goto ERR;
+		goto error;
 	}
 
-	err = sbi->osi_ops->o_get_info(&sbi->osi_conn,
+	error = sbi->osi_ops->o_get_info(&sbi->osi_conn,
 					 strlen("root_ino"), 
 					 "root_ino", 
 					 &scratch, (void *)&root_ino);
-	if ( err ) {
+	if ( error ) {
 		printk("Getinfo call to drive failed (root_ino)\n");
-		goto ERR;
+		goto error;
 	}
+	
+
 
         lock_super(sb);
 	
@@ -236,9 +241,9 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         if (!root || is_bad_inode(root)) {
 	    printk("OBDFS: bad iget for root\n");
 	    sb->s_dev = 0;
-	    err = ENOENT;
+	    error = ENOENT;
 	    unlock_super(sb);
-	    goto ERR;
+	    goto error;
 	} 
 	
 
@@ -251,7 +256,7 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
 	EXIT;  
         return sb;
 
-ERR:
+ error:
 	EXIT;  
 	MOD_DEC_USE_COUNT;
 	if (sbi) {
@@ -270,6 +275,8 @@ static void obdfs_put_super(struct super_block *sb)
         struct obdfs_sb_info *sbi;
 
         ENTRY;
+
+
         sb->s_dev = 0;
 	
 	/* XXX flush stuff */
@@ -298,7 +305,7 @@ void obdfs_read_inode(struct inode *inode)
 		EXIT;
 		return;
 	}
-	oa->o_valid = OBD_MD_FLALL;
+	oa->o_valid = ~OBD_MD_FLOBDMD;
 	oa->o_id = inode->i_ino;
 	err = IOPS(inode, getattr)(IID(inode), oa);
 	if (err) {
@@ -322,7 +329,6 @@ void obdfs_read_inode(struct inode *inode)
 	else
 		/* XXX what do we pass here??? */
 		init_special_inode(inode, inode->i_mode, 0 /* XXX XXX */ );
-
 	return;
 }
 
@@ -367,42 +373,6 @@ static void obdfs_delete_inode(struct inode *inode)
 }
 
 
-static void obdo_setattr(struct obdo *oa, struct iattr *attr)
-{
-	unsigned int ia_valid = attr->ia_valid;
-
-	if (ia_valid & ATTR_ATIME) {
-		oa->o_atime = attr->ia_atime;
-		oa->o_valid |= OBD_MD_FLATIME;
-	}
-	if (ia_valid & ATTR_MTIME) {
-		oa->o_mtime = attr->ia_mtime;
-		oa->o_valid |= OBD_MD_FLMTIME;
-	}
-	if (ia_valid & ATTR_CTIME) {
-		oa->o_ctime = attr->ia_ctime;
-		oa->o_valid |= OBD_MD_FLCTIME;
-	}
-	if (ia_valid & ATTR_SIZE) {
-		oa->o_size = attr->ia_size;
-		oa->o_valid |= OBD_MD_FLSIZE;
-	}
-	if (ia_valid & ATTR_MODE) {
-		oa->o_mode = attr->ia_mode;
-		oa->o_valid |= OBD_MD_FLMODE;
-		if (!in_group_p(oa->o_gid) && !capable(CAP_FSETID))
-			oa->o_mode &= ~S_ISGID;
-	}
-	if (ia_valid & ATTR_UID)
-	{
-		oa->o_uid = attr->ia_uid;
-		oa->o_valid |= OBD_MD_FLUID;
-	}
-	if (ia_valid & ATTR_GID) {
-		oa->o_gid = attr->ia_gid;
-		oa->o_valid |= OBD_MD_FLGID;
-	}
-}
 
 
 static int obdfs_notify_change(struct dentry *de, struct iattr *attr)
@@ -419,7 +389,7 @@ static int obdfs_notify_change(struct dentry *de, struct iattr *attr)
 	}
 
 	oa->o_id = inode->i_ino;
-	obdo_setattr(oa, attr);
+	obdo_from_iattr(oa, attr);
         err = IOPS(inode, setattr)(IID(inode), oa);
 	if ( err ) {
 		printk("obdfs_notify_change: obd_setattr fails (%d)\n", err);