lkml.org 
[lkml]   [2002]   [Mar]   [17]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH] struct super_block cleanup - affs
    Seperates affs_sb_info from struct super_block.

    --

    Brian Gerst
    diff -urN linux-2.5.7-pre2/fs/affs/amigaffs.c linux/fs/affs/amigaffs.c
    --- linux-2.5.7-pre2/fs/affs/amigaffs.c Thu Mar 7 21:18:18 2002
    +++ linux/fs/affs/amigaffs.c Sun Mar 17 19:20:24 2002
    @@ -246,7 +246,7 @@
    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 @@
    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 -urN linux-2.5.7-pre2/fs/affs/bitmap.c linux/fs/affs/bitmap.c
    --- linux-2.5.7-pre2/fs/affs/bitmap.c Thu Mar 7 21:18:28 2002
    +++ linux/fs/affs/bitmap.c Sun Mar 17 19:25:03 2002
    @@ -53,14 +53,14 @@
    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 @@
    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 @@

    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 @@
    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 @@
    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 @@
    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 @@
    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_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 @@
    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 @@
    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 @@
    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 -urN linux-2.5.7-pre2/fs/affs/dir.c linux/fs/affs/dir.c
    --- linux-2.5.7-pre2/fs/affs/dir.c Thu Mar 7 21:18:19 2002
    +++ linux/fs/affs/dir.c Sun Mar 17 19:20:24 2002
    @@ -122,7 +122,7 @@
    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 -urN linux-2.5.7-pre2/fs/affs/file.c linux/fs/affs/file.c
    --- linux-2.5.7-pre2/fs/affs/file.c Thu Mar 7 21:18:30 2002
    +++ linux/fs/affs/file.c Sun Mar 17 19:20:24 2002
    @@ -350,8 +350,8 @@
    //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 @@
    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 @@

    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 @@
    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 @@
    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 @@
    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 @@
    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 @@

    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 -urN linux-2.5.7-pre2/fs/affs/inode.c linux/fs/affs/inode.c
    --- linux-2.5.7-pre2/fs/affs/inode.c Thu Mar 7 21:18:29 2002
    +++ linux/fs/affs/inode.c Sun Mar 17 19:40:43 2002
    @@ -38,6 +38,7 @@
    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_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_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 @@
    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 @@
    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 -urN linux-2.5.7-pre2/fs/affs/namei.c linux/fs/affs/namei.c
    --- linux-2.5.7-pre2/fs/affs/namei.c Thu Mar 7 21:18:22 2002
    +++ linux/fs/affs/namei.c Sun Mar 17 19:20:24 2002
    @@ -64,7 +64,7 @@
    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 @@
    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 @@
    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 @@

    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 @@
    (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 @@
    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 -urN linux-2.5.7-pre2/fs/affs/super.c linux/fs/affs/super.c
    --- linux-2.5.7-pre2/fs/affs/super.c Sat Mar 16 00:17:32 2002
    +++ linux/fs/affs/super.c Sun Mar 17 19:34:56 2002
    @@ -38,21 +38,25 @@
    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 @@
    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 @@

    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 @@

    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 @@
    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 @@
    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 @@

    /* 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 @@
    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 @@

    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 @@
    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 @@
    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 @@
    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 @@
    {
    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 -urN linux-2.5.7-pre2/fs/affs/symlink.c linux/fs/affs/symlink.c
    --- linux-2.5.7-pre2/fs/affs/symlink.c Thu Mar 7 21:18:16 2002
    +++ linux/fs/affs/symlink.c Sun Mar 17 19:20:24 2002
    @@ -40,7 +40,7 @@
    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 -urN linux-2.5.7-pre2/include/linux/affs_fs.h linux/include/linux/affs_fs.h
    --- linux-2.5.7-pre2/include/linux/affs_fs.h Thu Mar 7 21:18:04 2002
    +++ linux/include/linux/affs_fs.h Sun Mar 17 19:38:14 2002
    @@ -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 -urN linux-2.5.7-pre2/include/linux/affs_fs_sb.h linux/include/linux/affs_fs_sb.h
    --- linux-2.5.7-pre2/include/linux/affs_fs_sb.h Thu Mar 7 21:18:15 2002
    +++ linux/include/linux/affs_fs_sb.h Sun Mar 17 19:11:04 2002
    @@ -50,6 +50,9 @@
    #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 -urN linux-2.5.7-pre2/include/linux/amigaffs.h linux/include/linux/amigaffs.h
    --- linux-2.5.7-pre2/include/linux/amigaffs.h Thu Mar 7 21:18:15 2002
    +++ linux/include/linux/amigaffs.h Sun Mar 17 19:38:14 2002
    @@ -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 @@
    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 @@
    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 @@
    {
    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 @@
    {
    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 -urN linux-2.5.7-pre2/include/linux/fs.h linux/include/linux/fs.h
    --- linux-2.5.7-pre2/include/linux/fs.h Sat Mar 16 00:17:34 2002
    +++ linux/include/linux/fs.h Sun Mar 17 19:38:14 2002
    @@ -650,7 +650,6 @@
    #include <linux/ntfs_fs_sb.h>
    #include <linux/iso_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/hfs_fs_sb.h>
    @@ -699,7 +698,6 @@
    struct ntfs_sb_info ntfs_sb;
    struct isofs_sb_info isofs_sb;
    struct sysv_sb_info sysv_sb;
    - struct affs_sb_info affs_sb;
    struct ufs_sb_info ufs_sb;
    struct shmem_sb_info shmem_sb;
    struct romfs_sb_info romfs_sb;
    \
     
     \ /
      Last update: 2005-03-22 13:25    [W:0.075 / U:92.860 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site