Segregate block and size counting between obdfs and obdext2.

diff --git a/lustre/include/linux/obdo.h b/lustre/include/linux/obdo.h
index c410354..1b456e9 100644 (file)
--- a/lustre/include/linux/obdo.h
+++ b/lustre/include/linux/obdo.h
@@ -83,6 +83,15 @@ static void inline obdfs_to_inode(struct inode *inode, struct obdo *oa)
         }
 } /* obdfs_to_inode */
 
+static void inline obdfs_set_size (struct inode *inode, obd_size size)
+{
+       inode->i_size = size;
+       inode->i_blocks = (inode->i_size + inode->i_sb->s_blocksize - 1) >>
+               inode->i_sb->s_blocksize_bits;
+       inode->i_bytes = inode->i_size &
+               ((1 << inode->i_sb->s_blocksize_bits) - 1);
+} /* obdfs_set_size */
+
 #define NOLOCK 0
 #define LOCKED 1
 

diff --git a/lustre/obdfs/namei.c b/lustre/obdfs/namei.c
index 55a58ba..d2f54e3 100644 (file)
--- a/lustre/obdfs/namei.c
+++ b/lustre/obdfs/namei.c
@@ -85,7 +85,8 @@ static struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
         struct obdo *oa;
        struct inode * inode = NULL;
        ino_t ino;
-       
+       int err;
+
         ENTRY;
        if (dentry->d_name.len > EXT2_NAME_LEN)
                return ERR_PTR(-ENAMETOOLONG);
@@ -102,10 +103,24 @@ static struct dentry *obdfs_lookup(struct inode * dir, struct dentry *dentry)
         }
 
        inode = iget4(dir->i_sb, ino, NULL, oa);
-        obdo_free(oa);
 
-       if (!inode) 
+       if (!inode) {
+               obdo_free(oa);
                return ERR_PTR(-EACCES);
+       }
+
+       err = IOPS(inode, getattr)(IID(inode), oa);
+       if (err) {
+               printk(__FUNCTION__ ": obd_getattr fails (%d)\n", err);
+       } else {
+#ifdef CHECK_SIZE
+               if (inode->i_size != oa->o_size)
+                       CDEBUG(D_SUPER, "update %Ld size to %Ld\n",
+                              inode->i_size, oa->o_size);
+#endif
+               obdfs_set_size (inode, oa->o_size);
+       }
+       obdo_free(oa);
 
  negative:
        d_add(dentry, inode);

diff --git a/lustre/obdfs/rw.c b/lustre/obdfs/rw.c
index edb6301..d94c965 100644 (file)
--- a/lustre/obdfs/rw.c
+++ b/lustre/obdfs/rw.c
@@ -67,7 +67,9 @@ static int obdfs_brw(int rw, struct inode *inode, struct page *page, int create)
         err = IOPS(inode, brw)(rw, IID(inode), num_obdo, &oa, &bufs_per_obdo,
                                &page, &count, &offset, &flags);
         if ( !err )
-                obdfs_to_inode(inode, oa); /* copy o_blocks to i_blocks */
+                obdfs_set_size (inode, oa->o_size); /* copy o_blocks to i_blocks */
+               
+
 
         obdo_free(oa);
         EXIT;
@@ -278,7 +280,7 @@ int obdfs_do_vec_wr(struct inode **inodes, obd_count num_io,
                 --num_obdos;
                 CDEBUG(D_INFO, "free obdo %ld\n",(long)obdos[num_obdos]->o_id);
                 /* copy o_blocks to i_blocks */
-                obdfs_to_inode(inodes[num_obdos], obdos[num_obdos]);
+                obdfs_set_size (inodes[num_obdos], obdos[num_obdos]->o_size);
                 obdo_free(obdos[num_obdos]);
         }
         CDEBUG(D_INFO, "obdo_free done\n");
@@ -394,7 +396,7 @@ int obdfs_commit_write(struct file *file, struct page *page, unsigned from, unsi
         rc = obdfs_do_writepage(page, 1);
         kunmap(page);
         if (pos > inode->i_size) {
-                inode->i_size = pos;
+               obdfs_set_size (inode, pos);
                 obdfs_change_inode(inode);
         }
         return 0;
@@ -524,6 +526,8 @@ void obdfs_truncate(struct inode *inode)
                 EXIT;
                 return;
         }
+
+       obdfs_set_size (inode, inode->i_size);
         oa = obdo_alloc();
         if ( !oa ) {
                 /* XXX This would give an inconsistent FS, so deal with it as

diff --git a/lustre/obdfs/super.c b/lustre/obdfs/super.c
index 8827bfb..96435a1 100644 (file)
--- a/lustre/obdfs/super.c
+++ b/lustre/obdfs/super.c
@@ -124,8 +124,6 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         char *version = NULL;
         int devno;
         int err;
-        unsigned long blocksize;
-        unsigned long blocksize_bits;
         unsigned long root_ino;
         int scratch;
        struct obdo *oa;
@@ -199,26 +197,6 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         sbi->osi_super = sb;
 
         CDEBUG(D_INFO, "\n"); 
-        err = sbi->osi_ops->o_get_info(&sbi->osi_conn, strlen("blocksize"),
-                                       "blocksize", &scratch,
-                                       (void *)&blocksize);
-        if ( err ) {
-                printk("getinfo call to drive failed (blocksize)\n");
-                EXIT;
-                goto ERR;
-        }
-
-        CDEBUG(D_INFO, "\n"); 
-        err = sbi->osi_ops->o_get_info(&sbi->osi_conn, strlen("blocksize_bits"),
-                                       "blocksize_bits", &scratch,
-                                       (void *)&blocksize_bits);
-        if ( err ) {
-                printk("getinfo call to drive failed (blocksize_bits)\n");
-                EXIT;
-                goto ERR;
-        }
-
-        CDEBUG(D_INFO, "\n"); 
         err = sbi->osi_ops->o_get_info(&sbi->osi_conn, strlen("root_ino"), 
                                        "root_ino", &scratch, (void *)&root_ino);
         if ( err ) {
@@ -228,8 +206,8 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         }
         
         CDEBUG(D_INFO, "\n"); 
-        sb->s_blocksize = blocksize;
-        sb->s_blocksize_bits = (unsigned char)blocksize_bits;
+        sb->s_blocksize = PAGE_SIZE;
+        sb->s_blocksize_bits = (unsigned char)PAGE_SHIFT;
         sb->s_magic = OBDFS_SUPER_MAGIC;
         sb->s_op = &obdfs_super_operations;
 
@@ -259,9 +237,9 @@ static struct super_block * obdfs_read_super(struct super_block *sb,
         } 
         
         CDEBUG(D_INFO, "obdfs_read_super: sbdev %d, rootino: %ld, dev %s, "
-               "minor: %d, blocksize: %ld, blocksize bits %ld\n", 
+               "minor: %d, blocksize: %ld, blocksize bits %d\n", 
                sb->s_dev, root->i_ino, device, MINOR(devno), 
-               blocksize, blocksize_bits);
+               sb->s_blocksize, sb->s_blocksize_bits);
         sb->s_root = d_alloc_root(root);
         list_add(&sbi->osi_list, &obdfs_super_list);
         OBD_FREE(device, strlen(device) + 1);
@@ -325,7 +303,7 @@ void obdfs_do_change_inode(struct inode *inode, int mask)
                 return;
         }
 
-        oa->o_valid = OBD_MD_FLNOTOBD & (~mask);
+        oa->o_valid = OBD_MD_FLNOTOBD & ~(mask | OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
         obdfs_from_inode(oa, inode);
         err = IOPS(inode, setattr)(IID(inode), oa);
 
@@ -437,7 +415,7 @@ out:
 int obdfs_setattr(struct dentry *de, struct iattr *attr)
 {
         struct inode *inode = de->d_inode;
-        struct obdo *oa;
+        struct obdo *oa, ooa;
         int err;
 
         ENTRY;
@@ -455,6 +433,21 @@ int obdfs_setattr(struct dentry *de, struct iattr *attr)
        inode_copy_attr(inode, attr);
         oa->o_id = inode->i_ino;
         obdo_from_iattr(oa, attr);
+
+       memcpy (&ooa, oa, sizeof (ooa));
+       err = IOPS(inode, getattr)(IID(inode), &ooa);
+       if (err) {
+               printk(__FUNCTION__ ": obd_getattr fails (%d)\n", err);
+       } else {
+#ifdef CHECK_SIZE
+               if (oa->o_size != ooa.o_size) {
+                       printk(__FUNCTION__ ": oa->o_size %Ld != ooa.o_size %Ld\n",
+                              oa->o_size, ooa.o_size);
+               }
+#endif
+       }
+
+        oa->o_valid &= ~(OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
         err = IOPS(inode, setattr)(IID(inode), oa);
 
         if ( err )
@@ -491,7 +484,7 @@ static inline void obdfs_read_inode2(struct inode *inode, void *opaque)
        struct obdo *oa = opaque; 
        
        ENTRY;
-       obdfs_to_inode(inode, oa); 
+       obdfs_to_inode(inode, oa);
 
         INIT_LIST_HEAD(obdfs_iplist(inode)); /* list of dirty pages on inode */
         INIT_LIST_HEAD(obdfs_islist(inode)); /* list of inodes in superblock */