Make all of the obdo<->inode and obdo<->iattr copy routines take a valid

flag as a parameter, to avoid copying fields into or out of the obdo/inode
that you don't want to copy, just because oa->o_valid is set.

When we do the ll_file_size call to the OST, return the blocks count at
the same time.

Remove some of the verbosity from the locked-page writeout case.  Real
fix is pending.

diff --git a/lustre/include/linux/obd_class.h b/lustre/include/linux/obd_class.h
index 793b1a6..1ad154b 100644 (file)
--- a/lustre/include/linux/obd_class.h
+++ b/lustre/include/linux/obd_class.h
@@ -507,39 +507,38 @@ static inline void obdo_from_iattr(struct obdo *oa, struct iattr *attr)
 }
 
 
-static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa)
+static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa,
+                                   obd_flag valid)
 {
-        unsigned int ia_valid = oa->o_valid;
-
         memset(attr, 0, sizeof(*attr));
-        if (ia_valid & OBD_MD_FLATIME) {
+        if (valid & OBD_MD_FLATIME) {
                 attr->ia_atime = oa->o_atime;
                 attr->ia_valid |= ATTR_ATIME;
         }
-        if (ia_valid & OBD_MD_FLMTIME) {
+        if (valid & OBD_MD_FLMTIME) {
                 attr->ia_mtime = oa->o_mtime;
                 attr->ia_valid |= ATTR_MTIME;
         }
-        if (ia_valid & OBD_MD_FLCTIME) {
+        if (valid & OBD_MD_FLCTIME) {
                 attr->ia_ctime = oa->o_ctime;
                 attr->ia_valid |= ATTR_CTIME;
         }
-        if (ia_valid & OBD_MD_FLSIZE) {
+        if (valid & OBD_MD_FLSIZE) {
                 attr->ia_size = oa->o_size;
                 attr->ia_valid |= ATTR_SIZE;
         }
-        if (ia_valid & OBD_MD_FLMODE) {
+        if (valid & OBD_MD_FLMODE) {
                 attr->ia_mode = oa->o_mode;
                 attr->ia_valid |= ATTR_MODE;
                 if (!in_group_p(oa->o_gid) && !capable(CAP_FSETID))
                         attr->ia_mode &= ~S_ISGID;
         }
-        if (ia_valid & OBD_MD_FLUID)
+        if (valid & OBD_MD_FLUID)
         {
                 attr->ia_uid = oa->o_uid;
                 attr->ia_valid |= ATTR_UID;
         }
-        if (ia_valid & OBD_MD_FLGID) {
+        if (valid & OBD_MD_FLGID) {
                 attr->ia_gid = oa->o_gid;
                 attr->ia_valid |= ATTR_GID;
         }
@@ -549,117 +548,121 @@ static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa)
 /* WARNING: the file systems must take care not to tinker with
    attributes they don't manage (such as blocks). */
 
-static inline void obdo_from_inode(struct obdo *dst, struct inode *src)
+static inline void obdo_from_inode(struct obdo *dst, struct inode *src,
+                                   obd_flag valid)
 {
-        if ( dst->o_valid & OBD_MD_FLID )
+        if (valid & OBD_MD_FLID)
                 dst->o_id = src->i_ino;
-        if ( dst->o_valid & OBD_MD_FLATIME )
+        if (valid & OBD_MD_FLATIME)
                 dst->o_atime = src->i_atime;
-        if ( dst->o_valid & OBD_MD_FLMTIME )
+        if (valid & OBD_MD_FLMTIME)
                 dst->o_mtime = src->i_mtime;
-        if ( dst->o_valid & OBD_MD_FLCTIME )
+        if (valid & OBD_MD_FLCTIME)
                 dst->o_ctime = src->i_ctime;
-        if ( dst->o_valid & OBD_MD_FLSIZE )
+        if (valid & OBD_MD_FLSIZE)
                 dst->o_size = src->i_size;
-        if ( dst->o_valid & OBD_MD_FLBLOCKS )   /* allocation of space */
+        if (valid & OBD_MD_FLBLOCKS)   /* allocation of space */
                 dst->o_blocks = src->i_blocks;
-        if ( dst->o_valid & OBD_MD_FLBLKSZ )
+        if (valid & OBD_MD_FLBLKSZ)
                 dst->o_blksize = src->i_blksize;
-        if ( dst->o_valid & OBD_MD_FLMODE )
+        if (valid & OBD_MD_FLMODE)
                 dst->o_mode = src->i_mode;
-        if ( dst->o_valid & OBD_MD_FLUID )
+        if (valid & OBD_MD_FLUID)
                 dst->o_uid = src->i_uid;
-        if ( dst->o_valid & OBD_MD_FLGID )
+        if (valid & OBD_MD_FLGID)
                 dst->o_gid = src->i_gid;
-        if ( dst->o_valid & OBD_MD_FLFLAGS )
+        if (valid & OBD_MD_FLFLAGS)
                 dst->o_flags = src->i_flags;
-        if ( dst->o_valid & OBD_MD_FLNLINK )
+        if (valid & OBD_MD_FLNLINK)
                 dst->o_nlink = src->i_nlink;
-        if ( dst->o_valid & OBD_MD_FLGENER ) 
+        if (valid & OBD_MD_FLGENER)
                 dst->o_generation = src->i_generation;
-        if ( dst->o_valid & OBD_MD_FLRDEV ) 
+        if (valid & OBD_MD_FLRDEV)
                 dst->o_rdev = src->i_rdev;
+
+        dst->o_valid |= valid;
 }
 
-static inline void obdo_to_inode(struct inode *dst, struct obdo *src)
+static inline void obdo_to_inode(struct inode *dst, struct obdo *src,
+                                 obd_flag valid)
 {
 
-        if ( src->o_valid & OBD_MD_FLID )
+        if (valid & OBD_MD_FLID)
                 dst->i_ino = src->o_id;
-        if ( src->o_valid & OBD_MD_FLATIME ) 
+        if (valid & OBD_MD_FLATIME)
                 dst->i_atime = src->o_atime;
-        if ( src->o_valid & OBD_MD_FLMTIME ) 
+        if (valid & OBD_MD_FLMTIME)
                 dst->i_mtime = src->o_mtime;
-        if ( src->o_valid & OBD_MD_FLCTIME ) 
+        if (valid & OBD_MD_FLCTIME)
                 dst->i_ctime = src->o_ctime;
-        if ( src->o_valid & OBD_MD_FLSIZE ) 
+        if (valid & OBD_MD_FLSIZE)
                 dst->i_size = src->o_size;
-        if ( src->o_valid & OBD_MD_FLBLOCKS ) /* allocation of space */
+        if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
                 dst->i_blocks = src->o_blocks;
-        if ( src->o_valid & OBD_MD_FLBLKSZ )
+        if (valid & OBD_MD_FLBLKSZ)
                 dst->i_blksize = src->o_blksize;
-        if ( src->o_valid & OBD_MD_FLMODE ) 
+        if (valid & OBD_MD_FLMODE)
                 dst->i_mode = src->o_mode;
-        if ( src->o_valid & OBD_MD_FLUID ) 
+        if (valid & OBD_MD_FLUID)
                 dst->i_uid = src->o_uid;
-        if ( src->o_valid & OBD_MD_FLGID ) 
+        if (valid & OBD_MD_FLGID)
                 dst->i_gid = src->o_gid;
-        if ( src->o_valid & OBD_MD_FLFLAGS ) 
+        if (valid & OBD_MD_FLFLAGS)
                 dst->i_flags = src->o_flags;
-        if ( src->o_valid & OBD_MD_FLNLINK )
+        if (valid & OBD_MD_FLNLINK)
                 dst->i_nlink = src->o_nlink;
-        if ( src->o_valid & OBD_MD_FLGENER )
+        if (valid & OBD_MD_FLGENER)
                 dst->i_generation = src->o_generation;
-        if ( src->o_valid & OBD_MD_FLRDEV )
+        if (valid & OBD_MD_FLRDEV)
                 dst->i_rdev = src->o_rdev;
 }
+#endif
 
-#endif 
-
-static inline void obdo_cpy_md(struct obdo *dst, struct obdo *src)
+static inline void obdo_cpy_md(struct obdo *dst, struct obdo *src,
+                               obd_flag valid)
 {
 #ifdef __KERNEL__
         CDEBUG(D_INODE, "src obdo %Ld valid 0x%x, dst obdo %Ld\n",
                (unsigned long long)src->o_id, src->o_valid,
                (unsigned long long)dst->o_id);
 #endif
-        if ( src->o_valid & OBD_MD_FLATIME ) 
+        if (valid & OBD_MD_FLATIME)
                 dst->o_atime = src->o_atime;
-        if ( src->o_valid & OBD_MD_FLMTIME ) 
+        if (valid & OBD_MD_FLMTIME)
                 dst->o_mtime = src->o_mtime;
-        if ( src->o_valid & OBD_MD_FLCTIME ) 
+        if (valid & OBD_MD_FLCTIME)
                 dst->o_ctime = src->o_ctime;
-        if ( src->o_valid & OBD_MD_FLSIZE ) 
+        if (valid & OBD_MD_FLSIZE)
                 dst->o_size = src->o_size;
-        if ( src->o_valid & OBD_MD_FLBLOCKS ) /* allocation of space */
+        if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
                 dst->o_blocks = src->o_blocks;
-        if ( src->o_valid & OBD_MD_FLBLKSZ )
+        if (valid & OBD_MD_FLBLKSZ)
                 dst->o_blksize = src->o_blksize;
-        if ( src->o_valid & OBD_MD_FLMODE ) 
+        if (valid & OBD_MD_FLMODE)
                 dst->o_mode = src->o_mode;
-        if ( src->o_valid & OBD_MD_FLUID ) 
+        if (valid & OBD_MD_FLUID)
                 dst->o_uid = src->o_uid;
-        if ( src->o_valid & OBD_MD_FLGID ) 
+        if (valid & OBD_MD_FLGID)
                 dst->o_gid = src->o_gid;
-        if ( src->o_valid & OBD_MD_FLFLAGS ) 
+        if (valid & OBD_MD_FLFLAGS)
                 dst->o_flags = src->o_flags;
         /*
-        if ( src->o_valid & OBD_MD_FLOBDFLG ) 
+        if (valid & OBD_MD_FLOBDFLG)
                 dst->o_obdflags = src->o_obdflags;
         */
-        if ( src->o_valid & OBD_MD_FLNLINK ) 
+        if (valid & OBD_MD_FLNLINK)
                 dst->o_nlink = src->o_nlink;
-        if ( src->o_valid & OBD_MD_FLGENER ) 
+        if (valid & OBD_MD_FLGENER)
                 dst->o_generation = src->o_generation;
-        if ( src->o_valid & OBD_MD_FLRDEV ) 
+        if (valid & OBD_MD_FLRDEV)
                 dst->o_rdev = src->o_rdev;
-        if ( src->o_valid & OBD_MD_FLINLINE &&
+        if (valid & OBD_MD_FLINLINE &&
              src->o_obdflags & OBD_FL_INLINEDATA) {
                 memcpy(dst->o_inline, src->o_inline, sizeof(src->o_inline));
                 dst->o_obdflags |= OBD_FL_INLINEDATA;
         }
 
-        dst->o_valid |= src->o_valid;
+        dst->o_valid |= valid;
 }
 
 

diff --git a/lustre/llite/super.c b/lustre/llite/super.c
index e078624..247d073 100644 (file)
--- a/lustre/llite/super.c
+++ b/lustre/llite/super.c
@@ -405,8 +405,7 @@ inline int ll_stripe_mds_md_size(struct super_block *sb)
         return mdc->cl_max_mdsize;
 }
 
-static int ll_file_size(struct inode *inode, struct lov_stripe_md *md,
-                        __u64 *size)
+static int ll_file_size(struct inode *inode, struct lov_stripe_md *md)
 {
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         struct lustre_handle *lockhs;
@@ -423,10 +422,12 @@ static int ll_file_size(struct inode *inode, struct lov_stripe_md *md,
          * like lov_getattr? --phil */
         oa.o_id = md->lmd_object_id;
         oa.o_mode = S_IFREG;
-        oa.o_valid = OBD_MD_FLID | OBD_MD_FLMODE | OBD_MD_FLSIZE;
+        oa.o_valid = OBD_MD_FLID|OBD_MD_FLMODE|OBD_MD_FLSIZE|OBD_MD_FLBLOCKS;
         rc = obd_getattr(&sbi->ll_osc_conn, &oa, md);
-        if (!rc)
-                *size = oa.o_size;
+        if (!rc) {
+                inode->i_size = oa.o_size;
+                inode->i_blocks = oa.o_blocks;
+        }
 
         err = ll_size_unlock(inode, md, LCK_PR, lockhs);
         if (err != ELDLM_OK) {
@@ -497,7 +498,7 @@ static void ll_read_inode2(struct inode *inode, void *opaque)
         if (lli->lli_smd && (inode->i_mode & S_IFREG)) {
                 int rc;
 
-                rc = ll_file_size(inode, lli->lli_smd, &inode->i_size);
+                rc = ll_file_size(inode, lli->lli_smd);
                 if (rc) {
                         CERROR("ll_file_size: %d\n", rc);
                         /* FIXME: need to somehow prevent inode creation */

diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c
index 310f4de..17ec57b 100644 (file)
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -481,14 +481,16 @@ static int filter_cleanup(struct obd_device * obddev)
 }
 
 
-static inline void filter_from_inode(struct obdo *oa, struct inode *inode)
+static inline void filter_from_inode(struct obdo *oa, struct inode *inode,
+                                     int valid)
 {
         int type = oa->o_mode & S_IFMT;
         ENTRY;
 
-        CDEBUG(D_INFO, "src inode %ld, dst obdo %ld valid 0x%08x\n",
-               inode->i_ino, (long)oa->o_id, oa->o_valid);
-        obdo_from_inode(oa, inode);
+        CDEBUG(D_INFO, "src inode %ld (%p), dst obdo %ld valid 0x%08x\n",
+               inode->i_ino, inode, (long)oa->o_id, valid);
+        /* Don't copy the inode number in place of the object ID */
+        obdo_from_inode(oa, inode, valid);
         oa->o_mode &= ~S_IFMT;
         oa->o_mode |= type;
 
@@ -519,14 +521,13 @@ static int filter_getattr(struct lustre_handle *conn, struct obdo *oa,
         if (IS_ERR(dentry))
                 RETURN(PTR_ERR(dentry));
 
-        oa->o_valid &= ~OBD_MD_FLID;
-        filter_from_inode(oa, dentry->d_inode);
+        filter_from_inode(oa, dentry->d_inode, oa->o_valid & ~OBD_MD_FLID);
 
         dput(dentry);
         RETURN(0);
 }
 
-static int filter_setattr(struct lustre_handle *conn, struct obdo *oa, 
+static int filter_setattr(struct lustre_handle *conn, struct obdo *oa,
                           struct lov_stripe_md *md)
 {
         struct obd_run_ctxt saved;
@@ -537,7 +538,7 @@ static int filter_setattr(struct lustre_handle *conn, struct obdo *oa,
         int rc;
         ENTRY;
 
-        iattr_from_obdo(&iattr, oa);
+        iattr_from_obdo(&iattr, oa, oa->o_valid);
         iattr.ia_mode = (iattr.ia_mode & ~S_IFMT) | S_IFREG;
         dentry = filter_fid2dentry(obd, filter_parent(obd, iattr.ia_mode),
                                    oa->o_id, iattr.ia_mode);
@@ -557,7 +558,7 @@ static int filter_setattr(struct lustre_handle *conn, struct obdo *oa,
         if (iattr.ia_mode & ATTR_SIZE) {
                 up(&inode->i_sem);
                 oa->o_valid = OBD_MD_FLBLOCKS | OBD_MD_FLCTIME | OBD_MD_FLMTIME;
-                obdo_from_inode(oa, inode);
+                obdo_from_inode(oa, inode, oa->o_valid);
         }
         unlock_kernel();
 
@@ -582,15 +583,16 @@ static int filter_open(struct lustre_handle *conn, struct obdo *oa,
         obd = class_conn2obd(conn);
         dentry = filter_fid2dentry(obd, filter_parent(obd, oa->o_mode),
                                    oa->o_id, oa->o_mode);
-        oa->o_size = dentry->d_inode->i_size;
         if (IS_ERR(dentry))
                 RETURN(PTR_ERR(dentry));
 
+        oa->o_size = dentry->d_inode->i_size;
+
         return 0;
 } /* filter_open */
 
 static int filter_close(struct lustre_handle *conn, struct obdo *oa,
-                          struct lov_stripe_md *ea)
+                        struct lov_stripe_md *ea)
 {
         struct obd_device *obd;
         struct dentry *dentry;
@@ -632,12 +634,13 @@ static int filter_create(struct lustre_handle* conn, struct obdo *oa,
                 return -EINVAL;
         }
 
-        oa->o_id = filter_next_id(obd);
         if (!(oa->o_mode && S_IFMT)) {
                 CERROR("filter obd: no type!\n");
                 return -ENOENT;
         }
 
+        oa->o_id = filter_next_id(obd);
+
         filter_id(name, oa->o_id, oa->o_mode);
         mode = (oa->o_mode & ~S_IFMT) | S_IFREG;
         push_ctxt(&saved, &obd->u.filter.fo_ctxt);
@@ -1229,10 +1232,6 @@ static int filter_write_locked_page(struct niobuf_local *lnb)
                 GOTO(out, rc);
         }
 
-        /* debugging: just seeing that this works correctly */
-        CERROR("copying data from %p (%ld) to %p (ino %ld:%ld)\n", lnb->addr,
-               lnb->page->index, page_address(lpage),
-               lnb->dentry->d_inode->i_ino, lpage->index);
         /* lpage is kmapped in lustre_get_page_write() above and kunmapped in
          * lustre_commit_write() below, lnb->page was kmapped previously in
          * filter_get_page_write() and kunmapped in lustre_put_page() below.
@@ -1277,9 +1276,6 @@ static int filter_commitrw(int cmd, struct lustre_handle *conn,
                                 LBUG();
 
                         if (r->flags & N_LOCAL_TEMP_PAGE) {
-                                /* debugging: just seeing if this happens */
-                                CERROR("found a locked page (index %ld)\n",
-                                       page->index);
                                 found_locked++;
                                 continue;
                         }
@@ -1293,11 +1289,6 @@ static int filter_commitrw(int cmd, struct lustre_handle *conn,
                         } else
                                 lustre_put_page(page);
 
-                        CDEBUG(D_INODE,
-                               "put inode %p (%ld), count = %d, nlink = %d\n",
-                               r->dentry->d_inode, r->dentry->d_inode->i_ino,
-                               atomic_read(&r->dentry->d_inode->i_count) - 1,
-                               r->dentry->d_inode->i_nlink);
                         dput(r->dentry);
                 }
         }
@@ -1316,11 +1307,6 @@ static int filter_commitrw(int cmd, struct lustre_handle *conn,
                         err = filter_write_locked_page(r);
                         if (!rc)
                                 rc = err;
-                        CDEBUG(D_INODE,
-                               "put inode %p (%ld), count = %d, nlink = %d\n",
-                               r->dentry->d_inode, r->dentry->d_inode->i_ino,
-                               atomic_read(&r->dentry->d_inode->i_count) - 1,
-                               r->dentry->d_inode->i_nlink);
                         dput(r->dentry);
                 }
         }