[PATCH] struct super_block cleanup - affs

Seperates affs_sb_info from struct super_block.

diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index d0532a67af605bd99b94f8f012aef4d26512b4d7..bc229488cfbfb3ae23fb802fcffc097adb624256 100644 (file)
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -246,7 +246,7 @@ affs_empty_dir(struct inode *inode)
                goto done;
 
        retval = -ENOTEMPTY;
-       for (size = AFFS_SB->s_hashsize - 1; size >= 0; size--)
+       for (size = AFFS_SB(sb)->s_hashsize - 1; size >= 0; size--)
                if (AFFS_HEAD(bh)->table[size])
                        goto not_empty;
        retval = 0;
@@ -458,7 +458,7 @@ affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
        if (!(sb->s_flags & MS_RDONLY))
                printk(KERN_WARNING "AFFS: Remounting filesystem read-only\n");
        sb->s_flags |= MS_RDONLY;
-       AFFS_SB->s_flags |= SF_READONLY;        /* Don't allow to remount rw */
+       AFFS_SB(sb)->s_flags |= SF_READONLY;    /* Don't allow to remount rw */
 }
 
 void

diff --git a/fs/affs/bitmap.c b/fs/affs/bitmap.c
index 1726db8a09a8ad23c2d8af25d1d5d1707b97dcf7..c0e48f698ee740d07ea2a15303d47e29bb8514ff 100644 (file)
--- a/fs/affs/bitmap.c
+++ b/fs/affs/bitmap.c
@@ -53,14 +53,14 @@ affs_count_free_blocks(struct super_block *sb)
        if (sb->s_flags & MS_RDONLY)
                return 0;
 
-       down(&AFFS_SB->s_bmlock);
+       down(&AFFS_SB(sb)->s_bmlock);
 
-       bm = AFFS_SB->s_bitmap;
+       bm = AFFS_SB(sb)->s_bitmap;
        free = 0;
-       for (i = AFFS_SB->s_bmap_count; i > 0; bm++, i--)
+       for (i = AFFS_SB(sb)->s_bmap_count; i > 0; bm++, i--)
                free += bm->bm_free;
 
-       up(&AFFS_SB->s_bmlock);
+       up(&AFFS_SB(sb)->s_bmlock);
 
        return free;
 }
@@ -68,6 +68,7 @@ affs_count_free_blocks(struct super_block *sb)
 void
 affs_free_block(struct super_block *sb, u32 block)
 {
+       struct affs_sb_info *sbi = AFFS_SB(sb);
        struct affs_bm_info *bm;
        struct buffer_head *bh;
        u32 blk, bmap, bit, mask, tmp;
@@ -75,24 +76,24 @@ affs_free_block(struct super_block *sb, u32 block)
 
        pr_debug("AFFS: free_block(%u)\n", block);
 
-       if (block > AFFS_SB->s_partition_size)
+       if (block > sbi->s_partition_size)
                goto err_range;
 
-       blk     = block - AFFS_SB->s_reserved;
-       bmap    = blk / AFFS_SB->s_bmap_bits;
-       bit     = blk % AFFS_SB->s_bmap_bits;
-       bm      = &AFFS_SB->s_bitmap[bmap];
+       blk     = block - sbi->s_reserved;
+       bmap    = blk / sbi->s_bmap_bits;
+       bit     = blk % sbi->s_bmap_bits;
+       bm      = &sbi->s_bitmap[bmap];
 
-       down(&AFFS_SB->s_bmlock);
+       down(&sbi->s_bmlock);
 
-       bh = AFFS_SB->s_bmap_bh;
-       if (AFFS_SB->s_last_bmap != bmap) {
+       bh = sbi->s_bmap_bh;
+       if (sbi->s_last_bmap != bmap) {
                affs_brelse(bh);
                bh = affs_bread(sb, bm->bm_key);
                if (!bh)
                        goto err_bh_read;
-               AFFS_SB->s_bmap_bh = bh;
-               AFFS_SB->s_last_bmap = bmap;
+               sbi->s_bmap_bh = bh;
+               sbi->s_last_bmap = bmap;
        }
 
        mask = 1 << (bit & 31);
@@ -112,19 +113,19 @@ affs_free_block(struct super_block *sb, u32 block)
        sb->s_dirt = 1;
        bm->bm_free++;
 
-       up(&AFFS_SB->s_bmlock);
+       up(&sbi->s_bmlock);
        return;
 
 err_free:
        affs_warning(sb,"affs_free_block","Trying to free block %u which is already free", block);
-       up(&AFFS_SB->s_bmlock);
+       up(&sbi->s_bmlock);
        return;
 
 err_bh_read:
        affs_error(sb,"affs_free_block","Cannot read bitmap block %u", bm->bm_key);
-       AFFS_SB->s_bmap_bh = NULL;
-       AFFS_SB->s_last_bmap = ~0;
-       up(&AFFS_SB->s_bmlock);
+       sbi->s_bmap_bh = NULL;
+       sbi->s_last_bmap = ~0;
+       up(&sbi->s_bmlock);
        return;
 
 err_range:
@@ -145,6 +146,7 @@ u32
 affs_alloc_block(struct inode *inode, u32 goal)
 {
        struct super_block *sb;
+       struct affs_sb_info *sbi;
        struct affs_bm_info *bm;
        struct buffer_head *bh;
        u32 *data, *enddata;
@@ -152,6 +154,7 @@ affs_alloc_block(struct inode *inode, u32 goal)
        int i;
 
        sb = inode->i_sb;
+       sbi = AFFS_SB(sb);
 
        pr_debug("AFFS: balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
 
@@ -161,53 +164,53 @@ affs_alloc_block(struct inode *inode, u32 goal)
                return ++AFFS_I(inode)->i_lastalloc;
        }
 
-       if (!goal || goal > AFFS_SB->s_partition_size) {
+       if (!goal || goal > sbi->s_partition_size) {
                if (goal)
                        affs_warning(sb, "affs_balloc", "invalid goal %d", goal);
                //if (!AFFS_I(inode)->i_last_block)
                //      affs_warning(sb, "affs_balloc", "no last alloc block");
-               goal = AFFS_SB->s_reserved;
+               goal = sbi->s_reserved;
        }
 
-       blk = goal - AFFS_SB->s_reserved;
-       bmap = blk / AFFS_SB->s_bmap_bits;
-       bm = &AFFS_SB->s_bitmap[bmap];
+       blk = goal - sbi->s_reserved;
+       bmap = blk / sbi->s_bmap_bits;
+       bm = &sbi->s_bitmap[bmap];
 
-       down(&AFFS_SB->s_bmlock);
+       down(&sbi->s_bmlock);
 
        if (bm->bm_free)
                goto find_bmap_bit;
 
 find_bmap:
        /* search for the next bmap buffer with free bits */
-       i = AFFS_SB->s_bmap_count;
+       i = sbi->s_bmap_count;
        do {
                bmap++;
                bm++;
-               if (bmap < AFFS_SB->s_bmap_count)
+               if (bmap < sbi->s_bmap_count)
                        continue;
                /* restart search at zero */
                bmap = 0;
-               bm = AFFS_SB->s_bitmap;
+               bm = sbi->s_bitmap;
                if (--i <= 0)
                        goto err_full;
        } while (!bm->bm_free);
-       blk = bmap * AFFS_SB->s_bmap_bits;
+       blk = bmap * sbi->s_bmap_bits;
 
 find_bmap_bit:
 
-       bh = AFFS_SB->s_bmap_bh;
-       if (AFFS_SB->s_last_bmap != bmap) {
+       bh = sbi->s_bmap_bh;
+       if (sbi->s_last_bmap != bmap) {
                affs_brelse(bh);
                bh = affs_bread(sb, bm->bm_key);
                if (!bh)
                        goto err_bh_read;
-               AFFS_SB->s_bmap_bh = bh;
-               AFFS_SB->s_last_bmap = bmap;
+               sbi->s_bmap_bh = bh;
+               sbi->s_last_bmap = bmap;
        }
 
        /* find an unused block in this bitmap block */
-       bit = blk % AFFS_SB->s_bmap_bits;
+       bit = blk % sbi->s_bmap_bits;
        data = (u32 *)bh->b_data + bit / 32 + 1;
        enddata = (u32 *)((u8 *)bh->b_data + sb->s_blocksize);
        mask = ~0UL << (bit & 31);
@@ -231,7 +234,7 @@ find_bmap_bit:
 find_bit:
        /* finally look for a free bit in the word */
        bit = ffs(tmp) - 1;
-       blk += bit + AFFS_SB->s_reserved;
+       blk += bit + sbi->s_reserved;
        mask2 = mask = 1 << (bit & 31);
        AFFS_I(inode)->i_lastalloc = blk;
 
@@ -253,18 +256,18 @@ find_bit:
        mark_buffer_dirty(bh);
        sb->s_dirt = 1;
 
-       up(&AFFS_SB->s_bmlock);
+       up(&sbi->s_bmlock);
 
        pr_debug("%d\n", blk);
        return blk;
 
 err_bh_read:
        affs_error(sb,"affs_read_block","Cannot read bitmap block %u", bm->bm_key);
-       AFFS_SB->s_bmap_bh = NULL;
-       AFFS_SB->s_last_bmap = ~0;
+       sbi->s_bmap_bh = NULL;
+       sbi->s_last_bmap = ~0;
 err_full:
        pr_debug("failed\n");
-       up(&AFFS_SB->s_bmlock);
+       up(&sbi->s_bmlock);
        return 0;
 }
 
@@ -276,35 +279,36 @@ affs_init_bitmap(struct super_block *sb)
        u32 *bmap_blk;
        u32 size, blk, end, offset, mask;
        int i, res = 0;
+       struct affs_sb_info *sbi = AFFS_SB(sb);
 
        if (sb->s_flags & MS_RDONLY)
                return 0;
 
-       if (!AFFS_ROOT_TAIL(sb, AFFS_SB->s_root_bh)->bm_flag) {
+       if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
                printk(KERN_NOTICE "AFFS: Bitmap invalid - mounting %s read only\n",
                        sb->s_id);
                sb->s_flags |= MS_RDONLY;
                return 0;
        }
 
-       AFFS_SB->s_last_bmap = ~0;
-       AFFS_SB->s_bmap_bh = NULL;
-       AFFS_SB->s_bmap_bits = sb->s_blocksize * 8 - 32;
-       AFFS_SB->s_bmap_count = (AFFS_SB->s_partition_size - AFFS_SB->s_reserved +
-                                AFFS_SB->s_bmap_bits - 1) / AFFS_SB->s_bmap_bits;
-       size = AFFS_SB->s_bmap_count * sizeof(struct affs_bm_info);
-       bm = AFFS_SB->s_bitmap = kmalloc(size, GFP_KERNEL);
-       if (!AFFS_SB->s_bitmap) {
+       sbi->s_last_bmap = ~0;
+       sbi->s_bmap_bh = NULL;
+       sbi->s_bmap_bits = sb->s_blocksize * 8 - 32;
+       sbi->s_bmap_count = (sbi->s_partition_size - sbi->s_reserved +
+                                sbi->s_bmap_bits - 1) / sbi->s_bmap_bits;
+       size = sbi->s_bmap_count * sizeof(struct affs_bm_info);
+       bm = sbi->s_bitmap = kmalloc(size, GFP_KERNEL);
+       if (!sbi->s_bitmap) {
                printk(KERN_ERR "AFFS: Bitmap allocation failed\n");
                return 1;
        }
-       memset(AFFS_SB->s_bitmap, 0, size);
+       memset(sbi->s_bitmap, 0, size);
 
-       bmap_blk = (u32 *)AFFS_SB->s_root_bh->b_data;
+       bmap_blk = (u32 *)sbi->s_root_bh->b_data;
        blk = sb->s_blocksize / 4 - 49;
        end = blk + 25;
 
-       for (i = AFFS_SB->s_bmap_count; i > 0; bm++, i--) {
+       for (i = sbi->s_bmap_count; i > 0; bm++, i--) {
                affs_brelse(bh);
 
                bm->bm_key = be32_to_cpu(bmap_blk[blk]);
@@ -341,7 +345,7 @@ affs_init_bitmap(struct super_block *sb)
                end = sb->s_blocksize / 4 - 1;
        }
 
-       offset = (AFFS_SB->s_partition_size - AFFS_SB->s_reserved) % AFFS_SB->s_bmap_bits;
+       offset = (sbi->s_partition_size - sbi->s_reserved) % sbi->s_bmap_bits;
        mask = ~(0xFFFFFFFFU << (offset & 31));
        pr_debug("last word: %d %d %d\n", offset, offset / 32 + 1, mask);
        offset = offset / 32 + 1;

diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index 460f8926d1024f6be9b7299b390484e831a9a272..aa69197ba0ab28cf40d3a0e107cbe7833285350f 100644 (file)
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -122,7 +122,7 @@ affs_readdir(struct file *filp, void *dirent, filldir_t filldir)
                goto inside;
        hash_pos++;
 
-       for (; hash_pos < AFFS_SB->s_hashsize; hash_pos++) {
+       for (; hash_pos < AFFS_SB(sb)->s_hashsize; hash_pos++) {
                ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[hash_pos]);
                if (!ino)
                        continue;

diff --git a/fs/affs/file.c b/fs/affs/file.c
index 4d7d470d209a09d97f93c6e6180215dc9e28296c..465d34cede282358b3a850d78984005e50c6aaef 100644 (file)
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -350,8 +350,8 @@ affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_resul
        //lock cache
        affs_lock_ext(inode);
 
-       ext = block / AFFS_SB->s_hashsize;
-       block -= ext * AFFS_SB->s_hashsize;
+       ext = block / AFFS_SB(sb)->s_hashsize;
+       block -= ext * AFFS_SB(sb)->s_hashsize;
        ext_bh = affs_get_extblock(inode, ext);
        if (IS_ERR(ext_bh))
                goto err_ext;
@@ -362,7 +362,7 @@ affs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_resul
                if (!blocknr)
                        goto err_alloc;
                bh_result->b_state |= (1UL << BH_New);
-               AFFS_I(inode)->mmu_private += AFFS_SB->s_data_blksize;
+               AFFS_I(inode)->mmu_private += AFFS_SB(sb)->s_data_blksize;
                AFFS_I(inode)->i_blkcnt++;
 
                /* store new block */
@@ -516,7 +516,7 @@ affs_do_readpage_ofs(struct file *file, struct page *page, unsigned from, unsign
 
        pr_debug("AFFS: read_page(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to);
        data = page_address(page);
-       bsize = AFFS_SB->s_data_blksize;
+       bsize = AFFS_SB(sb)->s_data_blksize;
        tmp = (page->index << PAGE_CACHE_SHIFT) + from;
        bidx = tmp / bsize;
        boff = tmp % bsize;
@@ -546,7 +546,7 @@ affs_extent_file_ofs(struct file *file, u32 newsize)
        u32 tmp;
 
        pr_debug("AFFS: extent_file(%u, %d)\n", (u32)inode->i_ino, newsize);
-       bsize = AFFS_SB->s_data_blksize;
+       bsize = AFFS_SB(sb)->s_data_blksize;
        bh = NULL;
        size = inode->i_size;
        bidx = size / bsize;
@@ -670,7 +670,7 @@ static int affs_commit_write_ofs(struct file *file, struct page *page, unsigned
        int written;
 
        pr_debug("AFFS: commit_write(%u, %ld, %d, %d)\n", (u32)inode->i_ino, page->index, from, to);
-       bsize = AFFS_SB->s_data_blksize;
+       bsize = AFFS_SB(sb)->s_data_blksize;
        data = page_address(page);
 
        bh = NULL;
@@ -811,8 +811,8 @@ affs_truncate(struct inode *inode)
        last_blk = 0;
        ext = 0;
        if (inode->i_size) {
-               last_blk = ((u32)inode->i_size - 1) / AFFS_SB->s_data_blksize;
-               ext = last_blk / AFFS_SB->s_hashsize;
+               last_blk = ((u32)inode->i_size - 1) / AFFS_SB(sb)->s_data_blksize;
+               ext = last_blk / AFFS_SB(sb)->s_hashsize;
        }
 
        if (inode->i_size > AFFS_I(inode)->mmu_private) {
@@ -857,11 +857,11 @@ affs_truncate(struct inode *inode)
        i = 0;
        blk = last_blk;
        if (inode->i_size) {
-               i = last_blk % AFFS_SB->s_hashsize + 1;
+               i = last_blk % AFFS_SB(sb)->s_hashsize + 1;
                blk++;
        } else
                AFFS_HEAD(ext_bh)->first_data = 0;
-       size = AFFS_SB->s_hashsize;
+       size = AFFS_SB(sb)->s_hashsize;
        if (size > blkcnt - blk + i)
                size = blkcnt - blk + i;
        for (; i < size; i++, blk++) {
@@ -885,7 +885,7 @@ affs_truncate(struct inode *inode)
 
        while (ext_key) {
                ext_bh = affs_bread(sb, ext_key);
-               size = AFFS_SB->s_hashsize;
+               size = AFFS_SB(sb)->s_hashsize;
                if (size > blkcnt - blk)
                        size = blkcnt - blk;
                for (i = 0; i < size; i++, blk++)

diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 33e2241a9944d5cb4282e8613ef52eb91cb82676..2a75344cd54c6438abd07f256e4e4a950cdee4ec 100644 (file)
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -38,6 +38,7 @@ void
 affs_read_inode(struct inode *inode)
 {
        struct super_block      *sb = inode->i_sb;
+       struct affs_sb_info     *sbi = AFFS_SB(sb);
        struct buffer_head      *bh;
        struct affs_head        *head;
        struct affs_tail        *tail;
@@ -83,35 +84,35 @@ affs_read_inode(struct inode *inode)
        AFFS_I(inode)->i_lastalloc = 0;
        AFFS_I(inode)->i_pa_cnt = 0;
 
-       if (AFFS_SB->s_flags & SF_SETMODE)
-               inode->i_mode = AFFS_SB->s_mode;
+       if (sbi->s_flags & SF_SETMODE)
+               inode->i_mode = sbi->s_mode;
        else
                inode->i_mode = prot_to_mode(prot);
 
        id = be16_to_cpu(tail->uid);
-       if (id == 0 || AFFS_SB->s_flags & SF_SETUID)
-               inode->i_uid = AFFS_SB->s_uid;
-       else if (id == 0xFFFF && AFFS_SB->s_flags & SF_MUFS)
+       if (id == 0 || sbi->s_flags & SF_SETUID)
+               inode->i_uid = sbi->s_uid;
+       else if (id == 0xFFFF && sbi->s_flags & SF_MUFS)
                inode->i_uid = 0;
        else
                inode->i_uid = id;
 
        id = be16_to_cpu(tail->gid);
-       if (id == 0 || AFFS_SB->s_flags & SF_SETGID)
-               inode->i_gid = AFFS_SB->s_gid;
-       else if (id == 0xFFFF && AFFS_SB->s_flags & SF_MUFS)
+       if (id == 0 || sbi->s_flags & SF_SETGID)
+               inode->i_gid = sbi->s_gid;
+       else if (id == 0xFFFF && sbi->s_flags & SF_MUFS)
                inode->i_gid = 0;
        else
                inode->i_gid = id;
 
        switch (be32_to_cpu(tail->stype)) {
        case ST_ROOT:
-               inode->i_uid = AFFS_SB->s_uid;
-               inode->i_gid = AFFS_SB->s_gid;
+               inode->i_uid = sbi->s_uid;
+               inode->i_gid = sbi->s_gid;
                /* fall through */
        case ST_USERDIR:
                if (be32_to_cpu(tail->stype) == ST_USERDIR ||
-                   AFFS_SB->s_flags & SF_SETMODE) {
+                   sbi->s_flags & SF_SETMODE) {
                        if (inode->i_mode & S_IRUSR)
                                inode->i_mode |= S_IXUSR;
                        if (inode->i_mode & S_IRGRP)
@@ -147,13 +148,13 @@ affs_read_inode(struct inode *inode)
                AFFS_I(inode)->mmu_private = inode->i_size = size;
                if (inode->i_size) {
                        AFFS_I(inode)->i_blkcnt = (size - 1) /
-                                              AFFS_SB->s_data_blksize + 1;
+                                              sbi->s_data_blksize + 1;
                        AFFS_I(inode)->i_extcnt = (AFFS_I(inode)->i_blkcnt - 1) /
-                                              AFFS_SB->s_hashsize + 1;
+                                              sbi->s_hashsize + 1;
                }
                if (tail->link_chain)
                        inode->i_nlink = 2;
-               inode->i_mapping->a_ops = (AFFS_SB->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
+               inode->i_mapping->a_ops = (sbi->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
                inode->i_op = &affs_file_inode_operations;
                inode->i_fop = &affs_file_operations;
                break;
@@ -207,18 +208,18 @@ affs_write_inode(struct inode *inode, int unused)
                tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect);
                tail->size = cpu_to_be32(inode->i_size);
                secs_to_datestamp(inode->i_mtime,&tail->change);
-               if (!(inode->i_ino == AFFS_SB->s_root_block)) {
+               if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) {
                        uid = inode->i_uid;
                        gid = inode->i_gid;
-                       if (sb->u.affs_sb.s_flags & SF_MUFS) {
+                       if (AFFS_SB(sb)->s_flags & SF_MUFS) {
                                if (inode->i_uid == 0 || inode->i_uid == 0xFFFF)
                                        uid = inode->i_uid ^ ~0;
                                if (inode->i_gid == 0 || inode->i_gid == 0xFFFF)
                                        gid = inode->i_gid ^ ~0;
                        }
-                       if (!(sb->u.affs_sb.s_flags & SF_SETUID))
+                       if (!(AFFS_SB(sb)->s_flags & SF_SETUID))
                                tail->uid = cpu_to_be16(uid);
-                       if (!(sb->u.affs_sb.s_flags & SF_SETGID))
+                       if (!(AFFS_SB(sb)->s_flags & SF_SETGID))
                                tail->gid = cpu_to_be16(gid);
                }
        }
@@ -240,11 +241,11 @@ affs_notify_change(struct dentry *dentry, struct iattr *attr)
        if (error)
                goto out;
 
-       if (((attr->ia_valid & ATTR_UID) && (inode->i_sb->u.affs_sb.s_flags & SF_SETUID)) ||
-           ((attr->ia_valid & ATTR_GID) && (inode->i_sb->u.affs_sb.s_flags & SF_SETGID)) ||
+       if (((attr->ia_valid & ATTR_UID) && (AFFS_SB(inode->i_sb)->s_flags & SF_SETUID)) ||
+           ((attr->ia_valid & ATTR_GID) && (AFFS_SB(inode->i_sb)->s_flags & SF_SETGID)) ||
            ((attr->ia_valid & ATTR_MODE) &&
-            (inode->i_sb->u.affs_sb.s_flags & (SF_SETMODE | SF_IMMUTABLE)))) {
-               if (!(inode->i_sb->u.affs_sb.s_flags & SF_QUIET))
+            (AFFS_SB(inode->i_sb)->s_flags & (SF_SETMODE | SF_IMMUTABLE)))) {
+               if (!(AFFS_SB(inode->i_sb)->s_flags & SF_QUIET))
                        error = -EPERM;
                goto out;
        }

diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 495a5481514aaaff333d56094f48a9613cb15d5e..80578e97be1893f65f119882719bb629b655a0e9 100644 (file)
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -64,7 +64,7 @@ affs_intl_toupper(int ch)
 static inline toupper_t
 affs_get_toupper(struct super_block *sb)
 {
-       return AFFS_SB->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;
+       return AFFS_SB(sb)->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;
 }
 
 /*
@@ -177,7 +177,7 @@ affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len)
        for (; len > 0; len--)
                hash = (hash * 13 + toupper(*name++)) & 0x7ff;
 
-       return hash % AFFS_SB->s_hashsize;
+       return hash % AFFS_SB(sb)->s_hashsize;
 }
 
 static struct buffer_head *
@@ -244,7 +244,7 @@ affs_lookup(struct inode *dir, struct dentry *dentry)
                        return ERR_PTR(-EACCES);
                }
        }
-       dentry->d_op = AFFS_SB->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
+       dentry->d_op = AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
        unlock_kernel();
        d_add(dentry, inode);
        return NULL;
@@ -289,7 +289,7 @@ affs_create(struct inode *dir, struct dentry *dentry, int mode)
 
        inode->i_op = &affs_file_inode_operations;
        inode->i_fop = &affs_file_operations;
-       inode->i_mapping->a_ops = (AFFS_SB->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
+       inode->i_mapping->a_ops = (AFFS_SB(sb)->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
        error = affs_add_entry(dir, inode, dentry, ST_FILE);
        if (error) {
                inode->i_nlink = 0;
@@ -367,7 +367,7 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
                 (int)dentry->d_name.len,dentry->d_name.name,symname);
 
        lock_kernel();
-       maxlen = AFFS_SB->s_hashsize * sizeof(u32) - 1;
+       maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
        error = -ENOSPC;
        inode  = affs_new_inode(dir);
        if (!inode) {
@@ -390,8 +390,8 @@ affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
        if (*symname == '/') {
                while (*symname == '/')
                        symname++;
-               while (AFFS_SB->s_volume[i])    /* Cannot overflow */
-                       *p++ = AFFS_SB->s_volume[i++];
+               while (AFFS_SB(sb)->s_volume[i])        /* Cannot overflow */
+                       *p++ = AFFS_SB(sb)->s_volume[i++];
        }
        while (i < maxlen && (c = *symname++)) {
                if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {

diff --git a/fs/affs/super.c b/fs/affs/super.c
index feb7cc91884179a53b98d010592ba819e2a7b9fb..adfefd10ff905d999e450179424207dbc1c046d0 100644 (file)
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -38,21 +38,25 @@ static int affs_remount (struct super_block *sb, int *flags, char *data);
 static void
 affs_put_super(struct super_block *sb)
 {
+       struct affs_sb_info *sbi = AFFS_SB(sb);
+
        pr_debug("AFFS: put_super()\n");
 
        if (!(sb->s_flags & MS_RDONLY)) {
-               AFFS_ROOT_TAIL(sb, AFFS_SB->s_root_bh)->bm_flag = be32_to_cpu(1);
+               AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag = be32_to_cpu(1);
                secs_to_datestamp(CURRENT_TIME,
-                                 &AFFS_ROOT_TAIL(sb, AFFS_SB->s_root_bh)->disk_change);
-               affs_fix_checksum(sb, AFFS_SB->s_root_bh);
-               mark_buffer_dirty(AFFS_SB->s_root_bh);
+                                 &AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->disk_change);
+               affs_fix_checksum(sb, sbi->s_root_bh);
+               mark_buffer_dirty(sbi->s_root_bh);
        }
 
-       affs_brelse(AFFS_SB->s_bmap_bh);
-       if (AFFS_SB->s_prefix)
-               kfree(AFFS_SB->s_prefix);
-       kfree(AFFS_SB->s_bitmap);
-       affs_brelse(AFFS_SB->s_root_bh);
+       affs_brelse(sbi->s_bmap_bh);
+       if (sbi->s_prefix)
+               kfree(sbi->s_prefix);
+       kfree(sbi->s_bitmap);
+       affs_brelse(sbi->s_root_bh);
+       kfree(sbi);
+       sb->u.generic_sbp = NULL;
 
        return;
 }
@@ -61,16 +65,17 @@ static void
 affs_write_super(struct super_block *sb)
 {
        int clean = 2;
+       struct affs_sb_info *sbi = AFFS_SB(sb);
 
        if (!(sb->s_flags & MS_RDONLY)) {
-               //      if (AFFS_SB->s_bitmap[i].bm_bh) {
-               //              if (buffer_dirty(AFFS_SB->s_bitmap[i].bm_bh)) {
+               //      if (sbi->s_bitmap[i].bm_bh) {
+               //              if (buffer_dirty(sbi->s_bitmap[i].bm_bh)) {
                //                      clean = 0;
-               AFFS_ROOT_TAIL(sb, AFFS_SB->s_root_bh)->bm_flag = be32_to_cpu(clean);
+               AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag = be32_to_cpu(clean);
                secs_to_datestamp(CURRENT_TIME,
-                                 &AFFS_ROOT_TAIL(sb, AFFS_SB->s_root_bh)->disk_change);
-               affs_fix_checksum(sb, AFFS_SB->s_root_bh);
-               mark_buffer_dirty(AFFS_SB->s_root_bh);
+                                 &AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->disk_change);
+               affs_fix_checksum(sb, sbi->s_root_bh);
+               mark_buffer_dirty(sbi->s_root_bh);
                sb->s_dirt = !clean;    /* redo until bitmap synced */
        } else
                sb->s_dirt = 0;
@@ -267,6 +272,7 @@ out_inv_arg:
 
 static int affs_fill_super(struct super_block *sb, void *data, int silent)
 {
+       struct affs_sb_info     *sbi;
        struct buffer_head      *root_bh = NULL;
        struct buffer_head      *boot_bh;
        struct inode            *root_inode = NULL;
@@ -285,22 +291,27 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
 
        sb->s_magic             = AFFS_SUPER_MAGIC;
        sb->s_op                = &affs_sops;
-       memset(AFFS_SB, 0, sizeof(struct affs_sb_info));
-       init_MUTEX(&AFFS_SB->s_bmlock);
+       
+       sbi = kmalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
+       if (!sbi)
+               return -ENOMEM;
+       sb->u.generic_sbp = sbi;
+       memset(sbi, 0, sizeof(struct affs_sb_info));
+       init_MUTEX(&sbi->s_bmlock);
 
        if (!parse_options(data,&uid,&gid,&i,&reserved,&root_block,
-                               &blocksize,&AFFS_SB->s_prefix,
-                               AFFS_SB->s_volume, &mount_flags)) {
+                               &blocksize,&sbi->s_prefix,
+                               sbi->s_volume, &mount_flags)) {
                printk(KERN_ERR "AFFS: Error parsing options\n");
                return -EINVAL;
        }
        /* N.B. after this point s_prefix must be released */
 
-       AFFS_SB->s_flags   = mount_flags;
-       AFFS_SB->s_mode    = i;
-       AFFS_SB->s_uid     = uid;
-       AFFS_SB->s_gid     = gid;
-       AFFS_SB->s_reserved= reserved;
+       sbi->s_flags   = mount_flags;
+       sbi->s_mode    = i;
+       sbi->s_uid     = uid;
+       sbi->s_gid     = gid;
+       sbi->s_reserved= reserved;
 
        /* Get the size of the device in 512-byte blocks.
         * If we later see that the partition uses bigger
@@ -320,12 +331,12 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                size = size / (blocksize / 512);
        }
        for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
-               AFFS_SB->s_root_block = root_block;
+               sbi->s_root_block = root_block;
                if (root_block < 0)
-                       AFFS_SB->s_root_block = (reserved + size - 1) / 2;
+                       sbi->s_root_block = (reserved + size - 1) / 2;
                pr_debug("AFFS: setting blocksize to %d\n", blocksize);
                affs_set_blocksize(sb, blocksize);
-               AFFS_SB->s_partition_size = size;
+               sbi->s_partition_size = size;
 
                /* The root block location that was calculated above is not
                 * correct if the partition size is an odd number of 512-
@@ -341,16 +352,16 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                        pr_debug("AFFS: Dev %s, trying root=%u, bs=%d, "
                                "size=%d, reserved=%d\n",
                                sb->s_id,
-                               AFFS_SB->s_root_block + num_bm,
+                               sbi->s_root_block + num_bm,
                                blocksize, size, reserved);
-                       root_bh = affs_bread(sb, AFFS_SB->s_root_block + num_bm);
+                       root_bh = affs_bread(sb, sbi->s_root_block + num_bm);
                        if (!root_bh)
                                continue;
                        if (!affs_checksum_block(sb, root_bh) &&
                            be32_to_cpu(AFFS_ROOT_HEAD(root_bh)->ptype) == T_SHORT &&
                            be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
-                               AFFS_SB->s_hashsize    = blocksize / 4 - 56;
-                               AFFS_SB->s_root_block += num_bm;
+                               sbi->s_hashsize    = blocksize / 4 - 56;
+                               sbi->s_root_block += num_bm;
                                key                        = 1;
                                goto got_root;
                        }
@@ -365,7 +376,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
 
        /* N.B. after this point bh must be released */
 got_root:
-       root_block = AFFS_SB->s_root_block;
+       root_block = sbi->s_root_block;
 
        /* Find out which kind of FS we have */
        boot_bh = sb_bread(sb, 0);
@@ -385,36 +396,36 @@ got_root:
                printk(KERN_NOTICE "AFFS: Dircache FS - mounting %s read only\n",
                        sb->s_id);
                sb->s_flags |= MS_RDONLY;
-               AFFS_SB->s_flags |= SF_READONLY;
+               sbi->s_flags |= SF_READONLY;
        }
        switch (chksum) {
                case MUFS_FS:
                case MUFS_INTLFFS:
                case MUFS_DCFFS:
-                       AFFS_SB->s_flags |= SF_MUFS;
+                       sbi->s_flags |= SF_MUFS;
                        /* fall thru */
                case FS_INTLFFS:
                case FS_DCFFS:
-                       AFFS_SB->s_flags |= SF_INTL;
+                       sbi->s_flags |= SF_INTL;
                        break;
                case MUFS_FFS:
-                       AFFS_SB->s_flags |= SF_MUFS;
+                       sbi->s_flags |= SF_MUFS;
                        break;
                case FS_FFS:
                        break;
                case MUFS_OFS:
-                       AFFS_SB->s_flags |= SF_MUFS;
+                       sbi->s_flags |= SF_MUFS;
                        /* fall thru */
                case FS_OFS:
-                       AFFS_SB->s_flags |= SF_OFS;
+                       sbi->s_flags |= SF_OFS;
                        sb->s_flags |= MS_NOEXEC;
                        break;
                case MUFS_DCOFS:
                case MUFS_INTLOFS:
-                       AFFS_SB->s_flags |= SF_MUFS;
+                       sbi->s_flags |= SF_MUFS;
                case FS_DCOFS:
                case FS_INTLOFS:
-                       AFFS_SB->s_flags |= SF_INTL | SF_OFS;
+                       sbi->s_flags |= SF_INTL | SF_OFS;
                        sb->s_flags |= MS_NOEXEC;
                        break;
                default:
@@ -433,12 +444,12 @@ got_root:
 
        sb->s_flags |= MS_NODEV | MS_NOSUID;
 
-       AFFS_SB->s_data_blksize = sb->s_blocksize;
-       if (AFFS_SB->s_flags & SF_OFS)
-               AFFS_SB->s_data_blksize -= 24;
+       sbi->s_data_blksize = sb->s_blocksize;
+       if (sbi->s_flags & SF_OFS)
+               sbi->s_data_blksize -= 24;
 
        /* Keep super block in cache */
-       AFFS_SB->s_root_bh = root_bh;
+       sbi->s_root_bh = root_bh;
        /* N.B. after this point s_root_bh must be released */
 
        if (affs_init_bitmap(sb))
@@ -463,17 +474,20 @@ got_root:
 out_error:
        if (root_inode)
                iput(root_inode);
-       if (AFFS_SB->s_bitmap)
-               kfree(AFFS_SB->s_bitmap);
+       if (sbi->s_bitmap)
+               kfree(sbi->s_bitmap);
        affs_brelse(root_bh);
-       if (AFFS_SB->s_prefix)
-               kfree(AFFS_SB->s_prefix);
+       if (sbi->s_prefix)
+               kfree(sbi->s_prefix);
+       kfree(sbi);
+       sb->u.generic_sbp = NULL;
        return -EINVAL;
 }
 
 static int
 affs_remount(struct super_block *sb, int *flags, char *data)
 {
+       struct affs_sb_info     *sbi = AFFS_SB(sb);
        int                      blocksize;
        uid_t                    uid;
        gid_t                    gid;
@@ -481,17 +495,17 @@ affs_remount(struct super_block *sb, int *flags, char *data)
        int                      reserved;
        int                      root_block;
        unsigned long            mount_flags;
-       unsigned long            read_only = AFFS_SB->s_flags & SF_READONLY;
+       unsigned long            read_only = sbi->s_flags & SF_READONLY;
 
        pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
 
        if (!parse_options(data,&uid,&gid,&mode,&reserved,&root_block,
-           &blocksize,&AFFS_SB->s_prefix,AFFS_SB->s_volume,&mount_flags))
+           &blocksize,&sbi->s_prefix,sbi->s_volume,&mount_flags))
                return -EINVAL;
-       AFFS_SB->s_flags = mount_flags | read_only;
-       AFFS_SB->s_mode  = mode;
-       AFFS_SB->s_uid   = uid;
-       AFFS_SB->s_gid   = gid;
+       sbi->s_flags = mount_flags | read_only;
+       sbi->s_mode  = mode;
+       sbi->s_uid   = uid;
+       sbi->s_gid   = gid;
 
        if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
                return 0;
@@ -500,7 +514,7 @@ affs_remount(struct super_block *sb, int *flags, char *data)
                while (sb->s_dirt)
                        affs_write_super(sb);
                sb->s_flags |= MS_RDONLY;
-       } else if (!(AFFS_SB->s_flags & SF_READONLY)) {
+       } else if (!(sbi->s_flags & SF_READONLY)) {
                sb->s_flags &= ~MS_RDONLY;
        } else {
                affs_warning(sb,"remount","Cannot remount fs read/write because of errors");
@@ -514,13 +528,13 @@ affs_statfs(struct super_block *sb, struct statfs *buf)
 {
        int              free;
 
-       pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB->s_partition_size,
-            AFFS_SB->s_reserved);
+       pr_debug("AFFS: statfs() partsize=%d, reserved=%d\n",AFFS_SB(sb)->s_partition_size,
+            AFFS_SB(sb)->s_reserved);
 
        free          = affs_count_free_blocks(sb);
        buf->f_type    = AFFS_SUPER_MAGIC;
        buf->f_bsize   = sb->s_blocksize;
-       buf->f_blocks  = AFFS_SB->s_partition_size - AFFS_SB->s_reserved;
+       buf->f_blocks  = AFFS_SB(sb)->s_partition_size - AFFS_SB(sb)->s_reserved;
        buf->f_bfree   = free;
        buf->f_bavail  = free;
        return 0;

diff --git a/fs/affs/symlink.c b/fs/affs/symlink.c
index f8eedba6fdd393a74c6e571c5dbc6c833525a043..b4c2e20e07e119ede7f8856350526daceffcfdc6 100644 (file)
--- a/fs/affs/symlink.c
+++ b/fs/affs/symlink.c
@@ -40,7 +40,7 @@ static int affs_symlink_readpage(struct file *file, struct page *page)
        j  = 0;
        lf = (struct slink_front *)bh->b_data;
        lc = 0;
-       pf = inode->i_sb->u.affs_sb.s_prefix ? inode->i_sb->u.affs_sb.s_prefix : "/";
+       pf = AFFS_SB(inode->i_sb)->s_prefix ? AFFS_SB(inode->i_sb)->s_prefix : "/";
 
        if (strchr(lf->symname,':')) {  /* Handle assign or volume name */
                while (i < 1023 && (c = pf[i]))

diff --git a/include/linux/affs_fs.h b/include/linux/affs_fs.h
index 7859a5e1883c8ecff66b2a5e6bf358d000936979..47ed05c8b744a0c1a30b0298bce4b093eca28d5c 100644 (file)
--- a/include/linux/affs_fs.h
+++ b/include/linux/affs_fs.h
@@ -7,6 +7,7 @@
 #include <linux/types.h>
 
 #include <linux/affs_fs_i.h>
+#include <linux/affs_fs_sb.h>
 
 #define AFFS_SUPER_MAGIC 0xadff
 

diff --git a/include/linux/affs_fs_sb.h b/include/linux/affs_fs_sb.h
index 5a0485e97fd9db024465e1c6587e5777e559c0be..1f39cd8068006dec83378c709690b473271ad9db 100644 (file)
--- a/include/linux/affs_fs_sb.h
+++ b/include/linux/affs_fs_sb.h
@@ -50,6 +50,9 @@ struct affs_sb_info {
 #define SF_READONLY    0x1000          /* Don't allow to remount rw */
 
 /* short cut to get to the affs specific sb data */
-#define AFFS_SB                (&sb->u.affs_sb)
+static inline struct affs_sb_info *AFFS_SB(struct super_block *sb)
+{
+       return sb->u.generic_sbp;
+}
 
 #endif

diff --git a/include/linux/amigaffs.h b/include/linux/amigaffs.h
index b4b1d430c306cfd5ac05b4b54df36aac00456ecd..342ab37e0c2e1b7328d4ba817486cdfe24895736 100644 (file)
--- a/include/linux/amigaffs.h
+++ b/include/linux/amigaffs.h
@@ -18,7 +18,7 @@
 
 #define GET_END_PTR(st,p,sz)            ((st *)((char *)(p)+((sz)-sizeof(st))))
 #define AFFS_GET_HASHENTRY(data,hashkey) be32_to_cpu(((struct dir_front *)data)->hashtable[hashkey])
-#define AFFS_BLOCK(sb, bh, blk)                (AFFS_HEAD(bh)->table[(sb)->u.affs_sb.s_hashsize-1-(blk)])
+#define AFFS_BLOCK(sb, bh, blk)                (AFFS_HEAD(bh)->table[AFFS_SB(sb)->s_hashsize-1-(blk)])
 
 static inline void
 affs_set_blocksize(struct super_block *sb, int size)
@@ -29,7 +29,7 @@ static inline struct buffer_head *
 affs_bread(struct super_block *sb, int block)
 {
        pr_debug(KERN_DEBUG "affs_bread: %d\n", block);
-       if (block >= AFFS_SB->s_reserved && block < AFFS_SB->s_partition_size)
+       if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                return sb_bread(sb, block);
        return NULL;
 }
@@ -37,7 +37,7 @@ static inline struct buffer_head *
 affs_getblk(struct super_block *sb, int block)
 {
        pr_debug(KERN_DEBUG "affs_getblk: %d\n", block);
-       if (block >= AFFS_SB->s_reserved && block < AFFS_SB->s_partition_size)
+       if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size)
                return sb_getblk(sb, block);
        return NULL;
 }
@@ -46,7 +46,7 @@ affs_getzeroblk(struct super_block *sb, int block)
 {
        struct buffer_head *bh;
        pr_debug(KERN_DEBUG "affs_getzeroblk: %d\n", block);
-       if (block >= AFFS_SB->s_reserved && block < AFFS_SB->s_partition_size) {
+       if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                bh = sb_getblk(sb, block);
                lock_buffer(bh);
                memset(bh->b_data, 0 , sb->s_blocksize);
@@ -61,7 +61,7 @@ affs_getemptyblk(struct super_block *sb, int block)
 {
        struct buffer_head *bh;
        pr_debug(KERN_DEBUG "affs_getemptyblk: %d\n", block);
-       if (block >= AFFS_SB->s_reserved && block < AFFS_SB->s_partition_size) {
+       if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) {
                bh = sb_getblk(sb, block);
                wait_on_buffer(bh);
                mark_buffer_uptodate(bh, 1);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index a1ae91bafcfc69c187b08ae20249b6c69095b1d0..85ae3dcb64964390ce82c2ccfa0a7fea15178f9b 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -648,7 +648,6 @@ struct quota_mount_options
 #include <linux/hpfs_fs_sb.h>
 #include <linux/ntfs_fs_sb.h>
 #include <linux/sysv_fs_sb.h>
-#include <linux/affs_fs_sb.h>
 #include <linux/ufs_fs_sb.h>
 #include <linux/romfs_fs_sb.h>
 #include <linux/adfs_fs_sb.h>
@@ -693,7 +692,6 @@ struct super_block {
                struct hpfs_sb_info     hpfs_sb;
                struct ntfs_sb_info     ntfs_sb;
                struct sysv_sb_info     sysv_sb;
-               struct affs_sb_info     affs_sb;
                struct ufs_sb_info      ufs_sb;
                struct romfs_sb_info    romfs_sb;
                struct adfs_sb_info     adfs_sb;