gfs2: Recover statfs info in journal head

Apply the outstanding statfs changes in the journal head to the
master statfs file. Zero out the local statfs file for good measure.

Previously, statfs updates would be read in from the local statfs inode and
synced to the master statfs inode during recovery.

We now use the statfs updates in the journal head to update the master statfs
inode instead of reading in from the local statfs inode. To preserve backward
compatibility with kernels that can't do this, we still need to keep the
local statfs inode up to date by writing changes to it. At some point in the
future, we can do away with the local statfs inodes altogether and keep the
statfs changes solely in the journal.

Signed-off-by: Abhi Das <adas@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index ed1da432396736224afa583277ccf9e1d222b6f7..ed69298dd824a23c53cf6a83e7dad64c011ecf3c 100644 (file)
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -823,7 +823,7 @@ static int buf_lo_scan_elements(struct gfs2_jdesc *jd, u32 start,
  *
  */
 
-static void gfs2_meta_sync(struct gfs2_glock *gl)
+void gfs2_meta_sync(struct gfs2_glock *gl)
 {
        struct address_space *mapping = gfs2_glock2aspace(gl);
        struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
index 9c5e4e491e03d871cd60aa17b459c72d226d6a82..4a3d8aecdf82765a22dd655c7e8913ff8a3a289d 100644 (file)
--- a/fs/gfs2/lops.h
+++ b/fs/gfs2/lops.h
@@ -27,6 +27,7 @@ extern void gfs2_log_submit_bio(struct bio **biop, int opf);
 extern void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh);
 extern int gfs2_find_jhead(struct gfs2_jdesc *jd,
                           struct gfs2_log_header_host *head, bool keep_cache);
+extern void gfs2_meta_sync(struct gfs2_glock *gl);
 
 static inline unsigned int buf_limit(struct gfs2_sbd *sdp)
 {

diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index a8bb17e355b853932b32de56e58c5f12b4a66292..b5cbe21efdfb3b5608b1fb35dd8fc5329604c051 100644 (file)
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -296,6 +296,109 @@ static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
                sdp->sd_lockstruct.ls_ops->lm_recovery_result(sdp, jid, message);
 }
 
+/**
+ * update_statfs_inode - Update the master statfs inode or zero out the local
+ *                      statfs inode for a given journal.
+ * @jd: The journal
+ * @head: If NULL, @inode is the local statfs inode and we need to zero it out.
+ *       Otherwise, it @head contains the statfs change info that needs to be
+ *       synced to the master statfs inode (pointed to by @inode).
+ * @inode: statfs inode to update.
+ */
+static int update_statfs_inode(struct gfs2_jdesc *jd,
+                              struct gfs2_log_header_host *head,
+                              struct inode *inode)
+{
+       struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
+       struct gfs2_inode *ip;
+       struct buffer_head *bh;
+       struct gfs2_statfs_change_host sc;
+       int error = 0;
+
+       BUG_ON(!inode);
+       ip = GFS2_I(inode);
+
+       error = gfs2_meta_inode_buffer(ip, &bh);
+       if (error)
+               goto out;
+
+       spin_lock(&sdp->sd_statfs_spin);
+
+       if (head) { /* Update the master statfs inode */
+               gfs2_statfs_change_in(&sc, bh->b_data + sizeof(struct gfs2_dinode));
+               sc.sc_total += head->lh_local_total;
+               sc.sc_free += head->lh_local_free;
+               sc.sc_dinodes += head->lh_local_dinodes;
+               gfs2_statfs_change_out(&sc, bh->b_data + sizeof(struct gfs2_dinode));
+
+               fs_info(sdp, "jid=%u: Updated master statfs Total:%lld, "
+                       "Free:%lld, Dinodes:%lld after change "
+                       "[%+lld,%+lld,%+lld]\n", jd->jd_jid, sc.sc_total,
+                       sc.sc_free, sc.sc_dinodes, head->lh_local_total,
+                       head->lh_local_free, head->lh_local_dinodes);
+       } else { /* Zero out the local statfs inode */
+               memset(bh->b_data + sizeof(struct gfs2_dinode), 0,
+                      sizeof(struct gfs2_statfs_change));
+               /* If it's our own journal, reset any in-memory changes too */
+               if (jd->jd_jid == sdp->sd_lockstruct.ls_jid) {
+                       memset(&sdp->sd_statfs_local, 0,
+                              sizeof(struct gfs2_statfs_change_host));
+               }
+       }
+       spin_unlock(&sdp->sd_statfs_spin);
+
+       mark_buffer_dirty(bh);
+       brelse(bh);
+       gfs2_meta_sync(ip->i_gl);
+
+out:
+       return error;
+}
+
+/**
+ * recover_local_statfs - Update the master and local statfs changes for this
+ *                       journal.
+ *
+ * Previously, statfs updates would be read in from the local statfs inode and
+ * synced to the master statfs inode during recovery.
+ *
+ * We now use the statfs updates in the journal head to update the master statfs
+ * inode instead of reading in from the local statfs inode. To preserve backward
+ * compatibility with kernels that can't do this, we still need to keep the
+ * local statfs inode up to date by writing changes to it. At some point in the
+ * future, we can do away with the local statfs inodes altogether and keep the
+ * statfs changes solely in the journal.
+ *
+ * @jd: the journal
+ * @head: the journal head
+ *
+ * Returns: errno
+ */
+static void recover_local_statfs(struct gfs2_jdesc *jd,
+                                struct gfs2_log_header_host *head)
+{
+       int error;
+       struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
+
+       if (!head->lh_local_total && !head->lh_local_free
+           && !head->lh_local_dinodes) /* No change */
+               goto zero_local;
+
+        /* First update the master statfs inode with the changes we
+         * found in the journal. */
+       error = update_statfs_inode(jd, head, sdp->sd_statfs_inode);
+       if (error)
+               goto out;
+
+zero_local:
+       /* Zero out the local statfs inode so any changes in there
+        * are not re-recovered. */
+       error = update_statfs_inode(jd, NULL,
+                                   find_local_statfs_inode(sdp, jd->jd_jid));
+out:
+       return;
+}
+
 void gfs2_recover_func(struct work_struct *work)
 {
        struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
@@ -415,6 +518,7 @@ void gfs2_recover_func(struct work_struct *work)
                                goto fail_gunlock_thaw;
                }
 
+               recover_local_statfs(jd, &head);
                clean_journal(jd, &head);
                up_read(&sdp->sd_log_flush_lock);