Store blocksize directly in struct fs

That saves a lot of dereferences through prime_sb

Signed-off-by: NeilBrown <neilb@suse.de>

diff --git a/clean.c b/clean.c
index 6909c4cb9fd222ceefa04a3bf3d8f1afa3093267..909874862855e5595dc1b477ef491e3e2f55580e 100644 (file)
--- a/clean.c
+++ b/clean.c
@@ -314,7 +314,7 @@ static int try_clean(struct fs *fs, struct toclean *tc)
                err = lafs_load_page_async(fs, tc->chead,
                                           tc->haddr,
                                           (PAGE_SIZE /
-                                           fs->prime_sb->s_blocksize),
+                                           fs->blocksize),
                                           &tc->ac);
 
                rv = 0;

diff --git a/cluster.c b/cluster.c
index 136f15f7f41d6903241442666053f4a091040473..cf43261d18d63de758d84518b2f6d6e65d91c940 100644 (file)
--- a/cluster.c
+++ b/cluster.c
@@ -374,7 +374,7 @@ static u64 seg_addr(struct fs *fs, struct segpos *seg)
 
 static void cluster_reset(struct fs *fs, struct wc *wc)
 {
-       int blocksize = fs->prime_sb->s_blocksize;
+       int blocksize = fs->blocksize;
        if (wc->seg.dev < 0) {
                wc->remaining = 0;
                wc->chead_size = 0;
@@ -476,11 +476,9 @@ static int flush_data_to_inode(struct block *b)
 
        char *ibuf, *dbuf;
        loff_t size = i_size_read(b->inode);
-       struct super_block *sb = b->inode->i_sb;
        struct lafs_inode *lai = LAFSI(b->inode);
        struct datablock *db;
-
-       struct fs *fs = sb->s_fs_info;
+       struct fs *fs = fs_from_inode(b->inode);
 
        lafs_iolock_block(&lai->iblock->b);
        dprintk("FLUSHING single block into inode - s=%d %s\n",
@@ -501,7 +499,7 @@ static int flush_data_to_inode(struct block *b)
                int credits = 1;
                /* Check size again, just in case it changed */
                size = i_size_read(b->inode);
-               if (size + lai->metadata_size > sb->s_blocksize) {
+               if (size + lai->metadata_size > fs->blocksize) {
                        /* Lost a race, better give up restoring Dirty bit */
                        if (test_and_set_bit(B_Dirty, &b->flags))
                                if (test_and_set_bit(B_Credit, &b->flags))
@@ -559,7 +557,7 @@ static int flush_data_to_inode(struct block *b)
               dbuf, size);
        memset(ibuf + lai->metadata_size + size,
               0,
-              sb->s_blocksize - lai->metadata_size - size);
+              fs->blocksize - lai->metadata_size - size);
        unmap_dblock_2(db, ibuf);
        unmap_dblock(dblk(b), dbuf);
        lafs_iounlock_block(&lai->iblock->b);
@@ -575,8 +573,7 @@ give_up:
 
 int lafs_cluster_allocate(struct block *b, int cnum)
 {
-       struct super_block *sb = b->inode->i_sb;
-       struct fs *fs = sb->s_fs_info;
+       struct fs *fs = fs_from_inode(b->inode);
        struct wc *wc = &fs->wc[cnum];
        struct lafs_inode *lai;
        loff_t size;
@@ -608,7 +605,7 @@ int lafs_cluster_allocate(struct block *b, int cnum)
            b->fileaddr == 0 &&
            b->parent == lai->iblock &&               /* No indexing */
            lai->type >= TypeBase &&                  /* 'size' is meaningful */
-           size + lai->metadata_size <= sb->s_blocksize) {
+           size + lai->metadata_size <= fs->blocksize) {
                int success = flush_data_to_inode(b);
                if (success) {
                        lafs_summary_update(fs, b->inode, b->physaddr, 0,
@@ -793,7 +790,7 @@ int lafs_cluster_allocate(struct block *b, int cnum)
                                          sizeof(struct descriptor)) ||
                    (wc->remaining > 2 &&
                     wc->chead_blocks < MAX_CHEAD_BLOCKS &&
-                    (wc->chead_blocks+1) * sb->s_blocksize <= PAGE_SIZE)
+                    (wc->chead_blocks+1) * fs->blocksize <= PAGE_SIZE)
                        )
                        avail = 2;
                else if (wc->cluster_space >= sizeof(struct descriptor))
@@ -834,7 +831,7 @@ int lafs_cluster_allocate(struct block *b, int cnum)
                /* need a new page */
                wc->chead_blocks++;
                wc->remaining--;
-               wc->cluster_space += sb->s_blocksize;
+               wc->cluster_space += fs->blocksize;
        }
        wc->remaining--;
        BUG_ON(wc->remaining < 0);
@@ -979,7 +976,6 @@ lafs_cluster_update_commit_both(struct update_handle *uh, struct fs *fs,
        /* flush 'size' bytes of data, as 'offset' of bnum in ino
         * in the next write cluster
         */
-       struct super_block *sb = ino->i_sb;
        struct wc *wc = &fs->wc[0];
        struct group_head *head_start;
        unsigned long long seq;
@@ -992,10 +988,10 @@ lafs_cluster_update_commit_both(struct update_handle *uh, struct fs *fs,
                                    sizeof(struct descriptor) +
                                    ROUND_UP(len))) {
                if (wc->remaining > 0 && wc->chead_blocks < MAX_CHEAD_BLOCKS &&
-                   (wc->chead_blocks+1) * sb->s_blocksize <= PAGE_SIZE) {
+                   (wc->chead_blocks+1) * fs->blocksize <= PAGE_SIZE) {
                        wc->chead_blocks++;
                        wc->remaining--;
-                       wc->cluster_space += sb->s_blocksize;
+                       wc->cluster_space += fs->blocksize;
                } else
                        cluster_flush(fs, 0);
        }
@@ -1135,7 +1131,6 @@ static void cluster_flush(struct fs *fs, int cnum)
        struct wc *wc = &fs->wc[cnum];
        int i;
        struct block *b;
-       struct super_block *sb = fs->prime_sb;
        struct inode *current_inode = NULL;
        u64 current_block = NoBlock;
        u64 head_addr[MAX_CHEAD_BLOCKS];
@@ -1181,7 +1176,7 @@ static void cluster_flush(struct fs *fs, int cnum)
                        current_block = b->fileaddr;
                } else
                        current_block++;
-               cluster_incdesc(wc, desc_start, b, sb->s_blocksize_bits);
+               cluster_incdesc(wc, desc_start, b, fs->blocksize_bits);
                addr = seg_next(fs, &wc->seg);
                if (cnum && test_bit(B_Dirty, &b->flags))
                        /* Were a cleaning but this block is now dirty.
@@ -1302,7 +1297,7 @@ static void cluster_flush(struct fs *fs, int cnum)
        for (i = 0; i < wc->chead_blocks; i++)
                lafs_write_head(fs,
                                page_address(wc->page[wc->pending_next])
-                               + i*sb->s_blocksize,
+                               + i * fs->blocksize,
                                head_addr[i], wc);
 
        while (!list_empty(&wc->clhead)) {

diff --git a/dir.c b/dir.c
index f53c674a893d9e4ad50e76e2306fd295f42eda67..faf50ad29d902d20e401dfd16045eadfc777b737 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -205,7 +205,7 @@ static int dir_create_prepare(struct fs *fs, struct inode *dir,
         * we only need the first of those.
         *
         */
-       int blocksize = fs->prime_sb->s_blocksize;
+       int blocksize = fs->blocksize;
        struct datablock *dirblk;
        char *buf, *n1, *n2;
        int bits = dir->i_blkbits-8;
@@ -315,8 +315,8 @@ dir_create_commit(struct dirop_handle *doh,
         * - else add doh->previndex into doh->index
         */
        char *buf;
-       int bits = fs->prime_sb->s_blocksize_bits - 8;
-       int blocksize = fs->prime_sb->s_blocksize;
+       int bits = fs->blocksize_bits - 8;
+       int blocksize = fs->blocksize;
        struct lafs_inode *lai = LAFSI(dir);
        u32 seed = lai->md.file.seed;
 
@@ -890,7 +890,7 @@ lafs_symlink(struct inode *dir, struct dentry *de,
        int err;
 
        l = strlen(symlink);
-       if (l > fs->prime_sb->s_blocksize-1)
+       if (l > fs->blocksize-1)
                return -ENAMETOOLONG;
 
        ino = lafs_new_inode(fs, dir, TypeSymlink, 0, 0666, &inodb);

diff --git a/index.c b/index.c
index c20a06c5a2ef9a3237a260b70ccd8518cf0b22f5..4c86d6aec29f2b40481da3ee9256bff4f170c1a8 100644 (file)
--- a/index.c
+++ b/index.c
@@ -146,7 +146,7 @@ lafs_iblock_alloc(struct fs *fs, int gfp, int with_buffer, REFARG)
        if (!ib)
                return NULL;
        if (with_buffer) {
-               ib->data = kmalloc(fs->prime_sb->s_blocksize, gfp);
+               ib->data = kmalloc(fs->blocksize, gfp);
                if (!ib->data) {
                        kfree(ib);
                        return NULL;
@@ -1602,7 +1602,7 @@ static int __lafs_find_next(struct inode *ino, loff_t *addrp)
                if (lai->depth == 1)
                        offset = lai->metadata_size;
                buf = map_iblock(leaf);
-               p = leaf_lookup(buf+offset, fs->prime_sb->s_blocksize-offset,
+               p = leaf_lookup(buf+offset, fs->blocksize-offset,
                                leaf->b.fileaddr, (u32)*addrp, &nextd);
                unmap_iblock(leaf, buf);
                if (p) {

diff --git a/inode.c b/inode.c
index d573dfb73bac9eb01adb326f5dde4e7ff482721b..8b9d9cfdaf7d5c110d9ceca149b7e856e06270da 100644 (file)
--- a/inode.c
+++ b/inode.c
@@ -566,7 +566,7 @@ void lafs_inode_init(struct datablock *b, int type, int mode, struct inode *dir)
        }
        size += sizeof(struct la_inode);
        lai->metadata_size = cpu_to_le32(size);
-       memset(((char *)lai)+size, 0, fs->prime_sb->s_blocksize-size);
+       memset(((char *)lai)+size, 0, fs->blocksize-size);
        *(u16 *)(((char *)lai)+size) = cpu_to_le16(IBLK_EXTENT);
 
        unmap_dblock(b, lai);
@@ -778,8 +778,8 @@ int lafs_inode_handle_orphan(struct datablock *b)
 
                ib2 = ib;
                lastaddr = (i_size_read(ino) +
-                           ino->i_sb->s_blocksize - 1)
-                       >> ino->i_sb->s_blocksize_bits;
+                           fs->blocksize - 1)
+                       >> fs->blocksize_bits;
                /* Find a Pinned descendent of ib which has no
                 * Pinned descendents and no PrimaryRef dependent
                 * (so take the last).
@@ -1209,7 +1209,7 @@ retry:
        bnum = LAFSI(im)->md.inodemap.thisblock;
 
        if (bnum == NoBlock ||
-           LAFSI(im)->md.inodemap.nextbit >= (filesys->i_sb->s_blocksize<<3)) {
+           LAFSI(im)->md.inodemap.nextbit >= (fs->blocksize<<3)) {
                if (bnum == NoBlock)
                        bnum = LAFSI(im)->md.inodemap.size;
 
@@ -1238,7 +1238,7 @@ retry:
 
                        buf = map_dblock(b);
                        /* Set block to "all are free" */
-                       memset(buf, 0xff, filesys->i_sb->s_blocksize);
+                       memset(buf, 0xff, fs->blocksize);
                        unmap_dblock(b, buf);
                        set_bit(B_Valid, &b->b.flags);
                        LAFSI(im)->md.inodemap.size = bnum+1;
@@ -1268,7 +1268,7 @@ retry:
                goto abort;
        if (b->b.physaddr == 0 && !test_bit(B_Valid, &b->b.flags)) {
                LAFSI(im)->md.inodemap.nextbit =
-                       (im->i_sb->s_blocksize<<3) + 1;
+                       (fs->blocksize<<3) + 1;
                goto retry;
        }
        err = lafs_read_block(b);
@@ -1279,10 +1279,10 @@ retry:
        LAFSI(im)->md.inodemap.thisblock = bnum;
        buf = map_dblock(b);
        bit = find_next_bit((unsigned long *)buf,
-                           im->i_sb->s_blocksize<<3, bit);
+                           fs->blocksize<<3, bit);
        unmap_dblock(b, buf);
        LAFSI(im)->md.inodemap.nextbit = bit+1;
-       if (bit >= im->i_sb->s_blocksize<<3)
+       if (bit >= fs->blocksize<<3)
                goto retry;
 
        mutex_unlock(&im->i_mutex);
@@ -1564,8 +1564,8 @@ void lafs_truncate(struct inode *ino)
        lafs_make_orphan(fs, db);
 
        LAFSI(ino)->trunc_next = (i_size_read(ino) +
-                                 ino->i_sb->s_blocksize - 1)
-               >> ino->i_sb->s_blocksize_bits;
+                                 fs->blocksize - 1)
+               >> fs->blocksize_bits;
        set_bit(I_Trunc, &LAFSI(ino)->iflags);
        putdref(db, MKREF(trunc));
 }

diff --git a/io.c b/io.c
index a7756abd21a599dbe992916ccd2bd9d30682d64c..0003a06e2b0e0c42215c42c6562ef94664423818 100644 (file)
--- a/io.c
+++ b/io.c
@@ -87,7 +87,7 @@ lafs_load_page(struct fs *fs, struct page *p, u64 vaddr, int blocks)
 
        bdev = fs->devs[dev].sb->s_bdev;
        return lafs_sync_page_io(bdev, sect, 0,
-                                blocks << fs->prime_sb->s_blocksize_bits,
+                                blocks << fs->blocksize_bits,
                                 p, 0) ? 0 : -EIO;
 }
 
@@ -145,7 +145,7 @@ lafs_load_page_async(struct fs *fs, struct page *p, u64 vaddr,
        ac->state = 2; /* loading */
        ac->fs = fs;
        async_page_io(bdev, sect, 0,
-                     blocks << fs->prime_sb->s_blocksize_bits,
+                     blocks << fs->blocksize_bits,
                      p, 0, ac);
        return -EAGAIN;
 }
@@ -522,7 +522,7 @@ lafs_load_block(struct block *b, struct bio *bio)
 
                bio->bi_bdev = bdev;
                bio->bi_sector = sect;
-               bio_add_page(bio, page, fs->prime_sb->s_blocksize, offset);
+               bio_add_page(bio, page, fs->blocksize, offset);
 
                bio->bi_private = b;
                bio->bi_end_io = block_loaded;
@@ -533,7 +533,7 @@ lafs_load_block(struct block *b, struct bio *bio)
        if (bio->bi_size == 0) {
                bio->bi_sector = sect;
                bio->bi_bdev = bdev;
-               bio_add_page(bio, page, fs->prime_sb->s_blocksize, offset);
+               bio_add_page(bio, page, fs->blocksize, offset);
                bio->bi_private = b;
                bio->bi_end_io = blocks_loaded;
                BUG_ON(!list_empty(&b->lru));
@@ -541,7 +541,7 @@ lafs_load_block(struct block *b, struct bio *bio)
        }
        if (bio->bi_sector + (bio->bi_size / 512) != sect
            || bio->bi_bdev != bdev
-           || bio_add_page(bio, page, fs->prime_sb->s_blocksize, offset) == 0)
+           || bio_add_page(bio, page, fs->blocksize, offset) == 0)
                return -EINVAL;
        /* added the block successfully */
        headb = bio->bi_private;
@@ -608,7 +608,7 @@ static void write_block(struct fs *fs, struct page *p, int offset,
        if (bio && virt == wc->bio_virt &&
            bio->bi_bdev == fs->devs[dev].sb->s_bdev &&
            which == wc->bio_which &&
-           bio_add_page(bio, p, fs->prime_sb->s_blocksize, offset) > 0) {
+           bio_add_page(bio, p, fs->blocksize, offset) > 0) {
                /* Added the current bio - too easy */
                wc->bio_virt++;
                return;
@@ -652,7 +652,7 @@ static void write_block(struct fs *fs, struct page *p, int offset,
        wc->bio_which = which;
        bio->bi_bdev = fs->devs[dev].sb->s_bdev;
        bio->bi_sector = sect;
-       bio_add_page(bio, p, fs->prime_sb->s_blocksize, offset);
+       bio_add_page(bio, p, fs->blocksize, offset);
 
        bio->bi_private = wc;
        bio->bi_end_io = lafs_cluster_endio_choose(which, head);

diff --git a/lafs.h b/lafs.h
index cc21d4df97db1e180c53f24f742e16a83fc73bf8..6ee9f19bb1d4bd3875158bae4470f64ccebdf1ba 100644 (file)
--- a/lafs.h
+++ b/lafs.h
@@ -234,7 +234,7 @@ virttophys(struct fs *fs, u64 virt, int *devp, sector_t *sectp)
        if (d < 0) return;
 
        virt -= dv->start;
-       virt <<= (fs->prime_sb->s_blocksize_bits - 9);
+       virt <<= (fs->blocksize_bits - 9);
        virt += (dv->segment_offset)>>9;
        *sectp = virt;
 }

diff --git a/modify.c b/modify.c
index 2d4d1afe9a2c6becc1eff27c7b883cda04d570e1..30678581251471e3db5b9e8071a4b66dfdc6b409 100644 (file)
--- a/modify.c
+++ b/modify.c
@@ -988,7 +988,7 @@ void lafs_walk_leaf_index(struct indexblock *ib,
                offset = LAFSI(ib->b.inode)->metadata_size;
        else
                offset = 0;
-       len = fs->prime_sb->s_blocksize - offset;
+       len = fs->blocksize - offset;
 
        current_layout = le16_to_cpu(*(u16 *)(ibuf+offset));
        buf = ibuf + offset + 2;
@@ -1169,7 +1169,7 @@ static int do_incorporate_leaf(struct fs *fs, struct indexblock *ib,
                offset = LAFSI(ib->b.inode)->metadata_size;
        else
                offset = 0;
-       len = fs->prime_sb->s_blocksize - offset;
+       len = fs->blocksize - offset;
 
        check_leaf(&leafinfo, ib->b.fileaddr, 0, len);
 
@@ -1209,7 +1209,7 @@ static int do_incorporate_leaf(struct fs *fs, struct indexblock *ib,
        nbuf = map_iblock_2(new);
        layout.data = nbuf;
        layout.size = len;
-       memset(nbuf, 0, fs->prime_sb->s_blocksize);
+       memset(nbuf, 0, fs->blocksize);
        set_bit(B_Valid, &new->b.flags);
 
        buf = ibuf + offset + 2;
@@ -1445,7 +1445,7 @@ static int do_incorporate_internal(struct fs *fs, struct indexblock *ib,
                offset = LAFSI(ib->b.inode)->metadata_size;
        else
                offset = 0;
-       len = fs->prime_sb->s_blocksize - offset;
+       len = fs->blocksize - offset;
 
        current_layout = le16_to_cpu(*(u16 *)(ibuf+offset));
        buf = ibuf + offset + 2;
@@ -1455,7 +1455,7 @@ static int do_incorporate_internal(struct fs *fs, struct indexblock *ib,
        nbuf = map_iblock_2(new);
        layout.data = nbuf;
        layout.size = len;
-       memset(nbuf, 0, fs->prime_sb->s_blocksize);
+       memset(nbuf, 0, fs->blocksize);
 
        ok = walk_index(ib->b.fileaddr,
                        &buf, len-2, uninc,
@@ -1615,7 +1615,7 @@ void lafs_incorporate(struct fs *fs, struct indexblock *ib)
        int rv = 0;
        char *buf;
        struct uninc uit;
-       int blocksize = fs->prime_sb->s_blocksize;
+       int blocksize = fs->blocksize;
 
        LAFS_BUG(!test_bit(B_IOLock, &ib->b.flags), &ib->b);
 

diff --git a/orphan.c b/orphan.c
index 34005e9379bdc4eaf44f6dd0af6347a1c89f1bd2..55c287a10cb6de4d500583754a78463f05cd6d40 100644 (file)
--- a/orphan.c
+++ b/orphan.c
@@ -67,11 +67,11 @@ void lafs_dump_orphans(void)
                u32 bnum;
                int ent;
 
-               bnum = slot >> (dfs->prime_sb->s_blocksize_bits-4);
+               bnum = slot >> (dfs->blocksize_bits-4);
                ob = lafs_get_block(dfs->orphans, bnum, NULL, GFP_KERNEL,
                                    MKREF(dumpo));
                or = map_dblock(ob);
-               ent = slot - (bnum << (dfs->prime_sb->s_blocksize_bits-4));
+               ent = slot - (bnum << (dfs->blocksize_bits-4));
                printk("%3d: %d %u %u %u\n", slot,
                       or[ent].type, or[ent].filesys, or[ent].inum,
                       or[ent].addr);
@@ -112,7 +112,7 @@ static int orphan_prepare(struct fs *fs, int async)
 #endif
        mutex_lock_nested(&fs->orphans->i_mutex, I_MUTEX_QUOTA);
        bnum = (om->nextfree + om->reserved) >>
-               (fs->prime_sb->s_blocksize_bits-4);
+               (fs->blocksize_bits-4);
 
        b = lafs_get_block(fs->orphans, bnum, NULL, GFP_KERNEL,
                           MKREF(orphan_reserve));
@@ -143,7 +143,7 @@ static struct datablock *orphan_pin(struct fs *fs, struct datablock *b)
        struct datablock *ob;
 
        slot = om->nextfree;
-       bnum = slot >> (fs->prime_sb->s_blocksize_bits-4);
+       bnum = slot >> (fs->blocksize_bits-4);
        dprintk("slot=%d bnum=%d\n", slot, bnum);
        ob = lafs_get_block(fs->orphans, bnum, NULL, GFP_KERNEL, MKREF(orphan));
        /* that *must* succeed as we own a reference on the block already */
@@ -177,7 +177,7 @@ static void orphan_commit(struct fs *fs, struct datablock *b, struct datablock *
 
        or = map_dblock(ob);
        ent = b->orphan_slot - (ob->b.fileaddr
-                               << (fs->prime_sb->s_blocksize_bits-4));
+                               << (fs->blocksize_bits-4));
        or[ent].type = cpu_to_le32(1);
        or[ent].filesys = cpu_to_le32(LAFSI(b->b.inode)->filesys->i_ino);
        or[ent].inum = cpu_to_le32(b->b.inode->i_ino);
@@ -200,7 +200,7 @@ static void orphan_abort(struct fs *fs)
 
        om->reserved--;
        bnum = (om->nextfree + om->reserved) >>
-               (fs->prime_sb->s_blocksize_bits-4);
+               (fs->blocksize_bits-4);
        b = lafs_get_block(fs->orphans, bnum, NULL, GFP_KERNEL,
                           MKREF(orphanx));
        /* Note that we now own two references to this block, one
@@ -215,7 +215,7 @@ static void orphan_abort(struct fs *fs)
         * this block.
         */
        if ((om->nextfree + om->reserved) <=
-           (bnum << (fs->prime_sb->s_blocksize_bits-4))
+           (bnum << (fs->blocksize_bits-4))
                )
                lafs_erase_dblock(b);
 

diff --git a/roll.c b/roll.c
index 2dd452f73f9bcc71fa3eebf0da6d35e820d29f7f..ceee0c34fbdc911e16c35706855218a9963f24a6 100644 (file)
--- a/roll.c
+++ b/roll.c
@@ -295,9 +295,9 @@ roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
                if (lai->filetype >= TypeBase &&
                    lai->filetype != TypeDir  &&
                    lai->depth == 0 &&
-                   mdsize > 1 && mdsize < fs->prime_sb->s_blocksize) {
+                   mdsize > 1 && mdsize < fs->blocksize) {
                        u64 sz = le64_to_cpu(lai->metadata[0].file.size);
-                       if (sz <= fs->prime_sb->s_blocksize - mdsize)
+                       if (sz <= fs->blocksize - mdsize)
                                err = roll_mini(fs, inum, bnum, -1, flg, 0, 0,
                                                (int)sz,
                                                page_address(p) + mdsize);
@@ -385,7 +385,7 @@ roll_one(struct fs *fs, u64 *addrp, struct page *p, struct page *pg,
        int i;
        u64 baddr = addr;
        int err;
-       int blocksize = fs->prime_sb->s_blocksize;
+       int blocksize = fs->blocksize;
 
        /* we "know" buf is big enough */
        err = lafs_load_page(fs, p, addr, max/blocksize);
@@ -476,7 +476,7 @@ static int roll_forward(struct fs *fs)
        struct page *p, *pg;
        char *buf;
        int err;
-       int blocksize = fs->prime_sb->s_blocksize;
+       int blocksize = fs->blocksize;
 
        fs->phase = 1;
        fs->qphase = 0;

diff --git a/segments.c b/segments.c
index f6e4da32ad9eaf816685cf840d1c44c245ecdab4..0398b470e183e497054969e4a4df928eca7e32d5 100644 (file)
--- a/segments.c
+++ b/segments.c
@@ -173,13 +173,13 @@ retry:
        INIT_HLIST_NODE(&new->hash);
        dv = fs->devs + devnum;
        addr = LAFSI(fs->ss[ssnum].root)->md.fs.usagetable * dv->tablesize;
-       addr += segnum >> (fs->prime_sb->s_blocksize_bits-1);
+       addr += segnum >> (fs->blocksize_bits-1);
        new->ssblk = lafs_get_block(dv->segsum, addr, NULL,
                                    GFP_KERNEL,
                                    MKREF(ss));
        if (ssnum == 0)
                new->youthblk = lafs_get_block(dv->segsum,
-                                              segnum >> (fs->prime_sb->s_blocksize_bits-1),
+                                              segnum >> (fs->blocksize_bits-1),
                                               NULL,
                                               GFP_KERNEL,
                                               MKREF(ssyouth));
@@ -356,7 +356,7 @@ static void seg_inc(struct fs *fs, struct segsum *ss, int diff, int in_phase)
                u16 *b, *p;
                b = map_dblock(ss->ssblk);
                spin_lock(&fs->stable_lock);
-               p = &b[ss->segnum & ((fs->prime_sb->s_blocksize-1)>>1)];
+               p = &b[ss->segnum & ((fs->blocksize-1)>>1)];
                //BUG_ON(diff < 0 && le16_to_cpu(*p) < -diff);
                if (diff < 0 && le16_to_cpu(*p) < -diff) {
                        printk("diff=%d p=%d segnum=%d\n", diff, le16_to_cpu(*p),
@@ -478,7 +478,7 @@ int lafs_seg_dup(struct fs *fs, int newtable)
 
                        from = map_dblock(obl);
                        to = map_dblock_2(nbl);
-                       memcpy(to, from, fs->prime_sb->s_blocksize);
+                       memcpy(to, from, fs->blocksize);
                        unmap_dblock_2(nbl, to);
                        unmap_dblock(obl, from);
                        lafs_dirty_dblock(nbl);
@@ -1096,7 +1096,7 @@ again:
        if (test_bit(FinalCheckpoint, &fs->fsstate) ||
            (db &&
             db->b.inode == fs->devs[*dev].segsum &&
-            db->b.fileaddr == ((*seg) >> (fs->prime_sb->s_blocksize_bits
+            db->b.fileaddr == ((*seg) >> (fs->blocksize_bits
                                           - 1)))) {
                /* HACK youth_next should always be at least 0x8000 so that
                 * cleanable score differentiates well for new segments.
@@ -1115,7 +1115,7 @@ again:
 
                if (db) {
                        youthp = map_dblock(db);
-                       youthp[(*seg) & ((1 << (fs->prime_sb->s_blocksize_bits
+                       youthp[(*seg) & ((1 << (fs->blocksize_bits
                                                - 1)) - 1)]
                                = fs->youth_next;
                        unmap_dblock(db, youthp);
@@ -1165,7 +1165,7 @@ again:
                        putdref(db, MKREF(youth));
 
                db = lafs_get_block(fs->devs[*dev].segsum,
-                                   (*seg) >> (fs->prime_sb->s_blocksize_bits
+                                   (*seg) >> (fs->blocksize_bits
                                               - 1),
                                    NULL, GFP_KERNEL,
                                    MKREF(youth));
@@ -1390,7 +1390,7 @@ static void clean_free(struct fs *fs)
                fs->free_blocks += fs->devs[ss->dev].segment_size;
                spin_unlock(&fs->lock);
                db = lafs_get_block(fs->devs[ss->dev].segsum,
-                                   ss->segment >> (fs->prime_sb->s_blocksize_bits-1),
+                                   ss->segment >> (fs->blocksize_bits-1),
                                    NULL, GFP_KERNEL | __GFP_NOFAIL,
                                    MKREF(cleanfree));
                err = lafs_read_block(db);
@@ -1399,7 +1399,7 @@ static void clean_free(struct fs *fs)
                if (err == 0) {
                        u16 *b = map_dblock(db);
                        spin_lock(&fs->stable_lock);
-                       b[ss->segment & ((fs->prime_sb->s_blocksize-1)>>1)] = 0;
+                       b[ss->segment & ((fs->blocksize-1)>>1)] = 0;
                        spin_unlock(&fs->stable_lock);
                        unmap_dblock(db, b);
                        lafs_dirty_dblock(db);
@@ -1689,7 +1689,7 @@ static int add_cleanable(struct fs *fs, unsigned int dev, u32 seg,
 static void merge_usage(struct fs *fs, u16 *d)
 {
        u16 *u = fs->scan.free_usages;
-       int segperblk = fs->prime_sb->s_blocksize / 2;
+       int segperblk = fs->blocksize / 2;
        int i;
 
        for (i = 0; i < segperblk; i++)
@@ -1750,7 +1750,7 @@ unsigned long lafs_scan_seg(struct fs *fs)
 
                while (fs->scan.free_block >
                       (fs->devs[fs->scan.free_dev].segment_count
-                       >> (fs->prime_sb->s_blocksize_bits - 1))) {
+                       >> (fs->blocksize_bits - 1))) {
                        fs->scan.free_dev++;
                        fs->scan.free_block = 0;
                        if (fs->scan.free_dev >= fs->devices) {
@@ -1801,7 +1801,7 @@ unsigned long lafs_scan_seg(struct fs *fs)
 
                int i;
                int firstseg;
-               int segperblk = fs->prime_sb->s_blocksize / 2;
+               int segperblk = fs->blocksize / 2;
                int segments = segperblk;
                int segcount;
                int blks;
@@ -1832,7 +1832,7 @@ unsigned long lafs_scan_seg(struct fs *fs)
                        break;
                }
                d = map_dblock(db);
-               memcpy(fs->scan.free_usages, d, fs->prime_sb->s_blocksize);
+               memcpy(fs->scan.free_usages, d, fs->blocksize);
                unmap_dblock(db, d);
 
                /* Now add any free blocks */
@@ -1925,7 +1925,7 @@ unsigned long lafs_scan_seg(struct fs *fs)
                u16 *yp = map_dblock(fs->scan.youth_db);
                u16 *up = fs->scan.free_usages;
                int i;
-               int segperblk = fs->prime_sb->s_blocksize / 2;
+               int segperblk = fs->blocksize / 2;
                int segments = segperblk;
                int segcount = fs->devs[fs->scan.free_dev].segment_count;
                int blks = segcount / segments;

diff --git a/state.h b/state.h
index 6d388aafb9bfe9ff0a8e214fc007417d0f620eaf..159172937f233db31bd6769e7562852eced68160 100644 (file)
--- a/state.h
+++ b/state.h
@@ -45,6 +45,7 @@ struct fs {
        u32     devices;
        u32     statesize;
 
+       int     blocksize, blocksize_bits;
        int     devs_loaded;
 
        atomic_t sb_writes_pending;

diff --git a/summary.c b/summary.c
index 1a49a1ef812dac0a58816b98d8267535b91db113..fe6665f04cdef4bd5ed17f99d8be2533ffe09dc3 100644 (file)
--- a/summary.c
+++ b/summary.c
@@ -55,7 +55,7 @@ void lafs_summary_update(struct fs *fs, struct inode *ino,
                        lai->ablocks--;
                else
                        ino->i_blocks -=
-                               1 << (fs->prime_sb->s_blocksize_bits - 9);
+                               1 << (fs->blocksize_bits - 9);
        }
        spin_unlock(&ino->i_lock);
 
@@ -103,7 +103,7 @@ int lafs_summary_allocate(struct fs *fs, struct inode *ino, int diff)
        if (err)
                return err;
 
-       err = lafs_quota_allocate(fs, ino, diff * fs->prime_sb->s_blocksize);
+       err = lafs_quota_allocate(fs, ino, diff * fs->blocksize);
        if (err) {
                spin_lock(&lai->vfs_inode.i_lock);
                lai->md.fs.ablocks_used -= diff;
@@ -114,7 +114,7 @@ int lafs_summary_allocate(struct fs *fs, struct inode *ino, int diff)
        lai = LAFSI(ino);
        spin_lock(&ino->i_lock);
        lai->ablocks += diff;
-       ino->i_blocks += (blkcnt_t)diff << (fs->prime_sb->s_blocksize_bits - 9) ;
+       ino->i_blocks += (blkcnt_t)diff << (fs->blocksize_bits - 9) ;
        spin_unlock(&ino->i_lock);
 
        return 0;

diff --git a/super.c b/super.c
index 3fc68e50faae95fa41bda93949c46074a7bf6d32..9b6119f8e550f07152771b51fa86f939708a36bd 100644 (file)
--- a/super.c
+++ b/super.c
@@ -496,6 +496,8 @@ lafs_load(struct options *op, int newest)
        fs->devices = op->devcnt;
        fs->devs_loaded = fs->devices; /* FIXME use this or lose this */
        fs->statesize = 1 << op->statebits;
+       fs->blocksize = 1 << op->blockbits;
+       fs->blocksize_bits = op->blockbits;
 
        fs->nonlog_segment = le32_to_cpu(st->nonlog_segment);
        fs->nonlog_dev = le16_to_cpu(st->nonlog_dev);
@@ -1053,7 +1055,7 @@ static int lafs_statfs(struct dentry *de, struct kstatfs *buf)
 
        spin_lock(&root->vfs_inode.i_lock);
        buf->f_type = 0x4C614654; /* "LaFS" */
-       buf->f_bsize = de->d_inode->i_sb->s_blocksize;
+       buf->f_bsize = fs->blocksize;
        buf->f_blocks = root->md.fs.blocks_allowed;
        if (buf->f_blocks == 0) {
                /* should subtract usage of all other filesystems...*/