1 files changed, 59 insertions, 20 deletions

diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index 4fdda974dc83..f916b9740c75 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -95,8 +95,8 @@ int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)
 {
         unsigned int x;
 
-        if (sb->sb_header.mh_magic != GFS2_MAGIC ||
-            sb->sb_header.mh_type != GFS2_METATYPE_SB) {
+        if (sb->sb_magic != GFS2_MAGIC ||
+            sb->sb_type != GFS2_METATYPE_SB) {
                 if (!silent)
                         printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
                 return -EINVAL;
@@ -174,10 +174,31 @@ static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
         return 0;
 }
 
+static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
+{
+        const struct gfs2_sb *str = buf;
+
+        sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
+        sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
+        sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
+        sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
+        sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
+        sb->sb_bsize = be32_to_cpu(str->sb_bsize);
+        sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
+        sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
+        sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
+        sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
+        sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
+
+        memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
+        memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
+}
+
 /**
  * gfs2_read_super - Read the gfs2 super block from disk
- * @sb: The VFS super block
+ * @sdp: The GFS2 super block
  * @sector: The location of the super block
+ * @error: The error code to return
  *
  * This uses the bio functions to read the super block from disk
  * because we want to be 100% sure that we never read cached data.
@@ -189,17 +210,19 @@ static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
  * the master directory (contains pointers to journals etc) and the
  * root directory.
  *
- * Returns: A page containing the sb or NULL
+ * Returns: 0 on success or error
  */
 
-struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
+int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)
 {
+        struct super_block *sb = sdp->sd_vfs;
+        struct gfs2_sb *p;
         struct page *page;
         struct bio *bio;
 
         page = alloc_page(GFP_KERNEL);
         if (unlikely(!page))
-                return NULL;
+                return -ENOBUFS;
 
         ClearPageUptodate(page);
         ClearPageDirty(page);
@@ -208,7 +231,7 @@ struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
         bio = bio_alloc(GFP_KERNEL, 1);
         if (unlikely(!bio)) {
                 __free_page(page);
-                return NULL;
+                return -ENOBUFS;
         }
 
         bio->bi_sector = sector * (sb->s_blocksize >> 9);
@@ -222,9 +245,13 @@ struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
         bio_put(bio);
         if (!PageUptodate(page)) {
                 __free_page(page);
-                return NULL;
+                return -EIO;
         }
-        return page;
+        p = kmap(page);
+        gfs2_sb_in(&sdp->sd_sb, p);
+        kunmap(page);
+        __free_page(page);
+        return 0;
 }
 
 /**
@@ -241,19 +268,13 @@ int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
         u32 tmp_blocks;
         unsigned int x;
         int error;
-        struct page *page;
-        char *sb;
 
-        page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
-        if (!page) {
+        error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
+        if (error) {
                 if (!silent)
                         fs_err(sdp, "can't read superblock\n");
-                return -EIO;
+                return error;
         }
-        sb = kmap(page);
-        gfs2_sb_in(&sdp->sd_sb, sb);
-        kunmap(page);
-        __free_page(page);
 
         error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
         if (error)
@@ -360,7 +381,7 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
                 name.len = sprintf(buf, "journal%u", sdp->sd_journals);
                 name.hash = gfs2_disk_hash(name.name, name.len);
 
-                error = gfs2_dir_search(sdp->sd_jindex, &name, NULL, NULL);
+                error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
                 if (error == -ENOENT) {
                         error = 0;
                         break;
@@ -593,6 +614,24 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
         return error;
 }
 
+static void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
+{
+        const struct gfs2_statfs_change *str = buf;
+
+        sc->sc_total = be64_to_cpu(str->sc_total);
+        sc->sc_free = be64_to_cpu(str->sc_free);
+        sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
+}
+
+static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
+{
+        struct gfs2_statfs_change *str = buf;
+
+        str->sc_total = cpu_to_be64(sc->sc_total);
+        str->sc_free = cpu_to_be64(sc->sc_free);
+        str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
+}
+
 int gfs2_statfs_init(struct gfs2_sbd *sdp)
 {
         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
@@ -772,7 +811,7 @@ static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
                             struct gfs2_statfs_change_host *sc)
 {
         gfs2_rgrp_verify(rgd);
-        sc->sc_total += rgd->rd_ri.ri_data;
+        sc->sc_total += rgd->rd_data;
         sc->sc_free += rgd->rd_rg.rg_free;
         sc->sc_dinodes += rgd->rd_rg.rg_dinodes;
         return 0;