*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License v.2.
+ * of the GNU General Public License version 2.
*/
#include <linux/sched.h>
#include <linux/buffer_head.h>
#include <linux/crc32.h>
#include <linux/gfs2_ondisk.h>
+#include <linux/bio.h>
+#include <linux/lm_interface.h>
#include "gfs2.h"
-#include "lm_interface.h"
#include "incore.h"
#include "bmap.h"
#include "dir.h"
-#include "format.h"
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "trans.h"
#include "util.h"
+static const u32 gfs2_old_fs_formats[] = {
+ 0
+};
+
+static const u32 gfs2_old_multihost_formats[] = {
+ 0
+};
+
/**
* gfs2_tune_init - Fill a gfs2_tune structure with default values
* @gt: tune
return 0;
}
+
+static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
+{
+ struct page *page = bio->bi_private;
+ if (bio->bi_size)
+ return 1;
+
+ if (!error)
+ SetPageUptodate(page);
+ else
+ printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);
+ unlock_page(page);
+ return 0;
+}
+
+struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
+{
+ struct page *page;
+ struct bio *bio;
+
+ page = alloc_page(GFP_KERNEL);
+ if (unlikely(!page))
+ return NULL;
+
+ ClearPageUptodate(page);
+ ClearPageDirty(page);
+ lock_page(page);
+
+ bio = bio_alloc(GFP_KERNEL, 1);
+ if (unlikely(!bio)) {
+ __free_page(page);
+ return NULL;
+ }
+
+ bio->bi_sector = sector;
+ bio->bi_bdev = sb->s_bdev;
+ bio_add_page(bio, page, PAGE_SIZE, 0);
+
+ bio->bi_end_io = end_bio_io_page;
+ bio->bi_private = page;
+ submit_bio(READ_SYNC | (1 << BIO_RW_META), bio);
+ wait_on_page_locked(page);
+ bio_put(bio);
+ if (!PageUptodate(page)) {
+ __free_page(page);
+ return NULL;
+ }
+ return page;
+}
+
/**
* gfs2_read_sb - Read super block
* @sdp: The GFS2 superblock
int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
{
- struct buffer_head *bh;
- uint32_t hash_blocks, ind_blocks, leaf_blocks;
- uint32_t tmp_blocks;
+ u32 hash_blocks, ind_blocks, leaf_blocks;
+ u32 tmp_blocks;
unsigned int x;
int error;
+ struct page *page;
+ char *sb;
- error = gfs2_meta_read(gl, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift,
- DIO_FORCE | DIO_START | DIO_WAIT, &bh);
- if (error) {
+ page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
+ if (!page) {
if (!silent)
fs_err(sdp, "can't read superblock\n");
- return error;
+ return -EIO;
}
-
- gfs2_assert(sdp, sizeof(struct gfs2_sb) <= bh->b_size);
- gfs2_sb_in(&sdp->sd_sb, bh->b_data);
- brelse(bh);
+ 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)
GFS2_BASIC_BLOCK_SHIFT;
sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
- sizeof(struct gfs2_dinode)) / sizeof(uint64_t);
+ sizeof(struct gfs2_dinode)) / sizeof(u64);
sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
- sizeof(struct gfs2_meta_header)) / sizeof(uint64_t);
+ sizeof(struct gfs2_meta_header)) / sizeof(u64);
sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
- sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(uint64_t);
+ sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
sizeof(struct gfs2_meta_header)) /
- sizeof(struct gfs2_quota_change);
+ sizeof(struct gfs2_quota_change);
/* Compute maximum reservation required to add a entry to a directory */
- hash_blocks = DIV_ROUND_UP(sizeof(uint64_t) * (1 << GFS2_DIR_MAX_DEPTH),
+ hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
sdp->sd_jbsize);
ind_blocks = 0;
sizeof(struct gfs2_dinode);
sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
for (x = 2;; x++) {
- uint64_t space, d;
- uint32_t m;
+ u64 space, d;
+ u32 m;
space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
d = space;
sizeof(struct gfs2_dinode);
sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
for (x = 2;; x++) {
- uint64_t space, d;
- uint32_t m;
+ u64 space, d;
+ u32 m;
space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
d = space;
error = gfs2_quota_init(sdp);
if (error)
- goto fail_unlinked;
+ goto fail;
set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
return 0;
- fail_unlinked:
-
- fail:
+fail:
t_gh.gh_flags |= GL_NOCACHE;
gfs2_glock_dq_uninit(&t_gh);
brelse(l_bh);
}
- out_m_bh:
+out_m_bh:
brelse(m_bh);
-
- out:
+out:
gfs2_glock_dq_uninit(&gh);
-
return 0;
}
-void gfs2_statfs_change(struct gfs2_sbd *sdp, int64_t total, int64_t free,
- int64_t dinodes)
+void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
+ s64 dinodes)
{
struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
l_sc->sc_total += total;
l_sc->sc_free += free;
l_sc->sc_dinodes += dinodes;
- gfs2_statfs_change_out(l_sc, l_bh->b_data +
- sizeof(struct gfs2_dinode));
+ gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
spin_unlock(&sdp->sd_statfs_spin);
brelse(l_bh);
spin_lock(&sdp->sd_statfs_spin);
gfs2_statfs_change_in(m_sc, m_bh->b_data +
- sizeof(struct gfs2_dinode));
+ sizeof(struct gfs2_dinode));
if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
spin_unlock(&sdp->sd_statfs_spin);
goto out_bh;
gfs2_trans_end(sdp);
- out_bh2:
+out_bh2:
brelse(l_bh);
-
- out_bh:
+out_bh:
brelse(m_bh);
-
- out:
+out:
gfs2_glock_dq_uninit(&gh);
-
return error;
}
gfs2_glock_dq_uninit(&ri_gh);
- out:
+out:
kfree(gha);
-
return error;
}
if (error)
gfs2_glock_dq_uninit(t_gh);
- out:
+out:
while (!list_empty(&list)) {
lfcc = list_entry(list.next, struct lfcc, list);
list_del(&lfcc->list);
kfree(lfcc);
}
gfs2_glock_dq_uninit(&ji_gh);
-
return error;
}