include/linux/obdfs.h: handle block special devices,

    remove check for dirty inode (explicitly only copy valid data to inode)

diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h
index 84c5b11..2be72f9 100644 (file)
--- a/lustre/include/linux/obd_support.h
+++ b/lustre/include/linux/obd_support.h
@@ -44,69 +44,68 @@ extern long obd_memory;
                printk(format, ## a); }                                 \
        } while (0)
 
-#define ENTRY if (obd_print_entry) \
+#define ENTRY if (obd_print_entry)                                     \
        printk(KERN_INFO "Process %d entered %s\n", current->pid, __FUNCTION__)
 
-#define EXIT if (obd_print_entry) \
-       printk(KERN_INFO "Process %d leaving %s [%d]\n", current->pid,\
+#define EXIT if (obd_print_entry)                                      \
+       printk(KERN_INFO "Process %d leaving %s [%d]\n", current->pid,  \
               __FUNCTION__, __LINE__)
 
 /* Inode common information printed out (used by obdfs and ext2obd inodes) */
-#define ICDEBUG(inode) { \
-       CDEBUG(D_INFO, "]]%s line %d[[ ino %ld, atm %ld, mtm %ld, ctm %ld, "\
-              "size %Ld, blocks %ld\n", __FUNCTION__ , __LINE__,\
+#define ICDEBUG(inode) {                                               \
+       CDEBUG(D_INFO,                                                  \
+              "ino %ld, atm %ld, mtm %ld, ctm %ld, size %Ld, blocks %ld\n",\
               inode->i_ino, inode->i_atime, inode->i_mtime, inode->i_ctime,\
-              inode->i_size, inode->i_blocks);\
-       CDEBUG(D_INFO,\
-              "]]%s line %d[[ mode %o, uid %d, gid %d, nlnk %d, count %d\n",\
-              __FUNCTION__, __LINE__, inode->i_mode, inode->i_uid,\
-              inode->i_gid, inode->i_nlink, inode->i_count);\
+              inode->i_size, inode->i_blocks);                         \
+       CDEBUG(D_INFO, "mode %o, uid %d, gid %d, nlnk %d, count %d\n",  \
+              inode->i_mode, inode->i_uid, inode->i_gid, inode->i_nlink,\
+              inode->i_count);                                         \
 }
 
 /* Ext2 inode information */
-#define EXDEBUG(inode) { \
-       ICDEBUG(inode);\
-       CDEBUG(D_INFO, "ext2 blocks: %d %d %d %d %d %d %d %d\n",\
-              inode->u.ext2_i.i_data[0], inode->u.ext2_i.i_data[1],\
-              inode->u.ext2_i.i_data[2], inode->u.ext2_i.i_data[3],\
-              inode->u.ext2_i.i_data[4], inode->u.ext2_i.i_data[5],\
-              inode->u.ext2_i.i_data[6], inode->u.ext2_i.i_data[7]);\
+#define EXDEBUG(inode) {                                               \
+       ICDEBUG(inode);                                                 \
+       CDEBUG(D_INFO, "ext2 blocks: %d %d %d %d %d %d %d %d\n",        \
+              inode->u.ext2_i.i_data[0], inode->u.ext2_i.i_data[1],    \
+              inode->u.ext2_i.i_data[2], inode->u.ext2_i.i_data[3],    \
+              inode->u.ext2_i.i_data[4], inode->u.ext2_i.i_data[5],    \
+              inode->u.ext2_i.i_data[6], inode->u.ext2_i.i_data[7]);   \
 }
 
 /* OBDFS inode information */
-#define OIDEBUG(inode) { \
-       ICDEBUG(inode);\
+#define OIDEBUG(inode) {                                               \
+       ICDEBUG(inode);                                                 \
        CDEBUG(D_INFO,"oinfo: flags 0x%08x\n", obdfs_i2info(inode)->oi_flags);\
-       /* obdfs_print_plist(inode); */\
+       /* obdfs_print_plist(inode); */                                 \
 }
 
-#define ODEBUG(obdo) { \
-       CDEBUG(D_INFO, "]]%s line %d[[  id %ld, atm %ld, mtm %ld, ctm %ld, "\
-              "size %ld, blocks %ld\n", __FUNCTION__ , __LINE__,\
-              (long)(obdo)->o_id, (long)(obdo)->o_atime,\
-              (long)(obdo)->o_mtime, (long)(obdo)->o_ctime,\
-              (long)(obdo)->o_size, (long)(obdo)->o_blocks);\
-       CDEBUG(D_INFO, "]]%s line %d[[  mode %o, uid %d, gid %d, flg 0x%0x, "\
-              "obdflg 0x%0x, nlnk %d, valid 0x%0x\n", __FUNCTION__ , __LINE__,\
+#define ODEBUG(obdo) {                                                 \
+       CDEBUG(D_INFO, "id %ld, atm %ld, mtm %ld, ctm %ld, "            \
+              "size %ld, blocks %ld\n",                                \
+              (long)(obdo)->o_id, (long)(obdo)->o_atime,               \
+              (long)(obdo)->o_mtime, (long)(obdo)->o_ctime,            \
+              (long)(obdo)->o_size, (long)(obdo)->o_blocks);           \
+       CDEBUG(D_INFO, " mode %o, uid %d, gid %d, flg 0x%0x, "          \
+              "obdflg 0x%0x, nlnk %d, valid 0x%0x\n",                  \
               (obdo)->o_mode, (obdo)->o_uid, (obdo)->o_gid, (obdo)->o_flags,\
-              (obdo)->o_obdflags, (obdo)->o_nlink, (obdo)->o_valid);\
+              (obdo)->o_obdflags, (obdo)->o_nlink, (obdo)->o_valid);   \
 }
 
 
-#define PDEBUG(page,msg) { \
-       if (page){\
+#define PDEBUG(page,msg) {                                             \
+       if (page){                                                      \
                char *uptodate = (Page_Uptodate(page)) ? "upto" : "outof";\
-               char *locked = (PageLocked(page)) ? "" : "un";\
-               char *buffer = page->buffers ? "buffer" : "";\
-               int count = page_count(page);\
-               long index = page->index;\
+               char *locked = (PageLocked(page)) ? "" : "un";          \
+               char *buffer = page->buffers ? "buffer" : "";           \
+               int count = page_count(page);                           \
+               long index = page->index;                               \
                CDEBUG(D_CACHE, "%s: ** off %ld, %sdate, %slocked, flag %ld,"\
-                      " cnt %d page 0x%p pages %ld virt %lx %s**\n",\
+                      " cnt %d page 0x%p pages %ld virt %lx %s**\n",   \
                       msg, index, uptodate, locked, page->flags, count,\
                       page, page->mapping ? page->mapping->nrpages : -1,\
-                      page->virtual, buffer);\
-       } else \
-               CDEBUG(D_CACHE, "** %s: no page\n", msg);\
+                      page->virtual, buffer);                          \
+       } else                                                          \
+               CDEBUG(D_CACHE, "** %s: no page\n", msg);               \
 }
 
 #if 0

diff --git a/lustre/include/linux/obdfs.h b/lustre/include/linux/obdfs.h
index 2359995..3787608 100644 (file)
--- a/lustre/include/linux/obdfs.h
+++ b/lustre/include/linux/obdfs.h
@@ -94,6 +94,7 @@ void obdfs_truncate(struct inode *inode);
 
 /* super.c */
 extern long obdfs_cache_count;
+extern long obdfs_mutex_start;
 
 /* symlink.c */
 extern struct inode_operations obdfs_fast_symlink_inode_operations;
@@ -135,14 +136,21 @@ static inline struct list_head *obdfs_slist(struct inode *inode)
        return &sbi->osi_inodes;
 }
 
-#define obd_down(mutex) {\
-       /* CDEBUG(D_INFO, "get lock\n"); */ \
-       down(mutex);\
+#define obd_down(mutex) {                                              \
+       /* CDEBUG(D_INFO, "get lock\n"); */                             \
+       obdfs_mutex_start = jiffies;                                    \
+       down(mutex);                                                    \
+       if (jiffies - obdfs_mutex_start)                                \
+               CDEBUG(D_CACHE, "waited on mutex %ld jiffies\n",        \
+                      jiffies - obdfs_mutex_start);                    \
 }
 
-#define obd_up(mutex) {\
-       up(mutex);\
-       /* CDEBUG(D_INFO, "free lock\n"); */ \
+#define obd_up(mutex) {                                                        \
+       up(mutex);                                                      \
+       if (jiffies - obdfs_mutex_start > 1)                            \
+               CDEBUG(D_CACHE, "held mutex for %ld jiffies\n",         \
+                      jiffies - obdfs_mutex_start);                    \
+       /* CDEBUG(D_INFO, "free lock\n"); */                            \
 }
 
 /* We track if a page has been added to the OBD page cache by stting a
@@ -189,7 +197,7 @@ static void inline obdfs_from_inode(struct obdo *oa, struct inode *inode)
               inode->i_ino, (long)oa->o_id, oa->o_valid);
        obdo_from_inode(oa, inode);
        if (obdfs_has_inline(inode)) {
-               CDEBUG(D_INFO, "copying inline data from inode to obdo\n");
+               CDEBUG(D_INODE, "copying inline data from inode to obdo\n");
                memcpy(oa->o_inline, oinfo->oi_inline, OBD_INLINESZ);
                oa->o_obdflags |= OBD_FL_INLINEDATA;
                oa->o_valid |= OBD_MD_FLINLINE;
@@ -202,20 +210,11 @@ static void inline obdfs_to_inode(struct inode *inode, struct obdo *oa)
 
        CDEBUG(D_INFO, "src obdo %ld valid 0x%08x, dst inode %ld\n",
               (long)oa->o_id, oa->o_valid, inode->i_ino);
-       /* If the inode is dirty, we won't overwrite the data there, as it
-        * is newer than the data on the disk.  The ext2obd side only will
-        * change the block count, so we are guaranteed that is safe.
-        */
-       if (inode->i_state & I_DIRTY) {
-               CDEBUG(D_INODE, "dirty inode %ld, only copying blocks\n",
-                      inode->i_ino);
-               oa->o_valid = OBD_MD_FLBLOCKS;
-       }
 
        obdo_to_inode(inode, oa);
 
        if (obdo_has_inline(oa)) {
-               CDEBUG(D_INFO, "copying inline data from obdo to inode\n");
+               CDEBUG(D_INODE, "copying inline data from obdo to inode\n");
                memcpy(oinfo->oi_inline, oa->o_inline, OBD_INLINESZ);
                oinfo->oi_flags |= OBD_FL_INLINEDATA;
        }