ocfs2: Pass struct ocfs2_caching_info to the journal functions.

The next step in divorcing metadata I/O management from struct inode is
to pass struct ocfs2_caching_info to the journal functions.  Thus the
journal locks a metadata cache with the cache io_lock function.  It also
can compare ci_last_trans and ci_created_trans directly.

This is a large patch because of all the places we change
ocfs2_journal_access..(handle, inode, ...) to
ocfs2_journal_access..(handle, INODE_CACHE(inode), ...).

Signed-off-by: Joel Becker <joel.becker@oracle.com>

1 files changed, 42 insertions, 33 deletions

diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 0bb6754c73f4..6163f28badda 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -90,57 +90,66 @@ static inline unsigned long ocfs2_inc_trans_id(struct ocfs2_journal *j)
         return old_id;
 }
 
-static inline void ocfs2_set_inode_lock_trans(struct ocfs2_journal *journal,
-                                              struct inode *inode)
+static inline void ocfs2_set_ci_lock_trans(struct ocfs2_journal *journal,
+                                           struct ocfs2_caching_info *ci)
 {
         spin_lock(&trans_inc_lock);
-        INODE_CACHE(inode)->ci_last_trans = journal->j_trans_id;
+        ci->ci_last_trans = journal->j_trans_id;
         spin_unlock(&trans_inc_lock);
 }
 
 /* Used to figure out whether it's safe to drop a metadata lock on an
- * inode. Returns true if all the inodes changes have been
+ * cached object. Returns true if all the object's changes have been
  * checkpointed to disk. You should be holding the spinlock on the
  * metadata lock while calling this to be sure that nobody can take
  * the lock and put it on another transaction. */
-static inline int ocfs2_inode_fully_checkpointed(struct inode *inode)
+static inline int ocfs2_ci_fully_checkpointed(struct ocfs2_caching_info *ci)
 {
         int ret;
-        struct ocfs2_journal *journal = OCFS2_SB(inode->i_sb)->journal;
+        struct ocfs2_journal *journal =
+                OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;
 
         spin_lock(&trans_inc_lock);
-        ret = time_after(journal->j_trans_id,
-                         INODE_CACHE(inode)->ci_last_trans);
+        ret = time_after(journal->j_trans_id, ci->ci_last_trans);
         spin_unlock(&trans_inc_lock);
         return ret;
 }
 
-/* convenience function to check if an inode is still new (has never
- * hit disk) Will do you a favor and set created_trans = 0 when you've
- * been checkpointed.  returns '1' if the inode is still new. */
-static inline int ocfs2_inode_is_new(struct inode *inode)
+/* convenience function to check if an object backed by struct
+ * ocfs2_caching_info  is still new (has never hit disk) Will do you a
+ * favor and set created_trans = 0 when you've
+ * been checkpointed.  returns '1' if the ci is still new. */
+static inline int ocfs2_ci_is_new(struct ocfs2_caching_info *ci)
 {
         int ret;
+        struct ocfs2_journal *journal =
+                OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;
+
+        spin_lock(&trans_inc_lock);
+        ret = !(time_after(journal->j_trans_id, ci->ci_created_trans));
+        if (!ret)
+                ci->ci_created_trans = 0;
+        spin_unlock(&trans_inc_lock);
+        return ret;
+}
 
+/* Wrapper for inodes so we can check system files */
+static inline int ocfs2_inode_is_new(struct inode *inode)
+{
         /* System files are never "new" as they're written out by
          * mkfs. This helps us early during mount, before we have the
          * journal open and j_trans_id could be junk. */
         if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
                 return 0;
-        spin_lock(&trans_inc_lock);
-        ret = !(time_after(OCFS2_SB(inode->i_sb)->journal->j_trans_id,
-                           INODE_CACHE(inode)->ci_created_trans));
-        if (!ret)
-                INODE_CACHE(inode)->ci_created_trans = 0;
-        spin_unlock(&trans_inc_lock);
-        return ret;
+
+        return ocfs2_ci_is_new(INODE_CACHE(inode));
 }
 
-static inline void ocfs2_inode_set_new(struct ocfs2_super *osb,
-                                       struct inode *inode)
+static inline void ocfs2_ci_set_new(struct ocfs2_super *osb,
+                                    struct ocfs2_caching_info *ci)
 {
         spin_lock(&trans_inc_lock);
-        INODE_CACHE(inode)->ci_created_trans = osb->journal->j_trans_id;
+        ci->ci_created_trans = osb->journal->j_trans_id;
         spin_unlock(&trans_inc_lock);
 }
 
@@ -201,7 +210,7 @@ static inline void ocfs2_checkpoint_inode(struct inode *inode)
         if (ocfs2_mount_local(osb))
                 return;
 
-        if (!ocfs2_inode_fully_checkpointed(inode)) {
+        if (!ocfs2_ci_fully_checkpointed(INODE_CACHE(inode))) {
                 /* WARNING: This only kicks off a single
                  * checkpoint. If someone races you and adds more
                  * metadata to the journal, you won't know, and will
@@ -211,7 +220,7 @@ static inline void ocfs2_checkpoint_inode(struct inode *inode)
                 ocfs2_start_checkpoint(osb);
 
                 wait_event(osb->journal->j_checkpointed,
-                           ocfs2_inode_fully_checkpointed(inode));
+                           ocfs2_ci_fully_checkpointed(INODE_CACHE(inode)));
         }
 }
 
@@ -267,31 +276,31 @@ int			     ocfs2_extend_trans(handle_t *handle, int nblocks);
 
 
 /* ocfs2_inode */
-int ocfs2_journal_access_di(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_di(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* ocfs2_extent_block */
-int ocfs2_journal_access_eb(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_eb(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* ocfs2_group_desc */
-int ocfs2_journal_access_gd(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_gd(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* ocfs2_xattr_block */
-int ocfs2_journal_access_xb(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_xb(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* quota blocks */
-int ocfs2_journal_access_dq(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_dq(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* dirblock */
-int ocfs2_journal_access_db(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_db(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* ocfs2_dx_root_block */
-int ocfs2_journal_access_dr(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_dr(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* ocfs2_dx_leaf */
-int ocfs2_journal_access_dl(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access_dl(handle_t *handle, struct ocfs2_caching_info *ci,
                             struct buffer_head *bh, int type);
 /* Anything that has no ecc */
-int ocfs2_journal_access(handle_t *handle, struct inode *inode,
+int ocfs2_journal_access(handle_t *handle, struct ocfs2_caching_info *ci,
                          struct buffer_head *bh, int type);
 
 /*